feat(image): add progressive JPEG generation support

- Add convertPDFToJpegBytes method for progressive JPEG images - Integrate @push.rocks/smartjimp for true progressive encoding - Update readme with comprehensive documentation - Update legal section to Task Venture Capital GmbH
BREAKING CHANGE(smartpdf): improve image generation quality and API consistency
2025-08-02 17:29:38 +00:00 · 2025-08-02 12:37:48 +00:00 · 2025-08-01 16:09:17 +00:00 · 2025-02-25 18:22:06 +00:00 · 2025-02-25 18:22:06 +00:00 · 2025-02-25 18:06:45 +00:00
28 changed files with 13058 additions and 2716 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.gitea/workflows/default_nottags.yaml
@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
--- a/.gitea/workflows/default_tags.yaml
+++ b/.gitea/workflows/default_tags.yaml
@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true
--- a/.gitignore
+++ b/.gitignore
@@ -15,8 +15,6 @@ node_modules/

 # builds
 dist/
-dist_web/
-dist_serve/
-dist_ts_web/
+dist_*/

 # custom
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,125 +0,0 @@
-# gitzone standard
-image: hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-  - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
-
-stages:
- security
- test
- release
- metadata
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-  - npmci git mirror
-  tags:
-  - docker
-  - notpriv
-
-snyk:
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install -g snyk
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# test stage
-# ====================
-
-testLTS:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install lts
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-    
-testSTABLE:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-
-release:
-  stage: release
-  script:
-  - npmci node install stable
-  - npmci npm publish
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  image: docker:stable
-  allow_failure: true
-  services:
-    - docker:stable-dind
-  script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SOURCE_CODE="$PWD"
-        --volume "$PWD":/code
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
-  tags:
-  - docker
-  - priv
-
-trigger:
-  stage: metadata
-  script:
-  - npmci trigger
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-pages:
-  image: hosttoday/ht-docker-node:npmci
-  stage: metadata
-  script:
-    - npmci command npm install -g @gitzone/tsdoc
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command tsdoc
-  tags:
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-    - public
-  allow_failure: true
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
--- a/assets/pdfdir/2HVHBoSVG.pdf
+++ b/assets/pdfdir/2HVHBoSVG.pdf
--- a/assets/pdfdir/Wcg5yDTbm.pdf
+++ b/assets/pdfdir/Wcg5yDTbm.pdf
--- a/assets/pdfdir/r2nfLxJWf.pdf
+++ b/assets/pdfdir/r2nfLxJWf.pdf
--- a/changelog.md
+++ b/changelog.md
@@ -0,0 +1,154 @@
+# Changelog
+
+## 2025-08-02 - 4.0.0 - BREAKING CHANGE(smartpdf)
+Improve image generation quality and API consistency
+
+- BREAKING: Renamed `convertPDFToWebpPreviews` to `convertPDFToWebpBytes` for API consistency
+- Added configurable scale options to `convertPDFToPngBytes` method
+- Changed default scale from 1.0 to 3.0 for PNG generation (216 DPI)
+- Changed default scale from 0.5 to 3.0 for WebP generation (216 DPI)
+- Added DPI helper methods: `getScaleForDPI()` and scale constants (SCALE_SCREEN, SCALE_HIGH, SCALE_PRINT)
+- Added maxWidth/maxHeight constraints for both PNG and WebP generation
+- Improved test file organization with clear naming conventions
+- Updated documentation with DPI/scale guidance and examples
+
+## 2025-08-01 - 3.3.0 - feat(smartpdf)
+Add automatic port allocation and multi-instance support
+
+- Added ISmartPdfOptions interface with port configuration options
+- Implemented automatic port allocation between 20000-30000 by default
+- Added support for custom port ranges via portRangeStart/portRangeEnd options
+- Added support for specific port assignment via port option
+- Fixed resource cleanup when port allocation fails
+- Multiple SmartPdf instances can now run simultaneously without port conflicts
+- Updated readme with comprehensive documentation for all features
+
+## 2025-02-25 - 3.2.2 - fix(SmartPdf)
+Fix buffer handling for PDF conversion and text extraction
+
+- Ensure Uint8Array is converted to Node Buffer for PDF conversion.
+- Correct the PDF page viewport handling by using document dimensions.
+- Fix extractTextFromPdfBuffer argument type from Uint8Array to Buffer.
+
+## 2025-02-25 - 3.2.1 - fix(SmartPdf)
+Fix type for extractTextFromPdfBuffer function
+
+- Corrected the parameter type from Buffer to Uint8Array for extractTextFromPdfBuffer function.
+
+## 2025-02-25 - 3.2.0 - feat(smartpdf)
+Improve dependency versions and optimize PDF to PNG conversion.
+
+- Update several dependencies to newer versions for better stability and performance.
+- Refactor tests to enhance readability and add directory creation validations.
+- Optimize PDF to PNG conversion by switching to a more efficient Puppeteer and PDF.js-based method.
+- Add checks for presence of required dependencies (GraphicsMagick and Ghostscript).
+- Fix media emulation issue by properly awaiting the emulateMediaType function.
+
+## 2024-11-30 - 3.1.8 - fix(core)
+Fix candidate handling in PDF generation
+
+- Added error handling for missing PDF candidates in server requests.
+- Updated devDependencies and dependencies to latest versions for better stability and new features.
+- Patched header retrieval logic during PDF generation for security check.
+
+## 2024-09-27 - 3.1.7 - fix(dependencies)
+Update dependencies to latest versions
+
+- Updated @git.zone/tsbuild to version ^2.1.84
+- Updated @git.zone/tsdoc to version ^1.3.12
+- Updated @git.zone/tsrun to version ^1.2.49
+- Updated @push.rocks/tapbundle to version ^5.3.0
+- Updated @types/node to version ^22.7.4
+- Updated @push.rocks/smartfile to version ^11.0.21
+- Updated @push.rocks/smartpromise to version ^4.0.4
+- Updated @tsclass/tsclass to version ^4.1.2
+- Updated express to version ^4.21.0
+- Updated pdf2pic to version ^3.1.3
+
+## 2024-05-29 - 3.1.6 - Core
+Updated description
+
+- Minor changes to documentation and internal text.
+
+## 2024-04-25 to 2024-04-30 - 3.1.0 to 3.1.5 - Core
+Fix updates in core functionality
+
+- Fixes and updates in core function in versions 3.1.0 to 3.1.5.
+
+## 2024-04-25 - 3.0.17 - Feature
+Now supports PDF to JPG conversion
+
+- Added support for converting PDF files to JPG format.
+  
+## 2024-03-19 to 2024-04-14 - 3.0.17 - Maintenance
+Various updates to project configuration files
+
+- Updated `tsconfig`.
+- Updated `npmextra.json`.
+
+## 2023-07-11 to 2024-03-19 - 3.0.15 to 3.0.16 - Organization
+Switch to new organization scheme and core updates
+
+- Switched to new organization scheme.
+- Applied core updates and bug fixes.
+
+## 2022-11-07 to 2023-07-10 - 3.0.13 to 3.0.14 - Core
+Fixes and updates to core functionality
+
+- Various minor bug fixes and updates to core components.
+
+## 2022-09-13 to 2022-11-07 - 3.0.10 to 3.0.12 - Core
+Ongoing core updates and maintenance
+
+- Regular fixes and operational improvements in core functionalities.
+
+## 2022-06-12 to 2022-09-13 - 3.0.7 to 3.0.9 - Core
+Continued focus on high-priority bug fixes and core functionalities
+
+- Regular fixes for critical bugs and enhancements.
+
+## 2022-03-24 to 2022-06-29 - 3.0.3 to 3.0.6 - Core
+Further optimization and maintenance releases
+
+- Further improvements and refinements of issues in core functionalities.
+
+## 2022-01-05 to 2022-03-25 - 3.0.0 to 3.0.2 - Major Version Release
+Major release for version 3.0.x, including core fixes
+
+- Increased version from 2.x to 3.0. New significant changes and fixes.
+
+## 2022-01-05 to 2022-03-24 - 2.0.13 to 2.0.19 - Core
+Routine core updates and bug fixes
+
+- Regular bug fixes in core components.
+
+## 2019-11-19 to 2022-01-06 - 2.0.0 to 2.0.11 - Core
+Multiple core updates and a few performance improvements
+
+- Some performance enhancements and multiple bug fixes.
+  
+## 2019-11-16 to 2019-11-19 - 1.0.27 to 1.0.29 - API
+Breaking change in API
+
+- Naming PDF results to better represent their content.
+
+## 2019-05-29 to 2019-11-15 - 1.0.13 to 1.0.26 - Core
+Core functional updates and some major restructuring
+
+- Introduced multiple updates to the core, addressing bugs and improving stability.
+  
+## 2019-04-10 to 2019-05-28 - 1.0.4 to 1.0.12 - Core
+Fixes and updates in the core
+
+- Implementation of multiple essential fixes for core components.
+
+## 2018-10-06 - 1.0.1 to 1.0.3 - Core and Typings
+Initial implementation and core fixes
+
+- Initial implementation of the project.
+- Fixed compilation problems in typings.
+  
+## 2016-01-29 - unknown - Initial
+Initial commit
+
+- Initial commit for the project setup.
--- a/0
+++ b/0
--- a/npmextra.json
+++ b/npmextra.json
@@ -4,13 +4,31 @@
    "npmAccessLevel": "public"
  },
  "gitzone": {
+    "projectType": "npm",
    "module": {
-      "githost": "gitlab.om",
-      "gitscope": "pushrocks",
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
      "gitrepo": "smartpdf",
-      "shortDescription": "Create PDFs fast and smoothly",
-      "npmPackagename": "@pushrocks/smartpdf",
-      "license": "MIT"
+      "description": "A library for creating PDFs dynamically from HTML or websites with additional features like merging PDFs.",
+      "npmPackagename": "@push.rocks/smartpdf",
+      "license": "MIT",
+      "keywords": [
+        "PDF generation",
+        "HTML to PDF",
+        "website to PDF",
+        "PDF manipulation",
+        "puppeteer",
+        "express",
+        "node.js",
+        "typescript",
+        "automation",
+        "PDF merging",
+        "text extraction",
+        "PDF management"
+      ]
    }
+  },
+  "tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
  }
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,42 +1,74 @@
 {
-  "name": "@pushrocks/smartpdf",
-  "version": "1.0.6",
+  "name": "@push.rocks/smartpdf",
+  "version": "4.0.0",
  "private": false,
-  "description": "create pdfs on the fly",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "description": "A library for creating PDFs dynamically from HTML or websites with additional features like merging PDFs.",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
  "author": "Lossless GmbH",
  "license": "MIT",
  "scripts": {
-    "test": "(tstest test/)",
-    "format": "(gitzone format)",
-    "build": "(tsbuild)"
+    "test": "(tstest test/ --verbose --timeout 120)",
+    "build": "(tsbuild tsfolders --allowimplicitany)",
+    "buildDocs": "tsdoc"
  },
  "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.11",
-    "@gitzone/tsrun": "^1.2.6",
-    "@gitzone/tstest": "^1.0.24",
-    "@pushrocks/tapbundle": "^3.0.9",
-    "@types/node": "^12.0.3"
+    "@git.zone/tsbuild": "^2.6.4",
+    "@git.zone/tsdoc": "^1.5.0",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^2.3.2",
+    "@types/node": "^24.1.0"
  },
  "dependencies": {
-    "@pushrocks/smartfile": "^7.0.2",
-    "@pushrocks/smartnetwork": "^1.1.6",
-    "@pushrocks/smartpromise": "^3.0.2",
-    "@pushrocks/smartunique": "^3.0.1",
-    "@types/express": "^4.16.1",
-    "@types/puppeteer": "^1.12.4",
-    "express": "^4.17.1",
-    "puppeteer": "^1.17.0"
+    "@push.rocks/smartbuffer": "^3.0.5",
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartfile": "^11.2.5",
+    "@push.rocks/smartjimp": "^1.2.0",
+    "@push.rocks/smartnetwork": "^4.1.2",
+    "@push.rocks/smartpath": "^6.0.0",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartpuppeteer": "^2.0.5",
+    "@push.rocks/smartunique": "^3.0.9",
+    "@tsclass/tsclass": "^9.2.0",
+    "@types/express": "^5.0.3",
+    "express": "^5.1.0",
+    "pdf-lib": "^1.17.1",
+    "pdf2json": "3.2.0"
  },
  "files": [
-    "ts/*",
-    "ts_web/*",
-    "dist/*",
-    "dist_web/*",
-    "assets/*",
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
    "cli.js",
    "npmextra.json",
    "readme.md"
-  ]
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ],
+  "keywords": [
+    "PDF generation",
+    "HTML to PDF",
+    "website to PDF",
+    "PDF manipulation",
+    "puppeteer",
+    "express",
+    "node.js",
+    "typescript",
+    "automation",
+    "PDF merging",
+    "text extraction",
+    "PDF management"
+  ],
+  "homepage": "https://code.foss.global/push.rocks/smartpdf",
+  "repository": {
+    "type": "git",
+    "url": "https://code.foss.global/push.rocks/smartpdf.git"
+  },
+  "packageManager": "pnpm@10.11.0+sha512.6540583f41cc5f628eb3d9773ecee802f4f9ef9923cc45b69890fb47991d4b092964694ec3a4f738a420c918a333062c8b925d312f42e4f0c263eb603551f977"
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -0,0 +1,2 @@
+onlyBuiltDependencies:
+  - sharp
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -0,0 +1 @@
+ 
--- a/readme.md
+++ b/readme.md
@@ -1,26 +1,425 @@
-# @pushrocks/smartpdf
-Create PDFs fast and smoothly
+# @push.rocks/smartpdf 📄✨

-## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartpdf)
-* [gitlab.com (source)](https://gitlab.om/pushrocks/smartpdf)
-* [github.com (source mirror)](https://github.com/pushrocks/smartpdf)
-* [docs (typedoc)](https://pushrocks.gitlab.io/smartpdf/)
+> **Transform HTML, websites, and PDFs into beautiful documents with just a few lines of code!**

-## Status for master
-[![build status](https://gitlab.om/pushrocks/smartpdf/badges/master/build.svg)](https://gitlab.om/pushrocks/smartpdf/commits/master)
-[![coverage report](https://gitlab.om/pushrocks/smartpdf/badges/master/coverage.svg)](https://gitlab.om/pushrocks/smartpdf/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartpdf.svg)](https://www.npmjs.com/package/@pushrocks/smartpdf)
-[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartpdf/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartpdf)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
+[![npm version](https://img.shields.io/npm/v/@push.rocks/smartpdf.svg?style=flat-square)](https://www.npmjs.com/package/@push.rocks/smartpdf)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue.svg?style=flat-square)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](./license)

-## Usage
+## 🚀 Why SmartPDF?

-For further information read the linked docs at the top of this readme.
+SmartPDF is your Swiss Army knife for PDF operations in Node.js. Whether you're generating invoices, creating reports, or converting web pages to PDFs, we've got you covered with a simple, powerful API.

-> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
+### ✨ Features at a Glance

-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)
+- 📝 **HTML to PDF** - Transform HTML strings with full CSS support
+- 🌐 **Website to PDF** - Capture any website as a perfectly formatted PDF
+- 🔀 **PDF Merging** - Combine multiple PDFs into one
+- 🖼️ **PDF to Images** - Convert PDFs to PNG, WebP, or progressive JPEG
+- 📑 **Text Extraction** - Pull text content from existing PDFs
+- 🎯 **Smart Port Management** - Automatic port allocation for concurrent instances
+- 💪 **TypeScript First** - Full type safety and IntelliSense support
+- ⚡ **High Performance** - Optimized for speed and reliability
+
+## 📦 Installation
+
+```bash
+# Using npm
+npm install @push.rocks/smartpdf --save
+
+# Using yarn
+yarn add @push.rocks/smartpdf
+
+# Using pnpm (recommended)
+pnpm add @push.rocks/smartpdf
+```
+
+## 🎯 Quick Start
+
+```typescript
+import { SmartPdf } from '@push.rocks/smartpdf';
+
+// Create and start SmartPdf
+const smartPdf = await SmartPdf.create();
+await smartPdf.start();
+
+// Generate a PDF from HTML
+const pdf = await smartPdf.getA4PdfResultForHtmlString(`
+  <h1>Hello, PDF World! 🌍</h1>
+  <p>This is my first SmartPDF document.</p>
+`);
+
+// Save it
+await fs.writeFile('my-first-pdf.pdf', pdf.buffer);
+
+// Don't forget to clean up!
+await smartPdf.stop();
+```
+
+## 📚 Core Concepts
+
+### 🏗️ Instance Management
+
+SmartPDF uses a client-server architecture for maximum performance. Always remember:
+
+1. **Create** an instance
+2. **Start** the server
+3. **Do your PDF magic**
+4. **Stop** the server
+
+```typescript
+const smartPdf = await SmartPdf.create();
+await smartPdf.start();
+// ... your PDF operations ...
+await smartPdf.stop();
+```
+
+### 🔌 Smart Port Allocation
+
+Run multiple instances without port conflicts:
+
+```typescript
+// Each instance automatically finds a free port
+const instance1 = await SmartPdf.create(); // Port: 20000
+const instance2 = await SmartPdf.create(); // Port: 20001
+const instance3 = await SmartPdf.create(); // Port: 20002
+
+// Or specify custom settings
+const customInstance = await SmartPdf.create({
+  port: 3000,              // Use specific port
+  portRangeStart: 4000,    // Or define a range
+  portRangeEnd: 5000
+});
+```
+
+## 🎨 PDF Generation
+
+### 📝 From HTML String
+
+Create beautiful PDFs from HTML with full CSS support:
+
+```typescript
+const smartPdf = await SmartPdf.create();
+await smartPdf.start();
+
+const pdf = await smartPdf.getA4PdfResultForHtmlString(`
+  <!DOCTYPE html>
+  <html>
+    <head>
+      <style>
+        @import url('https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap');
+        
+        body {
+          font-family: 'Roboto', sans-serif;
+          margin: 40px;
+          color: #333;
+        }
+        
+        .header {
+          background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+          color: white;
+          padding: 30px;
+          border-radius: 10px;
+          text-align: center;
+        }
+        
+        .content {
+          margin-top: 30px;
+          line-height: 1.6;
+        }
+        
+        .highlight {
+          background-color: #ffd93d;
+          padding: 2px 6px;
+          border-radius: 3px;
+        }
+      </style>
+    </head>
+    <body>
+      <div class="header">
+        <h1>Invoice #2024-001</h1>
+        <p>Generated on ${new Date().toLocaleDateString()}</p>
+      </div>
+      <div class="content">
+        <h2>Bill To:</h2>
+        <p>Acme Corporation</p>
+        <p>Total: <span class="highlight">$1,234.56</span></p>
+      </div>
+    </body>
+  </html>
+`);
+
+await fs.writeFile('invoice.pdf', pdf.buffer);
+await smartPdf.stop();
+```
+
+### 🌐 From Website
+
+Capture any website as a PDF with two powerful methods:
+
+#### Standard A4 Format
+Perfect for articles and documents:
+
+```typescript
+const pdf = await smartPdf.getPdfResultForWebsite('https://example.com');
+```
+
+#### Full Page Capture
+Capture the entire scrollable area:
+
+```typescript
+const fullPagePdf = await smartPdf.getFullWebsiteAsSinglePdf('https://example.com');
+```
+
+### 🔀 Merge Multiple PDFs
+
+Combine PDFs like a pro:
+
+```typescript
+// Load your PDFs
+const invoice = await smartPdf.readFileToPdfObject('./invoice.pdf');
+const terms = await smartPdf.readFileToPdfObject('./terms.pdf');
+const contract = await smartPdf.getA4PdfResultForHtmlString('<h1>Contract</h1>...');
+
+// Merge them in order
+const mergedPdf = await smartPdf.mergePdfs([
+  contract.buffer,
+  invoice.buffer,
+  terms.buffer
+]);
+
+await fs.writeFile('complete-document.pdf', mergedPdf);
+```
+
+## 🖼️ Image Generation
+
+### 🎨 Convert PDF to Images
+
+SmartPDF supports three image formats, each with its own strengths:
+
+#### PNG - Crystal Clear Quality
+
+```typescript
+const pngImages = await smartPdf.convertPDFToPngBytes(pdf.buffer, {
+  scale: SmartPdf.SCALE_HIGH  // 216 DPI - perfect for most uses
+});
+
+// Save each page
+pngImages.forEach((png, index) => {
+  fs.writeFileSync(`page-${index + 1}.png`, png);
+});
+```
+
+#### WebP - Modern & Efficient
+
+```typescript
+const webpImages = await smartPdf.convertPDFToWebpBytes(pdf.buffer, {
+  quality: 90,  // 0-100 quality scale
+  scale: 2.0    // 144 DPI - great for web
+});
+```
+
+#### JPEG - Progressive Loading
+
+```typescript
+const jpegImages = await smartPdf.convertPDFToJpegBytes(pdf.buffer, {
+  quality: 85,              // Balance between size and quality
+  scale: SmartPdf.SCALE_SCREEN,  // 144 DPI
+  maxWidth: 1920            // Constrain dimensions
+});
+```
+
+### 📏 DPI & Scale Guide
+
+SmartPDF makes it easy to get the right resolution:
+
+```typescript
+// Built-in scale constants
+SmartPdf.SCALE_SCREEN  // 2.0 = ~144 DPI (web display)
+SmartPdf.SCALE_HIGH    // 3.0 = ~216 DPI (high quality, default)
+SmartPdf.SCALE_PRINT   // 6.0 = ~432 DPI (print quality)
+
+// Or calculate your own
+const scale = SmartPdf.getScaleForDPI(300); // Get scale for 300 DPI
+```
+
+### 🖼️ Thumbnail Generation
+
+Create perfect thumbnails for document previews:
+
+```typescript
+const thumbnails = await smartPdf.convertPDFToWebpBytes(pdf.buffer, {
+  scale: 0.5,      // Small but readable
+  quality: 70,     // Lower quality for tiny files
+  maxWidth: 200,   // Constrain to thumbnail size
+  maxHeight: 200
+});
+```
+
+## 📊 Format Comparison
+
+Choose the right format for your needs:
+
+| Format | File Size | Best For | Special Features |
+|--------|-----------|----------|------------------|
+| **PNG** | Largest | Screenshots, diagrams, text | Lossless, transparency |
+| **JPEG** | 30-50% of PNG | Photos, complex images | Progressive loading |
+| **WebP** | 25-40% of PNG | Modern web apps | Best compression |
+
+## 🛡️ Best Practices
+
+### 1. Always Use Try-Finally
+
+```typescript
+let smartPdf: SmartPdf;
+
+try {
+  smartPdf = await SmartPdf.create();
+  await smartPdf.start();
+  
+  // Your PDF operations
+  
+} finally {
+  if (smartPdf) {
+    await smartPdf.stop(); // Always cleanup!
+  }
+}
+```
+
+### 2. Optimize HTML for PDFs
+
+```typescript
+const optimizedHtml = `
+  <style>
+    /* Use print-friendly styles */
+    @media print {
+      .no-print { display: none; }
+    }
+    
+    /* Avoid page breaks in wrong places */
+    h1, h2, h3 { page-break-after: avoid; }
+    table { page-break-inside: avoid; }
+  </style>
+  ${yourContent}
+`;
+```
+
+### 3. Handle Large Documents
+
+For documents with many pages:
+
+```typescript
+// Process in batches
+const pages = await smartPdf.convertPDFToPngBytes(largePdf.buffer);
+
+for (let i = 0; i < pages.length; i += 10) {
+  const batch = pages.slice(i, i + 10);
+  await processBatch(batch);
+}
+```
+
+## 🎯 Advanced Usage
+
+### 🌐 Custom Browser Instance
+
+Bring your own Puppeteer instance:
+
+```typescript
+import puppeteer from 'puppeteer';
+
+const browser = await puppeteer.launch({
+  headless: 'new',
+  args: ['--no-sandbox', '--disable-dev-shm-usage']
+});
+
+const smartPdf = await SmartPdf.create();
+await smartPdf.start(browser);
+
+// SmartPdf won't close your browser
+await smartPdf.stop();
+await browser.close(); // You manage it
+```
+
+### ⚡ Parallel Processing
+
+Process multiple PDFs concurrently:
+
+```typescript
+const urls = ['https://example1.com', 'https://example2.com', 'https://example3.com'];
+
+const pdfs = await Promise.all(
+  urls.map(url => smartPdf.getFullWebsiteAsSinglePdf(url))
+);
+
+// Or with multiple instances for maximum performance
+const instances = await Promise.all(
+  Array(3).fill(null).map(() => SmartPdf.create())
+);
+
+await Promise.all(instances.map(i => i.start()));
+
+// Process in parallel across instances
+const results = await Promise.all(
+  urls.map((url, i) => instances[i % instances.length].getFullWebsiteAsSinglePdf(url))
+);
+
+// Cleanup all instances
+await Promise.all(instances.map(i => i.stop()));
+```
+
+## 📝 API Reference
+
+### Class: SmartPdf
+
+#### Static Methods
+- `create(options?: ISmartPdfOptions)` - Create a new SmartPdf instance
+- `getScaleForDPI(dpi: number)` - Calculate scale factor for desired DPI
+
+#### Instance Methods
+- `start(browser?: Browser)` - Start the PDF server
+- `stop()` - Stop the PDF server
+- `getA4PdfResultForHtmlString(html: string)` - Generate A4 PDF from HTML
+- `getPdfResultForWebsite(url: string)` - Generate A4 PDF from website
+- `getFullWebsiteAsSinglePdf(url: string)` - Capture full webpage as PDF
+- `mergePdfs(buffers: Uint8Array[])` - Merge multiple PDFs
+- `readFileToPdfObject(path: string)` - Read PDF file from disk
+- `extractTextFromPdfBuffer(buffer: Buffer)` - Extract text from PDF
+- `convertPDFToPngBytes(buffer: Uint8Array, options?)` - Convert to PNG
+- `convertPDFToWebpBytes(buffer: Uint8Array, options?)` - Convert to WebP
+- `convertPDFToJpegBytes(buffer: Uint8Array, options?)` - Convert to JPEG
+
+### Interface: IPdf
+
+```typescript
+interface IPdf {
+  name: string;              // Filename
+  buffer: Buffer;            // PDF content
+  id: string | null;         // Unique identifier
+  metadata?: {
+    textExtraction?: string; // Extracted text
+  };
+}
+```
+
+## 🤝 Contributing
+
+We love contributions! Please feel free to submit a Pull Request.
+
+## License and Legal Information
+
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+
+### Company Information
+
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
--- a/test/test.port.ts
+++ b/test/test.port.ts
@@ -0,0 +1,97 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as smartpdf from '../ts/index.js';
+
+tap.test('should create multiple SmartPdf instances with automatic port allocation', async () => {
+  const instance1 = new smartpdf.SmartPdf();
+  const instance2 = new smartpdf.SmartPdf();
+  const instance3 = new smartpdf.SmartPdf();
+
+  // Start all instances
+  await instance1.start();
+  await instance2.start();
+  await instance3.start();
+
+  // Verify all instances have different ports
+  expect(instance1.serverPort).toBeGreaterThanOrEqual(20000);
+  expect(instance1.serverPort).toBeLessThanOrEqual(30000);
+  expect(instance2.serverPort).toBeGreaterThanOrEqual(20000);
+  expect(instance2.serverPort).toBeLessThanOrEqual(30000);
+  expect(instance3.serverPort).toBeGreaterThanOrEqual(20000);
+  expect(instance3.serverPort).toBeLessThanOrEqual(30000);
+
+  // Ensure all ports are different
+  expect(instance1.serverPort).not.toEqual(instance2.serverPort);
+  expect(instance1.serverPort).not.toEqual(instance3.serverPort);
+  expect(instance2.serverPort).not.toEqual(instance3.serverPort);
+
+  console.log(`Instance 1 port: ${instance1.serverPort}`);
+  console.log(`Instance 2 port: ${instance2.serverPort}`);
+  console.log(`Instance 3 port: ${instance3.serverPort}`);
+
+  // Test that all instances work correctly
+  const pdf1 = await instance1.getA4PdfResultForHtmlString('<h1>Instance 1</h1>');
+  const pdf2 = await instance2.getA4PdfResultForHtmlString('<h1>Instance 2</h1>');
+  const pdf3 = await instance3.getA4PdfResultForHtmlString('<h1>Instance 3</h1>');
+
+  expect(pdf1.buffer).toBeInstanceOf(Buffer);
+  expect(pdf2.buffer).toBeInstanceOf(Buffer);
+  expect(pdf3.buffer).toBeInstanceOf(Buffer);
+
+  // Clean up
+  await instance1.stop();
+  await instance2.stop();
+  await instance3.stop();
+});
+
+tap.test('should create SmartPdf instance with custom port range', async () => {
+  const customInstance = new smartpdf.SmartPdf({
+    portRangeStart: 25000,
+    portRangeEnd: 26000
+  });
+
+  await customInstance.start();
+
+  expect(customInstance.serverPort).toBeGreaterThanOrEqual(25000);
+  expect(customInstance.serverPort).toBeLessThanOrEqual(26000);
+
+  console.log(`Custom range instance port: ${customInstance.serverPort}`);
+
+  await customInstance.stop();
+});
+
+tap.test('should create SmartPdf instance with specific port', async () => {
+  const specificPortInstance = new smartpdf.SmartPdf({
+    port: 28888
+  });
+
+  await specificPortInstance.start();
+
+  expect(specificPortInstance.serverPort).toEqual(28888);
+
+  console.log(`Specific port instance: ${specificPortInstance.serverPort}`);
+
+  await specificPortInstance.stop();
+});
+
+tap.test('should throw error when specific port is already in use', async () => {
+  const instance1 = new smartpdf.SmartPdf({ port: 29999 });
+  await instance1.start();
+
+  const instance2 = new smartpdf.SmartPdf({ port: 29999 });
+  
+  let errorThrown = false;
+  try {
+    await instance2.start();
+  } catch (error) {
+    errorThrown = true;
+    expect(error.message).toInclude('already in use');
+  }
+
+  expect(errorThrown).toBeTrue();
+
+  await instance1.stop();
+});
+
+
+
+export default tap.start();
--- a/test/test.ts
+++ b/test/test.ts
@@ -1,27 +1,288 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import * as smartpdf from '../ts/index';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as smartpdf from '../ts/index.js';
+import * as fs from 'fs';
+import * as path from 'path';

 let testSmartPdf: smartpdf.SmartPdf;

-tap.test('should create a valid instance of smartpdf', async () => {
+/**
+ * Ensures that a directory exists.
+ * @param dirPath - The directory path to ensure.
+ */
+function ensureDir(dirPath: string): void {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+// Clean test results directory at start
+const testResultsDir = path.join('.nogit', 'testresults');
+if (fs.existsSync(testResultsDir)) {
+  fs.rmSync(testResultsDir, { recursive: true, force: true });
+}
+ensureDir(testResultsDir);
+
+tap.test('should create a valid instance of SmartPdf', async () => {
  testSmartPdf = new smartpdf.SmartPdf();
-  expect(testSmartPdf).to.be.instanceof(smartpdf.SmartPdf);
+  expect(testSmartPdf).toBeInstanceOf(smartpdf.SmartPdf);
 });

-tap.test('should create a pdf from html string', async () => {
-  await testSmartPdf.getPdfForHtmlString('hi');
+tap.test('should start the SmartPdf instance', async () => {
+  await testSmartPdf.start();
 });

-tap.test('should create a pdf from website as A4', async () => {
-  await testSmartPdf.getPdfForWebsite('https://maintainedby.lossless.com');
+tap.test('should create PDFs from HTML string', async () => {
+  const pdf1 = await testSmartPdf.getA4PdfResultForHtmlString('hi');
+  const pdf2 = await testSmartPdf.getA4PdfResultForHtmlString('hello');
+  expect(pdf1.buffer).toBeInstanceOf(Buffer);
+  expect(pdf2.buffer).toBeInstanceOf(Buffer);
 });

-tap.test('should create a pdf from website as single page PDF', async () => {
-  await testSmartPdf.getFullWebsiteAsSinglePdf('https://maintainedby.lossless.com');
+tap.test('should create PDFs from websites', async () => {
+  const pdfA4 = await testSmartPdf.getPdfResultForWebsite('https://www.wikipedia.org');
+  const pdfSingle = await testSmartPdf.getFullWebsiteAsSinglePdf('https://www.wikipedia.org');
+  expect(pdfA4.buffer).toBeInstanceOf(Buffer);
+  expect(pdfSingle.buffer).toBeInstanceOf(Buffer);
 });

-tap.test('should be able to close properly', async () => {
-  await testSmartPdf.close();
+tap.test('should create valid PDF results and write them to disk', async () => {
+  const writePdfToDisk = async (urlArg: string, fileName: string) => {
+    const pdfResult = await testSmartPdf.getFullWebsiteAsSinglePdf(urlArg);
+    expect(pdfResult.buffer).toBeInstanceOf(Buffer);
+    ensureDir('.nogit');
+    fs.writeFileSync(path.join('.nogit', fileName), pdfResult.buffer as Buffer);
+  };
+  await writePdfToDisk('https://lossless.com/', '1.pdf');
+  await writePdfToDisk('https://layer.io', '2.pdf');
 });

-tap.start();
+tap.test('should merge PDFs into a combined PDF', async () => {
+  const pdf1 = await testSmartPdf.readFileToPdfObject('.nogit/1.pdf');
+  const pdf2 = await testSmartPdf.readFileToPdfObject('.nogit/2.pdf');
+  const mergedBuffer = await testSmartPdf.mergePdfs([pdf1.buffer, pdf2.buffer]);
+  ensureDir('.nogit');
+  fs.writeFileSync(path.join('.nogit', 'combined.pdf'), mergedBuffer);
+});
+
+tap.test('should create PNG images from combined PDF using Puppeteer conversion', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/combined.pdf');
+  const images = await testSmartPdf.convertPDFToPngBytes(pdfObject.buffer);
+  expect(images.length).toBeGreaterThan(0);
+  console.log('Puppeteer-based conversion image sizes:', images.map(img => img.length));
+});
+
+tap.test('should store PNG results from both conversion functions in .nogit/testresults', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/combined.pdf');
+
+  // Convert using Puppeteer-based function and store images
+  const imagesPuppeteer = await testSmartPdf.convertPDFToPngBytes(pdfObject.buffer);
+  imagesPuppeteer.forEach((img, index) => {
+    const filePath = path.join(testResultsDir, `png_combined_page${index + 1}.png`);
+    fs.writeFileSync(filePath, Buffer.from(img));
+  });
+});
+
+tap.test('should create WebP preview images from PDF', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/3.pdf');
+  const webpPreviews = await testSmartPdf.convertPDFToWebpBytes(pdfObject.buffer);
+  expect(webpPreviews.length).toBeGreaterThan(0);
+  console.log('WebP preview sizes:', webpPreviews.map(img => img.length));
+  
+  // Also create PNG previews for comparison
+  const pngPreviews = await testSmartPdf.convertPDFToPngBytes(pdfObject.buffer);
+  console.log('PNG preview sizes:', pngPreviews.map(img => img.length));
+  
+  // Save the first page as both WebP and PNG preview
+  fs.writeFileSync(path.join(testResultsDir, 'webp_default_page1.webp'), Buffer.from(webpPreviews[0]));
+  fs.writeFileSync(path.join(testResultsDir, 'png_default_page1.png'), Buffer.from(pngPreviews[0]));
+});
+
+tap.test('should create WebP previews with custom scale and quality', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/3.pdf');
+  
+  // Create smaller previews with lower quality for thumbnails
+  const thumbnails = await testSmartPdf.convertPDFToWebpBytes(pdfObject.buffer, {
+    scale: 0.5,  // Create readable thumbnails at ~36 DPI
+    quality: 70
+  });
+  
+  expect(thumbnails.length).toBeGreaterThan(0);
+  console.log('Thumbnail sizes:', thumbnails.map(img => img.length));
+  
+  // Save thumbnails
+  thumbnails.forEach((thumb, index) => {
+    fs.writeFileSync(path.join(testResultsDir, `webp_thumbnail_page${index + 1}.webp`), Buffer.from(thumb));
+  });
+});
+
+tap.test('should create WebP previews with max dimensions', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/3.pdf');
+  
+  // Create previews with maximum dimensions (will use high scale but constrain to max size)
+  const constrainedPreviews = await testSmartPdf.convertPDFToWebpBytes(pdfObject.buffer, {
+    scale: smartpdf.SmartPdf.SCALE_HIGH,  // Start with high quality
+    quality: 90,
+    maxWidth: 800,
+    maxHeight: 1000
+  });
+  
+  expect(constrainedPreviews.length).toBeGreaterThan(0);
+  console.log('Constrained preview sizes:', constrainedPreviews.map(img => img.length));
+  
+  // Save constrained preview
+  fs.writeFileSync(path.join(testResultsDir, 'webp_constrained_page1.webp'), Buffer.from(constrainedPreviews[0]));
+});
+
+tap.test('should verify WebP files are smaller than PNG', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/3.pdf');
+  
+  // Generate both PNG and WebP versions at the same scale for fair comparison
+  const comparisonScale = smartpdf.SmartPdf.SCALE_HIGH; // Both use 3.0 scale
+  
+  const pngImages = await testSmartPdf.convertPDFToPngBytes(pdfObject.buffer, {
+    scale: comparisonScale
+  });
+  const webpImages = await testSmartPdf.convertPDFToWebpBytes(pdfObject.buffer, {
+    scale: comparisonScale,
+    quality: 85
+  });
+  
+  expect(pngImages.length).toEqual(webpImages.length);
+  
+  // Compare sizes
+  let totalPngSize = 0;
+  let totalWebpSize = 0;
+  
+  pngImages.forEach((png, index) => {
+    const pngSize = png.length;
+    const webpSize = webpImages[index].length;
+    totalPngSize += pngSize;
+    totalWebpSize += webpSize;
+    
+    const reduction = ((pngSize - webpSize) / pngSize * 100).toFixed(1);
+    console.log(`Page ${index + 1}: PNG=${pngSize} bytes, WebP=${webpSize} bytes, Reduction=${reduction}%`);
+    
+    // Save comparison files
+    fs.writeFileSync(path.join(testResultsDir, `comparison_png_page${index + 1}.png`), Buffer.from(png));
+    fs.writeFileSync(path.join(testResultsDir, `comparison_webp_page${index + 1}.webp`), Buffer.from(webpImages[index]));
+  });
+  
+  const totalReduction = ((totalPngSize - totalWebpSize) / totalPngSize * 100).toFixed(1);
+  console.log(`Total size reduction: ${totalReduction}% (PNG: ${totalPngSize} bytes, WebP: ${totalWebpSize} bytes)`);
+  
+  // WebP should be smaller
+  expect(totalWebpSize).toBeLessThan(totalPngSize);
+});
+
+tap.test('should create JPEG images from PDF', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/3.pdf');
+  const jpegImages = await testSmartPdf.convertPDFToJpegBytes(pdfObject.buffer);
+  expect(jpegImages.length).toBeGreaterThan(0);
+  console.log('JPEG image sizes:', jpegImages.map(img => img.length));
+  
+  // Save the first page as JPEG
+  fs.writeFileSync(path.join(testResultsDir, 'jpeg_default_page1.jpg'), Buffer.from(jpegImages[0]));
+});
+
+tap.test('should create JPEG images with different quality levels', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/3.pdf');
+  
+  // Test different quality levels
+  const qualityLevels = [50, 70, 85, 95];
+  
+  for (const quality of qualityLevels) {
+    const jpegImages = await testSmartPdf.convertPDFToJpegBytes(pdfObject.buffer, {
+      scale: smartpdf.SmartPdf.SCALE_HIGH,
+      quality: quality
+    });
+    
+    console.log(`JPEG quality ${quality}: ${jpegImages[0].length} bytes`);
+    
+    // Save first page at each quality level
+    fs.writeFileSync(
+      path.join(testResultsDir, `jpeg_quality_${quality}_page1.jpg`), 
+      Buffer.from(jpegImages[0])
+    );
+  }
+});
+
+tap.test('should create JPEG images with max dimensions', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/3.pdf');
+  
+  // Create constrained JPEG images
+  const constrainedJpegs = await testSmartPdf.convertPDFToJpegBytes(pdfObject.buffer, {
+    scale: smartpdf.SmartPdf.SCALE_HIGH,
+    quality: 85,
+    maxWidth: 1200,
+    maxHeight: 1200
+  });
+  
+  expect(constrainedJpegs.length).toBeGreaterThan(0);
+  console.log('Constrained JPEG sizes:', constrainedJpegs.map(img => img.length));
+  
+  // Save constrained JPEG
+  fs.writeFileSync(path.join(testResultsDir, 'jpeg_constrained_page1.jpg'), Buffer.from(constrainedJpegs[0]));
+});
+
+tap.test('should compare file sizes between PNG, WebP, and JPEG', async () => {
+  const pdfObject = await testSmartPdf.readFileToPdfObject('.nogit/3.pdf');
+  
+  // Generate all three formats at the same scale
+  const comparisonScale = smartpdf.SmartPdf.SCALE_HIGH; // 3.0 scale
+  
+  const pngImages = await testSmartPdf.convertPDFToPngBytes(pdfObject.buffer, {
+    scale: comparisonScale
+  });
+  const webpImages = await testSmartPdf.convertPDFToWebpBytes(pdfObject.buffer, {
+    scale: comparisonScale,
+    quality: 85
+  });
+  const jpegImages = await testSmartPdf.convertPDFToJpegBytes(pdfObject.buffer, {
+    scale: comparisonScale,
+    quality: 85
+  });
+  
+  expect(pngImages.length).toEqual(webpImages.length);
+  expect(pngImages.length).toEqual(jpegImages.length);
+  
+  // Compare sizes
+  let totalPngSize = 0;
+  let totalWebpSize = 0;
+  let totalJpegSize = 0;
+  
+  pngImages.forEach((png, index) => {
+    const pngSize = png.length;
+    const webpSize = webpImages[index].length;
+    const jpegSize = jpegImages[index].length;
+    
+    totalPngSize += pngSize;
+    totalWebpSize += webpSize;
+    totalJpegSize += jpegSize;
+    
+    const webpReduction = ((pngSize - webpSize) / pngSize * 100).toFixed(1);
+    const jpegReduction = ((pngSize - jpegSize) / pngSize * 100).toFixed(1);
+    
+    console.log(`Page ${index + 1}:`);
+    console.log(`  PNG: ${pngSize} bytes`);
+    console.log(`  WebP: ${webpSize} bytes (${webpReduction}% smaller than PNG)`);
+    console.log(`  JPEG: ${jpegSize} bytes (${jpegReduction}% smaller than PNG)`);
+  });
+  
+  const totalWebpReduction = ((totalPngSize - totalWebpSize) / totalPngSize * 100).toFixed(1);
+  const totalJpegReduction = ((totalPngSize - totalJpegSize) / totalPngSize * 100).toFixed(1);
+  
+  console.log('\nTotal size comparison:');
+  console.log(`PNG: ${totalPngSize} bytes`);
+  console.log(`WebP: ${totalWebpSize} bytes (${totalWebpReduction}% reduction)`);
+  console.log(`JPEG: ${totalJpegSize} bytes (${totalJpegReduction}% reduction)`);
+  
+  // JPEG and WebP should both be smaller than PNG
+  expect(totalJpegSize).toBeLessThan(totalPngSize);
+  expect(totalWebpSize).toBeLessThan(totalPngSize);
+});
+
+tap.test('should close the SmartPdf instance properly', async () => {
+  await testSmartPdf.stop();
+});
+
+tap.start();
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartpdf',
+  version: '3.2.2',
+  description: 'A library for creating PDFs dynamically from HTML or websites with additional features like merging PDFs.'
+}
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -6,4 +6,10 @@ declare global {
 }

 // normal
-export * from './smartpdf.classes.smartpdf';
+export * from './smartpdf.classes.smartpdf.js';
+
+// additional types
+import type * as tsclassTypes from '@tsclass/tsclass';
+type IPdf = tsclassTypes.business.IPdf;
+
+export type { IPdf };
--- a/ts/smartpdf.classes.pdfcandidate.ts
+++ b/ts/smartpdf.classes.pdfcandidate.ts
@@ -1,8 +1,15 @@
-import * as plugins from './smartpdf.plugins';
+/*
+ * pdf candidate is a construct used internally for mapping html
+ * to pdf buffers delivered by puppeteer
+ */
+import * as plugins from './smartpdf.plugins.js';

 export class PdfCandidate {
-  pdfId = plugins.smartunique.shortId();
-  doneDeferred = plugins.smartpromise.defer();
+  public htmlString: string;
+  public pdfId = plugins.smartunique.shortId();
+  public doneDeferred = plugins.smartpromise.defer();

-  constructor(public htmlString) {}
+  constructor(htmlStringArg: string) {
+    this.htmlString = htmlStringArg;
+  }
 }
--- a/ts/smartpdf.classes.smartpdf.ts
+++ b/ts/smartpdf.classes.smartpdf.ts
@@ -1,60 +1,149 @@
-import * as plugins from './smartpdf.plugins';
-import * as paths from './smartpdf.paths';
+import * as plugins from './smartpdf.plugins.js';
+import * as paths from './smartpdf.paths.js';
 import { Server } from 'http';
-import { PdfCandidate } from './smartpdf.classes.pdfcandidate';
+import { PdfCandidate } from './smartpdf.classes.pdfcandidate.js';
+import { type IPdf } from '@tsclass/tsclass/dist_ts/business/pdf.js';
+import { execFile } from 'child_process';

-declare const document;
+declare const document: any;
+
+export interface ISmartPdfOptions {
+  port?: number;
+  portRangeStart?: number;
+  portRangeEnd?: number;
+}

 export class SmartPdf {
+  // STATIC SCALE CONSTANTS
+  public static readonly SCALE_SCREEN = 2.0;    // ~144 DPI - Good for screen display
+  public static readonly SCALE_HIGH = 3.0;       // ~216 DPI - High quality (default)
+  public static readonly SCALE_PRINT = 6.0;      // ~432 DPI - Print quality
+  
+  /**
+   * Calculate scale factor for desired DPI
+   * PDF.js default is 72 DPI, so scale = desiredDPI / 72
+   */
+  public static getScaleForDPI(dpi: number): number {
+    return dpi / 72;
+  }
+  
+  // STATIC
+  public static async create(optionsArg?: ISmartPdfOptions) {
+    const smartpdfInstance = new SmartPdf(optionsArg);
+    return smartpdfInstance;
+  }
+
+  // INSTANCE
  htmlServerInstance: Server;
  serverPort: number;
-  headlessBrowser: plugins.puppeteer.Browser;
+  headlessBrowser: plugins.smartpuppeteer.puppeteer.Browser;
+  externalBrowserBool: boolean = false;
  private _readyDeferred: plugins.smartpromise.Deferred<void>;
  private _candidates: { [key: string]: PdfCandidate } = {};
+  private _options: ISmartPdfOptions;

-  constructor() {
+  constructor(optionsArg?: ISmartPdfOptions) {
    this._readyDeferred = new plugins.smartpromise.Deferred();
-    this.init();
+    this._options = {
+      portRangeStart: 20000,
+      portRangeEnd: 30000,
+      ...optionsArg
+    };
  }

-  async init() {
+  async start(headlessBrowserArg?: plugins.smartpuppeteer.puppeteer.Browser) {
+    const done = plugins.smartpromise.defer();
+    // lets set the external browser in case one is provided
+    this.headlessBrowser = headlessBrowserArg;
    // setup puppeteer
-    this.headlessBrowser = await plugins.puppeteer.launch();
+    if (this.headlessBrowser) {
+      this.externalBrowserBool = true;
+    } else {
+      this.headlessBrowser = await plugins.smartpuppeteer.getEnvAwareBrowserInstance({
+        forceNoSandbox: false,
+      });
+    }

-    // setup server
+    // Find an available port BEFORE creating server
+    const smartnetworkInstance = new plugins.smartnetwork.SmartNetwork();
+    
+    if (this._options.port) {
+      // If a specific port is requested, check if it's available
+      const isPortAvailable = await smartnetworkInstance.isLocalPortUnused(this._options.port);
+      if (isPortAvailable) {
+        this.serverPort = this._options.port;
+      } else {
+        // Clean up browser if we created one
+        if (!this.externalBrowserBool && this.headlessBrowser) {
+          await this.headlessBrowser.close();
+        }
+        throw new Error(`Requested port ${this._options.port} is already in use`);
+      }
+    } else {
+      // Find a free port in the specified range
+      this.serverPort = await smartnetworkInstance.findFreePort(
+        this._options.portRangeStart,
+        this._options.portRangeEnd
+      );
+      if (!this.serverPort) {
+        // Clean up browser if we created one
+        if (!this.externalBrowserBool && this.headlessBrowser) {
+          await this.headlessBrowser.close();
+        }
+        throw new Error(`No free ports available in range ${this._options.portRangeStart}-${this._options.portRangeEnd}`);
+      }
+    }
+    
+    // Now setup server after we know we have a valid port
    const app = plugins.express();
    app.get('/:pdfId', (req, res) => {
-      res.setHeader('PDF-ID', this._candidates[req.params.pdfId].pdfId);
-      res.send(this._candidates[req.params.pdfId].htmlString);
+      const wantedCandidate = this._candidates[req.params.pdfId];
+      if (!wantedCandidate) {
+        console.log(`${req.url} not attached to a candidate`);
+        return;
+      }
+      res.setHeader('pdf-id', wantedCandidate.pdfId);
+      res.send(wantedCandidate.htmlString);
    });
    this.htmlServerInstance = plugins.http.createServer(app);
-    const smartnetworkInstance = new plugins.smartnetwork.SmartNetwork();
-    const portAvailable = smartnetworkInstance.isLocalPortAvailable(3210);
-    this.htmlServerInstance.listen(3210, 'localhost');
+    
+    this.htmlServerInstance.listen(this.serverPort, 'localhost');
    this.htmlServerInstance.on('listening', () => {
+      console.log(`SmartPdf server listening on port ${this.serverPort}`);
      this._readyDeferred.resolve();
+      done.resolve();
    });
+    await done.promise;
  }

-  async close() {
+  // stop
+  async stop() {
    const done = plugins.smartpromise.defer<void>();
    this.htmlServerInstance.close(() => {
      done.resolve();
    });
-    await this.headlessBrowser.close();
+
+    if (!this.externalBrowserBool) {
+      await this.headlessBrowser.close();
+    }
+
    await done.promise;
  }

  /**
-   * returns a pdf for a given html string;
+   * Returns a PDF for a given HTML string.
   */
-  async getPdfForHtmlString(htmlStringArg: string) {
+  async getA4PdfResultForHtmlString(htmlStringArg: string): Promise<plugins.tsclass.business.IPdf> {
    await this._readyDeferred.promise;
    const pdfCandidate = new PdfCandidate(htmlStringArg);
    this._candidates[pdfCandidate.pdfId] = pdfCandidate;
    const page = await this.headlessBrowser.newPage();
-    const response = await page.goto(`http://localhost:3210/${pdfCandidate.pdfId}`, {
-      waitUntil: 'networkidle2'
+    await page.setViewport({
+      width: 794,
+      height: 1122,
+    });
+    const response = await page.goto(`http://localhost:${this.serverPort}/${pdfCandidate.pdfId}`, {
+      waitUntil: 'networkidle2',
    });
    const headers = response.headers();
    if (headers['pdf-id'] !== pdfCandidate.pdfId) {
@@ -64,49 +153,437 @@ export class SmartPdf {
      console.log(`id security check passed for ${pdfCandidate.pdfId}`);
    }

-    await page.pdf({
-      path: plugins.path.join(paths.pdfDir, `${pdfCandidate.pdfId}.pdf`),
-      format: 'A4'
+    const pdfBuffer = await page.pdf({
+      width: 794,
+      height: 1122,
+      printBackground: true,
+      displayHeaderFooter: false,
    });
+    // Convert Uint8Array to Node Buffer
+    const nodePdfBuffer = Buffer.from(pdfBuffer);
    await page.close();
    delete this._candidates[pdfCandidate.pdfId];
    pdfCandidate.doneDeferred.resolve();
    await pdfCandidate.doneDeferred.promise;
+    return {
+      id: pdfCandidate.pdfId,
+      name: `${pdfCandidate.pdfId}.js`,
+      metadata: {
+        textExtraction: await this.extractTextFromPdfBuffer(nodePdfBuffer),
+      },
+      buffer: nodePdfBuffer,
+    };
  }

-  async getPdfForWebsite(websiteUrl: string) {
+  async getPdfResultForWebsite(websiteUrl: string): Promise<plugins.tsclass.business.IPdf> {
    const page = await this.headlessBrowser.newPage();
-    const response = await page.goto(websiteUrl, { waitUntil: 'networkidle2' });
-    const pdfId = plugins.smartunique.shortId();
-    await page.pdf({
-      path: plugins.path.join(paths.pdfDir, `${pdfId}.pdf`),
-      format: 'A4',
-      printBackground: true,
-      displayHeaderFooter: false,
-      preferCSSPageSize: true
+    await page.setViewport({
+      width: 1980,
+      height: 1200,
    });
-    await page.close();
-  }
-
-  async getFullWebsiteAsSinglePdf(websiteUrl: string) {
-    const page = await this.headlessBrowser.newPage();
+    await page.emulateMediaType('screen');
    const response = await page.goto(websiteUrl, { waitUntil: 'networkidle2' });
    const pdfId = plugins.smartunique.shortId();
-    const {documentHeight, documentWidth} = await page.evaluate(() => {
-      
+    const { documentHeight, documentWidth } = await page.evaluate(() => {
      return {
        documentHeight: document.height,
-        documentWidth: document.width
+        documentWidth: document.width,
      };
    });
-    await page.pdf({
-      path: plugins.path.join(paths.pdfDir, `${pdfId}.pdf`),
-      height: documentWidth,
+    const pdfBuffer = await page.pdf({
+      height: documentHeight,
      width: documentWidth,
      printBackground: true,
      displayHeaderFooter: false,
-      preferCSSPageSize: true
    });
+    // Convert Uint8Array to Node Buffer
+    const nodePdfBuffer = Buffer.from(pdfBuffer);
    await page.close();
+    return {
+      id: pdfId,
+      name: `${pdfId}.js`,
+      metadata: {
+        textExtraction: await this.extractTextFromPdfBuffer(nodePdfBuffer),
+      },
+      buffer: nodePdfBuffer,
+    };
  }
-}
+
+  async getFullWebsiteAsSinglePdf(websiteUrl: string): Promise<plugins.tsclass.business.IPdf> {
+    const page = await this.headlessBrowser.newPage();
+    await page.setViewport({
+      width: 1920,
+      height: 1200,
+    });
+    await page.emulateMediaType('screen');
+    const response = await page.goto(websiteUrl, { waitUntil: 'networkidle2' });
+    const pdfId = plugins.smartunique.shortId();
+    // Use both document.body and document.documentElement to ensure we have a valid height and width.
+    const { documentHeight, documentWidth } = await page.evaluate(() => {
+      return {
+        documentHeight: Math.max(
+          document.body.scrollHeight,
+          document.documentElement.scrollHeight
+        ) || 1200,
+        documentWidth: Math.max(
+          document.body.clientWidth,
+          document.documentElement.clientWidth
+        ) || 1920,
+      };
+    });
+    // Update viewport height to the full document height.
+    await page.setViewport({
+      width: 1920,
+      height: documentHeight,
+    });
+    const pdfBuffer = await page.pdf({
+      height: documentHeight,
+      width: 1920,
+      printBackground: true,
+      displayHeaderFooter: false,
+      scale: 1,
+      pageRanges: '1',
+    });
+    // Convert Uint8Array to Node Buffer
+    const nodePdfBuffer = Buffer.from(pdfBuffer);
+    await page.close();
+    return {
+      id: pdfId,
+      name: `${pdfId}.js`,
+      metadata: {
+        textExtraction: await this.extractTextFromPdfBuffer(nodePdfBuffer),
+      },
+      buffer: nodePdfBuffer,
+    };
+  }
+
+  public async mergePdfs(inputPdfBuffers: Uint8Array[]): Promise<Uint8Array> {
+    const mergedPdf = await plugins.pdfLib.PDFDocument.create();
+    for (const pdfBytes of inputPdfBuffers) {
+      const pdfDoc = await plugins.pdfLib.PDFDocument.load(pdfBytes);
+      const pages = await mergedPdf.copyPages(pdfDoc, pdfDoc.getPageIndices());
+      pages.forEach((page) => mergedPdf.addPage(page));
+    }
+
+    const mergedPdfBytes = await mergedPdf.save();
+    return mergedPdfBytes;
+  }
+
+  public async readFileToPdfObject(pathArg: string): Promise<plugins.tsclass.business.IPdf> {
+    const absolutePath = plugins.smartpath.transform.makeAbsolute(pathArg);
+    const parsedPath = plugins.path.parse(absolutePath);
+    const buffer = await plugins.smartfile.fs.toBuffer(absolutePath);
+    return {
+      name: parsedPath.base,
+      buffer,
+      id: null,
+      metadata: null,
+    };
+  }
+
+  public async extractTextFromPdfBuffer(pdfBufferArg: Buffer): Promise<string> {
+    const deferred = plugins.smartpromise.defer<string>();
+    const pdfParser: any = new plugins.pdf2json();
+    pdfParser.on('pdfParser_dataReady', (pdfData: any) => {
+      let finalText = '';
+      for (const page of pdfData.Pages) {
+        for (const text of page.Texts) {
+          for (const letter of text.R) {
+            finalText = finalText + letter.T;
+          }
+        }
+      }
+      deferred.resolve(finalText);
+    });
+    pdfParser.parseBuffer(pdfBufferArg);
+    return deferred.promise;
+  }
+
+  /**
+   * Checks for the presence of required dependencies: GraphicsMagick and Ghostscript.
+   */
+  private async checkDependencies(): Promise<void> {
+    await Promise.all([
+      this.checkCommandExists('gm', ['version']),
+      this.checkCommandExists('gs', ['--version']),
+    ]);
+  }
+
+  /**
+   * Checks if a given command exists by trying to execute it.
+   */
+  private checkCommandExists(command: string, args: string[]): Promise<void> {
+    return new Promise((resolve, reject) => {
+      execFile(command, args, (error, stdout, stderr) => {
+        if (error) {
+          reject(new Error(`Dependency check failed: ${command} is not installed or not in the PATH. ${error.message}`));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * Converts a PDF to PNG bytes for each page using Puppeteer and PDF.js.
+   * This method creates a temporary HTML page that loads PDF.js from a CDN,
+   * renders each PDF page to a canvas, and then screenshots each canvas element.
+   */
+  public async convertPDFToPngBytes(
+    pdfBytes: Uint8Array,
+    options: {
+      scale?: number;      // Scale factor for output size (default: 3.0 for 216 DPI)
+      maxWidth?: number;   // Maximum width in pixels (optional)
+      maxHeight?: number;  // Maximum height in pixels (optional)
+    } = {}
+  ): Promise<Uint8Array[]> {
+    // Set default scale for higher quality output (3.0 = ~216 DPI)
+    const scale = options.scale || 3.0;
+
+    // Create a new page using the headless browser.
+    const page = await this.headlessBrowser.newPage();
+
+    // Prepare PDF data as a base64 string.
+    const base64Pdf: string = Buffer.from(pdfBytes).toString('base64');
+
+    // HTML template that loads PDF.js and renders the PDF.
+    const htmlTemplate: string = `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>PDF to PNG Converter</title>
+          <style>
+            body { margin: 0; }
+            canvas { display: block; margin: 10px auto; }
+          </style>
+          <script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.16.105/pdf.min.js"></script>
+        </head>
+        <body>
+          <script>
+            (async function() {
+              pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.16.105/pdf.worker.min.js';
+              const pdfData = "__PDF_DATA__";
+              const raw = atob(pdfData);
+              const pdfArray = new Uint8Array([...raw].map(c => c.charCodeAt(0)));
+              const loadingTask = pdfjsLib.getDocument({data: pdfArray});
+              const pdf = await loadingTask.promise;
+              const numPages = pdf.numPages;
+              for (let pageNum = 1; pageNum <= numPages; pageNum++) {
+                const page = await pdf.getPage(pageNum);
+                // Apply scale factor to viewport
+                const viewport = page.getViewport({ scale: ${scale} });
+                
+                // Apply max width/height constraints if specified
+                let finalScale = ${scale};
+                ${options.maxWidth ? `
+                if (viewport.width > ${options.maxWidth}) {
+                  finalScale = ${options.maxWidth} / (viewport.width / ${scale});
+                }` : ''}
+                ${options.maxHeight ? `
+                if (viewport.height > ${options.maxHeight}) {
+                  const heightScale = ${options.maxHeight} / (viewport.height / ${scale});
+                  finalScale = Math.min(finalScale, heightScale);
+                }` : ''}
+                
+                // Get final viewport with adjusted scale
+                const finalViewport = page.getViewport({ scale: finalScale });
+                
+                const canvas = document.createElement('canvas');
+                const context = canvas.getContext('2d');
+                canvas.width = finalViewport.width;
+                canvas.height = finalViewport.height;
+                canvas.setAttribute('data-page', pageNum);
+                
+                await page.render({ canvasContext: context, viewport: finalViewport }).promise;
+                document.body.appendChild(canvas);
+              }
+              window.renderComplete = true;
+            })();
+          </script>
+        </body>
+      </html>
+    `;
+
+    // Replace the placeholder with the actual base64 PDF data.
+    const htmlContent: string = htmlTemplate.replace("__PDF_DATA__", base64Pdf);
+
+    // Set the page content.
+    await page.setContent(htmlContent, { waitUntil: 'networkidle0' });
+
+    // Wait until the PDF.js rendering is complete.
+    await page.waitForFunction(() => (window as any).renderComplete === true, { timeout: 30000 });
+
+    // Query all canvas elements (each representing a rendered PDF page).
+    const canvasElements = await page.$$('canvas');
+    const pngBuffers: Uint8Array[] = [];
+
+    for (const canvasElement of canvasElements) {
+      // Screenshot the canvas element. The screenshot will be a PNG buffer.
+      const screenshotBuffer = (await canvasElement.screenshot({ encoding: 'binary' })) as Buffer;
+      pngBuffers.push(new Uint8Array(screenshotBuffer));
+    }
+
+    await page.close();
+    return pngBuffers;
+  }
+
+  /**
+   * Converts a PDF to WebP bytes for each page.
+   * This method creates web-optimized images using WebP format.
+   * WebP provides 25-35% better compression than JPEG/PNG while maintaining quality.
+   */
+  public async convertPDFToWebpBytes(
+    pdfBytes: Uint8Array,
+    options: {
+      scale?: number;      // Scale factor for preview size (default: 3.0 for 216 DPI)
+      quality?: number;    // WebP quality 0-100 (default: 85)
+      maxWidth?: number;   // Maximum width in pixels (optional)
+      maxHeight?: number;  // Maximum height in pixels (optional)
+    } = {}
+  ): Promise<Uint8Array[]> {
+    // Set default options for higher quality output (3.0 = ~216 DPI)
+    const scale = options.scale || 3.0;
+    const quality = options.quality || 85;
+
+    // Create a new page using the headless browser
+    const page = await this.headlessBrowser.newPage();
+
+    // Prepare PDF data as a base64 string
+    const base64Pdf: string = Buffer.from(pdfBytes).toString('base64');
+
+    // HTML template that loads PDF.js and renders the PDF with scaling
+    const htmlTemplate: string = `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>PDF to WebP Preview Converter</title>
+          <style>
+            body { margin: 0; }
+            canvas { display: block; margin: 10px auto; }
+          </style>
+          <script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.16.105/pdf.min.js"></script>
+        </head>
+        <body>
+          <script>
+            (async function() {
+              pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.16.105/pdf.worker.min.js';
+              const pdfData = "__PDF_DATA__";
+              const raw = atob(pdfData);
+              const pdfArray = new Uint8Array([...raw].map(c => c.charCodeAt(0)));
+              const loadingTask = pdfjsLib.getDocument({data: pdfArray});
+              const pdf = await loadingTask.promise;
+              const numPages = pdf.numPages;
+              
+              for (let pageNum = 1; pageNum <= numPages; pageNum++) {
+                const page = await pdf.getPage(pageNum);
+                // Apply scale factor to viewport
+                const viewport = page.getViewport({ scale: ${scale} });
+                
+                // Apply max width/height constraints if specified
+                let finalScale = ${scale};
+                ${options.maxWidth ? `
+                if (viewport.width > ${options.maxWidth}) {
+                  finalScale = ${options.maxWidth} / (viewport.width / ${scale});
+                }` : ''}
+                ${options.maxHeight ? `
+                if (viewport.height > ${options.maxHeight}) {
+                  const heightScale = ${options.maxHeight} / (viewport.height / ${scale});
+                  finalScale = Math.min(finalScale, heightScale);
+                }` : ''}
+                
+                // Get final viewport with adjusted scale
+                const finalViewport = page.getViewport({ scale: finalScale });
+                
+                const canvas = document.createElement('canvas');
+                const context = canvas.getContext('2d');
+                canvas.width = finalViewport.width;
+                canvas.height = finalViewport.height;
+                canvas.setAttribute('data-page', pageNum);
+                
+                await page.render({ canvasContext: context, viewport: finalViewport }).promise;
+                document.body.appendChild(canvas);
+              }
+              window.renderComplete = true;
+            })();
+          </script>
+        </body>
+      </html>
+    `;
+
+    // Replace the placeholder with the actual base64 PDF data
+    const htmlContent: string = htmlTemplate.replace("__PDF_DATA__", base64Pdf);
+
+    // Set the page content
+    await page.setContent(htmlContent, { waitUntil: 'networkidle0' });
+
+    // Wait until the PDF.js rendering is complete
+    await page.waitForFunction(() => (window as any).renderComplete === true, { timeout: 30000 });
+
+    // Query all canvas elements (each representing a rendered PDF page)
+    const canvasElements = await page.$$('canvas');
+    const webpBuffers: Uint8Array[] = [];
+
+    for (const canvasElement of canvasElements) {
+      // Screenshot the canvas element as WebP
+      const screenshotBuffer = (await canvasElement.screenshot({ 
+        type: 'webp',
+        quality: quality,
+        encoding: 'binary' 
+      })) as Buffer;
+      webpBuffers.push(new Uint8Array(screenshotBuffer));
+    }
+
+    await page.close();
+    return webpBuffers;
+  }
+
+  /**
+   * Converts a PDF to progressive JPEG bytes for each page.
+   * This method creates progressive JPEG images that load in multiple passes,
+   * showing a low-quality preview first, then progressively improving.
+   * Uses SmartJimp for true progressive JPEG encoding.
+   */
+  public async convertPDFToJpegBytes(
+    pdfBytes: Uint8Array,
+    options: {
+      scale?: number;      // Scale factor for output size (default: 3.0 for 216 DPI)
+      quality?: number;    // JPEG quality 0-100 (default: 85)
+      maxWidth?: number;   // Maximum width in pixels (optional)
+      maxHeight?: number;  // Maximum height in pixels (optional)
+    } = {}
+  ): Promise<Uint8Array[]> {
+    // First, convert PDF to PNG using our existing method
+    const pngBuffers = await this.convertPDFToPngBytes(pdfBytes, {
+      scale: options.scale,
+      maxWidth: options.maxWidth,
+      maxHeight: options.maxHeight
+    });
+
+    // Initialize SmartJimp in sharp mode for progressive JPEG support
+    const smartJimpInstance = new plugins.smartjimp.SmartJimp({ mode: 'sharp' });
+    
+    // Convert each PNG to progressive JPEG
+    const jpegBuffers: Uint8Array[] = [];
+    const quality = options.quality || 85;
+    
+    for (const pngBuffer of pngBuffers) {
+      // Convert PNG buffer to progressive JPEG
+      const jpegBuffer = await smartJimpInstance.computeAssetVariation(
+        Buffer.from(pngBuffer),
+        {
+          format: 'jpeg',
+          progressive: true,
+          // SmartJimp uses a different quality scale, need to check if adjustment is needed
+          // For now, pass through the quality value
+          quality
+        }
+      );
+      
+      jpegBuffers.push(new Uint8Array(jpegBuffer));
+    }
+    
+    return jpegBuffers;
+  }
+}
--- a/ts/smartpdf.paths.ts
+++ b/ts/smartpdf.paths.ts
@@ -1,6 +1,6 @@
-import * as plugins from './smartpdf.plugins';
+import * as plugins from './smartpdf.plugins.js';

-export const packageDir = plugins.path.join(__dirname, '../');
-export const pdfDir = plugins.path.join(packageDir, 'assets/pdfdir');
-
-plugins.smartfile.fs.ensureDirSync(pdfDir);
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);
--- a/ts/smartpdf.plugins.ts
+++ b/ts/smartpdf.plugins.ts
@@ -5,15 +5,36 @@ import * as path from 'path';
 export { http, path };

 // @pushrocks
-import * as smartfile from '@pushrocks/smartfile';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartnetwork from '@pushrocks/smartnetwork';
-import * as smartunique from '@pushrocks/smartunique';
+import * as smartbuffer from '@push.rocks/smartbuffer';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpuppeteer from '@push.rocks/smartpuppeteer';
+import * as smartnetwork from '@push.rocks/smartnetwork';
+import * as smartunique from '@push.rocks/smartunique';
+import * as smartjimp from '@push.rocks/smartjimp';

-export { smartfile, smartpromise, smartunique, smartnetwork };
+export {
+  smartbuffer,
+  smartfile,
+  smartdelay,
+  smartpromise,
+  smartpath,
+  smartpuppeteer,
+  smartunique,
+  smartnetwork,
+  smartjimp,
+};
+
+// tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export { tsclass };

 // thirdparty
 import express from 'express';
-import puppeteer from 'puppeteer';
+import pdf2json from 'pdf2json';
+import pdfLib from 'pdf-lib';

-export { express, puppeteer };
+export { express, pdf2json, pdfLib, };
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}
--- a/tslint.json
+++ b/tslint.json
@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}
Author	SHA1	Message	Date
Juergen Kunz	be574df599	feat(image): add progressive JPEG generation support Some checks failed Default (tags) / security (push) Failing after 24s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details - Add convertPDFToJpegBytes method for progressive JPEG images - Integrate @push.rocks/smartjimp for true progressive encoding - Update readme with comprehensive documentation - Update legal section to Task Venture Capital GmbH	2025-08-02 17:29:38 +00:00
Juergen Kunz	6a4aeed3e1	BREAKING CHANGE(smartpdf): improve image generation quality and API consistency - Renamed convertPDFToWebpPreviews to convertPDFToWebpBytes for consistency - Added configurable scale options with DPI support - Changed default scale to 3.0 (216 DPI) for better quality - Added DPI helper methods and scale constants	2025-08-02 12:37:48 +00:00
Juergen Kunz	a4c3415838	feat(smartpdf): add automatic port allocation and multi-instance support	2025-08-01 16:09:17 +00:00
Philipp Kunz	f535eacd97	3.2.2	2025-02-25 18:22:06 +00:00
Philipp Kunz	9908897aa2	fix(SmartPdf): Fix buffer handling for PDF conversion and text extraction	2025-02-25 18:22:06 +00:00
Philipp Kunz	29d3cbb0b6	3.2.1	2025-02-25 18:06:45 +00:00
Philipp Kunz	babc20649a	fix(SmartPdf): Fix type for extractTextFromPdfBuffer function	2025-02-25 18:06:45 +00:00
Philipp Kunz	1188643c4b	3.2.0	2025-02-25 18:03:27 +00:00
Philipp Kunz	6b74301588	feat(smartpdf): Improve dependency versions and optimize PDF to PNG conversion.	2025-02-25 18:03:27 +00:00
Philipp Kunz	168527573c	3.1.8	2024-11-30 20:43:05 +01:00
Philipp Kunz	3d7bb37849	fix(core): Fix candidate handling in PDF generation	2024-11-30 20:43:05 +01:00
Philipp Kunz	12a581ced9	3.1.7	2024-09-27 23:21:31 +02:00
Philipp Kunz	857e1717a5	fix(dependencies): Update dependencies to latest versions	2024-09-27 23:21:30 +02:00
Philipp Kunz	186bfb9d12	update description	2024-05-29 14:15:22 +02:00
Philipp Kunz	c5bc354f65	3.1.6	2024-04-30 17:48:12 +02:00
Philipp Kunz	c48bb0428f	fix(core): update	2024-04-30 17:48:11 +02:00
Philipp Kunz	46fbb615a0	3.1.5	2024-04-27 12:07:16 +02:00
Philipp Kunz	3df4e103f9	fix(core): update	2024-04-27 12:07:16 +02:00
Philipp Kunz	addff418c6	3.1.4	2024-04-26 13:39:58 +02:00
Philipp Kunz	14d653e701	fix(core): update	2024-04-26 13:39:57 +02:00
Philipp Kunz	040bac5256	3.1.3	2024-04-26 13:29:32 +02:00
Philipp Kunz	bf44901a0a	fix(core): update	2024-04-26 13:29:32 +02:00
Philipp Kunz	b4d0f4e949	3.1.2	2024-04-26 13:28:07 +02:00
Philipp Kunz	b2b47b1f6a	fix(core): update	2024-04-26 13:28:07 +02:00
Philipp Kunz	1b1398653b	3.1.1	2024-04-26 13:27:28 +02:00
Philipp Kunz	1f61dcb115	fix(core): update	2024-04-26 13:27:27 +02:00
Philipp Kunz	1476fc9174	3.1.0	2024-04-25 18:48:08 +02:00
Philipp Kunz	d157a3acd9	feat(now supports pdf -> jpg): update	2024-04-25 18:48:08 +02:00
Philipp Kunz	fe6be928a9	update tsconfig	2024-04-14 18:07:39 +02:00
Philipp Kunz	8e537be454	update npmextra.json: githost	2024-04-01 21:37:16 +02:00
Philipp Kunz	6947529e02	update npmextra.json: githost	2024-04-01 19:59:15 +02:00
Philipp Kunz	b6d78929b9	update npmextra.json: githost	2024-03-30 21:48:15 +01:00
Philipp Kunz	e997189a64	3.0.17	2024-03-19 17:52:28 +01:00
Philipp Kunz	31940deb7a	fix(core): update	2024-03-19 17:52:27 +01:00
Philipp Kunz	922c6da234	3.0.16	2023-07-26 14:17:12 +02:00
Philipp Kunz	aa8fb165eb	fix(core): update	2023-07-26 14:17:11 +02:00
Philipp Kunz	4cd4431565	switch to new org scheme	2023-07-11 01:24:04 +02:00
Philipp Kunz	826183be8c	switch to new org scheme	2023-07-10 10:17:20 +02:00
Philipp Kunz	6d9b7ee0e4	3.0.15	2022-11-07 23:11:30 +01:00
Philipp Kunz	3c66acb653	fix(core): update	2022-11-07 23:11:29 +01:00
Philipp Kunz	aa0ad1dce5	3.0.14	2022-10-26 23:04:59 +02:00
Philipp Kunz	65756457aa	fix(core): update	2022-10-26 23:04:59 +02:00
Philipp Kunz	67f21d2500	3.0.13	2022-10-26 22:58:26 +02:00
Philipp Kunz	1cf095a5cc	fix(core): update	2022-10-26 22:58:26 +02:00
Philipp Kunz	ffeaec7fe9	3.0.12	2022-09-16 08:27:25 +02:00
Philipp Kunz	a31e196e5b	fix(core): update	2022-09-16 08:27:25 +02:00
Philipp Kunz	57851d90a5	3.0.11	2022-09-15 20:52:22 +02:00
Philipp Kunz	1e4b16b734	fix(core): update	2022-09-15 20:52:22 +02:00
Philipp Kunz	876466b18d	3.0.10	2022-09-13 18:39:38 +02:00
Philipp Kunz	82b1c187ee	fix(core): update	2022-09-13 18:39:38 +02:00
Philipp Kunz	4f93d258b8	3.0.9	2022-09-13 18:26:15 +02:00
Philipp Kunz	60993fc005	fix(core): update	2022-09-13 18:26:14 +02:00
Philipp Kunz	db4965c8f5	3.0.8	2022-09-05 01:02:05 +02:00
Philipp Kunz	36a964d931	fix(core): update	2022-09-05 01:02:05 +02:00
Philipp Kunz	6d90f4c9b4	3.0.7	2022-06-29 00:24:44 +02:00
Philipp Kunz	839eafd73f	fix(core): update	2022-06-29 00:24:43 +02:00
Philipp Kunz	f4141bf201	3.0.6	2022-06-15 22:16:44 +02:00
Philipp Kunz	5a46028053	fix(core): update	2022-06-15 22:16:44 +02:00
Philipp Kunz	18d26647e1	3.0.5	2022-06-15 22:14:55 +02:00
Philipp Kunz	0b5ec86780	fix(core): update	2022-06-15 22:14:55 +02:00
Philipp Kunz	5e15729045	3.0.4	2022-06-12 19:26:49 +02:00
Philipp Kunz	c98a5f1ac3	fix(core): update	2022-06-12 19:26:49 +02:00
Philipp Kunz	7f02146a0e	3.0.3	2022-06-12 19:26:34 +02:00
Philipp Kunz	5dab8c7351	fix(core): update	2022-06-12 19:26:34 +02:00
Philipp Kunz	505e0e9a30	3.0.2	2022-03-25 01:14:12 +01:00
Philipp Kunz	9e3510955a	fix(core): update	2022-03-25 01:14:12 +01:00
Philipp Kunz	c006d4fbc7	3.0.1	2022-03-24 23:32:28 +01:00
Philipp Kunz	5e02c44647	fix(core): update	2022-03-24 23:32:27 +01:00
Philipp Kunz	47f7cb18b5	3.0.0	2022-03-24 14:34:46 +01:00
Philipp Kunz	3faf065c66	2.0.19	2022-03-24 14:32:50 +01:00
Philipp Kunz	dfffd03790	fix(core): update	2022-03-24 14:32:49 +01:00
Philipp Kunz	796aa905d2	2.0.18	2022-01-06 13:23:05 +01:00
Philipp Kunz	253fb95143	fix(core): update	2022-01-06 13:23:04 +01:00
Philipp Kunz	f3ea075b72	2.0.17	2022-01-06 13:10:12 +01:00
Philipp Kunz	af725a7f78	fix(core): update	2022-01-06 13:10:12 +01:00
Philipp Kunz	016e0db797	2.0.16	2022-01-05 23:55:38 +01:00
Philipp Kunz	4cf8b2e1f8	fix(core): update	2022-01-05 23:55:37 +01:00
Philipp Kunz	67b0aa9d47	2.0.15	2022-01-05 17:20:28 +01:00
Philipp Kunz	567c6eafea	fix(core): update	2022-01-05 17:20:28 +01:00
Philipp Kunz	ff890fb2af	2.0.14	2022-01-05 16:32:48 +01:00
Philipp Kunz	a512fd64b5	fix(core): update	2022-01-05 16:32:47 +01:00
Philipp Kunz	377318a62a	2.0.13	2022-01-05 14:19:40 +01:00
Philipp Kunz	671c871304	fix(core): update	2022-01-05 14:19:39 +01:00
Philipp Kunz	e0cc6b5655	2.0.12	2022-01-05 14:17:43 +01:00
Philipp Kunz	e74b44b49c	fix(core): update	2022-01-05 14:17:43 +01:00
Philipp Kunz	d6f0d88d4a	2.0.11	2021-10-14 16:04:58 +02:00
Philipp Kunz	9674e5b8dc	fix(core): update	2021-10-14 16:04:58 +02:00
Philipp Kunz	ea4cf777a9	2.0.10	2021-10-14 10:59:45 +02:00
Philipp Kunz	8a308fa9e3	fix(core): update	2021-10-14 10:59:45 +02:00
Phil Kunz	56fa53b701	2.0.9	2021-04-29 15:19:15 +00:00
Phil Kunz	2a4ddd4e41	fix(core): update	2021-04-29 15:19:14 +00:00
Phil Kunz	3d8a63fddd	2.0.8	2021-04-29 09:32:13 +00:00
Phil Kunz	9d9b1d0399	fix(core): update	2021-04-29 09:32:12 +00:00
Phil Kunz	739d60d410	2.0.7	2021-04-14 11:35:06 +00:00
Phil Kunz	9003034d0d	fix(core): update	2021-04-14 11:35:05 +00:00
Phil Kunz	5002513d21	2.0.6	2021-04-14 11:34:34 +00:00
Phil Kunz	12ede2be02	fix(core): update	2021-04-14 11:34:33 +00:00
Phil Kunz	163ec2bd50	2.0.5	2021-03-06 15:33:08 +00:00
Phil Kunz	7744839613	fix(core): update	2021-03-06 15:33:07 +00:00
Phil Kunz	df803d90cb	2.0.4	2021-03-05 15:38:12 +00:00
Phil Kunz	5fc22585bf	fix(core): update	2021-03-05 15:38:11 +00:00
Phil Kunz	b8387458db	2.0.3	2021-03-05 15:16:23 +00:00
Phil Kunz	04aed2556b	fix(core): update	2021-03-05 15:16:22 +00:00
Phil Kunz	4cde3a7fe0	2.0.2	2019-11-19 16:31:34 +00:00
Phil Kunz	466d6d47ba	fix(ci): further speed up snyk step	2019-11-19 16:31:33 +00:00
Phil Kunz	fa99b7f068	2.0.1	2019-11-19 16:28:14 +00:00
Phil Kunz	3e865b6c92	fix(ci): update snyk step for faster testing	2019-11-19 16:28:13 +00:00
Phil Kunz	94dd576d3b	2.0.0	2019-11-19 15:53:14 +00:00
Phil Kunz	9c19b4a3e4	BREAKING CHANGE(API): now clearly naming PDF Results what they are.	2019-11-19 15:53:14 +00:00
Philipp Kunz	1155656c2b	1.0.29	2019-11-16 00:50:12 +01:00
Philipp Kunz	5cf23c1134	fix(core): update	2019-11-16 00:50:11 +01:00
Philipp Kunz	67e9fdd10a	1.0.28	2019-11-15 20:00:25 +01:00
Philipp Kunz	b0e388c50d	1.0.27	2019-11-15 19:59:57 +01:00
Philipp Kunz	f37c9d8375	fix(core): update	2019-11-15 19:59:57 +01:00
Phil Kunz	18c8ef9606	1.0.26	2019-11-12 15:45:26 +01:00
Phil Kunz	6766a3d0dc	fix(core): update	2019-11-12 15:45:26 +01:00
Phil Kunz	d16f447048	1.0.25	2019-11-12 15:41:58 +01:00
Phil Kunz	37c752c2ae	fix(core): update	2019-11-12 15:41:58 +01:00
Phil Kunz	b088d26e6f	1.0.24	2019-11-12 14:41:04 +01:00
Phil Kunz	425f11a334	fix(core): update	2019-11-12 14:41:03 +01:00
Philipp Kunz	5ddbea1a5a	1.0.23	2019-11-11 13:04:36 +01:00
Philipp Kunz	42c5121784	fix(core): update	2019-11-11 13:04:36 +01:00
Philipp Kunz	d960d85539	1.0.22	2019-11-11 13:04:13 +01:00
Philipp Kunz	ca60217a18	fix(core): update	2019-11-11 13:04:13 +01:00
Phil Kunz	16f2829785	1.0.21	2019-08-14 11:39:36 +02:00
Phil Kunz	0381022b68	fix(core): update	2019-08-14 11:39:35 +02:00
Phil Kunz	aae8ec0ee1	1.0.20	2019-08-14 11:18:15 +02:00
Phil Kunz	ec4768e1cc	fix(core): update	2019-08-14 11:18:14 +02:00
Phil Kunz	3308895b3b	1.0.19	2019-06-04 11:29:30 +02:00
Phil Kunz	37e47fc33f	fix(core): update	2019-06-04 11:29:30 +02:00
Phil Kunz	b4a3a36b07	1.0.18	2019-06-03 23:34:33 +02:00
Phil Kunz	baf26dc492	fix(core): update	2019-06-03 23:34:33 +02:00
Phil Kunz	30e4b4665c	1.0.17	2019-06-03 17:09:16 +02:00
Phil Kunz	74a0a27fc1	fix(core): update	2019-06-03 17:09:16 +02:00
Phil Kunz	59eed53644	1.0.16	2019-06-03 16:39:21 +02:00
Phil Kunz	473aaa004a	fix(core): update	2019-06-03 16:39:21 +02:00
Phil Kunz	ecfd4115a1	1.0.15	2019-06-03 13:56:44 +02:00
Phil Kunz	0fbbfaac7c	fix(core): update	2019-06-03 13:56:43 +02:00
Phil Kunz	86d2fc2c5b	1.0.14	2019-06-03 13:45:57 +02:00
Phil Kunz	f97866fe82	fix(core): update	2019-06-03 13:45:57 +02:00
Phil Kunz	5c0b8c4df0	1.0.13	2019-06-03 13:02:01 +02:00
Phil Kunz	8da88be5e8	fix(core): update	2019-06-03 13:02:01 +02:00
Phil Kunz	4f0164965c	1.0.12	2019-06-03 13:00:06 +02:00
Phil Kunz	63f4321b04	fix(core): update	2019-06-03 13:00:06 +02:00
Phil Kunz	e4287e9943	1.0.11	2019-06-03 10:51:16 +02:00
Phil Kunz	337c299a5e	fix(core): update	2019-06-03 10:51:15 +02:00
Phil Kunz	4ac4d8d049	1.0.10	2019-05-29 19:49:24 +02:00
Phil Kunz	5e8abaa5b4	fix(core): update	2019-05-29 19:49:23 +02:00
Phil Kunz	d8fd7f9956	1.0.9	2019-05-29 19:19:36 +02:00
Phil Kunz	1711aadb6b	fix(core): update	2019-05-29 19:19:36 +02:00
Phil Kunz	06b9385e97	1.0.8	2019-05-29 19:18:44 +02:00
Phil Kunz	94386b0e02	fix(core): update	2019-05-29 19:18:43 +02:00
Phil Kunz	36fea0b0f2	Merge branch 'master' of gitlab.com:pushrocks/smartpdf	2019-05-29 19:17:54 +02:00
Phil Kunz	437d56e54d	1.0.7	2019-05-29 19:17:39 +02:00
Phil Kunz	1537705cde	fix(core): update	2019-05-29 19:17:39 +02:00
Phil Kunz	bb7cb4a6ab	1.0.7	2019-05-29 14:14:03 +02:00
Phil Kunz	bda43bf5e7	fix(core): update	2019-05-29 14:14:02 +02:00