lucasw89/bentopdf
1
0 Fork 0
mirror of https://github.com/alam00000/bentopdf.git synced 2026-11-12 01:33:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

feat: translate all pages, UI messages and docs and fix SEO redirects and indexing

Browse Source
This commit is contained in:
alam00000 committed 2026-10-25 12:55:21 +05:30
1 parent 5e019de5ae
commit 4edb1718cc
3344 files changed
+415643 -4759
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

docs/fr/contributing.md
+136
View File
@@ -0,0 +1,136 @@
# Contribuer
Merci de votre intérêt pour la contribution à BentoPDF ! Ce guide vous aidera à démarrer.
## Premiers pas
### Prérequis
- Node.js 18+
- npm 9+
- Git
### Installation
```bash
# Fork and clone the repository
git clone https://github.com/YOUR_USERNAME/bentopdf.git
cd bentopdf
# Install dependencies
npm install
# Start development server
npm run dev
```
## Structure du projet
```
bentopdf/
├── src/
│ ├── js/
│ │ ├── config/ # Tool definitions
│ │ ├── logic/ # Tool page logic
│ │ ├── utils/ # Shared utilities
│ │ └── ui.ts # UI helpers
│ ├── pages/ # Tool HTML pages
│ └── css/ # Styles
├── public/
│ ├── locales/ # Translations
│ └── pymupdf-wasm/ # WASM modules
├── docs/ # Documentation (VitePress)
└── scripts/ # Build scripts
```
## Ajouter un nouvel outil
### Étape 1 : créer le fichier de logique
Créez `src/js/logic/your-tool-page.ts` :
```typescript
import { showLoader, hideLoader, showAlert } from '../ui.js';
import { state } from '../state.js';
document.addEventListener('DOMContentLoaded', () => {
// Your tool logic here
});
```
### Étape 2 : créer la page HTML
Créez `src/pages/your-tool.html` en suivant les modèles d'outils existants.
### Étape 3 : enregistrer l'outil
Ajoutez dans `src/js/config/tools.ts` :
```typescript
{
href: import.meta.env.BASE_URL + 'your-tool.html',
name: 'Your Tool',
icon: 'ph-icon-name',
subtitle: 'Description of your tool.',
}
```
### Étape 4 : ajouter à la configuration de build
Ajoutez la page dans `vite.config.ts` :
```typescript
'your-tool': resolve(__dirname, 'src/pages/your-tool.html'),
```
### Étape 5 : ajouter les traductions
Ajoutez des entrées dans tous les fichiers de langue de `public/locales/` :
```json
{
"yourTool": {
"name": "Your Tool",
"subtitle": "Description"
}
}
```
## Style de code
- Utilisez TypeScript pour tout nouveau code
- Suivez les conventions existantes pour rester cohérent
- Exécutez `npm run format` avant de commiter
- Pas de commentaires dans le code de production (les commentaires sont supprimés lors du build)
## Processus de pull request
1. Créez une branche de fonctionnalité : `git checkout -b feature/your-feature`
2. Effectuez vos modifications
3. Testez soigneusement : `npm run build`
4. Soumettez une PR avec une description claire
## Traduction
Consultez [TRANSLATION.md](https://github.com/alam00000/bentopdf/blob/main/TRANSLATION.md) pour ajouter de nouvelles langues.
## Contrat de licence de contributeur
Avant que votre PR puisse être fusionnée, vous devrez signer notre CLA :
- [CLA individuel (ICLA)](https://github.com/alam00000/bentopdf/blob/main/ICLA.md)
- [CLA d'entreprise (CCLA)](https://github.com/alam00000/bentopdf/blob/main/CCLA.md)
## Obtenir de l'aide
- [GitHub Issues](https://github.com/alam00000/bentopdf/issues)
- [Communauté Discord](https://discord.gg/Bgq3Ay3f2w)
## Licence
BentoPDF est sous double licence :
- **AGPL-3.0** pour les projets open source où vous partagez publiquement l'intégralité de votre code source
- **Licence commerciale** pour les applications propriétaires ou à code source fermé - [Obtenir la licence à vie pour 79 $](https://buy.polar.sh/polar_cl_ThDfffbl733x7oAodcIryCzhlO57ZtcWPq6HJ1qMChd)
En contribuant, vous acceptez que vos contributions soient placées sous ces conditions de licence.
docs/fr/getting-started.md
+80
View File
@@ -0,0 +1,80 @@
# Premiers pas
Bienvenue sur BentoPDF ! Ce guide vous aidera à démarrer rapidement.
## Qu'est-ce que BentoPDF ?
BentoPDF est une boîte à outils PDF gratuite, open source et axée sur la confidentialité, qui fonctionne **entièrement dans votre navigateur**. Vos fichiers ne quittent jamais votre appareil : tout le traitement se fait en local grâce à la technologie WebAssembly (WASM).
## Démarrage rapide
### Option 1 : utiliser la version hébergée
Rendez-vous sur [bentopdf.com](https://www.bentopdf.com) pour utiliser BentoPDF immédiatement, sans aucune installation.
### Option 2 : auto-hébergement avec Docker
> [!IMPORTANT]
> La conversion de fichiers Office nécessite `SharedArrayBuffer`, qui requiert à la fois :
>
> - `Cross-Origin-Opener-Policy: same-origin`
> - `Cross-Origin-Embedder-Policy: require-corp`
> - un contexte sécurisé
>
> `http://localhost` fonctionne pour les tests locaux, car les navigateurs considèrent le bouclage local comme fiable. `http://192.168.x.x` ou d'autres adresses IP du réseau local ne le sont généralement pas, donc les conversions Word/Excel/PowerPoint nécessiteront HTTPS lorsqu'on y accède depuis d'autres appareils de votre réseau.
```bash
# Pull and run the Docker image (self-hosted build)
docker run -d -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest
# Or use Docker Compose
curl -O https://raw.githubusercontent.com/alam00000/bentopdf/main/docker-compose.yml
docker compose up -d
```
> [!TIP]
> BentoPDF est proposé en deux versions : la **version auto-hébergée** (`bentopdf-simple`, utilisée ci-dessus) pour les déploiements internes, d'équipe ou d'organisation, et la **version commerciale** (`bentopdf:latest`) utilisée par bentopdf.com lui-même et par les détenteurs d'une licence commerciale qui exploitent des déploiements publics. Les deux proposent les mêmes outils PDF : la version commerciale ajoute la section d'en-tête, la FAQ, les témoignages et le pied de page de bentopdf.com. En cas de doute, utilisez la version auto-hébergée.
Ouvrez ensuite `http://localhost:3000` dans votre navigateur.
> [!NOTE]
> Si vous préparez un déploiement OCR isolé du réseau (air-gapped), vous devez héberger en interne les polices de la couche de texte OCR, en plus du worker Tesseract, du runtime principal et des fichiers traineddata. La configuration complète est documentée dans [Auto-hébergement](/fr/self-hosting/), y compris `VITE_OCR_FONT_BASE_URL` et le dossier `ocr-fonts/` fourni.
### Option 3 : compiler depuis les sources
```bash
# Clone the repository
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
# Install dependencies
npm install
# Start development server
npm run dev
```
## Aperçu des fonctionnalités
| Catégorie | Outils |
| ------------------------ | -------------------------------------------------------------------------- |
| **Convertir en PDF** | Word, Excel, PowerPoint, images, Markdown, EPUB, MOBI et plus encore |
| **Convertir depuis PDF** | JPG, PNG, texte, Excel, SVG et plus encore |
| **Modifier et annoter** | Signer, surligner, caviarder, remplir des formulaires, ajouter des tampons |
| **Organiser** | Fusionner, diviser, pivoter, supprimer des pages, réorganiser |
| **Optimiser** | Compresser, réparer, aplatir, OCR |
| **Sécurité** | Chiffrer, déchiffrer, supprimer les restrictions |
## Prise en charge des navigateurs
BentoPDF fonctionne mieux sur les navigateurs modernes :
- ✅ Chrome/Edge 90+
- ✅ Firefox 90+
- ✅ Safari 15+
## Étapes suivantes
- [Explorer tous les outils](/fr/tools/)
- [Auto-héberger BentoPDF](/fr/self-hosting/)
- [Contribuer au projet](/fr/contributing)
docs/fr/index.md
+42
View File
@@ -0,0 +1,42 @@
---
# https://vitepress.dev/reference/default-theme-home-page
layout: home
hero:
name: 'BentoPDF'
text: 'Outils PDF gratuits et open source'
tagline: Traitez vos PDF entièrement dans votre navigateur. Aucun envoi. Aucun serveur. Confidentialité totale.
actions:
- theme: brand
text: Commencer
link: /fr/getting-started
- theme: alt
text: Voir les outils
link: /fr/tools/
- theme: alt
text: Auto-héberger
link: /fr/self-hosting/
- theme: alt
text: Licence commerciale
link: /fr/licensing
features:
- icon: 🔒
title: 100 % privé
details: Vos fichiers ne quittent jamais votre appareil. Tout le traitement se fait en local dans votre navigateur grâce à WebAssembly.
- icon: ⚡
title: Rapide et gratuit
details: Sans inscription, sans limites, sans filigranes. Traitez autant de PDF que vous voulez, gratuitement, pour toujours.
- icon: 🛠️
title: Plus de 50 outils
details: Convertissez, modifiez, fusionnez, divisez, compressez, signez, appliquez l'OCR et bien plus. Tout ce dont vous avez besoin au même endroit.
- icon: 🌐
title: Auto-hébergeable
details: Déployez sur votre propre infrastructure. Docker, Vercel, Netlify, AWS, ou environnements totalement isolés du réseau avec workers OCR, données de langue et polices de couche de texte auto-hébergés.
---
## OCR hors ligne
Si vous auto-hébergez BentoPDF dans un environnement isolé du réseau ou hors ligne, l'OCR nécessite plus que le worker Tesseract et les fichiers traineddata. La production de PDF avec texte recherchable exige aussi que les polices de la couche de texte OCR soient servies en interne.
Consultez [Auto-hébergement](/fr/self-hosting/) pour la configuration complète, y compris `VITE_OCR_FONT_BASE_URL`, le dossier `ocr-fonts/` fourni et le workflow isolé mis à jour.
docs/fr/licensing.md
+92
View File
@@ -0,0 +1,92 @@
# Commercial License
BentoPDF is dual-licensed under **AGPL-3.0** (for open-source projects) and a **Commercial License** (for proprietary/closed-source applications).
::: tip Full Details
For complete licensing information, delivery details, AGPL component notices, and invoicing, visit our [Licensing Page](https://www.bentopdf.com/licensing).
:::
## Get a Commercial License
**[Get Lifetime License for $79](https://buy.polar.sh/polar_cl_ThDfffbl733x7oAodcIryCzhlO57ZtcWPq6HJ1qMChd)**. A one-time purchase that includes all future updates forever.
## When Do You Need a Commercial License?
| Use Case | License Required |
| ------------------------------------------- | ---------------------- |
| Open-source project with public source code | AGPL-3.0 (Free) |
| Internal company tool (not distributed) | AGPL-3.0 (Free) |
| Proprietary/closed-source application | **Commercial License** |
| SaaS product without source code disclosure | **Commercial License** |
| Redistributing without AGPL compliance | **Commercial License** |
## Delivery & Licensing Model
- **No license key is required or provided.** BentoPDF intentionally does not use license keys to streamline deployment and reduce operational friction for users.
- Upon purchase, users receive a ZIP archive containing the complete BentoPDF source code and binaries.
- The source code provided is identical to the code published in our public open-source repository.
**GitHub Repository:** [github.com/alam00000/bentopdf](https://github.com/alam00000/bentopdf)
## Important Notice on Third-Party Components
::: info AGPL Components — Pre-configured via CDN
BentoPDF **does not bundle** AGPL-licensed processing libraries in its source code. These components are loaded at runtime from CDN URLs that are **pre-configured by default** — all features work out of the box with zero setup.
| Component | License | Status |
| --------------- | -------- | ---------------------- |
| **PyMuPDF** | AGPL-3.0 | Pre-configured via CDN |
| **Ghostscript** | AGPL-3.0 | Pre-configured via CDN |
| **CoherentPDF** | AGPL-3.0 | Pre-configured via CDN |
WASM module URLs are configured via environment variables at build time (`.env.production`). The defaults point to jsDelivr CDN. For custom deployments (air-gapped, self-hosted), you can override via environment variables, Docker build args, or per-user via **Advanced Settings** in the UI.
See [Self-Hosting > WASM Configuration](/fr/self-hosting/#configuration-wasm-composants-agpl) for details.
This approach ensures:
- BentoPDF's core code remains under its dual-license (AGPL-3.0 / Commercial)
- WASM binaries are loaded at runtime, not included in the source
- Clear compliance boundaries for commercial users
:::
::: tip Commercial License & AGPL Features
The commercial license covers BentoPDF's own code. If you configure and use AGPL components (PyMuPDF, Ghostscript, CoherentPDF), you must still comply with their respective AGPL-3.0 license terms, which may require source code disclosure if you distribute modified versions.
:::
## Invoicing
- Payments are handled by [Polar](https://polar.sh), which automatically emails an invoice after purchase.
- Polar handles VAT invoices for businesses in applicable regions. Select **"I'm purchasing as a business"** at checkout and enter your billing address and Tax/VAT number.
**Questions?** Contact [contact@bentopdf.com](mailto:contact@bentopdf.com) with your purchase details.
## What's Included
| Feature | Included |
| ----------------------------- | -------------- |
| Full source code | ✅ |
| All 50+ PDF tools | ✅ |
| Self-hosting rights | ✅ |
| Lifetime updates | ✅ |
| Remove branding (Simple Mode) | ✅ |
| Commercial support | ✅ (via email) |
| Priority feature requests | ✅ |
## FAQ
### Do I need a license key to use BentoPDF?
No. BentoPDF does not use license keys. The commercial license grants you legal rights to use the software in proprietary applications.
### Can I use BentoPDF in my SaaS product?
Yes, with a commercial license. Without it, you must comply with AGPL-3.0, which requires you to make your full source code available to users.
### What about the AGPL components?
Components like CoherentPDF are licensed under AGPL v3 and remain under that license. The commercial license covers BentoPDF's own code but does not override third-party AGPL obligations.
### How do I get an invoice?
Polar emails your invoice automatically after purchase. For a VAT invoice, select "I'm purchasing as a business" at checkout. If you need anything else, email [contact@bentopdf.com](mailto:contact@bentopdf.com) with your purchase details.
docs/fr/self-hosting/apache.md
+275
View File
@@ -0,0 +1,275 @@
# Déployer avec Apache
Hébergez BentoPDF avec Apache HTTP Server.
## Prérequis
- Apache 2.4+
- mod_rewrite activé
- Certificat SSL (recommandé)
## Étape 1 : compiler le projet
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
```
Pour personnaliser l'image de marque, définissez des variables d'environnement avant la compilation :
```bash
VITE_BRAND_NAME="AcmePDF" VITE_BRAND_LOGO="images/acme-logo.svg" npm run build
```
## Étape 2 : copier les fichiers
```bash
sudo mkdir -p /var/www/bentopdf
sudo cp -r dist/* /var/www/bentopdf/
sudo chown -R www-data:www-data /var/www/bentopdf
```
## Étape 3 : configuration d'Apache
Créez `/etc/apache2/sites-available/bentopdf.conf` :
```apache
<VirtualHost *:80>
ServerName your-domain.com
Redirect permanent / https://your-domain.com/
</VirtualHost>
<VirtualHost *:443>
ServerName your-domain.com
DocumentRoot /var/www/bentopdf
SSLEngine on
SSLCertificateFile /etc/letsencrypt/live/your-domain.com/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/your-domain.com/privkey.pem
<Directory /var/www/bentopdf>
Options -Indexes +FollowSymLinks
AllowOverride All
Require all granted
</Directory>
# WASM MIME type
AddType application/wasm .wasm
# Prevent double-compression of pre-compressed files
SetEnvIfNoCase Request_URI "\.gz$" no-gzip
# Compression
<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE text/html text/plain text/css application/javascript application/json application/wasm
</IfModule>
# Cache headers
<IfModule mod_expires.c>
ExpiresActive On
ExpiresByType application/javascript "access plus 1 year"
ExpiresByType text/css "access plus 1 year"
ExpiresByType application/wasm "access plus 1 year"
ExpiresByType image/png "access plus 1 year"
ExpiresByType image/svg+xml "access plus 1 year"
</IfModule>
# Required headers for SharedArrayBuffer (LibreOffice WASM)
Header always set Cross-Origin-Embedder-Policy "require-corp"
Header always set Cross-Origin-Opener-Policy "same-origin"
Header always set Cross-Origin-Resource-Policy "cross-origin"
# Security headers
Header always set X-Frame-Options "SAMEORIGIN"
Header always set X-Content-Type-Options "nosniff"
# Pre-compressed LibreOffice WASM files
<FilesMatch "soffice\.wasm\.gz$">
ForceType application/wasm
Header set Content-Encoding "gzip"
</FilesMatch>
<FilesMatch "soffice\.data\.gz$">
ForceType application/octet-stream
Header set Content-Encoding "gzip"
</FilesMatch>
</VirtualHost>
```
## Étape 4 : .htaccess pour le routage
Créez `/var/www/bentopdf/.htaccess` :
```apache
RewriteEngine On
RewriteBase /
# Existing files/dirs - serve directly
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]
# ============================================
# LANGUAGE ROUTES
# ============================================
# Supported languages: de, es, zh, zh-TW, vi, it, id, tr, fr, pt
# English has no prefix - served from root
# English prefix redirects to root
RewriteRule ^en/?$ / [R=301,L]
RewriteRule ^en/(.+)$ /$1 [R=301,L]
# Language prefix root (e.g., /de/ -> /de/index.html)
RewriteCond %{DOCUMENT_ROOT}/$1/index.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/?$ /$1/index.html [L]
# Language prefix with path (e.g., /de/merge-pdf -> /de/merge-pdf.html)
RewriteCond %{DOCUMENT_ROOT}/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /$1/$2.html [L]
# ============================================
# ADD .HTML EXTENSION (ROOT LEVEL)
# ============================================
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
ErrorDocument 404 /404.html
```
## Étape 5 : activer les modules requis
```bash
sudo a2enmod rewrite
sudo a2enmod ssl
sudo a2enmod headers
sudo a2enmod expires
sudo a2enmod deflate
```
## Étape 6 : activer le site
```bash
sudo a2ensite bentopdf.conf
sudo apache2ctl configtest
sudo systemctl reload apache2
```
## Déploiement dans un sous-répertoire
Pour héberger sous `/pdf/` :
1. Compilez avec l'URL de base :
```bash
BASE_URL=/pdf/ npm run build
```
2. Mettez à jour `.htaccess` :
```apache
RewriteEngine On
RewriteBase /pdf/
# Existing files/dirs - serve directly
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]
# Language routes
RewriteRule ^en/?$ /pdf/ [R=301,L]
RewriteRule ^en/(.+)$ /pdf/$1 [R=301,L]
RewriteCond %{DOCUMENT_ROOT}/pdf/$1/index.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/?$ /pdf/$1/index.html [L]
RewriteCond %{DOCUMENT_ROOT}/pdf/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /pdf/$1/$2.html [L]
# Root level .html extension
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
ErrorDocument 404 /pdf/404.html
```
## Dépannage
### Erreurs 404 sur les fichiers WASM
Vérifiez que le type MIME est configuré :
```apache
AddType application/wasm .wasm
```
### Signer un PDF ou le remplissage de formulaires affiche un visualiseur vide (erreur MIME `.mjs`)
Si la console du navigateur affiche :
```
Failed to load module script: The server responded with a non-JavaScript
MIME type of "application/octet-stream". Strict MIME type checking is
enforced for module scripts per HTML spec.
```
…et que la requête en échec se termine par `.mjs`, il manque à votre configuration Apache l'association `.mjs → application/javascript`. Le visualiseur PDF fourni livre des modules ES avec l'extension `.mjs`, et le fichier `mime.types` standard d'Apache ne les inclut pas par défaut.
Ajoutez à votre VirtualHost ou à `.htaccess` :
```apache
AddType application/javascript .mjs
```
Rechargez ensuite Apache :
```bash
sudo apache2ctl configtest && sudo systemctl reload apache2
```
Pour vérifier : dans les DevTools du navigateur → onglet Réseau, trouvez la requête `.mjs` en échec et consultez l'en-tête de réponse `Content-Type`. Il doit maintenant valoir `application/javascript`, et non `application/octet-stream`.
### La réécriture ne fonctionne pas
Vérifiez que mod_rewrite est activé :
```bash
sudo a2enmod rewrite
```
### La conversion Word/ODT/Excel vers PDF ne fonctionne pas
LibreOffice WASM nécessite `SharedArrayBuffer`, qui exige ces en-têtes :
```apache
Header always set Cross-Origin-Embedder-Policy "require-corp"
Header always set Cross-Origin-Opener-Policy "same-origin"
```
Un contexte sécurisé est également nécessaire. `http://localhost` fonctionne pour les tests locaux, mais `http://192.168.x.x` ou d'autres adresses IP du réseau local nécessitent généralement HTTPS. Si les en-têtes sont présents mais que `window.crossOriginIsolated` vaut toujours `false`, vérifiez si la page est ouverte en HTTP simple sur une origine autre que le bouclage local.
Les fichiers précompressés `.wasm.gz` et `.data.gz` ont aussi besoin du bon `Content-Encoding` :
```apache
<FilesMatch "soffice\.wasm\.gz$">
ForceType application/wasm
Header set Content-Encoding "gzip"
</FilesMatch>
<FilesMatch "soffice\.data\.gz$">
ForceType application/octet-stream
Header set Content-Encoding "gzip"
</FilesMatch>
```
Vérifiez que `mod_headers` est activé : `sudo a2enmod headers`
### Permission refusée
```bash
sudo chown -R www-data:www-data /var/www/bentopdf
sudo chmod -R 755 /var/www/bentopdf
```
docs/fr/self-hosting/aws.md
+200
View File
@@ -0,0 +1,200 @@
# Déployer sur AWS S3 + CloudFront
Hébergez BentoPDF sur AWS pour un contrôle et une évolutivité maximaux.
## Architecture
```
User → CloudFront (CDN) → S3 (Static Files)
```
## Étape 1 : créer le bucket S3
```bash
# Create bucket
aws s3 mb s3://your-bentopdf-bucket --region us-east-1
# Enable static website hosting
aws s3 website s3://your-bentopdf-bucket \
--index-document index.html \
--error-document index.html
```
## Étape 2 : compiler et téléverser
```bash
# Build the project (optionally with custom branding)
# VITE_BRAND_NAME="AcmePDF" VITE_BRAND_LOGO="images/acme-logo.svg" npm run build
npm run build
# Sync to S3
aws s3 sync dist/ s3://your-bentopdf-bucket \
--delete \
--cache-control "max-age=31536000"
# Set correct MIME types for WASM
aws s3 cp s3://your-bentopdf-bucket/ s3://your-bentopdf-bucket/ \
--recursive \
--exclude "*" \
--include "*.wasm" \
--content-type "application/wasm" \
--metadata-directive REPLACE
# Set correct MIME type for ES module files (.mjs)
# S3 defaults .mjs to application/octet-stream, which browsers refuse to
# execute as ES modules. The bundled PDF viewer (Sign PDF, Form Filler)
# ships ES modules with .mjs extensions and will fail without this step.
aws s3 cp s3://your-bentopdf-bucket/ s3://your-bentopdf-bucket/ \
--recursive \
--exclude "*" \
--include "*.mjs" \
--content-type "application/javascript" \
--metadata-directive REPLACE
```
## Étape 3 : créer la distribution CloudFront
```bash
aws cloudfront create-distribution \
--origin-domain-name your-bentopdf-bucket.s3.amazonaws.com \
--default-root-object index.html
```
Ou utilisez la console AWS :
1. Allez dans CloudFront → Create distribution
2. Origin domain : sélectionnez votre bucket S3
3. Activez « Origin Access Control »
4. Default root object : `index.html`
5. Créez la distribution
## Étape 3b : politique d'en-têtes de réponse (requise pour LibreOffice WASM)
Les conversions basées sur LibreOffice (Word, Excel, PowerPoint vers PDF) nécessitent `SharedArrayBuffer`, qui exige des en-têtes de réponse spécifiques. Créez une politique d'en-têtes de réponse CloudFront :
1. Allez dans CloudFront → Policies → Response headers
2. Créez une politique personnalisée avec ces en-têtes :
| Header | Value |
| ------------------------------ | -------------- |
| `Cross-Origin-Embedder-Policy` | `require-corp` |
| `Cross-Origin-Opener-Policy` | `same-origin` |
| `Cross-Origin-Resource-Policy` | `cross-origin` |
3. Associez la politique au comportement de cache par défaut de votre distribution
Ou via la CLI :
```bash
aws cloudfront create-response-headers-policy \
--response-headers-policy-config '{
"Name": "BentoPDF-COEP-COOP",
"CustomHeadersConfig": {
"Quantity": 3,
"Items": [
{"Header": "Cross-Origin-Embedder-Policy", "Value": "require-corp", "Override": true},
{"Header": "Cross-Origin-Opener-Policy", "Value": "same-origin", "Override": true},
{"Header": "Cross-Origin-Resource-Policy", "Value": "cross-origin", "Override": true}
]
}
}'
```
## Étape 3c : métadonnées S3 pour les fichiers WASM précompressés
Les fichiers WASM de LibreOffice sont précompressés (`.wasm.gz`, `.data.gz`). Définissez le bon Content-Type et le bon Content-Encoding pour que les navigateurs les décompressent :
```bash
# Set correct headers for soffice.wasm.gz
aws s3 cp s3://your-bentopdf-bucket/libreoffice-wasm/soffice.wasm.gz \
s3://your-bentopdf-bucket/libreoffice-wasm/soffice.wasm.gz \
--content-type "application/wasm" \
--content-encoding "gzip" \
--metadata-directive REPLACE
# Set correct headers for soffice.data.gz
aws s3 cp s3://your-bentopdf-bucket/libreoffice-wasm/soffice.data.gz \
s3://your-bentopdf-bucket/libreoffice-wasm/soffice.data.gz \
--content-type "application/octet-stream" \
--content-encoding "gzip" \
--metadata-directive REPLACE
```
::: warning Important
Sans la politique d'en-têtes de réponse, `SharedArrayBuffer` n'est pas disponible et les conversions LibreOffice WASM resteront bloquées à environ 55 %. Sans le bon Content-Encoding sur les fichiers `.gz`, le navigateur reçoit des octets gzip bruts et la compilation WASM échoue.
:::
## Étape 4 : politique du bucket S3
Autorisez CloudFront à accéder au bucket :
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowCloudFrontAccess",
"Effect": "Allow",
"Principal": {
"Service": "cloudfront.amazonaws.com"
},
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::your-bentopdf-bucket/*",
"Condition": {
"StringEquals": {
"AWS:SourceArn": "arn:aws:cloudfront::ACCOUNT_ID:distribution/DISTRIBUTION_ID"
}
}
}
]
}
```
## Étape 5 : pages d'erreur personnalisées
Configurez la 404 pour renvoyer `index.html` afin de gérer le routage SPA :
1. CloudFront → Error pages
2. Créez une réponse d'erreur personnalisée :
- HTTP error code : 404
- Response page path : `/index.html`
- HTTP response code : 200
## Estimation des coûts
| Ressource | Coût estimé |
| ----------------------------- | ------------ |
| Stockage S3 (~500 Mo) | ~0,01 $/mois |
| CloudFront (1 To transféré) | ~85 $/mois |
| CloudFront (10 Go transférés) | ~0,85 $/mois |
::: tip
Utilisez S3 Intelligent Tiering pour optimiser les coûts des fichiers rarement consultés.
:::
## Automatisation avec Terraform
```hcl
# main.tf
resource "aws_s3_bucket" "bentopdf" {
bucket = "your-bentopdf-bucket"
}
resource "aws_cloudfront_distribution" "bentopdf" {
origin {
domain_name = aws_s3_bucket.bentopdf.bucket_regional_domain_name
origin_id = "S3Origin"
}
enabled = true
default_root_object = "index.html"
default_cache_behavior {
allowed_methods = ["GET", "HEAD"]
cached_methods = ["GET", "HEAD"]
target_origin_id = "S3Origin"
viewer_protocol_policy = "redirect-to-https"
}
}
```
docs/fr/self-hosting/cloudflare.md
+154
View File
@@ -0,0 +1,154 @@
# Déployer sur Cloudflare Pages
[Cloudflare Pages](https://pages.cloudflare.com) propose un hébergement de sites statiques rapide et mondial, avec une bande passante illimitée.
## Déploiement rapide
1. Allez sur [Cloudflare Pages](https://dash.cloudflare.com/?to=/:account/pages)
2. Cliquez sur « Create a project »
3. Connectez votre dépôt GitHub
## Configuration du build
| Paramètre | Valeur |
| ---------------------- | --------------- |
| Framework preset | None |
| Build command | `npm run build` |
| Build output directory | `dist` |
| Root directory | `/` |
## Variables d'environnement
Ajoutez-les dans Settings → Environment variables :
| Variable | Valeur |
| ----------------------- | ---------------------------------------------------------- |
| `NODE_VERSION` | `18` |
| `SIMPLE_MODE` | `false` (facultatif) |
| `VITE_BRAND_NAME` | Nom de marque personnalisé (facultatif) |
| `VITE_BRAND_LOGO` | Chemin du logo relatif à `public/` (facultatif) |
| `VITE_FOOTER_TEXT` | Texte de pied de page/copyright personnalisé (facultatif) |
| `VITE_DEFAULT_LANGUAGE` | Langue par défaut de l'interface, p. ex. `fr` (facultatif) |
## Fichier de configuration
Créez `_headers` dans votre dossier `public` :
```
# Required security headers for SharedArrayBuffer (used by LibreOffice WASM)
/*
Cross-Origin-Embedder-Policy: require-corp
Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Resource-Policy: cross-origin
# Pre-compressed LibreOffice WASM binary
/libreoffice-wasm/soffice.wasm.gz
Content-Type: application/wasm
Content-Encoding: gzip
Cache-Control: public, max-age=31536000, immutable
# Pre-compressed LibreOffice WASM data
/libreoffice-wasm/soffice.data.gz
Content-Type: application/octet-stream
Content-Encoding: gzip
Cache-Control: public, max-age=31536000, immutable
# Cache WASM files aggressively
/*.wasm
Cache-Control: public, max-age=31536000, immutable
Content-Type: application/wasm
# Service worker
/sw.js
Cache-Control: no-cache
```
::: warning Important
Les en-têtes `Cross-Origin-Embedder-Policy` et `Cross-Origin-Opener-Policy` sont requis pour les conversions Word/ODT/Excel/PowerPoint vers PDF. Sans eux, `SharedArrayBuffer` n'est pas disponible et le moteur LibreOffice WASM ne parviendra pas à s'initialiser.
:::
Créez `_redirects` pour le routage SPA :
```
/* /index.html 200
```
## Domaine personnalisé
1. Ouvrez votre projet Pages
2. Cliquez sur « Custom domains »
3. Ajoutez votre domaine
4. Cloudflare configurera automatiquement le DNS si le domaine est chez Cloudflare
## Avantages
- **Bande passante illimitée et gratuite**
- **CDN mondial** avec plus de 300 points de présence
- **HTTPS automatique**
- **Déploiements de prévisualisation** pour les pull requests
- **Builds rapides**
## Dépannage
### Téléversement de gros fichiers
Cloudflare Pages prend en charge les fichiers jusqu'à 25 Mo. Les modules WASM ne devraient pas poser de problème, mais si vous atteignez les limites, envisagez :
```bash
# Split large files during build
npm run build
```
### Limites de taille des Workers
Si vous utilisez Cloudflare Workers pour un routage avancé, notez la limite de 1 Mo des offres gratuites.
## Worker proxy CORS (pour les signatures numériques)
L'outil de signature numérique nécessite un proxy CORS pour récupérer les chaînes de certificats. Déployez le worker fourni :
```bash
cd cloudflare
npx wrangler login
npx wrangler deploy
```
### Fonctionnalités de sécurité
| Fonctionnalité | Description |
| -------------------------- | --------------------------------------------- |
| **Restrictions d'URL** | Seules les URL de certificats sont autorisées |
| **Limite de taille** | 10 Mo max par requête |
| **Limitation de débit** | 60 req/IP/min (nécessite KV) |
| **Blocage des IP privées** | Bloque localhost et les IP internes |
### Activer la limitation de débit
```bash
# Create KV namespace
npx wrangler kv namespace create "RATE_LIMIT_KV"
# Add to wrangler.toml with returned ID:
# [[kv_namespaces]]
# binding = "RATE_LIMIT_KV"
# id = "YOUR_ID"
npx wrangler deploy
```
### Compiler avec l'URL du proxy
```bash
VITE_CORS_PROXY_URL=https://your-worker.workers.dev npm run build
```
Ou avec Docker :
```bash
export VITE_CORS_PROXY_URL="https://your-worker.workers.dev"
DOCKER_BUILDKIT=1 docker build \
--secret id=VITE_CORS_PROXY_URL,env=VITE_CORS_PROXY_URL \
-t your-bentopdf .
```
> **Remarque :** Consultez le [README](https://github.com/alam00000/bentopdf#digital-signature-cors-proxy-required) pour la configuration de la signature HMAC.
docs/fr/self-hosting/cors-proxy.md
+180
View File
@@ -0,0 +1,180 @@
# Proxy CORS pour la récupération des certificats
L'outil de signature numérique utilise un proxy CORS pour récupérer les certificats des émetteurs auprès d'autorités de certification (AC) externes. C'est nécessaire, car de nombreux serveurs d'AC n'incluent pas d'en-têtes CORS dans leurs réponses, ce qui empêche la récupération directe depuis le navigateur.
De plus, de nombreux serveurs d'AC diffusent leurs certificats en HTTP simple. Lorsque votre instance BentoPDF est servie en HTTPS, les navigateurs bloquent ces requêtes HTTP (politique de contenu mixte). Le proxy CORS résout ces deux problèmes en faisant transiter les requêtes par un point de terminaison HTTPS avec les bons en-têtes.
## Fonctionnement
Lors de la signature d'un PDF avec un certificat :
1. La bibliothèque `zgapdfsigner` tente de construire une chaîne de certificats complète
2. Elle récupère les certificats des émetteurs à partir des URL intégrées à l'extension AIA (Authority Information Access) de votre certificat
3. Ces requêtes passent par un proxy CORS qui ajoute les en-têtes `Access-Control-Allow-Origin` nécessaires
4. Le proxy renvoie les données du certificat au navigateur
## Auto-héberger le proxy CORS
Si vous auto-hébergez BentoPDF, vous devrez déployer votre propre proxy CORS pour que les signatures numériques fonctionnent avec les certificats qui nécessitent la récupération de la chaîne.
### Option 1 : Cloudflare Workers (recommandé)
1. **Installez la CLI Wrangler** :
```bash
npm install -g wrangler
```
2. **Connectez-vous à Cloudflare** :
```bash
wrangler login
```
3. **Clonez BentoPDF et mettez à jour les origines autorisées** :
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf/cloudflare
```
Ouvrez `cors-proxy-worker.js` et remplacez le tableau `ALLOWED_ORIGINS` par votre domaine :
```js
const ALLOWED_ORIGINS = [
'https://your-domain.com',
'https://www.your-domain.com',
];
```
::: warning Important
Sans cette modification, le proxy rejettera toutes les requêtes de votre site avec une erreur **403 Forbidden**. Par défaut, seules les requêtes provenant de `bentopdf.com` sont autorisées.
:::
4. **Déployez le proxy** :
```bash
wrangler deploy
```
Notez l'URL de votre worker (p. ex. `https://bentopdf-cors-proxy.your-subdomain.workers.dev`).
5. **Recompilez BentoPDF avec l'URL du proxy** :
Avec Docker :
```bash
export VITE_CORS_PROXY_URL="https://your-worker.workers.dev"
DOCKER_BUILDKIT=1 docker build \
--secret id=VITE_CORS_PROXY_URL,env=VITE_CORS_PROXY_URL \
-t your-bentopdf .
```
Avec une compilation depuis les sources :
```bash
VITE_CORS_PROXY_URL=https://your-worker.workers.dev npm run build
```
### Option 2 : proxy backend personnalisé
Vous pouvez aussi créer votre propre point de terminaison proxy. Les exigences sont les suivantes :
1. Accepter les requêtes GET avec un paramètre de requête `url`
2. Récupérer l'URL depuis votre serveur (aucune restriction CORS côté serveur)
3. Renvoyer la réponse avec ces en-têtes :
- `Access-Control-Allow-Origin: https://your-domain.com`
- `Access-Control-Allow-Methods: GET, OPTIONS`
- `X-Content-Type-Options: nosniff`
Exemple d'implémentation avec Express.js :
```javascript
app.get('/api/cert-proxy', async (req, res) => {
const targetUrl = req.query.url;
// Validate it's a certificate URL
if (!isValidCertUrl(targetUrl)) {
return res.status(400).json({ error: 'Invalid URL' });
}
try {
const response = await fetch(targetUrl);
const data = await response.arrayBuffer();
res.set('Access-Control-Allow-Origin', 'https://your-domain.com');
res.set('Content-Type', 'application/octet-stream');
res.set('X-Content-Type-Options', 'nosniff');
res.send(Buffer.from(data));
} catch (error) {
res.status(500).json({ error: 'Proxy error' });
}
});
```
## Considérations de sécurité
Le Cloudflare Worker fourni intègre plusieurs mesures de sécurité :
| Fonctionnalité | Description |
| --------------------------- | ----------------------------------------------------------------------------------------------- |
| **Validation de l'origine** | Autorise uniquement les requêtes des domaines listés dans `ALLOWED_ORIGINS` |
| **Restrictions d'URL** | Autorise uniquement les URL de certificats (`.crt`, `.cer`, `.pem`, `/certs/`, `/ocsp`, `/crl`) |
| **Blocage des IP privées** | Bloque les plages privées IPv4/IPv6, link-local, bouclage, IP décimales et métadonnées cloud |
| **Sûreté du Content-Type** | Ne renvoie que des types MIME de certificat sûrs, bloque l'injection de content-type en amont |
| **Limite de taille** | Réponse en flux limitée à 10 Mo, interrompue en cours de téléchargement en cas de dépassement |
| **Limitation de débit** | 60 requêtes par minute par IP ou IPv6 /64 (nécessite KV, laisse passer en cas d'erreur KV) |
| **Signatures HMAC** | Signature côté client facultative (dissuade les abus occasionnels) |
### DNS rebinding (auto-hébergement hors Cloudflare)
Le worker rejette toute URL qui se résout vers une IP privée ou interne. Il ne peut pas utiliser une liste fixe d'hôtes autorisés, car les URL des chaînes de certificats pointent vers l'AC qui a émis le certificat (FNMT, AC d'entreprise, etc.), donc les destinations ne sont pas connues à l'avance. Il reste une petite fenêtre de rebinding : une personne qui gère le DNS de son propre domaine pourrait renvoyer une IP publique lors du contrôle de sécurité, puis une IP privée pour la vraie requête un instant plus tard.
Sur Cloudflare, ce n'est pas exploitable : les Workers ne peuvent pas atteindre les IP privées ni le point de terminaison de métadonnées `169.254.169.254`, donc un rebinding n'aboutit à rien. Ne donnez simplement pas au worker de voie d'accès : n'associez ni Tunnel, ni Service, ni binding de réseau privé (il n'a besoin que de `RATE_LIMIT_KV`).
Si vous l'exécutez hors de Cloudflare (workerd, Node, etc.) dans un VPC, le runtime _peut_ atteindre les IP internes. Placez un pare-feu de sortie devant lui et bloquez les plages privées : `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, `127.0.0.0/8`, `169.254.0.0/16` et leurs équivalents IPv6. Le code de l'application ne peut pas l'imposer une fois hors de Cloudflare.
## Désactiver le proxy
Si vous ne souhaitez pas utiliser de proxy CORS, définissez la variable d'environnement sur une chaîne vide :
```
VITE_CORS_PROXY_URL=
```
**Remarque** : sans le proxy, la signature avec des certificats qui nécessitent la récupération externe de la chaîne (comme FNMT ou certaines AC d'entreprise) échouera avec une erreur « Failed to fetch ».
## Dépannage
### « Signing error: TypeError: Failed to fetch »
Cela signifie généralement :
1. **Aucun proxy CORS configuré** : définissez `VITE_CORS_PROXY_URL` et recompilez
2. **Contenu mixte bloqué** : votre site est en HTTPS mais l'URL de l'émetteur du certificat est en HTTP. Le proxy CORS résout ce problème.
3. **Le proxy CORS rejette votre origine** : vérifiez que votre domaine figure dans le tableau `ALLOWED_ORIGINS` de `cors-proxy-worker.js`
### « 403 Forbidden » renvoyé par le proxy
Votre domaine ne figure pas dans la liste `ALLOWED_ORIGINS`. Modifiez `cors-proxy-worker.js` :
```js
const ALLOWED_ORIGINS = ['https://your-domain.com'];
```
Redéployez ensuite : `npx wrangler deploy`
### Tester le proxy
```bash
curl -H "Origin: https://your-domain.com" \
"https://your-proxy.workers.dev?url=http://www.cert.fnmt.es/certs/ACUSU.crt"
```
### Certificats qui fonctionnent sans proxy
Certains certificats incluent la chaîne complète dans le fichier P12/PFX et ne nécessitent pas de récupération externe :
- Certificats auto-signés
- Certaines AC commerciales qui regroupent les certificats intermédiaires
- Certificats que vous avez assemblés manuellement avec la chaîne complète
docs/fr/self-hosting/docker.md
+622
View File
@@ -0,0 +1,622 @@
# Déployer avec Docker / Podman
Le moyen le plus simple d'auto-héberger BentoPDF en production.
> [!IMPORTANT]
> **En-têtes requis pour la conversion de fichiers Office**
>
> Les outils basés sur LibreOffice (conversion Word, Excel, PowerPoint) nécessitent ces en-têtes HTTP pour la prise en charge de `SharedArrayBuffer` :
>
> - `Cross-Origin-Opener-Policy: same-origin`
> - `Cross-Origin-Embedder-Policy: require-corp`
>
> La page doit aussi être servie depuis un contexte sécurisé. `http://localhost` fonctionne pour les tests locaux, mais `http://192.168.x.x` ou d'autres adresses IP du réseau local n'en font généralement pas partie : la conversion Office en HTTP simple échouera donc, même si les en-têtes sont présents.
>
> Les images de conteneur officielles incluent ces en-têtes. Si vous utilisez un reverse proxy (Traefik, Caddy, etc.), assurez-vous que ces en-têtes sont conservés ou ajoutés, et utilisez HTTPS pour tout accès hors bouclage local.
> [!TIP]
> **Utilisateurs de Podman :** toutes les commandes `docker` fonctionnent avec Podman en remplaçant `docker` par `podman` et `docker-compose` par `podman-compose`.
## Démarrage rapide
> [!TIP]
> BentoPDF est proposé en deux versions :
>
> - **Version auto-hébergée** : `ghcr.io/alam00000/bentopdf-simple:latest`. Tous les outils PDF, **sans** l'habillage marketing (ni section d'en-tête, ni FAQ, ni témoignages, ni pied de page). À utiliser pour les déploiements internes, d'équipe ou d'organisation. Ce n'est **pas** une version « allégée » aux fonctionnalités réduites.
> - **Version commerciale** : `ghcr.io/alam00000/bentopdf:latest`. Le site marketing complet, utilisé par bentopdf.com lui-même et par les détenteurs d'une licence commerciale qui exploitent des déploiements publics.
>
> En cas de doute : récupérez la version auto-hébergée.
```bash
# Docker
docker run -d \
--name bentopdf \
-p 3000:8080 \
--restart unless-stopped \
ghcr.io/alam00000/bentopdf-simple:latest
# Podman
podman run -d \
--name bentopdf \
-p 3000:8080 \
ghcr.io/alam00000/bentopdf-simple:latest
```
## Docker Compose / Podman Compose
Créez `docker-compose.yml` :
```yaml
services:
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
container_name: bentopdf
ports:
- '3000:8080'
restart: unless-stopped
healthcheck:
test: ['CMD', 'wget', '--spider', '-q', 'http://localhost:8080']
interval: 30s
timeout: 10s
retries: 3
```
Exécutez :
```bash
# Docker Compose
docker compose up -d
# Podman Compose
podman-compose up -d
```
## Construire votre propre image
```dockerfile
# Dockerfile
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
FROM nginxinc/nginx-unprivileged:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 8080
CMD ["nginx", "-g", "daemon off;"]
```
Construisez et exécutez :
```bash
docker build -t bentopdf:custom .
docker run -d -p 3000:8080 bentopdf:custom
```
## Variables d'environnement
| Variable | Description | Par défaut |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------- |
| `SIMPLE_MODE` | Compile la variante auto-hébergée (masque l'habillage marketing de bentopdf.com : section d'en-tête, FAQ, témoignages, pied de page). Tous les outils PDF restent disponibles. | `false` |
| `BASE_URL` | Déployer dans un sous-répertoire | `/` |
| `VITE_WASM_PYMUPDF_URL` | URL du module WASM PyMuPDF | `https://cdn.jsdelivr.net/npm/@bentopdf/pymupdf-wasm@0.11.16/` |
| `VITE_WASM_GS_URL` | URL du module WASM Ghostscript | `https://cdn.jsdelivr.net/npm/@bentopdf/gs-wasm@0.1.1/assets/` |
| `VITE_WASM_CPDF_URL` | URL du module WASM CoherentPDF | `https://cdn.jsdelivr.net/npm/coherentpdf@2.5.5/dist/` |
| `VITE_TESSERACT_WORKER_URL` | URL du script worker OCR | _(vide ; CDN par défaut de Tesseract.js)_ |
| `VITE_TESSERACT_CORE_URL` | Dossier du runtime principal OCR | _(vide ; CDN par défaut de Tesseract.js)_ |
| `VITE_TESSERACT_LANG_URL` | Dossier des fichiers traineddata OCR | _(vide ; CDN par défaut de Tesseract.js)_ |
| `VITE_TESSERACT_AVAILABLE_LANGUAGES` | Langues OCR séparées par des virgules affichées dans l'interface | _(vide ; catalogue complet affiché)_ |
| `VITE_OCR_FONT_BASE_URL` | Dossier des polices de la couche de texte OCR | _(vide ; URL de polices Noto distantes)_ |
| `VITE_DEFAULT_LANGUAGE` | Langue par défaut de l'interface | `en` |
| `VITE_BRAND_NAME` | Nom de marque personnalisé | `BentoPDF` |
| `VITE_BRAND_LOGO` | Chemin du logo relatif à `public/` | `images/favicon-no-bg.svg` |
| `VITE_FOOTER_TEXT` | Texte de pied de page/copyright personnalisé | `© 2026 BentoPDF. All rights reserved.` |
| `DISABLE_TOOLS` | ID d'outils séparés par des virgules à masquer | _(vide ; tous les outils activés)_ |
| `DISABLE_GITHUB_STARS` | Ignore la récupération du nombre d'étoiles GitHub au chargement de la page et retire `api.github.com` de la CSP. Les builds en Simple Mode l'ignorent toujours. | `false` |
| `SITE_URL` | URL publique écrite dans les liens canonical, hreflang et sitemap. Laissez la valeur par défaut, sauf si vous voulez que les moteurs de recherche traitent votre déploiement comme un site à part entière. | `https://www.bentopdf.com` |
| `ALLOW_INDEXING` | Avec un `SITE_URL` personnalisé, chaque page est marquée `noindex` pour que votre copie ne concurrence pas bentopdf.com dans les résultats de recherche. Définissez `true` pour autoriser l'indexation par les moteurs de recherche. | `false` |
Les URL des modules WASM sont préconfigurées avec des valeurs CDN par défaut : toutes les fonctionnalités avancées fonctionnent sans configuration. Remplacez-les pour les déploiements isolés du réseau ou auto-hébergés.
### Moteurs de recherche
Par défaut, chaque page indique aux moteurs de recherche que bentopdf.com est l'original, afin que votre déploiement n'apparaisse pas comme un doublon. Vous n'avez rien à changer pour une instance privée ou interne.
- **Exclure totalement votre instance des résultats de recherche :** lancez le conteneur avec `-e ROBOTS_NOINDEX=true`. Un simple redémarrage suffit, sans recompilation.
- **Faire de votre instance un site à part entière dans les résultats de recherche :** compilez avec `--build-arg SITE_URL=https://your-domain.example --build-arg ALLOW_INDEXING=true`. Sans `ALLOW_INDEXING=true`, un `SITE_URL` personnalisé marque chaque page `noindex`.
### Content-Security-Policy
L'image nginx est livrée avec un en-tête `Content-Security-Policy` appliqué. Les directives `script-src`, `connect-src` et `font-src` de la CSP sont **générées à la compilation** à partir des variables d'URL `VITE_*` ci-dessus : tous les hôtes que vous passez via `--build-arg` sont automatiquement ajoutés à la politique.
En conséquence :
- Si vous remplacez `VITE_CORS_PROXY_URL` ou `VITE_WASM_*_URL` à la compilation, la CSP autorise automatiquement ces origines, sans configuration supplémentaire.
- Pour les URL sur `cdn.jsdelivr.net`, `script-src` n'autorise que le dossier exact du paquet versionné, par exemple `https://cdn.jsdelivr.net/npm/@bentopdf/pymupdf-wasm@0.11.16/`, et non tout le CDN. jsDelivr sert n'importe quel paquet npm public ou dépôt GitHub : autoriser tout l'hôte permettrait à chacun de s'exécuter sur votre instance. Les URL sur tout autre hôte sont autorisées par origine.
- Si vous configurez des URL WASM personnalisées _à l'exécution_ via la page Paramètres avancés de l'application, ces origines ne figurent **pas** dans la CSP et le navigateur bloquera les requêtes vers elles. Cela s'applique aussi à une autre version du même paquet sur `cdn.jsdelivr.net`, car seule la version définie à la compilation est autorisée. La configuration à l'exécution est prévue pour l'expérimentation ; pour des URL personnalisées permanentes, définissez l'argument de build `VITE_*` correspondant.
- Dans les déploiements isolés du réseau qui remplacent les trois valeurs `VITE_WASM_*_URL`, ces dossiers de paquets `cdn.jsdelivr.net` sont aussi retirés de la CSP (chaque valeur par défaut est remplacée, pas complétée). Les valeurs par défaut de Tesseract OCR sur `cdn.jsdelivr.net` restent dans la politique tant que vous ne définissez pas aussi les trois valeurs `VITE_TESSERACT_*`. De même, définir `VITE_CORS_PROXY_URL` remplace la valeur publique par défaut `bentopdf-cors-proxy.bentopdf.workers.dev`.
La CSP inclut `'unsafe-eval'` dans `script-src`, car le runtime LibreOffice WASM (utilisé par les outils de conversion Word/Excel/PowerPoint) et la bibliothèque d'images wasm-vips (utilisée par PDF vers TIFF) compilent du code de dispatch interne via `new Function()`. Le supprimer casserait ces outils. Si vous compilez en `SIMPLE_MODE` (sans LibreOffice) et n'avez pas besoin de PDF vers TIFF, vous pouvez modifier manuellement le fichier `security-headers.conf` généré pour retirer `'unsafe-eval'` et obtenir une politique plus stricte.
Pour l'OCR, laissez les variables `VITE_TESSERACT_*` vides afin d'utiliser les ressources en ligne par défaut, ou définissez les trois ensemble pour un OCR auto-hébergé/hors ligne. Les remplacements OCR partiels sont refusés, car le worker, le runtime principal et le dossier traineddata doivent correspondre. Pour une production de PDF avec texte recherchable entièrement hors ligne, définissez aussi `VITE_OCR_FONT_BASE_URL` afin que les polices de la couche de texte OCR soient chargées depuis votre serveur interne plutôt que depuis les URL publiques des polices Noto.
`VITE_DEFAULT_LANGUAGE` définit la langue de l'interface pour les nouveaux visiteurs. Valeurs prises en charge : `en`, `ar`, `be`, `fr`, `de`, `es`, `zh`, `zh-TW`, `vi`, `tr`, `id`, `it`, `pt`, `nl`, `da`. Les utilisateurs peuvent toujours changer de langue : cela ne modifie que la valeur par défaut.
Exemple :
```bash
# Build with French as the default language
docker build --build-arg VITE_DEFAULT_LANGUAGE=fr -t bentopdf .
docker run -d -p 3000:8080 bentopdf
```
### Image de marque personnalisée
Remplacez le logo, le nom et le texte de pied de page par défaut de BentoPDF par les vôtres. Placez votre fichier de logo dans le dossier `public/` (ou utilisez une image existante), puis passez les variables de marque à la compilation :
```bash
docker build \
--build-arg VITE_BRAND_NAME="AcmePDF" \
--build-arg VITE_BRAND_LOGO="images/acme-logo.svg" \
--build-arg VITE_FOOTER_TEXT="© 2026 Acme Corp. Internal use only." \
-t acmepdf .
```
La personnalisation fonctionne en mode complet comme en Simple Mode, et peut se combiner avec toutes les autres options de compilation.
### Désactiver des outils spécifiques
Masquez des outils de l'interface pour des exigences de conformité ou de sécurité. Les outils désactivés sont retirés de la page d'accueil, des résultats de recherche, des raccourcis clavier et du créateur de workflows. L'accès direct par URL affiche une page « outil indisponible ».
Les ID d'outils correspondent à l'URL de la page sans `.html`. Par exemple, si l'outil se trouve à `bentopdf.com/edit-pdf.html`, l'ID est `edit-pdf`.
#### Trouver les ID d'outils
Le plus simple : ouvrez n'importe quel outil dans BentoPDF et regardez l'URL. La dernière partie du chemin (sans `.html`) est l'ID de l'outil.
<details>
<summary>Liste complète des ID d'outils</summary>
**Éditer et annoter :** `edit-pdf`, `bookmark`, `table-of-contents`, `page-numbers`, `add-page-labels`, `bates-numbering`, `add-watermark`, `header-footer`, `invert-colors`, `scanner-effect`, `adjust-colors`, `background-color`, `text-color`, `sign-pdf`, `add-stamps`, `remove-annotations`, `crop-pdf`, `form-filler`, `form-creator`, `remove-blank-pages`
**Convertir en PDF :** `image-to-pdf`, `jpg-to-pdf`, `png-to-pdf`, `webp-to-pdf`, `svg-to-pdf`, `bmp-to-pdf`, `heic-to-pdf`, `tiff-to-pdf`, `txt-to-pdf`, `markdown-to-pdf`, `json-to-pdf`, `csv-to-pdf`, `rtf-to-pdf`, `odt-to-pdf`, `word-to-pdf`, `excel-to-pdf`, `powerpoint-to-pdf`, `xps-to-pdf`, `mobi-to-pdf`, `epub-to-pdf`, `fb2-to-pdf`, `cbz-to-pdf`, `wpd-to-pdf`, `wps-to-pdf`, `xml-to-pdf`, `pages-to-pdf`, `odg-to-pdf`, `ods-to-pdf`, `odp-to-pdf`, `pub-to-pdf`, `vsd-to-pdf`, `psd-to-pdf`, `email-to-pdf`
**Convertir depuis PDF :** `pdf-to-jpg`, `pdf-to-png`, `pdf-to-webp`, `pdf-to-bmp`, `pdf-to-tiff`, `pdf-to-cbz`, `pdf-to-svg`, `pdf-to-csv`, `pdf-to-excel`, `pdf-to-greyscale`, `pdf-to-json`, `pdf-to-docx`, `extract-images`, `pdf-to-markdown`, `prepare-pdf-for-ai`, `pdf-to-text`
**Organiser et gérer :** `ocr-pdf`, `merge-pdf`, `alternate-merge`, `organize-pdf`, `add-attachments`, `extract-attachments`, `edit-attachments`, `pdf-multi-tool`, `pdf-layers`, `extract-tables`, `split-pdf`, `divide-pages`, `extract-pages`, `delete-pages`, `add-blank-page`, `reverse-pages`, `rotate-pdf`, `rotate-custom`, `n-up-pdf`, `pdf-booklet`, `combine-single-page`, `view-metadata`, `edit-metadata`, `pdf-to-zip`, `compare-pdfs`, `posterize-pdf`, `page-dimensions`
**Optimiser et réparer :** `compress-pdf`, `pdf-to-pdfa`, `fix-page-size`, `linearize-pdf`, `remove-restrictions`, `repair-pdf`, `rasterize-pdf`, `deskew-pdf`, `font-to-outline`
**Sécurité :** `encrypt-pdf`, `sanitize-pdf`, `decrypt-pdf`, `flatten-pdf`, `remove-metadata`, `change-permissions`, `digital-sign-pdf`, `validate-signature-pdf`, `timestamp-pdf`
</details>
#### Option 1 : à la compilation (argument de build Docker)
```bash
docker build \
--build-arg DISABLE_TOOLS="edit-pdf,sign-pdf,encrypt-pdf" \
-t bentopdf .
```
Cela intègre la liste des outils désactivés dans le bundle JavaScript. Une recompilation est nécessaire pour la modifier.
#### Option 2 : à l'exécution (config.json)
Montez un fichier `config.json` dans le répertoire servi, sans recompilation :
```json
{
"disabledTools": ["edit-pdf", "sign-pdf", "encrypt-pdf"]
}
```
```bash
docker run -d \
-p 3000:8080 \
-v ./config.json:/usr/share/nginx/html/config.json:ro \
ghcr.io/alam00000/bentopdf-simple:latest
```
Ou avec Docker Compose :
```yaml
services:
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
ports:
- '3000:8080'
volumes:
- ./config.json:/usr/share/nginx/html/config.json:ro
```
Les deux méthodes peuvent être combinées : les listes sont fusionnées. Si un outil figure dans l'une ou l'autre, il est désactivé.
#### Désactiver des fonctionnalités de l'éditeur
Vous pouvez aussi désactiver des fonctionnalités précises de l'éditeur PDF (p. ex. caviardage, annotations, formulaires) sans désactiver l'outil d'édition entier. Ajoutez `editorDisabledCategories` à votre `config.json` :
```json
{
"editorDisabledCategories": ["redaction", "annotation-stamp"]
}
```
<details>
<summary>Liste complète des catégories de l'éditeur</summary>
**Zoom :** `zoom`, `zoom-in`, `zoom-out`, `zoom-fit-page`, `zoom-fit-width`, `zoom-marquee`, `zoom-level`
**Annotation :** `annotation`, `annotation-markup`, `annotation-highlight`, `annotation-underline`, `annotation-strikeout`, `annotation-squiggly`, `annotation-ink`, `annotation-text`, `annotation-stamp`
**Formes :** `annotation-shape`, `annotation-rectangle`, `annotation-circle`, `annotation-line`, `annotation-arrow`, `annotation-polygon`, `annotation-polyline`
**Formulaire :** `form`, `form-textfield`, `form-checkbox`, `form-radio`, `form-select`, `form-listbox`, `form-fill-mode`
**Caviardage :** `redaction`, `redaction-area`, `redaction-text`, `redaction-apply`, `redaction-clear`
**Document :** `document`, `document-open`, `document-close`, `document-print`, `document-capture`, `document-export`, `document-fullscreen`, `document-protect`
**Page :** `page`, `spread`, `rotate`, `scroll`, `navigation`
**Panneau :** `panel`, `panel-sidebar`, `panel-search`, `panel-comment`
**Outils :** `tools`, `pan`, `pointer`, `capture`
**Sélection :** `selection`, `selection-copy`
**Historique :** `history`, `history-undo`, `history-redo`
</details>
Les catégories sont hiérarchiques : désactiver un parent (p. ex. `annotation`) désactive tous ses enfants.
### Désactiver le compteur d'étoiles GitHub
La barre de navigation affiche le nombre d'étoiles GitHub en direct, récupéré depuis `api.github.com` au chargement de la page. C'est la seule requête externe qui ne sert pas une fonctionnalité PDF. Désactivez-la à la compilation pour retirer le code de récupération du bundle et supprimer `api.github.com` de la Content-Security-Policy :
```bash
docker build --build-arg DISABLE_GITHUB_STARS=true -t bentopdf .
```
Les builds en Simple Mode (`bentopdf-simple`) ignorent toujours le compteur d'étoiles : cette option n'est utile que pour la version commerciale ou les builds complets personnalisés.
### URL WASM personnalisées (isolé du réseau / auto-hébergé)
> [!IMPORTANT]
> Les URL WASM sont intégrées au JavaScript **à la compilation**. Les fichiers WASM sont téléchargés par le **navigateur de l'utilisateur** à l'exécution : Docker ne les télécharge pas pendant le build. Pour les réseaux isolés, vous devez héberger les fichiers WASM sur un serveur interne accessible aux navigateurs.
**Workflow complet pour un réseau isolé :**
```bash
# 1. On a machine WITH internet — download WASM packages
bash scripts/prepare-airgap.sh --list-ocr-languages
bash scripts/prepare-airgap.sh --search-ocr-language german
# 2. Download WASM/OCR packages
npm pack @bentopdf/pymupdf-wasm@0.11.14
npm pack @bentopdf/gs-wasm
npm pack coherentpdf
npm pack tesseract.js@7.0.0
npm pack tesseract.js-core@7.0.0
mkdir -p tesseract-langdata
curl -fsSL https://cdn.jsdelivr.net/npm/@tesseract.js-data/eng/4.0.0_best_int/eng.traineddata.gz -o tesseract-langdata/eng.traineddata.gz
mkdir -p ocr-fonts
curl -fsSL https://raw.githack.com/googlefonts/noto-fonts/main/hinted/ttf/NotoSans/NotoSans-Regular.ttf -o ocr-fonts/NotoSans-Regular.ttf
# 3. Build the image with your internal server URLs
docker build \
--build-arg VITE_WASM_PYMUPDF_URL=https://internal-server.example.com/wasm/pymupdf/ \
--build-arg VITE_WASM_GS_URL=https://internal-server.example.com/wasm/gs/ \
--build-arg VITE_WASM_CPDF_URL=https://internal-server.example.com/wasm/cpdf/ \
--build-arg VITE_TESSERACT_WORKER_URL=https://internal-server.example.com/wasm/ocr/worker.min.js \
--build-arg VITE_TESSERACT_CORE_URL=https://internal-server.example.com/wasm/ocr/core \
--build-arg VITE_TESSERACT_LANG_URL=https://internal-server.example.com/wasm/ocr/lang-data \
--build-arg VITE_TESSERACT_AVAILABLE_LANGUAGES=eng,deu \
--build-arg VITE_OCR_FONT_BASE_URL=https://internal-server.example.com/wasm/ocr/fonts \
-t bentopdf .
# 4. Export the image
docker save bentopdf -o bentopdf.tar
# 5. Transfer bentopdf.tar + the .tgz packages + tesseract-langdata/ + ocr-fonts/ into the air-gapped network
# 6. Inside the air-gapped network — load and run
docker load -i bentopdf.tar
# Extract WASM packages to your internal web server
mkdir -p /var/www/wasm/pymupdf /var/www/wasm/gs /var/www/wasm/cpdf /var/www/wasm/ocr/core /var/www/wasm/ocr/lang-data /var/www/wasm/ocr/fonts
tar xzf bentopdf-pymupdf-wasm-0.11.14.tgz -C /var/www/wasm/pymupdf --strip-components=1
tar xzf bentopdf-gs-wasm-*.tgz -C /var/www/wasm/gs --strip-components=1
tar xzf coherentpdf-*.tgz -C /var/www/wasm/cpdf --strip-components=1
TEMP_TESS=$(mktemp -d)
tar xzf tesseract.js-7.0.0.tgz -C "$TEMP_TESS"
cp "$TEMP_TESS/package/dist/worker.min.js" /var/www/wasm/ocr/worker.min.js
rm -rf "$TEMP_TESS"
tar xzf tesseract.js-core-7.0.0.tgz -C /var/www/wasm/ocr/core --strip-components=1
cp ./tesseract-langdata/*.traineddata.gz /var/www/wasm/ocr/lang-data/
cp ./ocr-fonts/* /var/www/wasm/ocr/fonts/
# Run BentoPDF
docker run -d -p 3000:8080 --restart unless-stopped bentopdf
```
Utilisez pour `--ocr-languages` les codes affichés par `bash scripts/prepare-airgap.sh --list-ocr-languages`, ou cherchez par nom avec `bash scripts/prepare-airgap.sh --search-ocr-language <term>`. Lorsque vous compilez avec un sous-ensemble OCR restreint, passez les mêmes codes à `VITE_TESSERACT_AVAILABLE_LANGUAGES` afin que l'application n'affiche que les langues incluses. Pour une sortie OCR entièrement hors ligne, hébergez aussi le dossier `ocr-fonts/` fourni et pointez `VITE_OCR_FONT_BASE_URL` vers lui.
Définissez une variable sur une chaîne vide pour désactiver ce module (les utilisateurs devront le configurer manuellement via les Paramètres avancés).
## Port personnalisé
Par défaut, BentoPDF écoute sur le port `8080` à l'intérieur du conteneur. Pour le modifier, définissez la variable d'environnement `PORT` à l'exécution :
```bash
docker run -p 3000:9090 -e PORT=9090 ghcr.io/alam00000/bentopdf-simple:latest
```
| Variable | Description | Par défaut |
| -------- | ------------------------------------- | ---------- |
| `PORT` | Port d'écoute Nginx dans le conteneur | `8080` |
Cela fonctionne avec le Dockerfile standard comme avec le Dockerfile nonroot.
## ID utilisateur personnalisé (PUID/PGID)
Pour les environnements qui exigent une exécution sous un utilisateur non root précis (NAS, Kubernetes avec contextes de sécurité, politiques d'organisation), BentoPDF fournit un Dockerfile distinct avec prise en charge PUID/PGID de style LSIO.
### Construire et exécuter
```bash
# Build the non-root image
docker build -f Dockerfile.nonroot -t bentopdf-nonroot .
# Run with custom UID/GID
docker run -d \
--name bentopdf \
-p 3000:8080 \
-e PUID=1000 \
-e PGID=1000 \
--restart unless-stopped \
bentopdf-nonroot
```
### Variables d'environnement
| Variable | Description | Par défaut |
| -------------- | -------------------------- | ---------- |
| `PUID` | ID utilisateur d'exécution | `1000` |
| `PGID` | ID de groupe d'exécution | `1000` |
| `PORT` | Port d'écoute Nginx | `8080` |
| `DISABLE_IPV6` | Désactiver l'écoute IPv6 | `false` |
### Docker Compose
```yaml
services:
bentopdf:
build:
context: .
dockerfile: Dockerfile.nonroot
container_name: bentopdf
ports:
- '3000:8080'
environment:
- PUID=1000
- PGID=1000
restart: unless-stopped
```
### Fonctionnement
Le conteneur démarre en root, crée un utilisateur avec le PUID/PGID indiqué, ajuste la propriété de tous les répertoires inscriptibles, puis abandonne ses privilèges avec `su-exec`. Le processus nginx s'exécute entièrement sous l'utilisateur que vous avez indiqué.
> [!NOTE]
> Le `Dockerfile` standard utilise `nginx-unprivileged` (UID 101) et est recommandé pour la plupart des déploiements. N'utilisez `Dockerfile.nonroot` que si vous avez besoin d'un UID/GID précis.
> [!WARNING]
> PUID/PGID ne peuvent pas valoir `0` (root). Le point d'entrée valide les valeurs et s'arrête avec une erreur si elles sont invalides.
## Avec Traefik (reverse proxy)
```yaml
services:
traefik:
image: traefik:v2.10
command:
- '--providers.docker=true'
- '--entrypoints.web.address=:80'
- '--entrypoints.websecure.address=:443'
- '--certificatesresolvers.letsencrypt.acme.email=you@example.com'
- '--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json'
- '--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web'
ports:
- '80:80'
- '443:443'
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
- ./letsencrypt:/letsencrypt
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
labels:
- 'traefik.enable=true'
- 'traefik.http.routers.bentopdf.rule=Host(`pdf.example.com`)'
- 'traefik.http.routers.bentopdf.entrypoints=websecure'
- 'traefik.http.routers.bentopdf.tls.certresolver=letsencrypt'
- 'traefik.http.services.bentopdf.loadbalancer.server.port=8080'
# Required headers for SharedArrayBuffer (LibreOffice WASM)
- 'traefik.http.routers.bentopdf.middlewares=bentopdf-headers'
- 'traefik.http.middlewares.bentopdf-headers.headers.customresponseheaders.Cross-Origin-Opener-Policy=same-origin'
- 'traefik.http.middlewares.bentopdf-headers.headers.customresponseheaders.Cross-Origin-Embedder-Policy=require-corp'
restart: unless-stopped
```
## Avec Caddy (reverse proxy)
```yaml
services:
caddy:
image: caddy:2
ports:
- '80:80'
- '443:443'
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile
- caddy_data:/data
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
restart: unless-stopped
volumes:
caddy_data:
```
Caddyfile :
```
pdf.example.com {
reverse_proxy bentopdf:8080
header Cross-Origin-Opener-Policy "same-origin"
header Cross-Origin-Embedder-Policy "require-corp"
}
```
## Limites de ressources
```yaml
services:
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
deploy:
resources:
limits:
cpus: '1'
memory: 512M
reservations:
cpus: '0.25'
memory: 128M
```
## Podman Quadlet (intégration systemd)
[Quadlet](https://docs.podman.io/en/latest/markdown/podman-systemd.unit.5.html) permet d'exécuter des conteneurs Podman comme services systemd. C'est idéal pour les déploiements en production sur Linux.
### Configuration Quadlet de base
Créez un fichier d'unité de conteneur à `~/.config/containers/systemd/bentopdf.container` (utilisateur) ou `/etc/containers/systemd/bentopdf.container` (système) :
```ini
[Unit]
Description=BentoPDF - Privacy-first PDF toolkit
After=network-online.target
Wants=network-online.target
[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
AutoUpdate=registry
[Service]
Restart=always
TimeoutStartSec=300
[Install]
WantedBy=default.target
```
### Activer et démarrer
```bash
# Reload systemd to detect new unit
systemctl --user daemon-reload
# Start the service
systemctl --user start bentopdf
# Enable on boot
systemctl --user enable bentopdf
# Check status
systemctl --user status bentopdf
# View logs
journalctl --user -u bentopdf -f
```
> [!TIP]
> Pour un déploiement à l'échelle du système, utilisez `systemctl` sans l'option `--user` et placez le fichier dans `/etc/containers/systemd/`.
### Quadlet avec contrôle de santé
```ini
[Unit]
Description=BentoPDF with health monitoring
After=network-online.target
Wants=network-online.target
[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
AutoUpdate=registry
HealthCmd=wget --spider -q http://localhost:8080 || exit 1
HealthInterval=30s
HealthTimeout=10s
HealthRetries=3
[Service]
Restart=always
TimeoutStartSec=300
[Install]
WantedBy=default.target
```
### Mise à jour automatique avec Quadlet
Podman peut mettre à jour automatiquement les conteneurs lorsque de nouvelles images sont disponibles :
```bash
# Enable auto-update timer
systemctl --user enable --now podman-auto-update.timer
# Check for updates manually
podman auto-update
# Dry run (check without updating)
podman auto-update --dry-run
```
### Configuration réseau Quadlet
Pour une configuration réseau personnalisée, créez un fichier réseau `bentopdf.network` :
```ini
[Network]
Subnet=10.89.0.0/24
Gateway=10.89.0.1
```
Référencez-le ensuite dans votre fichier de conteneur :
```ini
[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
Network=bentopdf.network
```
## Mise à jour
```bash
# Pull latest image
docker compose pull
# Recreate container
docker compose up -d
```
docs/fr/self-hosting/hostinger.md
+266
View File
@@ -0,0 +1,266 @@
# Déployer sur Hostinger
[Hostinger](https://hostinger.com) est un hébergeur mutualisé très répandu. Ce guide explique comment déployer BentoPDF sur l'hébergement mutualisé de Hostinger.
## Prérequis
- Offre d'hébergement Hostinger avec accès au gestionnaire de fichiers
- Node.js installé en local pour la compilation
## Étape 1 : compiler le projet
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
```
Les fichiers compilés se trouvent dans le dossier `dist`.
## Étape 2 : téléverser sur Hostinger
### Déploiement à la racine du domaine
1. Connectez-vous à votre compte Hostinger
2. Allez dans **File Manager** → **public_html**
3. **Supprimez** tous les fichiers existants (faites une sauvegarde si nécessaire)
4. **Téléversez** tout le contenu de votre dossier local `dist` dans `public_html`
### Déploiement dans un sous-répertoire
Si vous déployez dans un sous-répertoire (p. ex. `yourdomain.com/pdf-tools/`) :
1. Compilez avec la bonne URL de base :
```bash
BASE_URL=/pdf-tools/ npm run build
```
2. Créez le dossier dans Hostinger :
- Allez dans **File Manager** → **public_html**
- Créez un nouveau dossier : `pdf-tools`
3. Téléversez tout le contenu de `dist` dans `public_html/pdf-tools/`
## Étape 3 : créer le fichier .htaccess
Créez un fichier `.htaccess` à la racine de votre dossier de déploiement (`public_html` ou `public_html/pdf-tools/`) :
::: warning Important
Pour un déploiement dans un sous-répertoire, remplacez `RewriteBase /` par `RewriteBase /pdf-tools/` (ou le nom de votre dossier).
:::
```apache
RewriteEngine On
RewriteBase /
# ============================================
# 1. SECURITY HEADERS (CRITICAL FOR WASM)
# ============================================
<IfModule mod_headers.c>
Header always set X-Frame-Options "SAMEORIGIN"
Header always set X-Content-Type-Options "nosniff"
Header always set X-XSS-Protection "1; mode=block"
Header always set Referrer-Policy "strict-origin-when-cross-origin"
Header always set Permissions-Policy "geolocation=(), microphone=(), camera=()"
# REQUIRED for soffice.js (SharedArrayBuffer)
Header always set Cross-Origin-Opener-Policy "same-origin"
Header always set Cross-Origin-Embedder-Policy "require-corp"
</IfModule>
# ============================================
# 2. BROWSER CACHING
# ============================================
<IfModule mod_expires.c>
ExpiresActive On
ExpiresByType image/jpeg "access plus 1 year"
ExpiresByType image/png "access plus 1 year"
ExpiresByType image/gif "access plus 1 year"
ExpiresByType image/webp "access plus 1 year"
ExpiresByType image/svg+xml "access plus 1 year"
ExpiresByType image/x-icon "access plus 1 year"
ExpiresByType font/woff2 "access plus 1 year"
ExpiresByType font/woff "access plus 1 year"
ExpiresByType font/ttf "access plus 1 year"
ExpiresByType text/css "access plus 1 month"
ExpiresByType application/javascript "access plus 1 month"
ExpiresByType application/wasm "access plus 1 year"
ExpiresByType application/gzip "access plus 1 year"
ExpiresByType text/html "access plus 0 seconds"
</IfModule>
# ============================================
# 3. COMPRESSION (STANDARD)
# ============================================
# Prevent server from double-compressing files
SetEnvIfNoCase Request_URI "\.gz$" no-gzip
SetEnvIfNoCase Request_URI "\.br$" no-gzip
SetEnvIfNoCase Request_URI "\.wasm$" no-gzip
<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE text/plain
AddOutputFilterByType DEFLATE text/html
AddOutputFilterByType DEFLATE text/xml
AddOutputFilterByType DEFLATE text/css
AddOutputFilterByType DEFLATE application/xml
AddOutputFilterByType DEFLATE application/xhtml+xml
AddOutputFilterByType DEFLATE application/rss+xml
AddOutputFilterByType DEFLATE application/javascript
AddOutputFilterByType DEFLATE application/x-javascript
AddOutputFilterByType DEFLATE application/json
AddOutputFilterByType DEFLATE image/svg+xml
AddOutputFilterByType DEFLATE font/woff
AddOutputFilterByType DEFLATE font/ttf
</IfModule>
# ============================================
# 4. MIME TYPES & SPECIAL FILE HANDLING
# ============================================
AddType application/javascript .js .mjs
AddType application/wasm .wasm
AddType font/woff2 .woff2
AddType font/woff .woff
AddType image/webp .webp
# Handle soffice.wasm.gz correctly
<FilesMatch "soffice\.wasm\.gz$">
ForceType application/wasm
Header set Content-Encoding "gzip"
Header set Cross-Origin-Resource-Policy "cross-origin"
Header append Vary Accept-Encoding
</FilesMatch>
# Handle data.gz
<FilesMatch "soffice\.data\.gz$">
ForceType application/octet-stream
Header set Content-Encoding "gzip"
Header append Vary Accept-Encoding
</FilesMatch>
# ============================================
# 5. REDIRECTS & ROUTING
# ============================================
# Canonical WWW (update domain as needed)
RewriteCond %{HTTP_HOST} ^bentopdf\.com [NC]
RewriteRule ^(.*)$ https://www.bentopdf.com/$1 [L,R=301]
# Force HTTPS
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]
# Remove trailing slash (except for language root directories)
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_URI} !^/(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/$
RewriteCond %{REQUEST_URI} (.+)/$
RewriteRule ^ %1 [R=301,L]
# Existing files/dirs - serve directly
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]
# ============================================
# 5.1. LANGUAGE ROUTES
# ============================================
# Supported languages: de, es, zh, zh-TW, vi, it, id, tr, fr, pt
# English has no prefix - served from root
# English prefix redirects to root (for SEO consistency)
RewriteRule ^en/?$ / [R=301,L]
RewriteRule ^en/(.+)$ /$1 [R=301,L]
# Language prefix root (e.g., /de/ -> /de/index.html)
RewriteCond %{DOCUMENT_ROOT}/$1/index.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/?$ /$1/index.html [L]
# Language prefix with path (e.g., /de/merge-pdf -> /de/merge-pdf.html)
RewriteCond %{DOCUMENT_ROOT}/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /$1/$2.html [L]
# ============================================
# 5.5. DOCS ROUTING (VitePress)
# ============================================
RewriteCond %{REQUEST_URI} ^/docs
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME}\.html -f
RewriteRule ^(.*)$ $1.html [L]
# ============================================
# 6. ADD .HTML EXTENSION IF FILE EXISTS (ROOT LEVEL ONLY)
# ============================================
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
# ============================================
# 7. ERROR PAGES
# ============================================
ErrorDocument 404 /404.html
```
## Exemple de .htaccess pour un sous-répertoire
Pour `yourdomain.com/pdf-tools/`, modifiez ces lignes :
```apache
RewriteBase /pdf-tools/
# ... (same content as above, but update paths) ...
# Language prefix root
RewriteCond %{DOCUMENT_ROOT}/pdf-tools/$1/index.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/?$ /pdf-tools/$1/index.html [L]
# Language prefix with path
RewriteCond %{DOCUMENT_ROOT}/pdf-tools/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /pdf-tools/$1/$2.html [L]
# Root level .html extension
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
ErrorDocument 404 /pdf-tools/404.html
```
## Dépannage
### Les fichiers WASM ne se chargent pas
Vérifiez que les types MIME sont correctement définis dans `.htaccess` :
```apache
AddType application/wasm .wasm
```
### Les outils LibreOffice ne fonctionnent pas
Les en-têtes de sécurité sont essentiels pour SharedArrayBuffer :
```apache
Header always set Cross-Origin-Opener-Policy "same-origin"
Header always set Cross-Origin-Embedder-Policy "require-corp"
```
Si les en-têtes ne sont pas appliqués, contactez le support Hostinger pour activer `mod_headers`.
### Erreurs 404 lors de l'actualisation de la page
Assurez-vous que la règle d'extension `.html` et les routes de langue sont correctement configurées. BentoPDF utilise des fichiers HTML statiques, pas un routage SPA :
```apache
# Language routes serve actual files from language directories
RewriteCond %{DOCUMENT_ROOT}/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /$1/$2.html [L]
# Root level pages
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
```
### Limites de téléversement
Hostinger peut imposer des limites de taille de fichier. Téléversez les fichiers WASM séparément si le téléversement groupé échoue.
docs/fr/self-hosting/index.md
+538
View File
@@ -0,0 +1,538 @@
# Guide d'auto-hébergement
BentoPDF peut être auto-hébergé sur votre propre infrastructure. Ce guide présente différentes options de déploiement.
## Démarrage rapide avec Docker / Podman
Le moyen le plus rapide d'auto-héberger BentoPDF :
> [!TIP]
> BentoPDF est disponible en deux versions :
>
> - **Version auto-hébergée** : `ghcr.io/alam00000/bentopdf-simple:latest`. Tous les outils PDF, **sans** l'habillage marketing (pas de section d'accueil, de FAQ, de témoignages ni de pied de page). À utiliser pour les déploiements internes, d'équipe ou d'organisation. Ce **n'est pas** une version « allégée » avec moins de fonctionnalités.
> - **Version commerciale** : `ghcr.io/alam00000/bentopdf:latest`. Le site marketing complet, utilisé par bentopdf.com lui-même et par les titulaires d'une licence commerciale qui exploitent des déploiements publics.
>
> Dans le doute : utilisez la version auto-hébergée.
> [!IMPORTANT]
> La conversion de fichiers Office nécessite `SharedArrayBuffer`, ce qui impose que l'application soit à la fois isolée cross-origin et servie depuis un contexte sécurisé. L'image officielle envoie déjà les en-têtes COOP/COEP requis, mais les navigateurs désactivent quand même `SharedArrayBuffer` sur les origines HTTP simples du réseau local comme `http://192.168.x.x`.
>
> N'utilisez `http://localhost` que pour des tests sur le même appareil. Si les utilisateurs accèdent à BentoPDF via une IP ou un nom d'hôte du réseau local, terminez la connexion en HTTPS.
```bash
# Docker
docker run -d -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest
# Podman
podman run -d -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest
```
Ou avec Docker Compose / Podman Compose :
```yaml
# docker-compose.yml
services:
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
ports:
- '3000:8080'
restart: unless-stopped
```
```bash
# Docker Compose
docker compose up -d
# Podman Compose
podman-compose up -d
```
## Podman Quadlet (systemd sous Linux)
Exécutez BentoPDF comme service systemd. Créez `~/.config/containers/systemd/bentopdf.container` :
```ini
[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
AutoUpdate=registry
[Service]
Restart=always
[Install]
WantedBy=default.target
```
```bash
systemctl --user daemon-reload
systemctl --user enable --now bentopdf
```
Consultez le [guide de déploiement Docker](/fr/self-hosting/docker) pour la documentation complète de Quadlet.
## Compiler depuis les sources
```bash
# Clone and build
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
# The built files are in the `dist` folder
```
## Options de configuration
### Version auto-hébergée (mode simple)
La version auto-hébergée (l'image `bentopdf-simple`, aussi appelée mode simple) est **fonctionnellement identique** à la version commerciale : tous les outils PDF sont présents et se comportent de la même façon. Elle masque simplement l'habillage marketing qui n'a de sens que sur bentopdf.com ou sur un déploiement commercial public. **Ce n'est pas une version allégée avec moins de fonctionnalités.**
**Ce que la version auto-hébergée masque** (purement cosmétique, aucune fonctionnalité PDF n'est retirée) :
- Barre de navigation, section d'accueil, section des fonctionnalités, FAQ, témoignages, pied de page
- Remplace le titre de la page par « Outils PDF »
**Ce que la version auto-hébergée conserve** (tout ce qui traite réellement les PDF) :
- Tous les outils PDF (fusion, scission, édition, signature, OCR, conversion Office, etc.)
- La personnalisation de la marque et toute la configuration au build et à l'exécution
La version commerciale (`ghcr.io/alam00000/bentopdf:latest`) est celle qui alimente bentopdf.com et qu'utilisent les titulaires d'une licence commerciale pour des déploiements publics : elle ajoute la section d'accueil, la FAQ, les témoignages et le pied de page qui n'auraient pas de sens sur un outil interne.
Si vous auto-hébergez BentoPDF pour votre équipe, votre organisation ou comme outil interne, utilisez la version auto-hébergée :
```bash
# Use the pre-built image (recommended)
docker run -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest
# Or build it yourself
SIMPLE_MODE=true npm run build
```
Consultez [SIMPLE_MODE.md](https://github.com/alam00000/bentopdf/blob/main/SIMPLE_MODE.md) pour tous les détails.
### Version commerciale (déploiements publics sous votre propre marque)
La version commerciale (l'image `bentopdf`, sans suffixe `-simple`) est celle qui alimente bentopdf.com. Elle inclut le site marketing complet (section d'accueil, fonctionnalités, FAQ, témoignages, pied de page) en plus de tous les outils PDF. Utilisez cette version si vous souhaitez **déployer BentoPDF comme service PDF public sous votre propre marque**, par exemple :
- Vous exploitez BentoPDF comme service SaaS hébergé pour des utilisateurs finaux sur votre propre domaine
- Vous voulez l'expérience de la page d'accueil (sections marketing + outils), et pas seulement la surface brute des outils
- Vous êtes titulaire d'une licence commerciale et intégrez BentoPDF dans un produit commercial
**Exécutez-la telle quelle** (marque BentoPDF, utile pour prévisualiser la version) :
```bash
docker run -p 3000:8080 ghcr.io/alam00000/bentopdf:latest
```
**Compilez-la avec votre propre marque** (le flux commercial typique) :
```bash
docker build \
--build-arg VITE_BRAND_NAME="AcmePDF" \
--build-arg VITE_BRAND_LOGO="images/acme-logo.svg" \
--build-arg VITE_FOOTER_TEXT="© 2026 Acme Corp. All rights reserved." \
-t acmepdf .
docker run -p 3000:8080 acmepdf
```
Toutes les autres options de build (`BASE_URL`, `VITE_DEFAULT_LANGUAGE`, `DISABLE_TOOLS`, remplacements d'URL WASM, etc.) fonctionnent comme sur la version auto-hébergée.
::: warning Licence
L'exécution de la version commerciale est autorisée selon l'une des deux options de licence de BentoPDF :
- **AGPL-3.0** (gratuite) : autorisée si votre déploiement publie l'intégralité de son code source sous AGPL, y compris les modifications de marque et la logique métier associée.
- **Licence commerciale** (79 $, à vie) : requise pour les déploiements propriétaires ou à code fermé où vous ne publiez pas votre fork de marque ni votre code métier.
Consultez la [page Licence](https://www.bentopdf.com/licensing) pour la comparaison complète. Les modules WASM sous licence AGPL (PyMuPDF, Ghostscript, CoherentPDF) sont chargés depuis un CDN à l'exécution : ils n'entrent donc pas dans votre image et ne changent pas votre situation en matière de licence.
:::
### URL de base
Déployer dans un sous-répertoire :
```bash
BASE_URL=/pdf-tools/ npm run build
```
### Marque personnalisée
Remplacez le logo, le nom et le texte de pied de page par défaut de BentoPDF par les vôtres au moment du build :
| Variable | Description | Valeur par défaut |
| ------------------ | ------------------------------------------------------- | --------------------------------------- |
| `VITE_BRAND_NAME` | Nom de marque affiché dans l'en-tête et le pied de page | `BentoPDF` |
| `VITE_BRAND_LOGO` | Chemin du logo relatif à `public/` | `images/favicon-no-bg.svg` |
| `VITE_FOOTER_TEXT` | Texte personnalisé du pied de page/copyright | `© 2026 BentoPDF. All rights reserved.` |
```bash
# Place your logo in public/, then build
VITE_BRAND_NAME="AcmePDF" \
VITE_BRAND_LOGO="images/acme-logo.svg" \
VITE_FOOTER_TEXT="© 2026 Acme Corp. Internal use only." \
npm run build
```
Ou via Docker :
```bash
docker build \
--build-arg VITE_BRAND_NAME="AcmePDF" \
--build-arg VITE_BRAND_LOGO="images/acme-logo.svg" \
--build-arg VITE_FOOTER_TEXT="© 2026 Acme Corp. Internal use only." \
-t acmepdf .
```
La personnalisation de la marque fonctionne en mode complet comme en mode simple, et peut être combinée avec toutes les autres options de build (`BASE_URL`, `SIMPLE_MODE`, `VITE_DEFAULT_LANGUAGE`).
### Désactiver des outils précis
Masquez des outils individuels pour des raisons de conformité ou de sécurité. Les outils désactivés sont retirés de la page d'accueil, de la recherche, des raccourcis, du constructeur de workflow et de l'accès direct par URL.
Les identifiants d'outils correspondent à l'URL de la page sans `.html` : ouvrez un outil et regardez l'URL (par ex. `edit-pdf`, `sign-pdf`, `encrypt-pdf`).
**Au build** (intégré au bundle) :
```bash
DISABLE_TOOLS="edit-pdf,sign-pdf" npm run build
```
**À l'exécution** (sans reconstruire : montez un `config.json`) :
```json
{
"disabledTools": ["edit-pdf", "sign-pdf"]
}
```
```bash
docker run -d -p 3000:8080 \
-v ./config.json:/usr/share/nginx/html/config.json:ro \
ghcr.io/alam00000/bentopdf-simple:latest
```
Les deux méthodes peuvent être combinées : les listes sont fusionnées.
Vous pouvez aussi désactiver des fonctionnalités précises de l'éditeur PDF (par ex. la rédaction) sans désactiver tout l'outil, en ajoutant `editorDisabledCategories` à `config.json`. Consultez le [guide Docker](/fr/self-hosting/docker#desactiver-des-fonctionnalites-de-l-editeur) pour la liste complète des catégories.
## Guides de déploiement
Choisissez votre plateforme :
- [Vercel](/fr/self-hosting/vercel)
- [Netlify](/fr/self-hosting/netlify)
- [Cloudflare Pages](/fr/self-hosting/cloudflare)
- [AWS S3 + CloudFront](/fr/self-hosting/aws)
- [Hostinger](/fr/self-hosting/hostinger)
- [Nginx](/fr/self-hosting/nginx)
- [Apache](/fr/self-hosting/apache)
- [Docker](/fr/self-hosting/docker)
- [Kubernetes](/fr/self-hosting/kubernetes)
- [Proxy CORS](/fr/self-hosting/cors-proxy) : requis pour les signatures numériques
## Problèmes courants
### La conversion Word / ODT / Excel / PowerPoint vers PDF se bloque (SharedArrayBuffer indisponible)
**Symptôme** : les conversions de documents basées sur LibreOffice (Word, ODT, Excel, PowerPoint vers PDF) se bloquent à environ 55 % ou ne démarrent pas. La console du navigateur peut afficher :
> `ReferenceError: SharedArrayBuffer is not defined`
…ou `window.crossOriginIsolated` renvoie `false`, ou la compilation WASM signale `expected magic word 00 61 73 6d, found 1f 8b 08 08`.
**Cause** : LibreOffice WASM nécessite `SharedArrayBuffer`, que le navigateur n'active que si la page est **isolée cross-origin** ET servie depuis un **contexte sécurisé**. Deux conditions doivent donc être remplies :
1. Chaque réponse inclut les deux en-têtes :
- `Cross-Origin-Embedder-Policy: require-corp`
- `Cross-Origin-Opener-Policy: same-origin`
2. La page est servie depuis `https://...` ou `http://localhost`. Le HTTP simple sur une IP du réseau local (par ex. `http://192.168.x.x`) n'est PAS considéré comme sécurisé : les navigateurs y désactivent `SharedArrayBuffer`.
L'écart `00 61 73 6d / 1f 8b 08 08` est un sous-symptôme distinct : il manque l'en-tête de réponse `Content-Encoding: gzip` sur les fichiers précompressés `.wasm.gz` / `.data.gz`, si bien que le navigateur reçoit des octets gzip bruts au lieu du WASM décompressé.
**Solution** : consultez le guide de déploiement de votre plateforme pour la configuration exacte :
- [Nginx →](/fr/self-hosting/nginx#la-conversion-word-odt-excel-vers-pdf-ne-fonctionne-pas)
- [Apache →](/fr/self-hosting/apache#la-conversion-word-odt-excel-vers-pdf-ne-fonctionne-pas)
- [AWS S3 + CloudFront →](/fr/self-hosting/aws#etape-3b-politique-d-en-tetes-de-reponse-requise-pour-libreoffice-wasm)
- [Cloudflare Pages →](/fr/self-hosting/cloudflare#fichier-de-configuration) (`_headers` file)
- [Netlify →](/fr/self-hosting/netlify#la-conversion-word-odt-excel-vers-pdf-reste-bloquee-a-55) (`netlify.toml`)
- [Vercel →](/fr/self-hosting/vercel#la-conversion-word-odt-excel-vers-pdf-ne-fonctionne-pas) (`vercel.json`)
- [Hostinger →](/fr/self-hosting/hostinger#les-outils-libreoffice-ne-fonctionnent-pas) (`.htaccess`)
- [Kubernetes →](/fr/self-hosting/kubernetes#verifier-que-les-en-tetes-sharedarraybuffer-fonctionnent-toujours-ingress-gateway)
- **Docker** : géré automatiquement par la configuration nginx fournie, aucune action nécessaire.
**Vérification** : ouvrez la console des DevTools sur n'importe quelle page BentoPDF et exécutez :
```js
console.log(window.crossOriginIsolated); // should be true
console.log(typeof SharedArrayBuffer); // should be "function"
```
Si la page est en HTTPS ou en `http://localhost` ET que les deux en-têtes COEP/COOP sont présents sur chaque réponse, les deux vérifications passent. Si vous êtes sur `http://192.168.x.x` ou une autre origine HTTP hors boucle locale, terminez la connexion en HTTPS : aucune correction par simples en-têtes n'existe.
### Fichiers `.mjs` servis en `application/octet-stream`
**Symptôme** : Signer un PDF, le remplissage de formulaire et certains autres outils affichent un lecteur vide ou ne se chargent pas. La console du navigateur signale :
> `Failed to load module script: The server responded with a non-JavaScript MIME type of "application/octet-stream". Strict MIME type checking is enforced for module scripts per HTML spec.`
**Cause** : votre serveur web ou reverse proxy n'a pas de correspondance de type MIME pour les fichiers `.mjs` (le lecteur PDF intégré fournit des modules ES avec cette extension). De nombreuses configurations de serveur par défaut utilisent `application/octet-stream` pour les extensions inconnues, ce que les navigateurs refusent d'exécuter comme modules ES.
**Solution** : consultez le guide de déploiement de votre plateforme pour l'extrait exact :
- [Nginx →](/fr/self-hosting/nginx#signer-un-pdf-ou-le-remplissage-de-formulaire-affiche-un-lecteur-vide-erreur-mime-mjs)
- [Apache →](/fr/self-hosting/apache#signer-un-pdf-ou-le-remplissage-de-formulaires-affiche-un-visualiseur-vide-erreur-mime-mjs)
- [AWS S3 + CloudFront →](/fr/self-hosting/aws#etape-2-compiler-et-televerser) (voir `aws s3 cp ... --include "*.mjs"`)
- [Kubernetes →](/fr/self-hosting/kubernetes#erreurs-de-type-mime-mjs-iframe-vide-dans-signer-un-pdf-remplissage-de-formulaire)
- **Docker, Vercel, Netlify, Cloudflare Pages, Hostinger** : géré automatiquement, aucune action nécessaire.
**Vérification** : ouvrez les DevTools, onglet Network, repérez la requête `.mjs` en échec et vérifiez l'en-tête de réponse `Content-Type`. Il doit valoir `application/javascript`. S'il vaut toujours `application/octet-stream`, un reverse proxy ou un CDN en amont détecte peut-être à nouveau le type : vérifiez chaque couche de votre chaîne de diffusion.
## Configuration WASM (composants AGPL)
BentoPDF **n'intègre pas** de bibliothèques de traitement sous licence AGPL dans son code source, mais **préconfigure des URL de CDN** pour que toutes les fonctionnalités marchent immédiatement, sans configuration manuelle.
::: tip Zéro configuration par défaut
Depuis la v2.0.0, les modules WASM sont préconfigurés pour se charger depuis le CDN jsDelivr via des variables d'environnement. Toutes les fonctionnalités avancées fonctionnent immédiatement, sans aucune configuration de l'utilisateur.
:::
| Composant | Licence | Fonctionnalités |
| --------------- | -------- | ------------------------------------------------------------------------- |
| **PyMuPDF** | AGPL-3.0 | Conversion EPUB/MOBI/FB2/XPS, extraction d'images, extraction de tableaux |
| **Ghostscript** | AGPL-3.0 | Conversion PDF/A, compression, redressement, rastérisation |
| **CoherentPDF** | AGPL-3.0 | Table des matières, pièces jointes, fusion de PDF avec signets |
### Variables d'environnement par défaut
Elles sont définies dans `.env.production` et intégrées au build :
```bash
VITE_WASM_PYMUPDF_URL=https://cdn.jsdelivr.net/npm/@bentopdf/pymupdf-wasm@0.11.16/
VITE_WASM_GS_URL=https://cdn.jsdelivr.net/npm/@bentopdf/gs-wasm@0.1.1/assets/
VITE_WASM_CPDF_URL=https://cdn.jsdelivr.net/npm/coherentpdf@2.5.5/dist/
VITE_TESSERACT_WORKER_URL=
VITE_TESSERACT_CORE_URL=
VITE_TESSERACT_LANG_URL=
VITE_TESSERACT_AVAILABLE_LANGUAGES=
VITE_OCR_FONT_BASE_URL=
```
### Remplacer les URL WASM
Vous pouvez remplacer les valeurs par défaut au moment du build pour des déploiements personnalisés :
```bash
# Via Docker build args
docker build \
--build-arg VITE_WASM_PYMUPDF_URL=https://your-server.com/pymupdf/ \
--build-arg VITE_WASM_GS_URL=https://your-server.com/gs/ \
--build-arg VITE_WASM_CPDF_URL=https://your-server.com/cpdf/ \
--build-arg VITE_TESSERACT_WORKER_URL=https://your-server.com/ocr/worker.min.js \
--build-arg VITE_TESSERACT_CORE_URL=https://your-server.com/ocr/core \
--build-arg VITE_TESSERACT_LANG_URL=https://your-server.com/ocr/lang-data \
--build-arg VITE_TESSERACT_AVAILABLE_LANGUAGES=eng,deu \
--build-arg VITE_OCR_FONT_BASE_URL=https://your-server.com/ocr/fonts \
-t bentopdf .
# Or via .env.production before building from source
VITE_WASM_PYMUPDF_URL=https://your-server.com/pymupdf/ npm run build
```
Pour désactiver complètement un module (la configuration manuelle par l'utilisateur via les paramètres avancés devient alors nécessaire), définissez sa variable sur une chaîne vide.
Pour l'OCR, laissez toutes les variables `VITE_TESSERACT_*` vides et conservez les ressources en ligne par défaut, ou définissez ensemble les URL worker/core/lang pour un OCR auto-hébergé ou hors ligne. Si vous n'intégrez que certaines langues d'OCR, définissez aussi `VITE_TESSERACT_AVAILABLE_LANGUAGES` avec les mêmes codes séparés par des virgules afin que l'interface ne propose que les langues installées et que les sélections non prises en charge échouent avec une erreur explicite. Pour une sortie PDF consultable entièrement hors ligne, définissez aussi `VITE_OCR_FONT_BASE_URL` sur le répertoire interne qui sert les polices OCR fournies.
Les utilisateurs peuvent aussi remplacer ces valeurs à tout moment via les **paramètres avancés** de l'interface : les remplacements enregistrés dans le navigateur ont priorité sur les valeurs d'environnement par défaut.
### Déploiement isolé du réseau / hors ligne
Pour les réseaux sans accès à Internet (administrations, santé, finance, etc.). Les URL WASM sont intégrées au JavaScript **au moment du build** : les fichiers WASM eux-mêmes sont téléchargés par le **navigateur de l'utilisateur** à l'exécution. Vous devez donc tout préparer sur une machine connectée à Internet, puis transférer le résultat dans le réseau isolé.
#### Script automatisé (recommandé)
Le script `prepare-airgap.sh` fourni automatise tout le processus : téléchargement des paquets WASM, construction de l'image Docker et production d'un bundle autonome avec un script d'installation.
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
# Show supported OCR language codes (for --ocr-languages)
bash scripts/prepare-airgap.sh --list-ocr-languages
# Search OCR language codes by name or abbreviation
bash scripts/prepare-airgap.sh --search-ocr-language german
# Interactive mode — prompts for all options
bash scripts/prepare-airgap.sh
# Or fully automated
bash scripts/prepare-airgap.sh --wasm-base-url https://internal.example.com/wasm
```
Cela produit un répertoire de bundle :
```
bentopdf-airgap-bundle/
bentopdf.tar # Docker image
*.tgz # WASM packages (PyMuPDF, Ghostscript, CoherentPDF, Tesseract)
tesseract-langdata/ # OCR traineddata files
ocr-fonts/ # OCR text-layer font files
setup.sh # Setup script for the air-gapped side
README.md # Instructions
```
Transférez le bundle dans le réseau isolé par clé USB, dépôt d'artefacts interne ou toute méthode approuvée. Exécutez ensuite le script d'installation fourni :
```bash
cd bentopdf-airgap-bundle
bash setup.sh
```
Le script d'installation charge l'image Docker, extrait les fichiers WASM et démarre éventuellement le conteneur.
**Options du script :**
| Option | Description | Valeur par défaut |
| ------------------------------ | ------------------------------------------------------------- | ------------------------------------ |
| `--wasm-base-url <url>` | Emplacement où les WASM seront hébergés en interne | _(obligatoire, demandée si absente)_ |
| `--image-name <name>` | Tag de l'image Docker | `bentopdf` |
| `--output-dir <path>` | Répertoire de sortie du bundle | `./bentopdf-airgap-bundle` |
| `--simple-mode` | Active le mode simple | désactivé |
| `--base-url <path>` | URL de base du sous-répertoire (par ex. `/pdf/`) | `/` |
| `--language <code>` | Langue par défaut de l'interface (par ex. `fr`, `de`) | _(aucune)_ |
| `--brand-name <name>` | Nom de marque personnalisé | _(aucun)_ |
| `--brand-logo <path>` | Chemin du logo relatif à `public/` | _(aucun)_ |
| `--footer-text <text>` | Texte de pied de page personnalisé | _(aucun)_ |
| `--ocr-languages <list>` | Langues d'OCR à intégrer, séparées par des virgules | `eng` |
| `--list-ocr-languages` | Affiche les codes et noms d'OCR pris en charge, puis quitte | désactivé |
| `--search-ocr-language <term>` | Recherche des codes d'OCR par nom ou abréviation | désactivé |
| `--dockerfile <path>` | Dockerfile à utiliser | `Dockerfile` |
| `--skip-docker` | Ignore la construction et l'export Docker | désactivé |
| `--skip-wasm` | Ignore le téléchargement WASM (réutilise les fichiers `.tgz`) | désactivé |
L'invite interactive accepte aussi `list` pour afficher la liste complète des codes Tesseract pris en charge et `search <term>` pour trouver des correspondances, par exemple `search german` ou `search chi`.
::: warning Exigence de même origine
Les fichiers WASM doivent être servis depuis la **même origine** que l'application BentoPDF. Les Web Workers utilisent `importScripts()`, qui ne peut pas charger de scripts cross-origin. Par exemple, si BentoPDF tourne sur `https://internal.example.com`, l'URL de base WASM doit aussi être `https://internal.example.com/wasm`.
:::
#### Étapes manuelles
<details>
<summary>Si vous préférez procéder manuellement, sans le script</summary>
**Étape 1 : télécharger les paquets WASM et OCR** (sur une machine connectée à Internet)
```bash
npm pack @bentopdf/pymupdf-wasm@0.11.14
npm pack @bentopdf/gs-wasm
npm pack coherentpdf
npm pack tesseract.js@7.0.0
npm pack tesseract.js-core@7.0.0
mkdir -p tesseract-langdata
curl -fsSL https://cdn.jsdelivr.net/npm/@tesseract.js-data/eng/4.0.0_best_int/eng.traineddata.gz -o tesseract-langdata/eng.traineddata.gz
mkdir -p ocr-fonts
curl -fsSL https://raw.githack.com/googlefonts/noto-fonts/main/hinted/ttf/NotoSans/NotoSans-Regular.ttf -o ocr-fonts/NotoSans-Regular.ttf
```
**Étape 2 : construire l'image Docker avec les URL internes**
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
docker build \
--build-arg VITE_WASM_PYMUPDF_URL=https://internal-server.example.com/wasm/pymupdf/ \
--build-arg VITE_WASM_GS_URL=https://internal-server.example.com/wasm/gs/ \
--build-arg VITE_WASM_CPDF_URL=https://internal-server.example.com/wasm/cpdf/ \
--build-arg VITE_TESSERACT_WORKER_URL=https://internal-server.example.com/wasm/ocr/worker.min.js \
--build-arg VITE_TESSERACT_CORE_URL=https://internal-server.example.com/wasm/ocr/core \
--build-arg VITE_TESSERACT_LANG_URL=https://internal-server.example.com/wasm/ocr/lang-data \
--build-arg VITE_OCR_FONT_BASE_URL=https://internal-server.example.com/wasm/ocr/fonts \
-t bentopdf .
```
**Étape 3 : exporter l'image Docker**
```bash
docker save bentopdf -o bentopdf.tar
```
**Étape 4 : transférer dans le réseau isolé**
Copiez par clé USB, dépôt d'artefacts interne ou méthode de transfert approuvée :
- `bentopdf.tar` : l'image Docker
- Les cinq paquets `.tgz` WASM/OCR de l'étape 1
- Le répertoire `tesseract-langdata/` de l'étape 1
- Le répertoire `ocr-fonts/` de l'étape 1
**Étape 5 : installer dans le réseau isolé**
```bash
# Load the Docker image
docker load -i bentopdf.tar
# Extract WASM packages
mkdir -p ./wasm/pymupdf ./wasm/gs ./wasm/cpdf ./wasm/ocr/core ./wasm/ocr/lang-data ./wasm/ocr/fonts
tar xzf bentopdf-pymupdf-wasm-0.11.14.tgz -C ./wasm/pymupdf --strip-components=1
tar xzf bentopdf-gs-wasm-*.tgz -C ./wasm/gs --strip-components=1
tar xzf coherentpdf-*.tgz -C ./wasm/cpdf --strip-components=1
TEMP_TESS=$(mktemp -d)
tar xzf tesseract.js-7.0.0.tgz -C "$TEMP_TESS"
cp "$TEMP_TESS/package/dist/worker.min.js" ./wasm/ocr/worker.min.js
rm -rf "$TEMP_TESS"
tar xzf tesseract.js-core-7.0.0.tgz -C ./wasm/ocr/core --strip-components=1
cp ./tesseract-langdata/*.traineddata.gz ./wasm/ocr/lang-data/
cp ./ocr-fonts/* ./wasm/ocr/fonts/
# Run BentoPDF
docker run -d -p 3000:8080 --restart unless-stopped bentopdf
```
Vérifiez que les fichiers sont accessibles aux URL configurées à l'étape 2, notamment `.../ocr/worker.min.js`, `.../ocr/core`, `.../ocr/lang-data` et `.../ocr/fonts`.
</details>
::: info Compilation depuis les sources plutôt que Docker ?
Définissez les variables dans `.env.production` avant d'exécuter `npm run build` :
```bash
VITE_WASM_PYMUPDF_URL=https://internal-server.example.com/wasm/pymupdf/
VITE_WASM_GS_URL=https://internal-server.example.com/wasm/gs/
VITE_WASM_CPDF_URL=https://internal-server.example.com/wasm/cpdf/
VITE_TESSERACT_WORKER_URL=https://internal-server.example.com/wasm/ocr/worker.min.js
VITE_TESSERACT_CORE_URL=https://internal-server.example.com/wasm/ocr/core
VITE_TESSERACT_LANG_URL=https://internal-server.example.com/wasm/ocr/lang-data
VITE_OCR_FONT_BASE_URL=https://internal-server.example.com/wasm/ocr/fonts
```
:::
### Héberger votre propre proxy WASM
Si vous devez servir des fichiers WASM AGPL avec les en-têtes CORS appropriés, vous pouvez déployer un proxy simple. Consultez le [guide du proxy WASM Cloudflare](https://github.com/alam00000/bentopdf/blob/main/cloudflare/WASM-PROXY.md) pour un exemple d'implémentation.
::: tip Pourquoi cette séparation ?
Cette séparation garantit :
- Une conformité juridique claire pour les utilisateurs commerciaux
- Le cœur de BentoPDF reste sous sa double licence (AGPL-3.0 / commerciale)
- Les fichiers WASM sont chargés à l'exécution et non intégrés au code source
:::
## Configuration requise
| Exigence | Minimum |
| -------- | ------------------------------------ |
| Stockage | ~100 Mo (cœur sans les modules AGPL) |
| RAM | 512 Mo |
| CPU | Tout processeur moderne |
::: tip
BentoPDF est un site statique : aucune base de données ni serveur backend n'est nécessaire !
:::
docs/fr/self-hosting/kubernetes.md
+211
View File
@@ -0,0 +1,211 @@
# Déployer avec Kubernetes
Kubernetes est peut-être excessif pour un site statique, mais il peut très bien convenir si vous standardisez déjà sur Helm + GitOps.
> [!IMPORTANT]
> **En-têtes requis pour la conversion de fichiers Office**
>
> Les outils basés sur LibreOffice (conversion Word, Excel, PowerPoint) nécessitent ces en-têtes HTTP pour la prise en charge de `SharedArrayBuffer` :
>
> - `Cross-Origin-Opener-Policy: same-origin`
> - `Cross-Origin-Embedder-Policy: require-corp`
>
> Les images nginx officielles de BentoPDF incluent ces en-têtes. Dans Kubernetes, **les contrôleurs Ingress/Gateway sont aussi des reverse proxies** : assurez-vous donc que ces en-têtes sont conservés (ou ajoutez-les en périphérie).
## Prérequis
- Un cluster Kubernetes
- Helm v3
- Une image nginx BentoPDF (par ex. `ghcr.io/alam00000/bentopdf:<tag>`) qui sert sur le **port 8080**
## Déployer avec Helm
### Installer depuis ce dépôt (chart local)
```bash
kubectl create namespace bentopdf
helm upgrade --install bentopdf /path/to/bentopdf/chart \
--namespace bentopdf \
--set image.repository=ghcr.io/alam00000/bentopdf \
--set image.tag=latest
```
### Installer depuis GHCR (chart OCI)
Si le chart est publié sur GHCR en tant qu'artefact OCI :
```bash
export GHCR_USERNAME="<github-org-or-user>"
helm upgrade --install bentopdf oci://ghcr.io/$GHCR_USERNAME/charts/bentopdf \
--namespace bentopdf \
--create-namespace \
--version 0.1.0 \
--set image.repository=ghcr.io/alam00000/bentopdf \
--set image.tag=latest
```
## L'exposer
### Port-forward (test rapide)
```bash
kubectl -n bentopdf port-forward deploy/bentopdf 8080:8080
```
### Ingress (facultatif)
Activez Ingress (exemple pour nginx-ingress) :
```yaml
ingress:
enabled: true
className: nginx
hosts:
- host: pdf.example.com
paths:
- path: /
pathType: Prefix
```
### Gateway API (facultatif)
Ce chart prend en charge `Gateway` + `HTTPRoute` de Gateway API.
Exemple (opérateur Gateway API de Cloudflare) :
```yaml
gateway:
enabled: true
name: bento-tunnel
namespace: bentopdf
gatewayClassName: cloudflare
httpRoute:
enabled: true
parentRefs:
- name: bento-tunnel
namespace: bentopdf
sectionName: http
hostnames:
- pdfs.example.com
```
## Vérifier que les en-têtes SharedArrayBuffer fonctionnent toujours (Ingress/Gateway)
### Ce qui « devrait » se passer
La configuration nginx de BentoPDF définit les en-têtes de réponse requis. La plupart des contrôleurs Ingress/Gateway **transmettent les en-têtes de réponse en amont sans les modifier**.
### Ce qui peut tout casser
- Une politique de contrôleur ou de périphérie qui **remplace** ou **supprime** les en-têtes de réponse
- Un middleware d'« en-têtes de sécurité » qui définit des valeurs COOP/COEP différentes
### Comment vérifier
Exécutez ceci sur votre point d'accès public :
```bash
curl -I https://pdf.example.com/ | egrep -i 'cross-origin-opener-policy|cross-origin-embedder-policy'
```
Vous devriez voir :
- `Cross-Origin-Opener-Policy: same-origin`
- `Cross-Origin-Embedder-Policy: require-corp`
### Si votre contrôleur Ingress ne les conserve pas
Ajoutez les en-têtes en périphérie (selon le contrôleur). Exemple pour **nginx-ingress** :
```yaml
ingress:
enabled: true
className: nginx
annotations:
nginx.ingress.kubernetes.io/configuration-snippet: |
add_header Cross-Origin-Opener-Policy "same-origin" always;
add_header Cross-Origin-Embedder-Policy "require-corp" always;
```
## Erreurs de type MIME `.mjs` (iframe vide dans Signer un PDF / remplissage de formulaire)
Si la console du navigateur affiche `Failed to load module script: ... non-JavaScript MIME type "application/octet-stream"` sur une requête `.mjs`, un contrôleur Ingress/Gateway placé devant le nginx de BentoPDF remplace l'en-tête `Content-Type` en amont par `application/octet-stream`.
Le nginx de l'image BentoPDF sert déjà `.mjs` en `application/javascript`. La solution consiste à empêcher le contrôleur de le supprimer ou de le remplacer. Pour nginx-ingress :
```yaml
ingress:
annotations:
nginx.ingress.kubernetes.io/configuration-snippet: |
location ~* \.mjs$ {
types {} default_type application/javascript;
}
```
Ou utilisez un filtre `ResponseHeaderModifier` dans Gateway API pour définir `Content-Type: application/javascript` sur les chemins `.mjs`. Vérifiez avec les DevTools, onglet Network : la requête `.mjs` en échec doit maintenant afficher `content-type: application/javascript`.
### Si vous utilisez Gateway API et voulez forcer l'ajout d'en-têtes
Gateway API prend en charge un filtre `ResponseHeaderModifier`. Vous pouvez l'attacher dans `httpRoute.rules[*].filters` :
```yaml
httpRoute:
enabled: true
hostnames: [pdf.example.com]
parentRefs:
- name: bento-tunnel
namespace: misc
sectionName: http
rules:
- matches:
- path: { type: PathPrefix, value: / }
filters:
- type: ResponseHeaderModifier
responseHeaderModifier:
set:
- name: Cross-Origin-Opener-Policy
value: same-origin
- name: Cross-Origin-Embedder-Policy
value: require-corp
```
La prise en charge de filtres précis dépend de votre contrôleur Gateway ; si un filtre est ignoré, ajoutez plutôt les en-têtes au niveau de la périphérie ou du contrôleur.
## Désactiver des outils précis
Utilisez un ConfigMap pour désactiver des outils à l'exécution sans reconstruire l'image :
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: bentopdf-config
namespace: bentopdf
data:
config.json: |
{
"disabledTools": ["edit-pdf", "sign-pdf", "encrypt-pdf"]
}
```
Montez-le dans le répertoire servi :
```yaml
spec:
containers:
- name: bentopdf
volumeMounts:
- name: config
mountPath: /usr/share/nginx/html/config.json
subPath: config.json
readOnly: true
volumes:
- name: config
configMap:
name: bentopdf-config
```
Les identifiants d'outils correspondent à l'URL de la page sans `.html` : ouvrez un outil et regardez l'URL (par ex. `edit-pdf`, `merge-pdf`, `compress-pdf`). Les outils désactivés sont masqués de la page d'accueil, de la recherche, des raccourcis, du constructeur de workflow et de l'accès direct par URL. Consultez le [guide Docker](/fr/self-hosting/docker#desactiver-des-outils-specifiques) pour la liste complète des options.
docs/fr/self-hosting/netlify.md
+139
View File
@@ -0,0 +1,139 @@
# Déployer sur Netlify
[Netlify](https://netlify.com) propose un excellent hébergement de sites statiques avec une offre gratuite généreuse.
## Déploiement en un clic
[![Deploy to Netlify](https://www.netlify.com/img/deploy/button.svg)](https://app.netlify.com/start/deploy?repository=https://github.com/alam00000/bentopdf)
## Déploiement manuel
### Étape 1 : connecter le dépôt
1. Connectez-vous à [Netlify](https://app.netlify.com)
2. Cliquez sur « Add new site » → « Import an existing project »
3. Connectez votre compte GitHub
4. Sélectionnez votre fork de BentoPDF
### Étape 2 : configurer les paramètres de build
| Paramètre | Valeur |
| ------------------------- | --------------- |
| Commande de build | `npm run build` |
| Répertoire de publication | `dist` |
| Version de Node | 18+ |
### Étape 3 : déployer
Cliquez sur « Deploy site » et attendez la fin du build.
## Fichier de configuration
Créez `netlify.toml` à la racine de votre projet :
```toml
[build]
command = "npm run build"
publish = "dist"
[build.environment]
NODE_VERSION = "18"
# Required security headers for SharedArrayBuffer (used by LibreOffice WASM)
[[headers]]
for = "/*"
[headers.values]
Cross-Origin-Embedder-Policy = "require-corp"
Cross-Origin-Opener-Policy = "same-origin"
Cross-Origin-Resource-Policy = "cross-origin"
# Pre-compressed LibreOffice WASM binary - must be served with Content-Encoding
[[headers]]
for = "/libreoffice-wasm/soffice.wasm.gz"
[headers.values]
Content-Type = "application/wasm"
Content-Encoding = "gzip"
Cache-Control = "public, max-age=31536000, immutable"
# Pre-compressed LibreOffice WASM data - must be served with Content-Encoding
[[headers]]
for = "/libreoffice-wasm/soffice.data.gz"
[headers.values]
Content-Type = "application/octet-stream"
Content-Encoding = "gzip"
Cache-Control = "public, max-age=31536000, immutable"
# Cache other WASM files
[[headers]]
for = "*.wasm"
[headers.values]
Cache-Control = "public, max-age=31536000, immutable"
Content-Type = "application/wasm"
# SPA routing
[[redirects]]
from = "/*"
to = "/index.html"
status = 200
```
::: warning Important
Les en-têtes `Cross-Origin-Embedder-Policy` et `Cross-Origin-Opener-Policy` sont nécessaires pour les conversions Word/ODT/Excel/PowerPoint vers PDF. Sans eux, `SharedArrayBuffer` n'est pas disponible et le moteur LibreOffice WASM ne parviendra pas à s'initialiser.
Les en-têtes `Content-Encoding: gzip` sur les fichiers `.wasm.gz` et `.data.gz` indiquent au navigateur de les décompresser automatiquement. Sans eux, le navigateur reçoit des octets gzip bruts et la compilation WASM échoue.
:::
## Variables d'environnement
Définissez-les dans Site settings → Environment variables :
| Variable | Description |
| ----------------------- | ----------------------------------------------------------------- |
| `SIMPLE_MODE` | Mettre à `true` pour un build minimal |
| `VITE_BRAND_NAME` | Nom de marque personnalisé (remplace « BentoPDF ») |
| `VITE_BRAND_LOGO` | Chemin du logo relatif à `public/` (par ex. `images/my-logo.svg`) |
| `VITE_FOOTER_TEXT` | Texte personnalisé du pied de page/copyright |
| `VITE_DEFAULT_LANGUAGE` | Langue par défaut de l'interface (par ex. `fr`, `de`, `es`) |
## Domaine personnalisé
1. Allez dans Site settings → Domain management
2. Cliquez sur « Add custom domain »
3. Suivez les instructions de configuration DNS
## Large Media
Pour les gros fichiers WASM, envisagez d'activer [Netlify Large Media](https://docs.netlify.com/large-media/overview/):
```bash
netlify lm:setup
git lfs track "*.wasm"
```
## Dépannage
### La conversion Word/ODT/Excel vers PDF reste bloquée à 55 %
Si les conversions de documents restent bloquées à 55 %, ouvrez la console des DevTools et vérifiez :
```js
console.log(window.crossOriginIsolated); // should be true
console.log(typeof SharedArrayBuffer); // should be "function"
```
Si `crossOriginIsolated` vaut `false`, les en-têtes COEP/COOP de votre `netlify.toml` ne sont pas appliqués. Vérifiez que le fichier se trouve à la racine de votre projet et redéployez.
Si vous voyez `expected magic word 00 61 73 6d, found 1f 8b 08 08` dans la console, il manque les en-têtes `Content-Encoding: gzip` sur les fichiers `.wasm.gz`. Assurez-vous que les blocs `[[headers]]` pour `soffice.wasm.gz` et `soffice.data.gz` figurent dans votre `netlify.toml`.
### Échec du build
Vérifiez la compatibilité de la version de Node :
```toml
[build.environment]
NODE_VERSION = "20"
```
### Chargement initial lent
Activez l'optimisation des ressources dans Site settings → Build & deploy → Asset optimization.
docs/fr/self-hosting/nginx.md
+232
View File
@@ -0,0 +1,232 @@
# Déployer avec Nginx
Hébergez BentoPDF sur votre propre serveur avec Nginx.
## Prérequis
- Serveur Ubuntu/Debian
- Nginx installé
- Certificat SSL (recommandé : Let's Encrypt)
## Étape 1 : construire le projet
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
```
Pour personnaliser l'image de marque, définissez des variables d'environnement avant le build :
```bash
VITE_BRAND_NAME="AcmePDF" VITE_BRAND_LOGO="images/acme-logo.svg" npm run build
```
## Étape 2 : copier les fichiers
```bash
sudo mkdir -p /var/www/bentopdf
sudo cp -r dist/* /var/www/bentopdf/
sudo chown -R www-data:www-data /var/www/bentopdf
```
## Étape 3 : configuration de Nginx
Créez `/etc/nginx/sites-available/bentopdf` :
```nginx
server {
listen 80;
server_name your-domain.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name your-domain.com;
# SSL Configuration
ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;
root /var/www/bentopdf;
index index.html;
# Gzip compression
gzip on;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/wasm;
gzip_min_length 1000;
# WASM MIME type
types {
application/wasm wasm;
}
# Required headers for SharedArrayBuffer (LibreOffice WASM)
# These must be on every response - especially HTML pages
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
add_header Cross-Origin-Resource-Policy "cross-origin" always;
# Security headers
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
# Pre-compressed LibreOffice WASM binary
location ~* /libreoffice-wasm/soffice\.wasm\.gz$ {
gzip off;
types {} default_type application/wasm;
add_header Content-Encoding gzip;
add_header Cache-Control "public, immutable";
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
}
# Pre-compressed LibreOffice WASM data
location ~* /libreoffice-wasm/soffice\.data\.gz$ {
gzip off;
types {} default_type application/octet-stream;
add_header Content-Encoding gzip;
add_header Cache-Control "public, immutable";
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
}
# Cache static assets
location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|wasm)$ {
expires 1y;
add_header Cache-Control "public, immutable";
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
}
# SPA routing - serve index.html for all routes
location / {
try_files $uri $uri/ /index.html;
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
}
}
```
## Étape 4 : activer le site
```bash
sudo ln -s /etc/nginx/sites-available/bentopdf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```
## Étape 5 : SSL avec Let's Encrypt
```bash
sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d your-domain.com
```
## Déploiement dans un sous-répertoire
Pour héberger sous `/pdf/` :
```nginx
location /pdf/ {
alias /var/www/bentopdf/;
try_files $uri $uri/ /pdf/index.html;
}
```
Construisez avec :
```bash
BASE_URL=/pdf/ npm run build
```
## Optimisation des performances
Ajoutez à `nginx.conf` :
```nginx
http {
# Enable sendfile
sendfile on;
tcp_nopush on;
tcp_nodelay on;
# Increase buffer sizes
client_max_body_size 100M;
# Worker connections
worker_connections 2048;
}
```
## Dépannage
### Le WASM ne se charge pas
Vérifiez que le type MIME est défini :
```nginx
types {
application/wasm wasm;
}
```
### Signer un PDF ou le remplissage de formulaire affiche un lecteur vide (erreur MIME `.mjs`)
Si la console du navigateur affiche :
```
Failed to load module script: The server responded with a non-JavaScript
MIME type of "application/octet-stream". Strict MIME type checking is
enforced for module scripts per HTML spec.
```
…et que la requête en échec se termine par `.mjs`, il manque à votre nginx la correspondance `.mjs → application/javascript`. Le lecteur PDF intégré (utilisé par Signer un PDF, le remplissage de formulaire et quelques autres outils) fournit des modules ES avec l'extension `.mjs`, et le fichier `mime.types` par défaut de nginx ne les inclut pas.
Corrigez-le en ajoutant `mjs` à la ligne `application/javascript` existante dans `/etc/nginx/mime.types` :
```nginx
application/javascript js mjs;
```
> N'ajoutez PAS une _seconde_ ligne `application/javascript` : nginx analyse `mime.types` ligne par ligne et une seule correspondance type-extension l'emporte, donc une seconde ligne est ignorée silencieusement sur certaines versions. Modifiez la ligne existante pour ajouter `mjs` à côté de `js`.
Ou redéfinissez-le localement dans votre bloc server (sans modifier le fichier global) :
```nginx
types {
application/javascript js mjs;
application/wasm wasm;
}
```
Rechargez nginx après la modification :
```bash
sudo nginx -t && sudo systemctl reload nginx
```
Pour confirmer : dans les DevTools du navigateur, onglet Network, repérez la requête `.mjs` en échec et vérifiez l'en-tête de réponse `Content-Type`. Il doit maintenant valoir `application/javascript` et non `application/octet-stream`.
### La conversion Word/ODT/Excel vers PDF ne fonctionne pas
LibreOffice WASM nécessite `SharedArrayBuffer`, qui exige les en-têtes `Cross-Origin-Embedder-Policy` et `Cross-Origin-Opener-Policy`. Il faut aussi un contexte sécurisé : `http://localhost` fonctionne pour les tests locaux, mais `http://192.168.x.x` ou d'autres IP du réseau local nécessitent généralement HTTPS. Notez que les directives `add_header` d'un bloc `location` **remplacent** celles du niveau server, elles ne fusionnent pas. Chaque bloc `location` ayant son propre `add_header` doit inclure les en-têtes COEP/COOP.
Vérifiez avec :
```bash
curl -I https://your-domain.com/ | grep -i cross-origin
```
Si vous utilisez un reverse proxy devant nginx, assurez-vous qu'il conserve ces en-têtes.
### 502 Bad Gateway
Consultez les journaux d'erreurs de Nginx :
```bash
sudo tail -f /var/log/nginx/error.log
```
docs/fr/self-hosting/vercel.md
+122
View File
@@ -0,0 +1,122 @@
# Déployer sur Vercel
[Vercel](https://vercel.com) offre l'expérience de déploiement la plus simple pour les sites statiques.
## Déploiement en un clic
[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https://github.com/alam00000/bentopdf)
## Déploiement manuel
### Étape 1 : forker le dépôt
Forkez [bentopdf/bentopdf](https://github.com/alam00000/bentopdf) vers votre compte GitHub.
### Étape 2 : importer dans Vercel
1. Rendez-vous sur [vercel.com/new](https://vercel.com/new)
2. Sélectionnez votre dépôt forké
3. Configurez le projet :
| Paramètre | Valeur |
| ----------------------- | --------------- |
| Préréglage du framework | Vite |
| Commande de build | `npm run build` |
| Répertoire de sortie | `dist` |
| Commande d'installation | `npm install` |
### Étape 3 : variables d'environnement (facultatif)
Ajoutez-les si nécessaire :
| Variable | Description |
| ----------------------- | ----------------------------------------------------------------- |
| `SIMPLE_MODE` | Mettre à `true` pour une interface minimale |
| `VITE_BRAND_NAME` | Nom de marque personnalisé (remplace « BentoPDF ») |
| `VITE_BRAND_LOGO` | Chemin du logo relatif à `public/` (par ex. `images/my-logo.svg`) |
| `VITE_FOOTER_TEXT` | Texte personnalisé du pied de page/copyright |
| `VITE_DEFAULT_LANGUAGE` | Langue par défaut de l'interface (par ex. `fr`, `de`, `es`) |
### Étape 4 : déployer
Cliquez sur « Deploy » et attendez la fin du build.
## Domaine personnalisé
1. Ouvrez les paramètres de votre projet
2. Allez dans « Domains »
3. Ajoutez votre domaine personnalisé
4. Configurez le DNS comme indiqué
## Limitations
::: warning Fichiers volumineux
Les fonctions serverless de Vercel ont une limite de 50 Mo. BentoPDF étant un site statique, cela ne devrait pas vous concerner, mais les modules WASM sont volumineux (~100 Mo au total). Assurez-vous qu'ils sont servis depuis le dossier `/public`.
:::
## Dépannage
### Délai d'attente du build dépassé
Si les builds dépassent le délai, essayez :
```json
// vercel.json
{
"buildCommand": "npm run build",
"outputDirectory": "dist"
}
```
### Erreur 404 à l'actualisation
Ajoutez un fichier `vercel.json` pour le routage SPA :
```json
{
"rewrites": [{ "source": "/(.*)", "destination": "/index.html" }]
}
```
### La conversion Word/ODT/Excel vers PDF ne fonctionne pas
Les conversions LibreOffice WASM nécessitent `SharedArrayBuffer`, qui exige ces en-têtes de réponse sur toutes les pages :
- `Cross-Origin-Embedder-Policy: require-corp`
- `Cross-Origin-Opener-Policy: same-origin`
Les fichiers précompressés `.wasm.gz` et `.data.gz` ont aussi besoin de `Content-Encoding: gzip` pour que le navigateur les décompresse.
Ajoutez-les à votre `vercel.json` :
```json
{
"rewrites": [{ "source": "/(.*)", "destination": "/index.html" }],
"headers": [
{
"source": "/(.*)",
"headers": [
{ "key": "Cross-Origin-Embedder-Policy", "value": "require-corp" },
{ "key": "Cross-Origin-Opener-Policy", "value": "same-origin" },
{ "key": "Cross-Origin-Resource-Policy", "value": "cross-origin" }
]
},
{
"source": "/libreoffice-wasm/soffice.wasm.gz",
"headers": [
{ "key": "Content-Type", "value": "application/wasm" },
{ "key": "Content-Encoding", "value": "gzip" }
]
},
{
"source": "/libreoffice-wasm/soffice.data.gz",
"headers": [
{ "key": "Content-Type", "value": "application/octet-stream" },
{ "key": "Content-Encoding", "value": "gzip" }
]
}
]
}
```
Pour vérifier, ouvrez la console des DevTools et exécutez `console.log(window.crossOriginIsolated)` : le résultat doit être `true`.
docs/fr/tools/add-attachments.md
+49
View File
@@ -0,0 +1,49 @@
---
title: Ajouter des pièces jointes
description: Intégrez des fichiers de tout type dans un PDF, au niveau du document ou rattachés à des pages précises.
---
# Ajouter des pièces jointes
Intégrez un ou plusieurs fichiers directement dans un document PDF. Les pièces jointes peuvent être ajoutées au niveau du document (visibles dans le panneau des pièces jointes de n'importe quel lecteur PDF) ou liées à des pages précises.
## Fonctionnement
1. Importez le PDF auquel vous souhaitez joindre des fichiers.
2. Utilisez la zone de dépôt des pièces jointes pour sélectionner les fichiers à intégrer (tout type de fichier).
3. Choisissez le niveau de la pièce jointe : **Document** (par défaut) ou **Page**.
4. Si vous choisissez le niveau Page, saisissez une plage de pages (par exemple `1-3` ou `5`).
5. Cliquez sur le bouton de traitement. Le PDF modifié est téléchargé avec vos fichiers intégrés.
## Fonctionnalités
- Joignez n'importe quel type de fichier : images, feuilles de calcul, archives, exécutables, tout est possible
- Placement des pièces jointes au niveau du document ou de la page
- Possibilité de joindre plusieurs fichiers en une seule opération
- Affichage du nom et de la taille de toutes les pièces jointes sélectionnées
- Le PDF de sortie conserve le contenu d'origine, avec les fichiers intégrés en plus
## Options
| Option | Description |
| ------------------- | --------------------------------------------------------------------------------------------- |
| **Niveau document** | Joint les fichiers au PDF dans son ensemble, accessibles depuis le panneau des pièces jointes |
| **Niveau page** | Joint les fichiers à des pages précises, indiquées par une plage de pages |
## Cas d'usage
- Regrouper des données sources (fichiers Excel, CSV) avec un rapport PDF
- Joindre les images originales à un portfolio photo au format PDF
- Intégrer des documents justificatifs dans un contrat ou une proposition
- Ajouter des documents complémentaires à des pages précises d'un manuel de formation
## Astuces
- Les pièces jointes au niveau du document sont les mieux prises en charge par les lecteurs PDF. Celles au niveau de la page peuvent ne pas être visibles dans tous les lecteurs.
- Il n'y a pas de limite de taille pour les pièces jointes, mais les fichiers intégrés très volumineux augmentent la taille du PDF d'autant.
## Outils associés
- [Extraire les pièces jointes](./extract-attachments)
- [Gérer les pièces jointes](./edit-attachments)
- [Fusionner des PDF](./merge-pdf)
docs/fr/tools/add-blank-page.md
+40
View File
@@ -0,0 +1,40 @@
---
title: Ajouter une page vierge
description: Insérez une ou plusieurs pages vierges à n'importe quelle position d'un document PDF.
---
# Ajouter une page vierge
Insérez des pages vides dans un PDF à la position de votre choix. Vous contrôlez l'emplacement des pages vierges et leur nombre.
## Fonctionnement
1. Importez un fichier PDF. L'outil affiche le nombre de pages.
2. Saisissez la **position** où insérer les pages vierges. Utilisez `0` pour insérer au tout début, ou le nombre total de pages pour ajouter à la fin.
3. Saisissez le **nombre** de pages vierges à ajouter (1 par défaut).
4. Cliquez sur le bouton de traitement. Le PDF modifié est téléchargé avec les pages vierges insérées.
## Fonctionnalités
- Insertion à n'importe quelle position : début, milieu ou fin du document
- Ajout de plusieurs pages vierges en une seule opération
- L'indication de position se met à jour dynamiquement selon le nombre de pages du PDF importé
- Pages vierges au format A4 standard
## Cas d'usage
- Ajouter une page de séparation vierge entre les sections d'un document compilé
- Insérer des pages vierges pour l'alignement de l'impression recto verso
- Prévoir de l'espace pour des notes manuscrites dans un support d'étude imprimé
- Compléter un document pour atteindre un nombre minimal de pages
## Astuces
- La position `0` insère avant la première page. Une position égale au nombre total de pages ajoute après la dernière page.
- Si vous devez insérer du contenu (et pas seulement des pages vierges) à une position précise, utilisez [Outil PDF tout-en-un](./pdf-multi-tool) pour insérer un autre PDF après une page donnée.
## Outils associés
- [Dupliquer et organiser](./organize-pdf)
- [Outil PDF tout-en-un](./pdf-multi-tool)
- [Fusionner des PDF](./merge-pdf)
docs/fr/tools/add-page-labels.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Ajouter des étiquettes de page
description: Ajoutez des étiquettes de page PDF avec chiffres romains, préfixes alphabétiques, numérotation personnalisée et plusieurs règles par document.
---
# Ajouter des étiquettes de page
Les étiquettes de page déterminent l'affichage des numéros de page dans les lecteurs PDF (le numéro indiqué dans la barre d'outils, et non imprimé sur la page). Cet outil vous permet d'attribuer différents schémas d'étiquetage à différentes plages de pages : chiffres romains pour les pages liminaires, chiffres décimaux pour le corps du texte, annexes en lettres, et plus encore.
## Fonctionnement
1. Importez votre fichier PDF.
2. Le panneau d'options apparaît avec une règle d'étiquetage par défaut.
3. Configurez chaque règle avec une plage de pages, un style, un préfixe facultatif et une valeur de départ.
4. Cliquez sur **Ajouter une règle** pour créer des règles supplémentaires pour d'autres sections.
5. Cliquez sur **Ajouter des étiquettes de page** pour appliquer toutes les règles et télécharger le résultat.
## Options
Chaque règle d'étiquetage dispose des paramètres suivants :
- **Plage de pages** : les pages auxquelles la règle s'applique. Laissez vide pour toutes les pages. Accepte des plages comme `1-4`, `7`, `odd` ou `1-9,30-40`.
- **Style d'étiquette** : chiffres arabes décimaux, chiffres romains minuscules (i, ii, iii), chiffres romains majuscules (I, II, III), lettres minuscules (a, b, c), lettres majuscules (A, B, C), ou aucune étiquette (préfixe uniquement).
- **Préfixe d'étiquette** : texte facultatif ajouté devant chaque étiquette, par exemple « A- » pour obtenir des étiquettes comme A-1, A-2, A-3.
- **Valeur de départ** : le nombre à partir duquel commencer le décompte. 1 par défaut. Mettez 0 pour une numérotation commençant à zéro.
- **Poursuivre la numérotation sur des plages disjointes** : activez cette option lorsqu'une règle cible des pages non contiguës (comme `1-9,30-40` ou `odd`) et que vous souhaitez que la numérotation continue de façon séquentielle.
- **Supprimer les étiquettes de page existantes** : cochée par défaut. Efface les étiquettes précédentes avant d'appliquer vos nouvelles règles.
## Fonctionnalités
- Plusieurs règles d'étiquetage par document pour les schémas de numérotation complexes
- Six styles d'étiquettes couvrant tous les systèmes de numérotation courants
- Préfixe personnalisé pour un étiquetage par section
- Prise en charge des plages disjointes avec numérotation progressive
- Option pour conserver ou supprimer les étiquettes existantes
## Cas d'usage
- Définir des étiquettes en chiffres romains (i, ii, iii) pour la préface d'un livre et des étiquettes décimales pour le texte principal
- Étiqueter les pages d'annexe avec des préfixes alphabétiques comme « A-1 », « A-2 », « B-1 », « B-2 »
- Corriger les étiquettes de page d'un document numérisé dont les numéros de page physiques ne correspondent pas à l'ordre des pages du PDF
- Ajouter une numérotation commençant à zéro pour des documents techniques
## Astuces
- Les étiquettes de page sont des métadonnées que les lecteurs PDF affichent dans leur barre de navigation. Elles ne s'impriment pas sur la page. Pour des numéros visibles, utilisez [Numéros de page](./page-numbers).
- Cet outil nécessite que CoherentPDF (CPDF) soit configuré dans vos paramètres WASM. S'il ne l'est pas, il vous sera proposé de le configurer.
## Outils associés
- [Numéros de page](./page-numbers)
- [Numérotation Bates](./bates-numbering)
- [Modifier les signets](./bookmark)
docs/fr/tools/add-stamps.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Ajouter des tampons
description: Ajoutez des tampons image à vos pages PDF grâce à une barre d'outils d'annotation intégrée avec attribution par nom d'utilisateur.
---
# Ajouter des tampons
Placez des tampons image sur vos pages PDF à l'aide d'un lecteur intégré doté d'une barre d'outils d'annotation de tampons. Les tampons peuvent inclure votre nom pour l'attribution, ce qui est utile pour les circuits d'approbation, les processus de relecture et le marquage de documents.
## Fonctionnement
1. Saisissez votre nom dans le champ **Nom d'utilisateur du tampon**. Ce nom apparaîtra sur les tampons que vous créez.
2. Importez votre fichier PDF en cliquant ou en le glissant dans la zone de dépôt.
3. L'éditeur de tampons s'ouvre avec votre document chargé dans un lecteur.
4. Utilisez l'outil de tampon image de la barre d'outils pour sélectionner et placer des tampons sur n'importe quelle page.
5. Positionnez et redimensionnez les tampons selon vos besoins.
6. Cliquez sur **Enregistrer le PDF tamponné** pour télécharger le résultat.
## Fonctionnalités
- Lecteur PDF intégré avec une barre d'outils d'annotation dédiée aux tampons
- Attribution par nom d'utilisateur sur les tampons créés
- Placement de tampons image sur n'importe quelle page
- Positionnement et redimensionnement par glisser-déposer
- Dimensionnement automatique du lecteur selon le format de la page
- Affichage du fichier avec son nom et sa taille
## Cas d'usage
- Ajouter des tampons image « APPROUVÉ » ou « RELU » aux documents d'un circuit de relecture
- Placer le sceau d'une entreprise ou le cachet d'un notaire sur des documents officiels
- Marquer des pages avec des tampons « REÇU » incluant le nom du relecteur
- Ajouter des tampons de contrôle qualité à des rapports d'inspection
## Astuces
- Définissez le nom d'utilisateur du tampon avant d'importer le PDF. Le nom d'utilisateur est intégré aux métadonnées du tampon.
- Le lecteur ajuste sa hauteur selon le format de la première page du PDF pour un affichage optimal.
- Pour des filigranes textuels plutôt que des tampons image, utilisez l'outil [Ajouter un filigrane](./add-watermark).
## Outils associés
- [Signer un PDF](./sign-pdf)
- [Ajouter un filigrane](./add-watermark)
- [Éditeur PDF](./edit-pdf)
docs/fr/tools/add-watermark.md
+79
View File
@@ -0,0 +1,79 @@
---
title: Ajouter un filigrane
description: Apposez des filigranes texte ou image sur les pages PDF avec un éditeur visuel par glisser-déposer et un aperçu en direct.
---
# Ajouter un filigrane
Ajoutez des filigranes texte ou image à vos pages PDF grâce à un éditeur visuel. Vous pouvez positionner le filigrane en le faisant glisser directement sur l'aperçu, le redimensionner avec les poignées d'angle, et configurer l'opacité, la rotation, la police et la couleur. Chaque page peut avoir sa propre position de filigrane, ou vous pouvez appliquer le même filigrane à toutes les pages à la fois.
## Fonctionnement
1. Importez votre fichier PDF.
2. L'éditeur s'ouvre avec un aperçu en direct de la première page et une superposition de filigrane déplaçable.
3. Choisissez entre le mode filigrane **Texte** ou **Image** avec les boutons de bascule.
4. Configurez les paramètres du filigrane dans le panneau latéral.
5. Faites glisser le filigrane sur l'aperçu pour le positionner exactement où vous le souhaitez. Utilisez les poignées d'angle pour le redimensionner.
6. Naviguez entre les pages pour définir des filigranes par page, ou laissez **Appliquer à toutes les pages** coché.
7. Cliquez sur **Ajouter un filigrane** pour traiter et télécharger.
## Options
**Paramètres du filigrane texte :**
- **Texte** : le texte du filigrane (par exemple « CONFIDENTIEL », « BROUILLON »).
- **Taille de police** : de 10 à 200 points. 72 par défaut.
- **Couleur** : n'importe quelle couleur via le sélecteur de couleur.
- **Opacité** : contrôle la transparence, de totalement transparent à totalement opaque.
- **Rotation** : fait pivoter le texte du filigrane de -180 à 180 degrés.
**Paramètres du filigrane image :**
- **Import d'image** : importez un fichier PNG, JPG ou un autre format d'image à utiliser comme filigrane.
- **Opacité** : contrôle la transparence de l'image.
- **Échelle** : redimensionne le filigrane image.
**Paramètres de disposition :**
- **Unique** : un filigrane par page, positionné par glisser-déposer ou avec les positions prédéfinies.
- **En mosaïque** : répète le filigrane sur toute la page selon une grille diagonale qui suit l'angle de rotation, de sorte que la marque couvre le document d'un bord à l'autre.
- **Espacement horizontal** : espace entre les motifs le long de la direction du texte, en pourcentage de la largeur du filigrane (mode mosaïque uniquement).
- **Espacement vertical** : espace entre les rangées de motifs, en pourcentage de la hauteur du filigrane (mode mosaïque uniquement).
**Paramètres généraux :**
- **Appliquer à toutes les pages** : lorsque cette option est cochée, le même filigrane s'applique à chaque page. Décochez-la pour définir des filigranes individuels par page.
- **Plage de pages** : indiquez les pages qui reçoivent le filigrane (par exemple « 1-3, 5, 7-9 » ou « all »).
## Fonctionnalités
- Positionnement visuel par glisser-déposer sur un aperçu PDF en direct
- Filigrane redimensionnable avec des poignées d'angle
- Modes filigrane texte et image
- Disposition unique ou en mosaïque sur toute la page (répétée) avec espacement réglable
- Application par page ou globale du filigrane
- Navigation page par page dans l'aperçu
- Contrôles d'opacité et de rotation
- Filtrage par plage de pages
## Cas d'usage
- Marquer des brouillons avec « BROUILLON » avant de les diffuser pour relecture
- Ajouter des filigranes « CONFIDENTIEL » à des rapports financiers sensibles
- Personnaliser des documents avec un filigrane image représentant le logo d'une entreprise
- Apposer « EXEMPLE » sur la documentation produit partagée avec des prospects
- Ajouter des mentions de droit d'auteur aux documents PDF diffusés
## Astuces
- Pour des filigranes en diagonale sur la page, définissez une rotation d'environ 45 degrés et augmentez la taille de police.
- Le mode mosaïque rend un document beaucoup plus difficile à réutiliser après un rognage, car supprimer une marque en laisse des dizaines d'autres. Réduisez l'opacité en mosaïque pour que le texte sous-jacent reste lisible.
- Les filigranes image à fond transparent (format PNG) se fondent plus naturellement dans le contenu du document.
- Si vous avez besoin d'un texte de filigrane différent selon les pages, décochez « Appliquer à toutes les pages » et naviguez page par page.
## Outils associés
- [En-tête et pied de page](./header-footer)
- [Ajouter des tampons](./add-stamps)
- [Numérotation Bates](./bates-numbering)
- [Signer un PDF](./sign-pdf)
docs/fr/tools/adjust-colors.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Ajuster les couleurs
description: Affinez la luminosité, le contraste, la saturation, la teinte, la température, la nuance, le gamma et le sépia de votre PDF.
---
# Ajuster les couleurs
Une boîte à outils complète d'étalonnage des couleurs pour les PDF. Réglez huit paramètres indépendants (luminosité, contraste, saturation, décalage de teinte, température, nuance, gamma et sépia) avec un aperçu en direct qui se met à jour à chaque mouvement de curseur.
## Fonctionnement
1. Importez votre fichier PDF.
2. L'éditeur s'ouvre avec un aperçu de la première page et un panneau de réglages des couleurs.
3. Déplacez les curseurs pour ajuster chaque paramètre de couleur. L'aperçu se met à jour en temps réel.
4. Cliquez sur **Réinitialiser** pour remettre tous les curseurs à leur position par défaut.
5. Cliquez sur **Appliquer** pour traiter toutes les pages et télécharger le PDF ajusté.
## Options
- **Luminosité** : éclaircit ou assombrit toute la page (-100 à +100).
- **Contraste** : augmente ou diminue la différence entre les zones claires et sombres (-100 à +100).
- **Saturation** : renforce ou réduit l'intensité des couleurs (-100 à +100). Une valeur de -100 produit un résultat en niveaux de gris.
- **Décalage de teinte** : fait tourner la roue chromatique pour décaler toutes les couleurs de façon uniforme.
- **Température** : rend les couleurs plus chaudes (jaune/orange) ou plus froides (bleu).
- **Nuance** : ajoute une dominante verte ou magenta.
- **Gamma** : ajuste la luminosité des tons moyens à l'aide d'une courbe gamma. Les valeurs inférieures à 1,0 assombrissent les tons moyens, celles supérieures à 1,0 les éclaircissent.
- **Sépia** : applique un effet sépia classique. Plus la valeur est élevée, plus la teinte brune est marquée.
## Fonctionnalités
- Huit paramètres de couleur réglables indépendamment
- Aperçu en direct qui réagit immédiatement aux mouvements des curseurs
- Bouton de réinitialisation pour revenir rapidement aux valeurs par défaut
- Traitement de toutes les pages du document
- Fonctionne avec tout contenu PDF (texte, images, graphiques)
## Cas d'usage
- Éclaircir une numérisation sombre ou corriger des pages surexposées
- Désaturer un document très coloré pour réduire la consommation d'encre avant l'impression
- Appliquer un ton sépia pour donner un aspect ancien à des certificats ou des diplômes
- Corriger la température de couleur de photos intégrées à un PDF
- Renforcer le contraste de documents numérisés ternes ou de mauvaise qualité
## Astuces
- Pour une conversion rapide en niveaux de gris, faites glisser le curseur de saturation jusqu'à -100.
- Le curseur gamma est particulièrement utile pour améliorer la lisibilité des documents numérisés dont les tons moyens sont trop sombres ou trop clairs.
- Comme les autres outils d'effets d'image, celui-ci rastérise chaque page. Le résultat sera basé sur des images, le texte ne sera donc pas sélectionnable.
## Outils associés
- [Inverser les couleurs](./invert-colors)
- [Effet scanner](./scanner-effect)
- [Couleur de fond](./background-color)
docs/fr/tools/alternate-merge.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Alterner et mélanger les pages
description: Fusionnez des PDF en entrelaçant les pages de chaque fichier en alternance, avec conservation des signets.
---
# Alterner et mélanger les pages
Entrelacez les pages de plusieurs fichiers PDF pour que les pages alternent entre les documents. C'est l'outil à utiliser quand une fusion classique ne ferait que mettre les fichiers bout à bout, alors que vous voulez la page 1 du fichier A, puis la page 1 du fichier B, puis la page 2 du fichier A, et ainsi de suite.
## Fonctionnement
1. Importez au moins deux fichiers PDF à l'aide de la zone de dépôt.
2. L'outil affiche chaque fichier avec son nombre de pages et sa taille.
3. Faites glisser les poignées pour réordonner les fichiers dont les pages passent en premier dans la séquence d'entrelacement.
4. Cliquez sur **Mélanger les pages** pour produire le résultat entrelacé.
5. Le résultat est téléchargé sous le nom `alternated-mixed.pdf`.
## Fonctionnalités
- Entrelace les pages d'un nombre quelconque de PDF (deux minimum)
- Réorganisation des fichiers par glisser-déposer pour contrôler la priorité d'entrelacement
- Conserve les signets des documents sources
- Affiche le nombre de pages et la taille de chaque fichier importé
- Traitement dans un web worker dédié pour une interface réactive
## Cas d'usage
- Reconstituer des numérisations recto verso dont les pages impaires et paires ont été numérisées séparément
- Combiner des feuilles de questions avec leur corrigé pour que chaque question soit suivie de sa réponse
- Fusionner des documents bilingues page par page (par exemple, l'anglais d'un côté, la traduction sur la page suivante)
- Entrelacer les numérisations de recto et de verso issues d'un scanner à passage simple face
## Astuces
- Si vos PDF sources n'ont pas le même nombre de pages, les pages du document le plus court seront épuisées en premier et les pages restantes du document le plus long apparaîtront à la fin.
- L'ordre des fichiers compte : le premier fichier de la liste fournit la première page du résultat. Faites glisser pour réorganiser si nécessaire.
## Outils associés
- [Fusionner des PDF](./merge-pdf)
- [Dupliquer et organiser](./organize-pdf)
- [Scinder un PDF](./split-pdf)
docs/fr/tools/background-color.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Couleur de fond
description: Changez la couleur de fond de chaque page de votre PDF tout en conservant l'ensemble du contenu au-dessus.
---
# Couleur de fond
Définissez une couleur de fond unie derrière tout le contenu existant de votre PDF. L'outil crée un rectangle coloré sur chaque page et superpose le contenu d'origine, de sorte que le texte, les images et les graphiques restent parfaitement visibles sur le nouveau fond.
## Fonctionnement
1. Importez votre fichier PDF.
2. Choisissez une couleur de fond avec le sélecteur de couleur. La valeur par défaut est un jaune clair (#FFFFCC).
3. Cliquez sur **Changer la couleur de fond** pour lancer le traitement.
4. Le PDF mis à jour est téléchargé automatiquement.
## Options
- **Couleur de fond** : un sélecteur de couleur standard pour choisir n'importe quelle couleur unie. Jaune clair par défaut.
## Fonctionnalités
- Applique une couleur de fond uniforme à chaque page
- Conserve tout le contenu d'origine (texte, images, graphiques vectoriels) au-dessus de la couche colorée
- Conserve les dimensions d'origine des pages
- Fonctionne avec des documents de n'importe quel nombre de pages
## Cas d'usage
- Ajouter un fond crème ou ivoire clair pour donner aux documents un aspect plus doux, proche du papier
- Coder par couleur des ensembles de documents en appliquant des couleurs de fond différentes selon les catégories
- Créer des versions visuellement distinctes d'un même document pour différents publics
- Ajouter une légère teinte de fond pour améliorer la lisibilité lors de la projection de documents à l'écran
## Astuces
- Les couleurs claires et douces donnent les meilleurs résultats. Un fond très sombre peut rendre le texte difficile à lire, sauf si le texte est déjà de couleur claire.
- Si vous voulez changer à la fois la couleur de fond et celle du texte, appliquez d'abord la couleur de fond, puis utilisez [Changer la couleur du texte](./text-color) sur le résultat.
- Cet outil travaille au niveau de la structure du PDF (sans rastérisation), le texte reste donc sélectionnable et consultable par recherche dans le résultat.
## Outils associés
- [Changer la couleur du texte](./text-color)
- [Inverser les couleurs](./invert-colors)
- [Ajuster les couleurs](./adjust-colors)
docs/fr/tools/bates-numbering.md
+62
View File
@@ -0,0 +1,62 @@
---
title: Numérotation Bates
description: Appliquez des numéros Bates à un ou plusieurs PDF avec des modèles personnalisables, du remplissage, des polices et un positionnement au choix.
---
# Numérotation Bates
La numérotation Bates appose des identifiants séquentiels sur chaque page de vos PDF. C'est la méthode standard pour étiqueter les documents dans les procédures judiciaires, les audits et les processus de conformité. Cet outil prend en charge plusieurs fichiers et des modèles personnalisables, et produit des PDF numérotés individuellement ou une seule archive ZIP.
## Fonctionnement
1. Importez un ou plusieurs fichiers PDF. Vous pouvez glisser plusieurs fichiers à la fois.
2. Choisissez un style prédéfini ou créez un modèle personnalisé.
3. Configurez la position, la police, la taille, la couleur et les numéros de départ.
4. Cliquez sur **Appliquer les numéros Bates** pour lancer le traitement.
5. Un fichier unique est téléchargé directement. Plusieurs fichiers sont téléchargés sous forme d'archive ZIP.
## Options
- **Style prédéfini** : choisissez parmi les formats intégrés :
- Pièce + Dossier + Bates + Page (par exemple «Exhibit 1 Case XYZ 000001 Page 1»)
- Pièce + Dossier + Bates (sans numéro de page)
- Dossier + Bates
- Numéro Bates uniquement (par exemple « 000001 »)
- Personnalisé (écrivez votre propre modèle)
- **Personnaliser le style** : une chaîne de modèle utilisant des variables : `[BATES]`, `[PAGE]`, `[FILE]`, `[FILENAME]`.
- **Remplissage Bates** : nombre de chiffres (3 à 6) des numéros Bates complétés par des zéros. Visible uniquement en mode personnalisé.
- **Position** : en-tête ou pied de page, à gauche, au centre ou à droite.
- **Les numéros Bates commencent à** : le premier numéro Bates. 1 par défaut. La numérotation se poursuit d'un fichier à l'autre.
- **Le compteur de fichiers commence à** : le numéro de départ de la variable `[FILE]`.
- **Police** : Helvetica, Times New Roman ou Courier.
- **Taille de police** : taille du texte apposé.
- **Couleur** : sélecteur de couleur pour le texte du numéro Bates.
## Fonctionnalités
- Aperçu en direct montrant l'apparence des numéros Bates sur tous les fichiers importés
- Prise en charge de plusieurs fichiers avec numérotation continue entre les documents
- Réorganisation des fichiers par glisser-déposer pour contrôler la séquence de numérotation
- Six positions possibles (en-tête/pied de page, gauche/centre/droite)
- Calcul adaptatif des marges qui respecte les différents formats de page
- Sortie ZIP pour les lots de plusieurs fichiers
- Variables de modèle pour une flexibilité maximale
## Cas d'usage
- Numéroter des documents de communication de pièces dans un litige avec des numéros de pièces séquentiels
- Numéroter des dossiers de preuves d'audit répartis sur des dizaines de fichiers
- Appliquer des numéros de référence réglementaires à la documentation de conformité
- Étiqueter les pièces d'une demande de brevet avec des identifiants propres au dossier
## Astuces
- Faites glisser les fichiers dans la liste pour les réordonner avant le traitement. La séquence de numérotation Bates suit cet ordre.
- Utilisez la variable `[FILENAME]` pour inclure le nom du fichier d'origine dans le tampon, ce qui aide à retrouver la source des pages.
- La zone d'aperçu se met à jour en temps réel lorsque vous modifiez les réglages, ce qui vous permet de vérifier le format avant le traitement.
## Outils associés
- [Numéros de page](./page-numbers)
- [Ajouter des étiquettes de page](./add-page-labels)
- [En-tête et pied de page](./header-footer)
docs/fr/tools/bmp-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: BMP vers PDF
description: Convertissez des images bitmap BMP au format PDF directement dans votre navigateur, sans aucun envoi vers un serveur.
---
# BMP vers PDF
Convertissez des fichiers Windows Bitmap (BMP) en PDF. Le BMP est un format d'image non compressé que l'on trouve encore dans les systèmes anciens, l'imagerie médicale et les scanners industriels. Cet outil les convertit en PDF sans rien installer.
## Formats pris en charge
| Format | Extensions |
| :----- | :--------- |
| BMP | `.bmp` |
## Fonctionnement
1. Cliquez sur la zone d'import ou glissez-déposez vos fichiers BMP.
2. Vérifiez la liste des fichiers. Ajoutez-en d'autres ou retirez ceux dont vous n'avez pas besoin.
3. Cliquez sur **Convertir en PDF**. Le résultat est téléchargé sous le nom `from_bmps.pdf`.
Chaque BMP est dessiné sur un canvas, exporté en PNG, puis intégré au PDF avec pdf-lib. La taille de la page correspond aux dimensions de l'image d'origine.
## Options
Cet outil n'expose pas de réglages de qualité supplémentaires. Les images sont intégrées à leur résolution d'origine, en PNG sans perte, dans le PDF.
## Cas d'usage
- Convertir en PDF d'archivage des documents numérisés anciens stockés en BMP
- Transformer des captures d'écran BMP d'anciennes applications Windows en documents partageables
- Traiter les sorties de scanners médicaux ou industriels qui produisent du BMP par défaut
- Migrer d'anciennes archives d'images vers un format plus portable
## Astuces
- Les fichiers BMP ne sont pas compressés et sont donc souvent volumineux. Le PDF obtenu sera nettement plus léger, car les images sont réencodées en PNG en interne.
- Si vous avez des fichiers BMP à côté d'autres formats d'image, utilisez l'outil [Images vers PDF](./image-to-pdf) pour tout convertir en un seul lot.
## Outils associés
- [Images vers PDF](./image-to-pdf)
- [PNG vers PDF](./png-to-pdf)
- [TIFF vers PDF](./tiff-to-pdf)
docs/fr/tools/bookmark.md
+57
View File
@@ -0,0 +1,57 @@
---
title: Modifier les signets
description: Ajoutez, modifiez, importez, exportez et supprimez les signets d'un PDF avec un éditeur visuel et la prise en charge de CSV/JSON.
---
# Modifier les signets
L'éditeur de signets vous donne un contrôle total sur les signets de navigation d'un PDF (aussi appelés plan du document). Vous pouvez ajouter de nouveaux signets, modifier les existants, réorganiser la hiérarchie et importer ou exporter les données des signets aux formats CSV et JSON.
## Fonctionnement
1. Importez votre PDF en cliquant ou en glissant un fichier dans la zone de dépôt.
2. Cochez éventuellement **Extraire automatiquement les signets existants** pour récupérer l'arborescence de signets actuelle du document.
3. L'éditeur s'ouvre en vue partagée : visionneuse PDF à gauche, panneau des signets à droite.
4. Saisissez un titre de signet et cliquez sur **Ajouter à la page** pour créer un signet pointant vers la page actuelle.
5. Utilisez les boutons de la barre d'outils pour réorganiser, mettre en forme ou supprimer des signets.
6. Cliquez sur **Enregistrer le PDF avec les signets** pour télécharger le fichier mis à jour.
## Fonctionnalités
- Visionneuse PDF visuelle avec navigation entre les pages, commandes de zoom et saisie d'un numéro de page
- Ajout de signets sur n'importe quelle page en un clic
- Clic direct sur le PDF pour définir une destination précise du signet (mode sélection)
- Hiérarchie de signets imbriqués avec réorganisation par glisser-déposer
- Opérations par lots : sélectionnez plusieurs signets pour changer la couleur, le style ou les supprimer d'un coup
- Recherche de signets pour retrouver rapidement des entrées dans de grandes arborescences
- Annulation et rétablissement pour toutes les modifications
- Import de signets depuis des fichiers CSV (titre, page, niveau) ou JSON
- Export des signets en CSV ou JSON pour une modification externe
- Mise en forme des signets : couleur (rouge, bleu, vert, jaune, violet) et style de police (gras, italique, gras italique)
- Navigation rapide : parcourez les pages avec les touches Page précédente/suivante
## Options
- **Extraire automatiquement les signets existants** : lorsque cette option est cochée, l'outil lit et affiche les signets actuels du PDF au chargement.
- **Mode par lots** : activez-le pour sélectionner plusieurs signets et appliquer des changements de couleur, de style ou des suppressions en masse.
- **Tout développer/réduire** : affichez ou masquez rapidement les signets enfants imbriqués.
## Cas d'usage
- Ajouter une table des matières à un manuel ou un ouvrage qui n'a pas de signets
- Restructurer les signets d'un document numérisé après un traitement OCR
- Exporter les signets en CSV, les modifier dans un tableur, puis les réimporter
- Nettoyer des signets générés automatiquement dont les références de page sont incorrectes
- Ajouter des signets colorés pour repérer les sections importantes d'un mémoire juridique
## Conseils
- Utilisez l'import CSV pour créer des signets en masse. Le format est simple : `title,page,level`, où le niveau 1 correspond au premier niveau.
- Le mode sélection vous permet de cliquer sur un endroit précis de la page PDF pour définir la destination du signet, ce qui est plus précis que de cibler simplement un numéro de page.
- Exportez vos signets avant de faire des modifications importantes pour avoir une sauvegarde.
## Outils associés
- [Table des matières](./table-of-contents)
- [Éditeur PDF](./edit-pdf)
- [Ajouter des étiquettes de page](./add-page-labels)
docs/fr/tools/cbz-to-pdf.md
+47
View File
@@ -0,0 +1,47 @@
---
title: CBZ vers PDF
description: Convertissez des archives de bandes dessinées CBZ et CBR en PDF dans votre navigateur. Gratuit, privé, sans envoi de fichiers.
---
# CBZ vers PDF
Transformez des archives de bandes dessinées en PDF. CBZ et CBR sont les formats standards des BD numériques : ce sont simplement des archives ZIP ou RAR remplies d'images. Cet outil extrait chaque page, conserve l'ordre de lecture et produit un PDF propre où chaque image devient une page en taille réelle.
## Formats pris en charge
| Format | Extension | Remarques |
| :----- | :-------- | :------------------------------------------------------------ |
| CBZ | `.cbz` | Archive de BD basée sur ZIP (traitée localement avec pdf-lib) |
| CBR | `.cbr` | Archive de BD basée sur RAR (traitée via le moteur PyMuPDF) |
Le convertisseur CBZ reconnaît les images JPEG, PNG, GIF, BMP, WebP, AVIF, TIFF, HEIC et JXL contenues dans l'archive. Les formats non standard sont automatiquement convertis en PNG avant d'être intégrés.
## Fonctionnement
1. Cliquez sur la zone d'import ou glissez-déposez vos fichiers CBZ ou CBR. Vous pouvez mélanger les deux formats dans un même lot.
2. Vérifiez la liste des fichiers. Retirez ceux dont vous n'avez pas besoin, ou cliquez sur **Ajouter d'autres fichiers** pour en ajouter.
3. Cliquez sur **Convertir en PDF**. Pour les fichiers CBZ, l'outil décompresse l'archive, trie les images par nom dans l'ordre naturel, détecte le format réel de chaque image et les intègre dans un PDF avec pdf-lib. Les fichiers CBR passent plutôt par le moteur PyMuPDF.
4. Un seul fichier est téléchargé sous forme de PDF. Plusieurs fichiers produisent une archive ZIP nommée `comic-converted.zip`.
## Options
Aucune configuration n'est nécessaire. Chaque image devient une page dont la taille correspond à ses dimensions d'origine : les doubles pages restent larges et les pages simples restent étroites.
## Cas d'usage
- Lire des BD sur une tablette ou une application mobile qui prend en charge le PDF mais pas CBZ/CBR
- Imprimer certaines pages d'une BD numérique
- Archiver une collection de BD dans un format que n'importe quel lecteur de fichiers peut ouvrir
- Partager une BD avec quelqu'un qui n'a pas de lecteur de BD dédié
## Conseils
- Les images de l'archive sont triées dans l'ordre naturel (ainsi `page2.jpg` vient avant `page10.jpg`). Nommez vos fichiers avec une numérotation cohérente pour obtenir le bon ordre des pages.
- Le convertisseur détecte les formats d'image grâce à leurs signatures binaires, pas à leurs extensions. Un PNG nommé par erreur `.jpg` sera quand même intégré correctement.
- Les fichiers CBZ sont traités entièrement dans le navigateur sans charger le moteur PyMuPDF, ils se convertissent donc plus vite que les fichiers CBR.
## Outils associés
- [EPUB vers PDF](./epub-to-pdf)
- [MOBI vers PDF](./mobi-to-pdf)
- [Images vers PDF](./image-to-pdf)
docs/fr/tools/change-permissions.md
+61
View File
@@ -0,0 +1,61 @@
---
title: Modifier les autorisations
description: Définissez ou modifiez les autorisations d'utilisation d'un PDF pour l'impression, la copie, la modification et l'annotation. Utilise le chiffrement AES 256 bits.
---
# Modifier les autorisations
Réglez précisément ce que les destinataires peuvent faire avec votre PDF. Contrairement au chiffrement basique qui verrouille simplement le fichier derrière un mot de passe, cet outil vous permet d'autoriser ou d'interdire sélectivement l'impression, la copie, la modification, l'annotation, le remplissage de formulaires, l'assemblage de documents et l'extraction de pages, le tout appliqué par un chiffrement AES 256 bits.
## Fonctionnement
1. Importez un fichier PDF.
2. Si le PDF est déjà chiffré, saisissez le **Mot de passe actuel**.
3. Définissez un **Nouveau mot de passe utilisateur** (requis pour ouvrir) et/ou un **Nouveau mot de passe propriétaire** (contrôle les autorisations).
4. Activez ou désactivez chaque autorisation avec les cases à cocher.
5. Cliquez sur **Modifier les autorisations**.
6. Téléchargez le PDF mis à jour.
Si vous laissez vides les deux champs de nouveau mot de passe, l'outil déchiffre entièrement le PDF et supprime tout chiffrement et toute restriction.
## Contrôles des autorisations
| Autorisation | Ce qu'elle contrôle |
| ------------------------------------------- | ---------------------------------------------------------------- |
| **Autoriser l'impression** | Si le document peut être imprimé |
| **Autoriser la copie** | Si le texte et les images peuvent être sélectionnés et copiés |
| **Autoriser la modification** | Si le contenu du document peut être modifié |
| **Autoriser l'annotation** | Si des commentaires, surlignages et tampons peuvent être ajoutés |
| **Autoriser le remplissage de formulaires** | Si les champs de formulaire interactifs peuvent être remplis |
| **Autoriser l'assemblage du document** | Si des pages peuvent être insérées, supprimées ou pivotées |
| **Autoriser l'extraction de pages** | Si des pages individuelles peuvent être extraites |
Toutes les autorisations nécessitent un mot de passe propriétaire pour être appliquées. Sans mot de passe propriétaire, les indicateurs d'autorisation sont ignorés par la plupart des lecteurs PDF.
## Comment fonctionnent les autorisations dans un PDF
Les autorisations PDF font partie de la spécification de chiffrement. Elles sont stockées sous forme d'indicateurs binaires dans le dictionnaire de chiffrement et appliquées par les lecteurs PDF conformes. La distinction essentielle :
- **Mot de passe utilisateur** : requis pour ouvrir le fichier.
- **Mot de passe propriétaire** : requis pour modifier les autorisations ou lever les restrictions. Sans lui, les indicateurs d'autorisation déterminent les opérations que l'utilisateur peut effectuer.
Si vous ne définissez qu'un mot de passe propriétaire (sans mot de passe utilisateur), tout le monde peut ouvrir le fichier, mais sera limité aux opérations autorisées. Si vous définissez les deux, le fichier exige un mot de passe pour être ouvert et reste restreint après l'authentification.
## Cas d'usage
- Distribuer un rapport qui peut être consulté et imprimé, mais pas modifié ni copié
- Partager un modèle de contrat que les destinataires peuvent remplir sans le modifier
- Publier un catalogue PDF dont la copie des images est désactivée
- Autoriser l'annotation d'un brouillon en relecture tout en empêchant les changements de structure
## Conseils
- Pour être efficace, définissez toujours un mot de passe propriétaire. Les autorisations sans mot de passe propriétaire ne peuvent pas être appliquées.
- Certains outils PDF tiers ignorent les indicateurs d'autorisation. Pour une protection plus solide, envisagez de rastériser le PDF ou d'utiliser un DRM.
- Utilisez cet outil pour faire passer d'anciens PDF chiffrés en RC4 à l'AES 256.
## Outils associés
- [Protéger un PDF](./protect-pdf) : protection simple par mot de passe, sans autorisations détaillées
- [Déverrouiller un PDF](./unlock-pdf) : supprime entièrement le chiffrement
- [Supprimer les restrictions](./remove-restrictions) : retire toutes les restrictions lorsque vous avez le mot de passe propriétaire
docs/fr/tools/combine-single-page.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Combiner en une seule page
description: Assemblez toutes les pages d'un PDF en un seul défilement continu, vertical ou horizontal.
---
# Combiner en une seule page
Fusionnez toutes les pages d'un PDF en une seule longue page. Les pages sont assemblées verticalement (comme un rouleau) ou horizontalement (côte à côte), pour produire une page continue en sortie.
## Fonctionnement
1. Importez un fichier PDF.
2. Choisissez la direction de la mise en page : **Vertical** (pages empilées de haut en bas) ou **Horizontal** (pages placées côte à côte).
3. Définissez l'espacement entre les pages en points.
4. Choisissez une couleur de fond pour les espaces entre les pages.
5. Activez éventuellement les séparateurs (fines lignes entre les pages) et réglez leur épaisseur et leur couleur.
6. Cliquez sur le bouton de traitement. Le résultat est un PDF d'une seule page.
## Fonctionnalités
- Assemblage des pages à la verticale ou à l'horizontale
- Espacement configurable entre les pages
- Sélecteur de couleur de fond pour les zones d'espacement
- Lignes de séparation facultatives avec épaisseur et couleur réglables
- Rendu de chaque page d'origine en pleine résolution sur le canevas combiné
## Options
| Option | Description |
| --------------------------- | ------------------------------------------------- |
| **Sens de la mise en page** | Verticale (empilées) ou horizontale (côte à côte) |
| **Espacement des pages** | Écart entre les pages en points |
| **Couleur de fond** | Couleur de la zone entre les pages |
| **Ajouter un séparateur** | Active de fines lignes entre les pages |
| **Épaisseur du séparateur** | Épaisseur de la ligne en points |
| **Couleur du séparateur** | Couleur des lignes de séparation |
## Cas d'usage
- Créer une longue image unique à partir d'une maquette ou d'un wireframe de plusieurs pages
- Générer une vue défilante continue d'un document pour l'intégrer à un site web
- Assembler une BD ou un storyboard de plusieurs pages en une seule bande
- Produire une vue panoramique de pages successives pour une relecture
## Conseils
- L'orientation verticale convient mieux aux documents à pages en portrait. L'horizontale est préférable pour le contenu en paysage.
- Les documents volumineux comportant beaucoup de pages produiront un résultat très haut ou très large. Certaines visionneuses PDF peuvent avoir du mal avec des pages uniques extrêmement grandes.
- Ajouter des séparateurs d'une couleur contrastée permet de voir facilement où une page d'origine se termine et où la suivante commence.
## Outils associés
- [PDF N-up](./n-up-pdf)
- [Fusionner des PDF](./merge-pdf)
- [Diviser les pages](./divide-pages)
docs/fr/tools/compare-pdfs.md
+60
View File
@@ -0,0 +1,60 @@
---
title: Comparer des PDF
description: Comparez deux documents PDF côte à côte ou en mode superposition, avec détection et classement détaillés des modifications.
---
# Comparer des PDF
Importez deux PDF et voyez exactement ce qui a changé entre eux. L'outil associe intelligemment les pages, détecte les différences de texte, d'images, d'annotations, d'en-têtes et de mise en forme, puis les présente en vue côte à côte ou en superposition.
## Fonctionnement
1. Importez deux fichiers PDF : l'original (à gauche) et la version révisée (à droite).
2. L'outil associe les pages des deux documents à l'aide de signatures de contenu.
3. Choisissez un mode d'affichage : **Côte à côte** ou **Superposition**.
4. Naviguez entre les paires de pages avec les commandes de pagination.
5. Les différences sont surlignées et classées. Utilisez le panneau de filtres pour vous concentrer sur certains types de modifications.
6. Exportez éventuellement la comparaison sous forme de rapport PDF.
## Fonctionnalités
- Association automatique des pages selon la similarité du contenu
- Vues de comparaison côte à côte et en superposition
- Classement des modifications : texte, image, en-tête/pied de page, annotation, mise en forme, arrière-plan
- Filtres par catégorie pour afficher ou masquer certains types de modifications
- Recherche dans les modifications de texte avec filtrage par requête
- Prise en charge de l'OCR pour comparer des documents numérisés
- Commandes de zoom pour une inspection détaillée
- Défilement synchronisé entre les panneaux en mode côte à côte
- Export des résultats de la comparaison en PDF
## Options
| Option | Description |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| **Mode d'affichage** | Côte à côte ou superposition |
| **OCR** | Active/désactive l'OCR pour la comparaison de documents numérisés |
| **Langue de l'OCR** | Langue utilisée pour l'extraction du texte par OCR |
| **Filtres par catégorie** | Active ou masque l'affichage des modifications de texte, d'image, d'en-tête/pied de page, d'annotation, de mise en forme et d'arrière-plan |
| **Portée des modifications** | En mode superposition, filtre entre toutes les modifications ou le contenu uniquement |
| **Zoom** | Ajuste le niveau d'agrandissement pour une inspection détaillée |
## Cas d'usage
- Relire les révisions d'un contrat pour trouver exactement ce qui a changé entre deux versions
- Comparer des maquettes de design pour vérifier que les exports PDF correspondent aux attentes
- Auditer les modifications de documents dans des secteurs réglementés où chaque changement doit être tracé
- Vérifier qu'un processus de conversion PDF a fidèlement préservé le contenu d'origine
- Comparer des documents traduits à la source pour repérer les changements de mise en page
## Conseils
- La vue en superposition empile les deux documents l'un sur l'autre, ce qui rend immédiatement visibles les différences spatiales (éléments déplacés, images redimensionnées).
- Activez l'OCR pour comparer des documents numérisés sans couche de texte. Le moteur de comparaison extraira le texte des images de page.
- Utilisez les filtres par catégorie pour vous concentrer sur l'essentiel. Par exemple, masquez les changements de mise en forme si seules les différences de contenu textuel vous intéressent.
## Outils associés
- [Afficher les métadonnées](./view-metadata)
- [OCR PDF](./ocr-pdf)
- [Fusionner des PDF](./merge-pdf)
docs/fr/tools/compress-pdf.md
+73
View File
@@ -0,0 +1,73 @@
---
title: Compresser un PDF
description: Réduisez la taille d'un PDF jusqu'à 90 % avec le moteur Hyper Compress. Prend en charge les tailles cibles, le traitement par lots et des réglages de qualité personnalisés.
---
# Compresser un PDF
Réduisez le poids de vos fichiers PDF sans les abîmer. Compresser un PDF s'appuie sur [Hyper Compress](https://www.bentopdf.com/hyper-compress), le moteur de compression propre à BentoPDF. Il recompresse les images, crée des sous-ensembles de polices et les fusionne, et supprime le superflu comme les miniatures intégrées et les données privées d'applications. Le PDF reste pleinement fonctionnel : le texte reste sélectionnable, les liens et les champs de formulaire continuent de fonctionner.
Hyper Compress est compilé en WebAssembly et livré avec BentoPDF, la compression fonctionne donc hors ligne et dans les déploiements isolés du réseau, sans configuration supplémentaire.
## Fonctionnement
1. Importez un ou plusieurs PDF en cliquant sur la zone de dépôt ou en y glissant des fichiers.
2. Choisissez un **Niveau de compression** : Faible, Moyen, Élevé ou Sans perte.
3. Saisissez éventuellement une **Taille de fichier cible**, ou développez **Paramètres personnalisés** pour un contrôle précis, y compris **Convertir en niveaux de gris**.
4. Cliquez sur **Compresser un PDF**. Pour plusieurs fichiers, vous obtenez un seul téléchargement ZIP.
## Documents particuliers
- **Les PDF signés numériquement** sont renvoyés tels quels, car toute modification invaliderait la signature. Activez **Ignorer la protection du contenu** dans les paramètres personnalisés pour supprimer les signatures et les compresser ; la signature visible reste sur la page, mais le fichier n'est plus signé.
- **Les fichiers PDF/A** perdent leur étiquette PDF/A après la compression, afin que le fichier ne prétende jamais à une conformité qu'il ne respecte plus. Activez **Préserver le PDF/A** dans les paramètres personnalisés pour garder le fichier conforme.
- **Les PDF protégés par mot de passe** affichent un champ de mot de passe sur la carte de leur fichier. Saisissez-y le mot de passe et Hyper Compress ouvre lui-même le fichier, sans étape de déverrouillage séparée. Avec au moins deux fichiers verrouillés, un champ partagé déverrouille tous les fichiers qui utilisent le même mot de passe. La copie compressée n'a pas de mot de passe ; utilisez [Protéger un PDF](./protect-pdf) pour en ajouter un à nouveau.
- **Les scans sans couche de texte** peuvent être réduits davantage avec **Rastériser les pages** dans les paramètres personnalisés, qui remplace chaque page par une image optimisée. Cette option est ignorée pour tout document contenant du texte sélectionnable, y compris les scans traités par OCR, sauf si **Ignorer la protection du contenu** est activé. Les pages de texte deviennent alors aussi des images : le texte n'est plus sélectionnable et les liens ne fonctionnent plus.
## Niveaux de compression
| Niveau | Qualité d'image | Résolution max. | Idéal pour |
| -------------- | --------------- | --------------- | ------------------------------------------ |
| **Faible** | 80 | 200 DPI | Préserver la qualité visuelle |
| **Moyen** | 50 | 150 DPI | Documents courants |
| **Élevé** | 20 | 72 DPI | Pièces jointes d'e-mail, envois sur le web |
| **Sans perte** | Images intactes | Inchangée | Copies d'archivage |
Le niveau Élevé retire aussi l'incorporation des 14 polices PDF standard, ainsi que des polices similaires comme Arial lorsque c'est sans risque.
## Taille de fichier cible
Saisissez une taille en Ko ou en Mo et Hyper Compress recherche la meilleure qualité d'image qui tienne encore dans cette taille, en partant du niveau choisi. Si le document ne peut pas devenir aussi petit, vous obtenez la plus petite version possible et un message vous l'indique. Les pages dédiées, comme [Compresser un PDF à 1 Mo](https://www.bentopdf.com/compress-pdf-to-1mb), s'ouvrent avec la cible déjà renseignée.
## Paramètres personnalisés
Développez le panneau Paramètres personnalisés pour régler directement Hyper Compress. Choisir un niveau de compression réinitialise ces paramètres aux valeurs de ce niveau, et en modifier un fait passer le niveau sur Personnalisé.
- **Ignorer la protection du contenu** : par défaut, Hyper Compress laisse intacts les PDF signés et ne rastérise pas les pages contenant du texte. Activer cette option contourne les deux. Elle reste activée lorsque vous changez de niveau.
- **Images** : qualité d'image, résolution maximale, rééchantillonnage forcé, réduction des couleurs, découpe des zones d'image invisibles, suppression des images alternatives, simplification des profils de couleur, JPEG 2000 et mode sans perte
- **Polices** : création de sous-ensembles, fusion des doublons et retrait de l'incorporation des polices standard et de leurs équivalents
- **Contenu** : aplatissement des annotations, des champs de formulaire ou des liens
- **Nettoyage** : suppression des miniatures, des données d'application, des fils d'articles, des informations de capture web, de l'arbre de structure ou des intentions de sortie
- **Rastérisation** : remplacement des pages par des images, pour les scans composés uniquement d'images ; ignorée lorsque le document contient du texte sélectionnable
- **Sortie** : Préserver le PDF/A, et compression Brotli pour les lecteurs PDF 2.0 qui la prennent en charge
## Cas d'usage
- Ramener un rapport de 50 Mo sous la limite de taille d'une pièce jointe d'e-mail
- Faire passer un scan sous la limite d'envoi stricte d'un portail grâce à une taille de fichier cible
- Optimiser des PDF marketing pour des téléchargements plus rapides sur un site web
- Archiver de gros ensembles de documents lorsque le coût de stockage compte
- Réduire la consommation de données mobiles lors du partage de PDF via des applications de messagerie
## Conseils
- Commencez par Moyen. Si le résultat est encore trop gros, définissez une taille de fichier cible ou passez à Élevé.
- Pour un scan sans couche de texte, activez Rastériser les pages dans les paramètres personnalisés.
- Convertir en niveaux de gris, dans les paramètres personnalisés, peut réduire la taille des documents très colorés.
## Outils associés
- [Optimiser pour le web](./linearize-pdf) : optimisez le PDF compressé pour un affichage web rapide
- [Rastériser le PDF](./rasterize-pdf) : convertissez les pages en images à un DPI précis, y compris les pages contenant du texte
- [Réparer un PDF](./repair-pdf) : réparez un PDF endommagé par une compression effectuée ailleurs
- [Supprimer les métadonnées](./remove-metadata) : supprimez les données cachées pour préserver la confidentialité
docs/fr/tools/crop-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: Rogner un PDF
description: Rognez visuellement les pages d'un PDF en dessinant une zone de rognage sur chaque page avec un éditeur basé sur Cropper.js.
---
# Rogner un PDF
Réduisez les marges de vos pages PDF grâce à une interface de rognage visuelle. Dessinez un rectangle de rognage directement sur chaque page, prévisualisez le résultat et appliquez le rognage. Vous pouvez définir des zones de rognage différentes selon les pages ou appliquer le même rognage à tout le document.
## Fonctionnement
1. Importez votre fichier PDF.
2. L'éditeur de rognage s'ouvre et affiche la première page avec une superposition de rognage déplaçable.
3. Ajustez le rectangle de rognage en faisant glisser ses bords ou ses coins.
4. Utilisez les boutons de navigation pour passer d'une page à l'autre et définir la zone de rognage de chacune.
5. Cliquez sur **Rogner** pour appliquer le rognage et télécharger le résultat.
## Fonctionnalités
- Éditeur de rognage visuel basé sur Cropper.js, avec des poignées pour un réglage précis
- Navigation page par page pour définir des zones de rognage individuelles
- Mémorisation des réglages de rognage par page, pour définir des rognages différents selon les pages
- Aperçu en direct de la zone de rognage sélectionnée
- Prise en charge des PDF de toute taille de page ou orientation
## Cas d'usage
- Supprimer les larges marges de documents numérisés pour se concentrer sur la zone de contenu
- Retirer les traits de coupe ou les repères de calage des PDF de prépresse
- Rogner des diapositives de cours pour supprimer la zone des notes du présentateur
- Supprimer les en-têtes ou pieds de page de chaque page avant de partager un extrait de document
- Redimensionner des pages pour les adapter à un affichage ou une mise en page d'impression précis
## Conseils
- La superposition de rognage peut être librement redimensionnée et repositionnée. Faites glisser les coins pour un redimensionnement proportionnel ou les bords pour un ajustement sur un seul axe.
- Pour les documents dont chaque page nécessite le même rognage, définissez-le sur la première page : l'outil mémorise votre zone de rognage au fil de la navigation entre les pages.
- Si vous devez uniformiser la taille des pages plutôt que rogner visuellement, l'outil Uniformiser la taille des pages peut mieux convenir.
## Outils associés
- [Éditeur PDF](./edit-pdf)
- [Numéros de page](./page-numbers)
- [Supprimer les pages blanches](./remove-blank-pages)
docs/fr/tools/csv-to-pdf.md
+51
View File
@@ -0,0 +1,51 @@
---
title: CSV vers PDF
description: Convertissez des fichiers tableur CSV en tableaux PDF mis en forme, directement dans votre navigateur.
---
# CSV vers PDF
Transformez des fichiers CSV en documents PDF propres et mis en forme. Chaque CSV est analysé et rendu sous forme de tableau dans le PDF obtenu. C'est utile lorsque vous devez imprimer ou partager des données tabulaires sans que le destinataire ait besoin d'un tableur.
## Formats pris en charge
| Format | Extensions |
| :----- | :--------- |
| CSV | `.csv` |
## Fonctionnement
1. Cliquez sur la zone d'import ou glissez-déposez un ou plusieurs fichiers CSV.
2. Vérifiez la liste des fichiers. Ajoutez-en d'autres ou retirez ceux dont vous ne voulez pas.
3. Cliquez sur **Convertir en PDF**. Un indicateur de progression affiche l'état de la conversion.
4. Un seul fichier est téléchargé directement sous forme de PDF. Plusieurs fichiers sont regroupés dans `csv-converted.zip`.
## Options
Cet outil n'a pas de configuration supplémentaire. Le CSV est automatiquement analysé et mis en forme sous forme de tableau.
## Résultat
| Nombre de fichiers | Résultat |
| :----------------- | :------------------------------------------------------------- |
| 1 fichier | Téléchargement d'un seul PDF (par ex. `data.pdf`) |
| 2 fichiers ou plus | Archive ZIP (`csv-converted.zip`) contenant un PDF par fichier |
## Cas d'usage
- Convertir des rapports de base de données exportés en tableaux PDF imprimables
- Partager des données financières ou des listes d'inventaire avec des personnes qui n'ont pas Excel
- Créer des versions PDF de fichiers journaux CSV pour la documentation de conformité
- Imprimer des listes d'adresses, des feuilles de notes ou toute donnée tabulaire stockée au format CSV
## Conseils
- Pour de meilleurs résultats, assurez-vous que votre CSV utilise des séparateurs virgule standard. L'outil suit les conventions courantes d'analyse des CSV.
- Si votre CSV comporte beaucoup de colonnes, le tableau peut être compressé pour tenir dans la largeur de la page. Pensez à diviser les jeux de données larges en plusieurs fichiers.
- Pour les fichiers Excel (`.xls`, `.xlsx`), utilisez l'outil [Excel vers PDF](./excel-to-pdf), qui préserve la mise en forme du tableur et les feuilles multiples.
## Outils associés
- [Excel vers PDF](./excel-to-pdf)
- [Texte vers PDF](./txt-to-pdf)
- [JSON vers PDF](./json-to-pdf)
docs/fr/tools/delete-pages.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Supprimer des pages
description: Supprimez des pages précises d'un PDF par numéro de page, plage ou sélection visuelle de miniatures.
---
# Supprimer des pages
Retirez les pages indésirables d'un document PDF. Indiquez les pages à supprimer en saisissant des numéros ou des plages de pages, ou cliquez directement sur les miniatures pour les marquer en vue de la suppression.
## Fonctionnement
1. Importez un fichier PDF. L'outil affiche des miniatures de toutes les pages.
2. Saisissez les pages à supprimer dans le champ de texte avec la syntaxe de plages (par ex. `2, 5-8`), ou cliquez sur les miniatures pour les activer ou désactiver.
3. Les pages marquées sont mises en évidence pour que vous puissiez confirmer votre sélection.
4. Cliquez sur le bouton de traitement. Un nouveau PDF est créé sans les pages sélectionnées.
## Fonctionnalités
- Sélection des pages par texte avec la syntaxe de plages (`2, 5-8, 12`)
- Grille de miniatures pour une suppression par simple clic
- Surbrillance en temps réel des pages marquées pour la suppression
- Validation de la saisie par rapport au nombre réel de pages
- Conserve toutes les pages non supprimées dans leur ordre d'origine
## Cas d'usage
- Supprimer les pages blanches ou de remplissage d'un document numérisé
- Retirer les pages de couverture ou les annexes avant de partager un document
- Nettoyer les pages de brouillon laissées par erreur dans un PDF final
- Supprimer les pages contenant des informations sensibles avant diffusion
## Conseils
- Supprimer des pages n'affecte ni le contenu ni la mise en forme des pages restantes. Le résultat est une copie fidèle de l'original, moins les pages retirées.
- Si vous voulez conserver uniquement certaines pages plutôt que d'en retirer, [Extraire des pages](./extract-pages) convient mieux.
- L'affichage des miniatures se charge progressivement, ce qui garde les gros documents réactifs.
## Outils associés
- [Extraire des pages](./extract-pages)
- [Dupliquer et organiser](./organize-pdf)
- [Scinder un PDF](./split-pdf)
docs/fr/tools/deskew-pdf.md
+46
View File
@@ -0,0 +1,46 @@
---
title: Redresser un PDF
description: Redressez automatiquement les pages inclinées des PDF numérisés grâce à la détection d'inclinaison d'OpenCV. Seuil et DPI réglables.
---
# Redresser un PDF
Les documents numérisés sont rarement parfaitement droits. Même une légère inclinaison réduit la précision de l'OCR et donne un aspect négligé à l'impression. Cet outil utilise les algorithmes de traitement d'image d'OpenCV pour détecter l'angle d'inclinaison de chaque page et la remettre d'aplomb.
## Fonctionnement
1. Importez un ou plusieurs PDF numérisés.
2. Définissez le **Seuil d'inclinaison** : les pages dont l'inclinaison détectée est inférieure à cette valeur ne sont pas modifiées.
3. Choisissez une **Qualité de traitement (DPI)** : un DPI plus élevé améliore la précision de la détection mais prend plus de temps.
4. Cliquez sur **Redresser un PDF**.
5. Après le traitement, un panneau de résultats affiche l'angle détecté pour chaque page et indique si elle a été corrigée.
## Options
| Paramètre | Valeurs | Par défaut |
| ----------------------- | ------------------------- | ---------- |
| **Seuil d'inclinaison** | 0,1, 0,5, 1,0, 2,0 degrés | 0,5 |
| **DPI de traitement** | 100, 150, 200, 300 | 150 |
## Comment fonctionne la détection d'inclinaison
L'outil rend chaque page sous forme d'image au DPI sélectionné, puis utilise OpenCV pour détecter les angles dominants des lignes du contenu. Si l'inclinaison détectée dépasse le seuil, la page est pivotée de l'angle inverse pour la redresser. Les pages en dessous du seuil sont transmises sans modification.
## Cas d'usage
- Nettoyer des contrats ou des documents juridiques numérisés par lots
- Préparer des reçus ou des factures numérisés pour un traitement OCR
- Redresser des pages issues d'un scanner à plat dont le placement du papier est irrégulier
- Améliorer la qualité visuelle de documents d'archives numérisés
## Conseils
- Abaissez le seuil à 0,1 degré si vous avez besoin d'un alignement parfait au pixel près pour l'OCR.
- 150 DPI est rapide et précis pour la plupart des documents. Utilisez 300 DPI pour du texte très petit ou des pages très détaillées.
- Le redressement fonctionne mieux sur les documents avec des lignes de texte horizontales nettes. Il peut avoir du mal avec les pages composées surtout d'images ou d'éléments de design en diagonale.
## Outils associés
- [Rastériser le PDF](./rasterize-pdf) : convertissez le résultat redressé en PDF à plat basé sur des images
- [Compresser un PDF](./compress-pdf) : réduisez la taille du fichier après le redressement
- [Réparer un PDF](./repair-pdf) : corrigez les problèmes de structure dans les PDF numérisés
docs/fr/tools/digital-sign-pdf.md
+65
View File
@@ -0,0 +1,65 @@
---
title: Signature numérique PDF
description: Ajoutez des signatures numériques cryptographiques aux PDF avec des certificats X.509. Prend en charge les formats PKCS#12 et PEM, avec options de signature visible.
---
# Signature numérique PDF
Une signature numérique est la preuve cryptographique qu'une personne précise a signé un document et que ce dernier n'a pas été altéré depuis. Contrairement à une signature dessinée (qui n'est qu'une image), une signature numérique utilise des certificats X.509 et les standards PKCS#7 pour garantir une authenticité et une intégrité vérifiables.
BentoPDF applique les signatures numériques entièrement dans votre navigateur. Votre clé privée ne quitte jamais votre appareil.
## Fonctionnement
1. Importez un fichier PDF.
2. Importez votre fichier de certificat (.pfx, .p12 ou .pem).
3. Saisissez le mot de passe du certificat pour le déverrouiller. L'outil affiche le sujet du certificat, l'émetteur et la période de validité.
4. Configurez éventuellement les métadonnées de la signature (motif, lieu, coordonnées).
5. Activez éventuellement une **signature visible** avec personnalisation de la position, de la taille, de l'image et du texte.
6. Cliquez sur **Signer le PDF**.
## Formats de certificat pris en charge
| Format | Extensions | Description |
| ----------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| **PKCS#12** | .pfx, .p12 | Bundle standard du secteur contenant la clé privée et la chaîne de certificats. Format le plus courant. |
| **PEM** | .pem | Format texte. Doit contenir à la fois le certificat et la clé privée dans un seul fichier. Prend en charge les clés privées chiffrées. |
## Options de signature visible
Lorsqu'elle est activée, un bloc de signature visible est rendu sur la page du PDF :
- **Position** : coordonnées X/Y et largeur/hauteur en points
- **Page** : première page, dernière page, toutes les pages ou un numéro de page précis
- **Image** : importez une image PNG, JPG ou WebP (votre signature manuscrite, le sceau de votre entreprise, etc.)
- **Texte** : texte personnalisé avec couleur et taille de police configurables. Si aucune image ni aucun texte n'est fourni, l'outil génère automatiquement un texte à partir du nom commun du certificat et de la date du jour.
## Métadonnées de la signature
- **Motif** : pourquoi le document a été signé (par ex. « Approuvé », « Relu »)
- **Lieu** : où la signature a eu lieu (par ex. « Paris »)
- **Coordonnées** : comment joindre le signataire (par ex. une adresse e-mail)
## Remarque sur la connexion Internet
La signature peut nécessiter une connexion Internet. La bibliothèque de signature récupère la chaîne de certificats à partir des URL intégrées dans l'extension Authority Information Access (AIA) de votre certificat. Si ces serveurs sont inaccessibles, la signature échouera pour les certificats qui exigent une validation de la chaîne.
## Cas d'usage
- Signer des contrats, des propositions et des accords avec des signatures numériques juridiquement contraignantes
- Certifier des documents officiels dans des flux de travail qui exigent une authentification basée sur une PKI
- Signer des factures PDF pour la conformité réglementaire (de nombreux pays de l'UE exigent des factures électroniques signées numériquement)
- Ajouter une approbation organisationnelle à des plans d'ingénierie ou à des documents qualité
## Conseils
- Les certificats auto-signés conviennent pour des tests, mais afficheront des avertissements dans Adobe Reader. Utilisez un certificat d'une autorité de certification de confiance pour les documents en production.
- La signature visible est purement visuelle. La signature cryptographique est intégrée que le bloc visible soit activé ou non.
- Vérifiez votre PDF signé avec l'outil Valider la signature PDF pour confirmer que la signature est intacte.
## Outils associés
- [Valider la signature PDF](./validate-signature-pdf) : vérifiez les signatures numériques des PDF signés
- [Aplatir le PDF](./flatten-pdf) : aplatissez les formulaires avant de signer pour empêcher les modifications
- [Protéger un PDF](./protect-pdf) : ajoutez une protection par mot de passe en plus de la signature numérique
- [Supprimer les métadonnées](./remove-metadata) : supprimez les métadonnées avant de signer
docs/fr/tools/divide-pages.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Diviser les pages
description: Divisez les pages d'un PDF horizontalement ou verticalement en pages plus petites.
---
# Diviser les pages
Coupez chaque page d'un PDF en deux moitiés, horizontalement ou verticalement. C'est utile lorsqu'une même page contient du contenu qui devrait être réparti sur des pages distinctes, par exemple une mise en page à deux colonnes numérisée comme une seule page large.
## Fonctionnement
1. Importez un fichier PDF.
2. Choisissez la direction de la division : **Verticale** (moitiés gauche/droite) ou **Horizontale** (moitiés haut/bas).
3. Indiquez éventuellement une plage de pages pour limiter les pages à diviser. Laissez vide pour diviser toutes les pages.
4. Cliquez sur le bouton de traitement pour générer le PDF divisé.
## Fonctionnalités
- Division verticale : coupe chaque page en moitiés gauche et droite
- Division horizontale : coupe chaque page en moitiés haut et bas
- Filtre par plage de pages pour diviser uniquement certaines pages
- Les pages non ciblées passent sans modification
- Préserve la qualité du contenu sans nouveau rendu
## Cas d'usage
- Séparer des pages numérisées en deux par feuille (par ex. un scan de livre avec la page gauche et la page droite sur une même feuille)
- Diviser un PDF en paysage au contenu côte à côte en pages portrait individuelles
- Découper de grandes infographies ou affiches en sections haute et basse distinctes
- Préparer des documents grand format pour une impression sur papier standard
## Conseils
- Si le contenu de vos pages est réparti de façon inégale, la division se fait quand même exactement au milieu. Pour des divisions asymétriques, utilisez plutôt [Rogner un PDF](./crop-pdf).
- Combinez cet outil avec [Faire pivoter un PDF](./rotate-pdf) si vos pages doivent être pivotées avant ou après la division.
## Outils associés
- [Scinder un PDF](./split-pdf)
- [Rogner un PDF](./crop-pdf)
- [PDF N-up](./n-up-pdf)
- [Posteriser un PDF](./posterize-pdf)
docs/fr/tools/duplex-collate.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Assembler un scan recto/verso
description: Réordonnez les PDF de scans recto/verso dont les pages de recto et de verso sont dans des blocs séparés pour obtenir le bon ordre recto/verso.
---
# Assembler un scan recto/verso
Assembler un scan recto/verso est conçu pour les flux de numérisation avec chargeur automatique de documents (ADF) où un PDF contient deux blocs de pages :
- tous les rectos d'abord
- tous les versos ensuite
Au lieu de scinder et de réassembler manuellement, cet outil entrelace les deux blocs dans l'ordre de lecture naturel : recto1, verso1, recto2, verso2, et ainsi de suite.
## Fonctionnement
1. Importez un seul PDF créé par une numérisation recto/verso d'une pile.
2. Définissez le point de séparation où le bloc des rectos se termine.
3. Choisissez le traitement du bloc des versos :
- **Inverser le bloc des versos** (fréquent lorsque la pile est retournée avant de numériser les versos)
- **Conserver le bloc des versos tel quel**
4. Cliquez sur **Assembler le PDF** pour télécharger le résultat réordonné.
## Options
- **Détection automatique de la séparation (moitié)** : place le point de séparation à `ceil(totalPages / 2)`.
- **Avertissement de page impaire** : avertit lorsque le nombre total de pages est impair (souvent un décalage de numérisation).
- **Confirmation de blocs inégaux** : demande une confirmation lorsque les blocs de rectos et de versos n'ont pas la même taille.
- **Export groupé** : scinde le résultat assemblé en PDF distincts selon le nombre de pages du document d'origine et le télécharge au format ZIP.
## Comportement de sortie
- **Par défaut** : un seul PDF en sortie (un PDF en entrée, un PDF en sortie).
- **Mode groupé** : la sortie est découpée selon votre valeur de pages par document ; si plusieurs morceaux sont produits, ils sont téléchargés dans un seul ZIP, sinon un seul PDF est téléchargé.
Si les blocs sont de taille inégale, les pages appariées sont assemblées en premier, puis les pages restantes sans paire sont ajoutées à la fin.
## Cas d'usage courants
- Rétablir l'ordre après avoir numérisé une pile de formulaires recto verso en deux passes.
- Reconstituer des liasses recto/verso à partir de scanners de bureau qui produisent tous les rectos puis tous les versos.
- Post-traiter des numérisations d'archives avant de les scinder en fichiers par document.
## Conseils
- La plupart des lots recto/verso devraient avoir un nombre total de pages pair.
- Si les versos semblent inversés dans le résultat, basculez entre **Inverser le bloc des versos** et **Conserver le bloc des versos tel quel**.
- Pour des originaux de 2 pages (recto + verso), utilisez l'export groupé avec `2` pages par document.
## Outils associés
- [Alterner et mélanger les pages](./alternate-merge)
- [Scinder un PDF](./split-pdf)
- [Fusionner des PDF](./merge-pdf)
- [Dupliquer et organiser](./organize-pdf)
docs/fr/tools/edit-attachments.md
+43
View File
@@ -0,0 +1,43 @@
---
title: Gérer les pièces jointes
description: Affichez et supprimez sélectivement les fichiers joints intégrés dans un document PDF.
---
# Gérer les pièces jointes
Inspectez et gérez les fichiers joints d'un PDF. L'outil liste chaque fichier intégré avec son nom et son niveau de rattachement, puis vous permet de marquer des pièces jointes individuelles pour les supprimer ou de toutes les retirer d'un coup.
## Fonctionnement
1. Importez un fichier PDF.
2. L'outil recherche automatiquement les pièces jointes et les affiche dans une liste.
3. Chaque pièce jointe affiche son nom de fichier et indique s'il s'agit d'une pièce jointe au niveau du document ou de la page.
4. Cliquez sur l'icône de corbeille à côté d'une pièce jointe pour la marquer en vue de sa suppression (cliquez à nouveau pour annuler).
5. Utilisez le bouton **Supprimer toutes les pièces jointes** pour tout sélectionner d'un coup, ou **Tout désélectionner** pour effacer votre sélection.
6. Cliquez sur le bouton de traitement pour enregistrer un nouveau PDF sans les pièces jointes sélectionnées.
## Fonctionnalités
- Liste toutes les pièces jointes au niveau du document et de la page
- Suppression individuelle ou groupée des pièces jointes
- Sélection activable et désactivable avant de valider les modifications
- Texte barré et opacité réduite pour les éléments marqués en vue de leur suppression
- Télécharge le PDF modifié sans les pièces jointes sélectionnées
## Cas d'usage
- Supprimer des fichiers obsolètes ou incorrects intégrés dans un document avant sa redistribution
- Retirer des pièces jointes sensibles (données financières, informations personnelles) d'un PDF avant de le partager
- Réduire la taille d'un PDF en supprimant de gros fichiers intégrés devenus inutiles
- Auditer le contenu intégré et nettoyer un document avant de l'archiver
## Conseils
- Les pièces jointes marquées en vue de leur suppression sont affichées barrées. Vous pouvez annuler le marquage avant le traitement si vous changez d'avis.
- Si aucune pièce jointe n'est trouvée, l'outil affiche un message clair « Aucune pièce jointe trouvée » : le PDF ne contient simplement pas de fichiers intégrés.
## Outils associés
- [Ajouter des pièces jointes](./add-attachments)
- [Extraire les pièces jointes](./extract-attachments)
- [Afficher les métadonnées](./view-metadata)
docs/fr/tools/edit-metadata.md
+58
View File
@@ -0,0 +1,58 @@
---
title: Modifier les métadonnées
description: Affichez et modifiez les champs de métadonnées d'un PDF, notamment le titre, l'auteur, les mots-clés, les dates et les propriétés personnalisées.
---
# Modifier les métadonnées
Modifiez les métadonnées intégrées à un fichier PDF. L'outil pré-remplit un formulaire avec les métadonnées existantes du document, vous laisse modifier n'importe quel champ et enregistre les changements dans un nouveau PDF.
## Fonctionnement
1. Importez un fichier PDF. L'outil lit ses métadonnées actuelles et remplit le formulaire.
2. Modifiez n'importe quel champ standard : Titre, Auteur, Sujet, Mots-clés, Créateur, Producteur.
3. Ajustez la date de création et la date de modification avec les sélecteurs de date et d'heure.
4. Ajoutez des champs de métadonnées personnalisés en cliquant sur le bouton d'ajout et en saisissant une paire clé-valeur.
5. Cliquez sur le bouton de traitement pour enregistrer le PDF modifié.
## Fonctionnalités
- Pré-remplit toutes les métadonnées existantes du PDF importé
- Champs standard : Titre, Auteur, Sujet, Mots-clés, Créateur, Producteur
- Sélecteurs de date et d'heure pour la date de création et la date de modification
- Champs de métadonnées personnalisés clé-valeur pour des propriétés arbitraires
- Enregistre les changements directement dans le dictionnaire d'informations du document PDF
## Champs modifiables
| Champ | Description |
| ------------------------ | ------------------------------------------------------------------ |
| **Titre** | Le titre du document affiché dans les lecteurs PDF |
| **Auteur** | La personne ou l'organisation qui a créé le document |
| **Sujet** | Une brève description du thème du document |
| **Mots-clés** | Termes séparés par des virgules pour la recherche et le classement |
| **Créateur** | L'application qui a créé le contenu à l'origine |
| **Producteur** | L'application qui a généré le PDF |
| **Date de création** | Quand le document a été créé à l'origine |
| **Date de modification** | Quand le document a été modifié pour la dernière fois |
| **Champs personnalisés** | Toutes les paires clé-valeur supplémentaires que vous définissez |
## Cas d'usage
- Définir un titre et un auteur appropriés avant de publier un document
- Ajouter des mots-clés pour améliorer la recherche dans les systèmes de gestion documentaire
- Mettre à jour la date de modification pour refléter la révision en cours
- Ajouter des champs de métadonnées personnalisés comme Service, ID de projet ou Classification
- Nettoyer les métadonnées laissées par le logiciel de création d'origine
## Conseils
- Les champs personnalisés sont écrits directement dans le dictionnaire d'informations du PDF. Certains lecteurs PDF peuvent ne pas les afficher, mais ils sont conservés dans le fichier.
- Laissez un champ vide pour l'effacer des métadonnées. Le bouton de traitement enregistre tout ce qui se trouve dans le formulaire.
- Pour consulter les métadonnées sans les modifier, utilisez [Afficher les métadonnées](./view-metadata). Pour supprimer entièrement toutes les métadonnées, utilisez Supprimer les métadonnées.
## Outils associés
- [Afficher les métadonnées](./view-metadata)
- [Calques PDF (OCG)](./pdf-layers)
- [Compresser un PDF](./compress-pdf)
docs/fr/tools/edit-pdf.md
+48
View File
@@ -0,0 +1,48 @@
---
title: Éditeur PDF
description: Annotez, surlignez, caviardez, ajoutez des formes et des images, recherchez et affichez des PDF directement dans votre navigateur.
---
# Éditeur PDF
L'éditeur PDF de BentoPDF vous permet d'annoter, surligner, caviarder, commenter, ajouter des formes et des images, et de faire des recherches dans vos PDF. Il charge un éditeur complet directement dans votre navigateur, sans aucun envoi vers un serveur.
## Fonctionnement
1. Importez votre PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. L'éditeur PDF intégré s'ouvre automatiquement avec votre document chargé.
3. Utilisez la barre d'outils pour annoter, surligner, caviarder, ajouter du texte, dessiner des formes ou insérer des images.
4. Cliquez sur **Télécharger le PDF modifié** pour enregistrer vos modifications.
## Fonctionnalités
- Barre d'outils d'annotation complète avec surlignage, soulignement, texte barré et dessin à main levée
- Insertion de texte et commentaires
- Outils de caviardage qui suppriment définitivement le contenu marqué une fois le caviardage appliqué. Si des marques n'ont pas été appliquées lorsque vous cliquez sur **Télécharger le PDF modifié**, l'éditeur propose de les appliquer d'abord.
- Outils de formes pour rectangles, cercles, lignes et flèches
- Insertion d'images sur les pages du PDF
- Recherche de texte intégrée dans tout le document
- Prise en charge de plusieurs documents avec des onglets (jusqu'à 10 documents ouverts simultanément)
- Chargement de fichiers par glisser-déposer
## Cas d'usage
- Relire des contrats et marquer les modifications avec des surlignages et des commentaires
- Caviarder des informations confidentielles comme des numéros de sécurité sociale ou des données financières avant de partager un document
- Ajouter des annotations à des plans d'architecture ou à des dessins techniques
- Insérer des logos ou des tampons d'entreprise sur les pages d'un document
- Rechercher des termes précis dans de longs documents juridiques
## Conseils
- Vous pouvez ouvrir plusieurs PDF à la fois et passer de l'un à l'autre avec la barre d'onglets en haut de l'éditeur.
- L'éditeur préserve la structure d'origine du PDF : les polices, les mises en page et les champs de formulaire restent intacts.
- Marquer du texte ou une zone pour le caviardage ne supprime rien tant que le caviardage n'est pas appliqué. Lorsque vous caviardez du texte sélectionné, ses copies dans les propriétés du fichier, les signets, les commentaires et les pièces jointes sont également supprimées du téléchargement, sauf si le fichier est chiffré.
- Pour ajouter un filigrane ou numéroter les pages en masse, utilisez plutôt les outils dédiés, qui offrent plus de contrôle sur la mise en forme.
## Outils associés
- [Ajouter un filigrane](./add-watermark)
- [Signer un PDF](./sign-pdf)
- [Ajouter des tampons](./add-stamps)
- [Supprimer les annotations](./remove-annotations)
docs/fr/tools/email-to-pdf.md
+50
View File
@@ -0,0 +1,50 @@
---
title: Email vers PDF
description: Convertissez des fichiers e-mail EML et MSG en PDF dans votre navigateur. Conserve les en-têtes, le corps et la liste des pièces jointes.
---
# Email vers PDF
Convertissez des e-mails enregistrés en PDF propres et imprimables. L'outil analyse les fichiers EML et MSG, extrait le message complet (en-têtes, contenu du corps et métadonnées des pièces jointes) et restitue le tout dans un PDF structuré. Utile pour la découverte juridique, la conservation de documents, ou simplement pour imprimer un e-mail important.
## Formats pris en charge
| Format | Extension | Remarques |
| :----- | :-------- | :------------------------------------------------------------------------------- |
| EML | `.eml` | Format d'e-mail MIME standard (exporté par la plupart des clients de messagerie) |
| MSG | `.msg` | Format propriétaire de Microsoft Outlook |
## Fonctionnement
1. Cliquez sur la zone d'import ou glissez-déposez vos fichiers EML ou MSG. Vous pouvez mélanger les deux formats dans un même lot.
2. Vérifiez la liste des fichiers. Retirez les entrées indésirables avec l'icône de corbeille, ou cliquez sur **Ajouter d'autres fichiers** pour inclure d'autres e-mails.
3. Configurez les options de conversion (voir ci-dessous).
4. Cliquez sur **Convertir en PDF**. L'outil analyse chaque e-mail, restitue le contenu en HTML mis en forme et le convertit en PDF avec le moteur PyMuPDF.
5. Un seul e-mail est téléchargé directement en PDF. Plusieurs e-mails sont regroupés dans `emails-converted.zip`.
## Options
| Option | Par défaut | Description |
| :-------------------------------------- | :--------- | :------------------------------------------------------------------------------------------------------------------------------------ |
| **Taille de page** | A4 | Choisissez entre les dimensions A4, Letter ou Legal. |
| **Inclure Cc et Cci** | Activé | Lorsque cette option est activée, les listes de destinataires en Cc et Cci apparaissent dans la section d'en-tête de l'e-mail du PDF. |
| **Inclure la liste des pièces jointes** | Activé | Lorsque cette option est activée, une liste des pièces jointes de l'e-mail (avec noms de fichiers et tailles) apparaît dans le PDF. |
## Cas d'usage
- Archiver des échanges professionnels importants en PDF pour la conformité ou l'audit
- Imprimer des fils de discussion par e-mail pour des procédures judiciaires ou des demandes de communication de pièces
- Créer une trace permanente de confirmations de commande, de reçus ou de contrats reçus par e-mail
- Sauvegarder des fichiers Outlook MSG dans un format qui ne nécessite pas Outlook pour être lu
- Documenter des échanges avec le support client à partir de fichiers EML exportés
## Conseils
- Les fichiers EML (utilisés par Thunderbird, Apple Mail et la plupart des clients de messagerie) et les fichiers Outlook MSG sont tous deux pris en charge. Exportez les e-mails depuis votre client de messagerie et déposez-les directement dans l'outil.
- Les e-mails au format HTML conservent leur mise en forme dans le PDF. Les e-mails en texte brut sont restitués avec une mise en forme propre et lisible.
- La liste des pièces jointes affiche les noms de fichiers et les tailles, mais n'intègre pas les fichiers joints eux-mêmes dans le PDF.
## Outils associés
- [XML vers PDF](./xml-to-pdf)
- [XPS vers PDF](./xps-to-pdf)
docs/fr/tools/epub-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: EPUB vers PDF
description: Convertissez des livres numériques EPUB en PDF dans votre navigateur. Gratuit, sans envoi de fichiers, conversion axée sur la confidentialité.
---
# EPUB vers PDF
Convertissez des livres numériques EPUB en fichiers PDF sans quitter votre navigateur. EPUB est le standard ouvert des livres numériques, mais il arrive qu'il vous faille un PDF à mise en page fixe pour l'impression, l'annotation ou le partage avec des personnes qui n'ont pas de liseuse.
## Formats pris en charge
| Format | Extension | Remarques |
| :----- | :-------- | :------------------------ |
| EPUB | `.epub` | Fichiers EPUB 2 et EPUB 3 |
## Fonctionnement
1. Cliquez sur la zone d'import ou glissez-déposez vos fichiers EPUB. La sélection multiple est prise en charge.
2. Vérifiez les fichiers importés. Retirez les entrées indésirables avec l'icône de corbeille, ou cliquez sur **Ajouter d'autres fichiers** pour agrandir le lot.
3. Cliquez sur **Convertir en PDF**. Le moteur PyMuPDF restitue le contenu de l'EPUB (texte, images et mise en forme) dans un PDF paginé.
4. Un seul EPUB est téléchargé directement en PDF. Plusieurs fichiers sont regroupés dans une archive ZIP nommée `epub-converted.zip`.
## Options
La conversion s'exécute avec des valeurs par défaut adaptées et sans configuration obligatoire. Le texte se réorganise dans des dimensions de page standard, et les polices et images intégrées sont conservées dans le PDF.
## Cas d'usage
- Imprimer un livre numérique sans DRM pour le lire loin des écrans
- Soumettre un manuscrit EPUB sous forme de PDF à mise en page fixe pour relecture
- Archiver des livres numériques dans un format que tous les systèmes d'exploitation peuvent ouvrir nativement
- Partager un chapitre avec un collègue qui n'a pas de lecteur EPUB
- Convertir une documentation technique distribuée en EPUB en PDF annotables
## Conseils
- Les fonctionnalités d'EPUB 3 comme l'audio et la vidéo intégrés ne sont pas conservées dans le PDF, mais tout le texte, les images et les tableaux se convertissent correctement.
- Pour de meilleurs résultats avec des EPUB très stylisés, vérifiez les premières pages du résultat pour confirmer la fidélité de la mise en page.
## Outils associés
- [MOBI vers PDF](./mobi-to-pdf)
- [FB2 vers PDF](./fb2-to-pdf)
- [CBZ vers PDF](./cbz-to-pdf)
docs/fr/tools/excel-to-pdf.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Excel vers PDF
description: Convertissez des feuilles de calcul Excel (XLS, XLSX), ODS et CSV en PDF en conservant la mise en forme.
---
# Excel vers PDF
Convertissez des fichiers de tableur en PDF. L'outil prend en charge les fichiers Excel modernes, l'ancien format XLS, les feuilles de calcul OpenDocument et même le CSV, le tout rendu par un moteur LibreOffice exécuté dans le navigateur, qui préserve la mise en forme des cellules, les formules (sous forme de valeurs calculées), les graphiques et les mises en page multi-feuilles.
## Formats pris en charge
| Format | Extensions |
| :----------------------- | :--------- |
| Excel (moderne) | `.xlsx` |
| Excel (ancien) | `.xls` |
| OpenDocument Spreadsheet | `.ods` |
| CSV | `.csv` |
## Fonctionnement
1. Cliquez sur la zone d'import ou glissez-déposez vos fichiers de tableur.
2. Vérifiez la liste des fichiers. Ajoutez-en d'autres ou retirez ceux dont vous ne voulez pas.
3. Cliquez sur **Convertir en PDF**. Le moteur LibreOffice s'initialise à la première utilisation, puis traite chaque fichier.
4. Un seul fichier est téléchargé directement en PDF. Plusieurs fichiers sont livrés sous la forme `excel-converted.zip`.
## Options
Cet outil n'a pas de configuration supplémentaire. Le moteur LibreOffice détermine la mise en page, la mise à l'échelle et la zone d'impression d'après les paramètres intégrés du tableur.
## Résultat
| Nombre de fichiers | Résultat |
| :----------------- | :------------------------------------------------------------------------------ |
| 1 fichier | Téléchargement d'un seul PDF (nom de fichier d'origine avec l'extension `.pdf`) |
| 2 fichiers ou plus | Archive ZIP (`excel-converted.zip`) contenant un PDF par fichier |
## Cas d'usage
- Convertir des rapports financiers ou des budgets Excel en PDF pour la diffusion
- Créer des PDF prêts à imprimer à partir de tableurs d'inventaire ou de catalogues de produits
- Partager des résultats d'analyse de données avec des parties prenantes qui n'ont pas Excel installé
- Archiver des rapports trimestriels dans un format non modifiable
- Convertir en PDF des fichiers ODS de LibreOffice Calc
## Conseils
- Les graphiques intégrés au tableur sont rendus dans le PDF. Vérifiez qu'ils s'affichent correctement dans le fichier source avant de convertir.
- Si votre tableur comporte plusieurs feuilles, toutes les feuilles sont incluses dans le PDF obtenu.
- Pour des données CSV simples sans mise en forme, l'outil [CSV vers PDF](./csv-to-pdf) offre une conversion plus légère. Utilisez Excel vers PDF lorsque vous devez conserver la mise en forme, les graphiques ou plusieurs feuilles.
## Outils associés
- [CSV vers PDF](./csv-to-pdf)
- [Word vers PDF](./word-to-pdf)
- [PowerPoint vers PDF](./powerpoint-to-pdf)
docs/fr/tools/extract-attachments.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Extraire les pièces jointes
description: Extrayez tous les fichiers joints intégrés d'un ou plusieurs PDF et téléchargez-les dans une archive ZIP.
---
# Extraire les pièces jointes
Récupérez chaque pièce jointe intégrée d'un ou plusieurs fichiers PDF. Tous les fichiers extraits sont regroupés dans une seule archive ZIP à télécharger.
## Fonctionnement
1. Importez un ou plusieurs fichiers PDF contenant des pièces jointes intégrées.
2. Cliquez sur **Extraire les pièces jointes**.
3. L'outil analyse chaque PDF à la recherche de pièces jointes au niveau du document et de la page.
4. Tous les fichiers trouvés sont regroupés dans une archive ZIP et téléchargés automatiquement.
5. Un message d'état confirme le nombre de pièces jointes trouvées et leur taille totale.
## Fonctionnalités
- Extraction par lots depuis plusieurs PDF à la fois
- Extrait les pièces jointes au niveau du document comme de la page
- Produit un seul fichier ZIP contenant tous les fichiers extraits
- Affiche le nombre total de pièces jointes et la taille cumulée des fichiers
- Messages d'état clairs si aucune pièce jointe n'est trouvée
## Cas d'usage
- Récupérer des fichiers de données intégrés dans un PDF de rapport
- Extraire des ressources d'images d'un portfolio ou d'un document de spécifications
- Extraire des documents complémentaires de PDF de formation ou de conformité
- Auditer les fichiers intégrés dans un lot de PDF
## Conseils
- Si l'outil ne signale aucune pièce jointe, le PDF peut contenir des images intégrées ou des données de formulaire à la place : ce ne sont pas des fichiers joints. Utilisez [Extraire les images](./extract-images) pour les images intégrées.
- Lors du traitement de plusieurs PDF, toutes les pièces jointes de chaque fichier se retrouvent dans un seul ZIP. Les noms de fichiers d'origine sont conservés.
## Outils associés
- [Ajouter des pièces jointes](./add-attachments)
- [Gérer les pièces jointes](./edit-attachments)
- [Extraire les images](./extract-images)
docs/fr/tools/extract-images.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Extraire les images
description: Extrayez toutes les images intégrées de fichiers PDF. Prévisualisez-les dans une grille et téléchargez-les individuellement ou dans une archive ZIP.
---
# Extraire les images
Récupère chaque image intégrée d'un ou plusieurs fichiers PDF. Les images extraites s'affichent dans une grille d'aperçu où vous pouvez les télécharger individuellement, ou toutes d'un coup dans un ZIP. Propulsé par PyMuPDF.
## Fonctionnement
1. Importez un ou plusieurs PDF en cliquant sur la zone de dépôt ou en y glissant des fichiers. Ajoutez d'autres fichiers ou retirez-en au besoin.
2. Cliquez sur **Extraire** pour lancer le traitement.
3. L'outil analyse chaque page de chaque PDF importé, puis trouve et extrait les images intégrées.
4. Les images extraites apparaissent dans une grille de miniatures. Chaque image dispose d'un bouton de téléchargement.
5. Cliquez sur **Tout télécharger** pour tout enregistrer dans une archive ZIP.
## Options
Cet outil n'a aucune option configurable. Toutes les images intégrées sont extraites dans leur format d'origine (généralement PNG, JPEG, ou le format utilisé lors de l'intégration de l'image dans le PDF).
## Format de sortie
- Les images s'affichent dans une grille d'aperçu sous les noms `image_1.png`, `image_2.jpg`, etc.
- **Tout télécharger** produit `extracted-images.zip` contenant toutes les images.
- Les images peuvent être téléchargées une par une depuis la grille.
## Cas d'usage
- Récupérer des photos ou des graphiques d'un PDF pour les réutiliser dans un autre projet.
- Extraire des images de produits d'un PDF de catalogue pour une fiche e-commerce.
- Récupérer des schémas de documentation technique pour des présentations.
- Auditer les images intégrées à un document avant de le partager.
## Conseils
- L'outil extrait les images exactement telles qu'elles sont stockées dans le PDF. Il ne rend pas les pages sous forme d'images : pour cela, utilisez [PDF vers PNG](./pdf-to-png) ou [PDF vers JPG](./pdf-to-jpg).
- Si l'outil indique « Aucune image trouvée », le PDF utilise peut-être des graphiques vectoriels plutôt que des images matricielles intégrées, ou il s'agit d'un document numérisé dont chaque page est une seule grande image.
- Le traitement par lots fonctionne sur plusieurs PDF. Toutes les images de tous les fichiers sont réunies dans une seule grille et un seul ZIP.
## Outils associés
- [PDF vers PNG](./pdf-to-png)
- [PDF vers JPG](./pdf-to-jpg)
- [Constructeur de workflow PDF](./pdf-workflow)
docs/fr/tools/extract-pages.md
+41
View File
@@ -0,0 +1,41 @@
---
title: Extraire des pages
description: Enregistrez une plage précise de pages d'un PDF dans un nouveau document.
---
# Extraire des pages
Récupérez un ensemble de pages d'un PDF et enregistrez-les dans un nouveau fichier. Indiquez exactement les pages souhaitées avec la syntaxe de plages, et l'outil crée un PDF propre contenant uniquement ces pages.
## Fonctionnement
1. Importez un fichier PDF. L'outil affiche le nom du fichier, sa taille et son nombre total de pages.
2. Saisissez les pages à extraire avec la syntaxe de plages (par ex. `1-5`, `3, 7, 10-12`).
3. Choisissez éventuellement de télécharger chaque plage sous forme de PDF distinct dans une archive ZIP.
4. Cliquez sur le bouton de traitement. Les pages extraites sont téléchargées sous forme d'un nouveau PDF (ou d'un ZIP).
## Fonctionnalités
- Syntaxe de plages flexible : pages individuelles, plages ou combinaisons séparées par des virgules
- Affiche le nombre total de pages après l'import pour s'y référer facilement
- Option de sortie en un seul PDF combiné ou en fichiers distincts dans un ZIP
- Préserve le contenu et la mise en forme d'origine des pages
## Cas d'usage
- Extraire le résumé exécutif (les premières pages) d'un long rapport
- Extraire un seul chapitre d'un manuel au format PDF
- Enregistrer des pages précises d'un dossier de formulaires sous forme de documents autonomes
- Créer un document d'exemple à partir de pages sélectionnées d'un fichier plus volumineux
## Conseils
- Les numéros de page commencent à 1. Utilisez `1` pour la première page, pas `0`.
- Pour supprimer des pages plutôt que les extraire, utilisez [Supprimer des pages](./delete-pages) : c'est l'opération inverse.
- Si vous avez besoin d'une sélection visuelle des pages avec des miniatures, utilisez [Scinder un PDF](./split-pdf) en mode Sélection visuelle.
## Outils associés
- [Scinder un PDF](./split-pdf)
- [Supprimer des pages](./delete-pages)
- [Fusionner des PDF](./merge-pdf)
docs/fr/tools/extract-tables.md
+46
View File
@@ -0,0 +1,46 @@
---
title: Extraire les tableaux PDF
description: Détectez et extrayez les tableaux de documents PDF. Exportez en CSV, JSON ou Markdown, tableau par tableau.
---
# Extraire les tableaux PDF
Détecte tous les tableaux d'un PDF et vous permet de les exporter au format de votre choix : CSV, JSON ou Markdown. Chaque tableau est extrait individuellement avec ses métadonnées de page et de position. Propulsé par le moteur de détection de tableaux de PyMuPDF.
## Fonctionnement
1. Importez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. Sélectionnez votre **format d'export** préféré : CSV, JSON ou Markdown.
3. Cliquez sur **Extraire** pour lancer le traitement.
4. Si un seul tableau est trouvé, il est téléchargé sous forme d'un seul fichier. Plusieurs tableaux produisent une archive ZIP avec un fichier par tableau.
## Options
- **Format d'export** : choisissez entre :
- **CSV** : valeurs séparées par des virgules, avec des guillemets appropriés pour les champs contenant des virgules, des guillemets ou des sauts de ligne. Convient aux tableurs et aux bases de données.
- **JSON** : structure de tableaux de tableaux, mise en forme avec une indentation de 2 espaces. Convient à une exploitation par programme.
- **Markdown** : format de tableau délimité par des barres verticales, produit par PyMuPDF. Convient à la documentation et aux fichiers README.
## Format de sortie
- **Un seul tableau** : `filename_table.csv` (ou `.json` / `.md`)
- **Plusieurs tableaux** : `filename_tables.zip` contenant des fichiers nommés `table_1_page3.csv`, `table_2_page5.csv`, etc.
## Cas d'usage
- Extraire des tableaux précis de longs rapports PDF sans récupérer les données de tout le document.
- Obtenir des tableaux au format Markdown à coller directement dans des tickets GitHub, des wikis ou de la documentation.
- Récupérer des données JSON structurées à partir de tableaux PDF pour des intégrations d'API ou des scripts.
- Comparer des tableaux entre différentes versions de PDF en exportant les deux en CSV et en comparant les différences.
## Conseils
- Cet outil vous donne un contrôle tableau par tableau. Si vous voulez simplement tous les tableaux dans un seul CSV, utilisez [PDF vers CSV](./pdf-to-csv). Pour un classeur Excel complet, utilisez [PDF vers Excel](./pdf-to-excel).
- Les tableaux qui s'étendent sur plusieurs pages peuvent être détectés comme des tableaux distincts par page. Vous devrez peut-être les concaténer manuellement.
- Si aucun tableau n'est détecté, le PDF est peut-être une image numérisée. Passez-le d'abord par l'OCR pour ajouter une couche de texte.
## Outils associés
- [PDF vers CSV](./pdf-to-csv)
- [PDF vers Excel](./pdf-to-excel)
- [PDF vers texte](./pdf-to-text)
docs/fr/tools/fb2-to-pdf.md
+43
View File
@@ -0,0 +1,43 @@
---
title: FB2 vers PDF
description: Convertissez des livres numériques FictionBook (FB2) en PDF dans votre navigateur. Gratuit, privé, sans envoi vers un serveur.
---
# FB2 vers PDF
Convertissez des fichiers FictionBook 2 (FB2) en documents PDF. Le FB2 est un format de livre numérique basé sur XML, populaire en Russie et en Europe de l'Est. Bien pris en charge sur certaines plateformes, il est pratiquement inconnu sur d'autres : la conversion en PDF rend vos livres lisibles partout.
## Formats pris en charge
| Format | Extension | Remarques |
| :------------ | :-------- | :------------------------------------- |
| FictionBook 2 | `.fb2` | Format de livre numérique basé sur XML |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez vos fichiers FB2. La sélection multiple est possible.
2. Vérifiez la liste des fichiers. Utilisez l'icône de corbeille pour retirer un fichier, ou **Ajouter d'autres fichiers** pour en inclure davantage.
3. Cliquez sur **Convertir en PDF**. Le moteur PyMuPDF analyse la structure XML du FB2 et la restitue en contenu PDF paginé.
4. Un seul fichier est téléchargé directement en PDF. Plusieurs conversions sont regroupées dans `fb2-converted.zip`.
## Options
Aucune configuration n'est nécessaire. Le convertisseur gère automatiquement la structure XML du FB2 et conserve les sauts de chapitre, la mise en forme et les images intégrées.
## Cas d'usage
- Lire des livres FB2 sur des appareils ou des applications qui ne prennent en charge que le PDF
- Imprimer de la littérature russe distribuée au format FB2
- Archiver une bibliothèque FB2 dans un format universellement pris en charge
- Partager un livre avec quelqu'un dont la liseuse ne gère pas FictionBook
## Astuces
- Les fichiers FB2 sont du XML en texte brut : ils sont généralement légers et se convertissent rapidement, même dans le navigateur.
- Si vos fichiers FB2 sont compressés en `.fb2.zip`, extrayez-les avant de les envoyer.
## Outils associés
- [EPUB vers PDF](./epub-to-pdf)
- [MOBI vers PDF](./mobi-to-pdf)
- [XML vers PDF](./xml-to-pdf)
docs/fr/tools/fix-page-size.md
+44
View File
@@ -0,0 +1,44 @@
---
title: Uniformiser la taille des pages
description: Uniformisez toutes les pages d'un PDF à une même taille. Choisissez un format de papier standard ou définissez des dimensions personnalisées.
---
# Uniformiser la taille des pages
Les PDF assemblés à partir de plusieurs sources se retrouvent souvent avec des tailles de page différentes : certaines en Letter, d'autres en A4, d'autres totalement non standard. Cet outil impose une taille cible unique à chaque page, en ajustant ou en remplissant le contenu selon le besoin.
## Fonctionnement
1. Envoyez un fichier PDF.
2. Sélectionnez une **Taille de page cible** dans la liste déroulante (A4, Letter, Legal, A3, A5, Tabloid ou Personnalisée).
3. Choisissez une **Orientation** : Auto conserve l'orientation d'origine de chaque page, ou vous pouvez forcer Portrait ou Paysage.
4. Choisissez un mode de **Mise à l'échelle du contenu** : Ajuster (conserve tout le contenu, peut ajouter des marges) ou Remplir (remplit la page, peut rogner les bords).
5. Si besoin, définissez une **Couleur de fond** pour les marges ajoutées.
6. Cliquez sur **Uniformiser la taille des pages**.
## Options
- **Tailles standard** : A4, Letter, Legal, A3, A5, Tabloid
- **Dimensions personnalisées** : saisissez la largeur et la hauteur en pouces ou en millimètres
- **Orientation** : Auto, Portrait, Paysage
- **Mode de mise à l'échelle** : Ajuster ou Remplir (rogner)
- **Couleur de fond** : n'importe quelle couleur pour le remplissage des marges
## Cas d'usage
- Normaliser un PDF fusionné dont les pages proviennent de scanners différents
- Convertir un document US Letter en A4 pour une diffusion internationale
- Préparer des PDF prêts à imprimer qui exigent un format de coupe constant
- Corriger des pages légèrement hors norme (par ex. 8,49 x 11,02 pouces au lieu de 8,5 x 11)
## Astuces
- Utilisez le mode Ajuster pour garantir qu'aucun contenu n'est perdu. Le mode Remplir est plus propre visuellement mais peut couper les bords.
- Vérifiez le résultat avec l'outil Dimensions des pages pour confirmer que chaque page correspond à la cible.
- Le blanc est la couleur de fond par défaut ; choisissez une couleur sombre si votre document a des marges sombres.
## Outils associés
- [Dimensions des pages](./page-dimensions) : inspectez les tailles de page avant et après la correction
- [Compresser un PDF](./compress-pdf) : réduisez la taille du fichier après l'uniformisation
- [Rogner un PDF](./crop-pdf) : rognez les pages manuellement au lieu de les mettre à l'échelle automatiquement
docs/fr/tools/flatten-pdf.md
+51
View File
@@ -0,0 +1,51 @@
---
title: Aplatir le PDF
description: Aplatissez les formulaires interactifs et les annotations en contenu statique. Rend les champs non modifiables et intègre les annotations à la page.
---
# Aplatir le PDF
L'aplatissement fusionne les éléments interactifs (champs de formulaire, listes déroulantes, cases à cocher, annotations, surlignages, notes) directement dans le contenu de la page. L'apparence visuelle reste identique, mais plus rien n'est modifiable ni extractible. C'est l'équivalent PDF d'imprimer un formulaire rempli puis de le numériser, sauf que la qualité reste parfaite.
## Fonctionnement
1. Envoyez un ou plusieurs fichiers PDF.
2. Cliquez sur **Aplatir le PDF**.
3. Un seul fichier est téléchargé directement. Plusieurs fichiers produisent une archive ZIP.
L'outil utilise pdf-lib pour aplatir les champs de formulaire (via `form.flatten()`) et un aplatisseur d'annotations dédié pour intégrer les annotations au flux de la page. Les deux opérations s'effectuent en une seule passe.
## Ce qui est aplati
- **Champs de formulaire** : saisies de texte, cases à cocher, boutons radio, listes déroulantes, champs de signature
- **Annotations** : commentaires, surlignages, texte barré, soulignements, notes, tampons, annotations manuscrites
- **Éléments interactifs** : boutons, déclencheurs d'actions
## Ce qui reste inchangé
- Le contenu textuel (reste sélectionnable et consultable)
- Les images et les graphiques
- La mise en page et les dimensions
- Les signets et la table des matières
- Les liens hypertextes (sauf ceux basés sur des annotations)
## Cas d'usage
- Verrouiller un formulaire rempli pour que les destinataires ne puissent pas modifier les réponses soumises
- Préparer un PDF pour l'archivage lorsque les éléments interactifs sont inutiles
- Corriger des problèmes d'affichage causés par des annotations rendues différemment selon les lecteurs
- S'assurer qu'un document signé ne peut plus être modifié après l'application de la signature
- Réduire la taille du fichier en éliminant les définitions de champs et les objets d'annotation
## Astuces
- Aplatissez une fois toutes les modifications terminées. Il n'est pas possible d'annuler l'aplatissement d'un PDF.
- Si vous devez aplatir et aussi supprimer les métadonnées, le JavaScript et les pièces jointes, utilisez plutôt l'outil Nettoyer un PDF, qui inclut l'aplatissement parmi ses options.
- Certains PDF affichent « aucun formulaire trouvé » : c'est normal si le document ne contient que des annotations et aucun champ de formulaire.
## Outils associés
- [Nettoyer un PDF](./sanitize-pdf) : aplatit les formulaires et supprime les métadonnées, les scripts, etc.
- [Rastériser le PDF](./rasterize-pdf) : convertit en PDF basé sur des images pour un aplatissement maximal
- [Polices en contours](./font-to-outline) : convertit les polices en tracés vectoriels
- [Protéger un PDF](./protect-pdf) : protégez le PDF aplati par un mot de passe
docs/fr/tools/font-to-outline.md
+52
View File
@@ -0,0 +1,52 @@
---
title: Polices en contours
description: Convertissez toutes les polices d'un PDF en contours vectoriels pour un rendu identique sur tous les appareils. Élimine les problèmes de dépendance aux polices.
---
# Polices en contours
Convertir les polices en contours transforme chaque caractère, d'un glyphe de police en un tracé vectoriel. Le PDF ne dépend plus d'aucune police installée : il s'affiche à l'identique sur chaque appareil, chaque système d'exploitation et chaque imprimante. C'est une étape standard des flux de prépresse.
## Fonctionnement
1. Envoyez un ou plusieurs fichiers PDF.
2. Cliquez sur **Convertir en contours**.
3. Ghostscript convertit tout le texte en tracés vectoriels.
4. Téléchargez le résultat. Plusieurs fichiers produisent une archive ZIP.
Aucun réglage n'est à configurer. L'outil utilise Ghostscript (WebAssembly) pour convertir toutes les références de police en tracés dessinés, en une seule passe.
## Ce qui change
- Les caractères deviennent des courbes vectorielles (tracés de Bézier)
- L'incorporation des polices n'est plus nécessaire : le PDF est autonome au niveau des glyphes
- La taille du fichier peut augmenter, car les tracés vectoriels sont généralement plus lourds que les références de police
- L'apparence visuelle est conservée à l'identique
## Ce que vous perdez
- La sélection et le copier-coller du texte
- La recherche dans le texte (Ctrl+F ne fonctionne plus)
- La possibilité de modifier le contenu textuel
- L'accessibilité pour les lecteurs d'écran
## Cas d'usage
- Envoyer des PDF à un imprimeur qui exige des polices vectorisées
- Partager des documents qui utilisent des polices personnalisées ou sous licence avec des personnes qui ne les ont pas
- Éviter la substitution de polices qui change l'aspect de votre document sur d'autres systèmes
- Préparer des PDF pour la gravure laser ou la découpe CNC, qui exigent une source vectorielle
- S'assurer qu'un PDF riche en logos s'affiche correctement sur toutes les plateformes
## Astuces
- Conservez votre PDF d'origine. La conversion en contours est irréversible : il est impossible de retransformer les tracés en texte modifiable.
- Si le texte doit rester consultable, envisagez plutôt l'outil Rastériser le PDF suivi d'une OCR.
- Les PDF en contours sont généralement plus volumineux. Lancez ensuite Compresser un PDF si la taille compte.
## Outils associés
- [Aplatir le PDF](./flatten-pdf) : aplatit les formulaires et les annotations sans toucher aux polices
- [Rastériser le PDF](./rasterize-pdf) : convertit en PDF basé sur des images plutôt qu'en contours vectoriels
- [Compresser un PDF](./compress-pdf) : réduit la taille du fichier après la conversion en contours
- [PDF vers PDF/A](./pdf-to-pdfa) : convertissez pour l'archivage après avoir éliminé la dépendance aux polices
docs/fr/tools/form-creator.md
+76
View File
@@ -0,0 +1,76 @@
---
title: Créer un formulaire PDF
description: Créez des formulaires PDF remplissables avec des champs de texte, cases à cocher, listes déroulantes, boutons radio et plus encore, par glisser-déposer.
---
# Créer un formulaire PDF
Concevez des formulaires PDF remplissables professionnels à partir de zéro ou en ajoutant des champs à un PDF existant. L'éditeur visuel vous permet de glisser-déposer des éléments de formulaire (champs de texte, cases à cocher, listes déroulantes, boutons radio, champs de signature, etc.) directement sur les aperçus de pages. Configurez les propriétés des champs, définissez des règles de visibilité conditionnelle et exportez un formulaire PDF entièrement interactif.
## Fonctionnement
1. Envoyez un PDF existant **ou** cliquez sur **Créer un PDF vierge** pour partir de zéro.
2. Pour un PDF vierge, sélectionnez une taille de page (Letter, A4, A5, Legal, Tabloid, A3 ou dimensions personnalisées).
3. L'éditeur de formulaire s'ouvre avec une barre d'outils des types de champs et une zone d'aperçu de la page.
4. Sélectionnez un type de champ dans la barre d'outils, puis cliquez sur la page pour le placer.
5. Faites glisser les champs pour les repositionner. Utilisez les poignées pour ajuster les dimensions.
6. Cliquez sur un champ pour ouvrir le panneau de propriétés, où vous pouvez définir le nom du champ, la valeur par défaut, la taille de police, l'alignement, etc.
7. Naviguez entre les pages avec les commandes de page.
8. Cliquez sur **Enregistrer** pour télécharger le PDF remplissable terminé.
## Fonctionnalités
- Placement des champs par glisser-déposer avec poignées visuelles de redimensionnement
- Types de champs : saisie de texte, texte multiligne, case à cocher, liste déroulante, bouton radio, signature, date, nombre et code-barres
- Panneau de propriétés pour configurer le nom, le libellé, la valeur par défaut, la taille de police, la couleur, l'alignement et la validation de chaque champ
- Actions sur les champs et règles de visibilité conditionnelle (afficher/masquer des champs selon la valeur d'autres champs)
- Navigation entre les pages pour les formulaires de plusieurs pages
- Extraction des champs existants : détecte et importe automatiquement les champs de formulaire des PDF envoyés
- Prise en charge des PDF envoyés comme des pages vierges en tant que support du formulaire
- Plusieurs tailles de page prédéfinies, ainsi que des dimensions personnalisées
- Génération de codes-barres grâce à bwip-js
- Gestion des groupes de boutons radio
## Options
**Tailles de page prédéfinies (pour les PDF vierges) :**
- Letter (8,5" x 11")
- A4 (210 mm x 297 mm)
- A5 (148 mm x 210 mm)
- Legal (8,5" x 14")
- Tabloid (11" x 17")
- A3 (297 mm x 420 mm)
- Personnalisée (précisez la largeur et la hauteur)
**Propriétés des champs (variables selon le type de champ) :**
- Nom, libellé et texte d'indication
- Valeur par défaut
- Famille, taille et couleur de la police
- Alignement du texte (gauche, centre, droite)
- Option champ obligatoire
- Option lecture seule
- Longueur maximale des champs de texte
- Liste d'options pour les listes déroulantes et les boutons radio
- Actions de visibilité conditionnelle
## Cas d'usage
- Créer des formulaires d'accueil d'employés avec des champs de texte pour les informations personnelles et des cases à cocher pour l'acceptation des règles
- Créer des questionnaires d'admission client avec des listes déroulantes pour le choix du service
- Concevoir des bons de commande avec des champs calculés et des identifiants en code-barres
- Créer des listes de contrôle d'inspection avec des boutons radio pour les notes réussi/échec
- Créer des formulaires d'enquête avec des questions de suivi conditionnelles qui apparaissent selon les réponses
## Astuces
- Si vous envoyez un PDF existant, l'outil tente d'extraire les champs de formulaire déjà présents, ce qui vous permet de les modifier ou d'en ajouter.
- Utilisez la fonction de groupe de boutons radio pour créer des choix mutuellement exclusifs. Les champs d'un même groupe partagent un nom de groupe.
- Testez votre formulaire en le téléchargeant puis en l'ouvrant dans le [Remplir un formulaire PDF](./form-filler) pour vérifier le comportement des champs.
## Outils associés
- [Remplir un formulaire PDF](./form-filler)
- [Signer un PDF](./sign-pdf)
- [Éditeur PDF](./edit-pdf)
docs/fr/tools/form-filler.md
+47
View File
@@ -0,0 +1,47 @@
---
title: Remplir un formulaire PDF
description: Remplissez des formulaires PDF, y compris les formulaires XFA, directement dans votre navigateur grâce à un lecteur intégré.
---
# Remplir un formulaire PDF
Ouvrez un PDF contenant des champs de formulaire et remplissez-le directement dans un lecteur intégré. L'outil prend en charge les champs AcroForm standard ainsi que les formulaires XFA (XML Forms Architecture) hérités. Une fois le formulaire complété, téléchargez la version remplie en un clic.
## Fonctionnement
1. Envoyez un PDF contenant des champs de formulaire.
2. Le document s'ouvre dans un lecteur PDF intégré qui affiche les champs sous forme de saisies interactives.
3. Cliquez sur les champs de texte, cases à cocher, listes déroulantes et boutons radio pour les remplir.
4. Cliquez sur **Enregistrer et télécharger le formulaire rempli** pour obtenir le PDF complété.
## Fonctionnalités
- Lecteur PDF.js intégré avec interaction complète avec les champs de formulaire
- Prise en charge des champs AcroForm standard (saisies de texte, cases à cocher, listes déroulantes, boutons radio)
- Prise en charge des formulaires XFA, l'ancien format basé sur XML
- Dimensionnement automatique du lecteur selon les dimensions des pages
- Affichage du fichier avec son nom et sa taille
## Options
Il n'y a aucune option de configuration supplémentaire. Envoyez le formulaire, remplissez-le et téléchargez-le.
## Cas d'usage
- Remplir des formulaires fiscaux, des demandes d'assurance ou des documents administratifs
- Remplir des formulaires de candidature reçus en pièce jointe PDF
- Compléter des formulaires d'accueil de fournisseurs ou des questionnaires fournisseurs
- Valider des listes de conformité avec des cases à cocher
- Remplir des formulaires d'admission médicale avant un rendez-vous
## Astuces
- Les formulaires XFA sont un format hérité, pris en charge seulement par certains lecteurs PDF. Si vous ouvrez un PDF XFA dans Chrome ou la plupart des autres outils et voyez des pages blanches, c'est que ces lecteurs ne prennent pas en charge XFA. Le remplissage de formulaires de BentoPDF et Firefox gèrent tous deux correctement XFA.
- Pour les PDF sans champs de formulaire, utilisez d'abord l'outil [Créer un formulaire PDF](./form-creator) pour ajouter des champs, puis remplissez-les ici.
- Le lecteur ajuste automatiquement sa taille aux dimensions des pages du PDF.
## Outils associés
- [Créer un formulaire PDF](./form-creator)
- [Signer un PDF](./sign-pdf)
- [Éditeur PDF](./edit-pdf)
docs/fr/tools/header-footer.md
+53
View File
@@ -0,0 +1,53 @@
---
title: En-tête et pied de page
description: Ajoutez un texte d'en-tête et de pied de page personnalisable aux pages d'un PDF, avec des variables dynamiques de numéro de page.
---
# En-tête et pied de page
Ajoutez du texte à six emplacements sur les pages de votre PDF : en-tête à gauche, au centre et à droite, pied de page à gauche, au centre et à droite. L'outil prend en charge des variables dynamiques pour le numéro de page et le nombre total de pages, ce qui permet de créer des modèles comme « Page 3 sur 10 » mis à jour automatiquement pour chaque page.
## Fonctionnement
1. Envoyez votre fichier PDF.
2. Le panneau d'options apparaît avec les commandes de mise en forme et six champs de texte.
3. Saisissez le texte souhaité dans n'importe quel emplacement d'en-tête ou de pied de page.
4. Utilisez les marqueurs `{page}` et `{total}` pour une numérotation dynamique.
5. Ajustez la taille et la couleur de la police, et limitez éventuellement à une plage de pages.
6. Cliquez sur **Ajouter en-tête et pied de page** pour traiter et télécharger.
## Options
- **Plage de pages** : limitez éventuellement les pages qui reçoivent un en-tête et un pied de page. Laissez vide pour toutes les pages. Format : « 1-3, 5 » (plages séparées par des virgules).
- **Taille de police** : entre 6 et 24 points. 10 par défaut.
- **Couleur de police** : choisissez n'importe quelle couleur avec le sélecteur de couleur.
- **En-tête gauche / centre / droite** : champs de texte pour le haut de chaque page.
- **Pied de page gauche / centre / droite** : champs de texte pour le bas de chaque page.
## Fonctionnalités
- Six emplacements de texte indépendants par page
- Variable dynamique `{page}` qui insère le numéro de la page courante
- Variable dynamique `{total}` qui insère le nombre total de pages
- Filtrage par plage de pages pour cibler des pages précises
- Taille et couleur de police personnalisables
- Police Helvetica pour un rendu net et professionnel
## Cas d'usage
- Ajouter « Page {page} sur {total} » au centre du pied de page d'un rapport
- Placer le nom d'une entreprise en en-tête à gauche et la date du document en en-tête à droite
- Ajouter des mentions de confidentialité au pied de page de documents juridiques
- Apposer des numéros de révision sur des plages de pages précises
## Astuces
- Combinez `{page}` et `{total}` dans un même champ pour des formats comme « Page {page} sur {total} » ou « {page}/{total} ».
- Vous pouvez laisser la plupart des champs vides et ne remplir que les emplacements dont vous avez besoin. Les champs vides sont simplement ignorés.
- Pour des en-têtes plus complexes avec des images ou des logos, envisagez l'outil [Ajouter un filigrane](./add-watermark) positionné en haut de la page.
## Outils associés
- [Numéros de page](./page-numbers)
- [Ajouter un filigrane](./add-watermark)
- [Numérotation Bates](./bates-numbering)
docs/fr/tools/heic-to-pdf.md
+46
View File
@@ -0,0 +1,46 @@
---
title: HEIC vers PDF
description: Convertissez des images HEIC et HEIF d'iPhone et d'iPad en PDF directement dans votre navigateur.
---
# HEIC vers PDF
Convertissez des images HEIC/HEIF en PDF. Le HEIC est le format de photo par défaut des iPhone et iPad depuis iOS 11. Cet outil vous permet de transformer ces photos en PDF sans installer de logiciel ni envoyer de fichiers vers un serveur.
## Formats pris en charge
| Format | Extensions |
| :----- | :--------- |
| HEIC | `.heic` |
| HEIF | `.heif` |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez vos fichiers HEIC/HEIF.
2. Vérifiez la liste des fichiers et retirez ceux dont vous ne voulez pas.
3. Cliquez sur **Convertir en PDF**. Le résultat est téléchargé sous le nom `from_heic.pdf`.
Chaque fichier HEIC est décodé avec la bibliothèque heic2any, qui le convertit en PNG avec une qualité de 92 %. Le PNG est ensuite intégré au PDF avec pdf-lib, chaque image occupant sa propre page en pleine résolution.
## Options
Cet outil n'expose aucun réglage supplémentaire. Les images HEIC sont converties en PNG en haute qualité (0,92) avant l'intégration.
## Cas d'usage
- Créer un PDF à partir de photos d'iPhone à joindre à une déclaration de sinistre ou à un rapport
- Convertir des photos HEIC pour une annonce immobilière en un seul document imprimable
- Transformer des captures d'écran d'iPad (format HEIF) en PDF partageable
- Convertir par lots des photos de vacances pour un carnet de voyage
## Astuces
- Le décodage HEIC s'effectue entièrement dans le navigateur avec WebAssembly. La première conversion peut prendre un moment, le temps de charger le décodeur.
- Si vous devez mélanger du HEIC avec d'autres formats d'image (JPG, PNG, etc.), utilisez l'outil [Images vers PDF](./image-to-pdf), qui gère le HEIC avec tous les autres formats.
- Les fichiers HEIC des iPhone contiennent souvent des données EXIF, notamment des coordonnées GPS. Le PDF produit ne conserve pas ces métadonnées.
## Outils associés
- [Images vers PDF](./image-to-pdf)
- [JPG vers PDF](./jpg-to-pdf)
- [PNG vers PDF](./png-to-pdf)
docs/fr/tools/image-to-pdf.md
+65
View File
@@ -0,0 +1,65 @@
---
title: Images vers PDF
description: Convertissez des images JPG, PNG, BMP, GIF, TIFF, SVG, HEIC, WebP, PSD et plus de 10 autres formats en un seul fichier PDF.
---
# Images vers PDF
Le convertisseur d'images en PDF universel. Envoyez des images dans pratiquement n'importe quel format et combinez-les en un seul document PDF. Chaque image occupe sa propre page, à la taille de l'original.
## Formats pris en charge
| Format | Extensions |
| :-------------- | :------------------------------------- |
| JPEG | `.jpg`, `.jpeg` |
| JPEG 2000 | `.jp2`, `.jpx` |
| PNG | `.png` |
| BMP | `.bmp` |
| GIF | `.gif` |
| TIFF | `.tiff`, `.tif` |
| SVG | `.svg` |
| HEIC/HEIF | `.heic`, `.heif` |
| WebP | `.webp` |
| PSD | `.psd` |
| Portable Anymap | `.pnm`, `.pgm`, `.pbm`, `.ppm`, `.pam` |
| JPEG XR | `.jxr` |
C'est la prise en charge de formats la plus large de tous les convertisseurs d'images de BentoPDF. Si vous n'avez besoin que d'un format précis, utilisez plutôt l'un des outils dédiés.
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez vos fichiers image. Vous pouvez en sélectionner plusieurs à la fois.
2. Vérifiez la liste des fichiers. Retirez les fichiers indésirables avec l'icône de corbeille, ou cliquez sur **Ajouter d'autres fichiers** pour inclure d'autres images.
3. Choisissez un niveau de **Qualité du PDF** dans la liste déroulante.
4. Cliquez sur **Convertir en PDF**. L'outil traite les images avec le moteur PyMuPDF et télécharge le résultat sous le nom `images_to_pdf.pdf`.
## Options
**Qualité du PDF** contrôle la compression appliquée aux images lors de leur intégration au PDF :
- **Haute qualité** : compression minimale, fichier plus volumineux. Idéal pour l'impression ou l'archivage.
- **Qualité moyenne** (par défaut) : compression équilibrée. Convient à la plupart des usages.
- **Basse qualité** : compression agressive, fichier le plus léger. Adaptée à l'envoi par email ou au partage rapide.
Les fichiers HEIC et WebP sont automatiquement convertis en PNG avant l'intégration. Cela se fait de façon transparente, sans étape supplémentaire.
## Cas d'usage
- Combiner en un seul PDF des reçus ou documents numérisés avec l'appareil photo d'un téléphone
- Créer un portfolio ou un lookbook à partir d'images de formats variés
- Convertir des photos d'iPhone (HEIC) en PDF partageable sans installer de logiciel
- Assembler des maquettes issues d'exports PSD et de captures d'écran en un livrable client
- Archiver un dossier d'anciens formats d'image (PNM, JXR, JP2) en un seul PDF
## Astuces
- L'ordre des images dans le PDF suit celui de la liste des fichiers. Envoyez-les dans la séquence souhaitée.
- Pour la taille de fichier la plus petite possible, choisissez Basse qualité. La différence visuelle est souvent négligeable pour les numérisations riches en texte.
- Si vous n'avez qu'un seul format d'image, les convertisseurs dédiés (JPG vers PDF, PNG vers PDF, etc.) donnent le même résultat avec une interface plus simple.
## Outils associés
- [JPG vers PDF](./jpg-to-pdf)
- [PNG vers PDF](./png-to-pdf)
- [HEIC vers PDF](./heic-to-pdf)
- [WebP vers PDF](./webp-to-pdf)
docs/fr/tools/index.md
+183
View File
@@ -0,0 +1,183 @@
# Référence des outils
BentoPDF propose **plus de 130 outils** pour travailler avec les PDF. Tous les outils s'exécutent entièrement dans votre navigateur : vos fichiers ne quittent jamais votre appareil.
---
## Modifier et annoter
Modifiez, annotez et enrichissez vos documents PDF avec une suite complète d'outils d'édition.
<div class="tool-grid">
- [**Éditeur PDF**](./edit-pdf) : annotez, surlignez, caviardez, commentez, ajoutez des formes ou des images, recherchez et consultez des PDF.
- [**Modifier les signets**](./bookmark) : ajoutez, modifiez, importez, supprimez et extrayez les signets d'un PDF.
- [**Table des matières**](./table-of-contents) : générez une page de table des matières à partir des signets du PDF.
- [**Numéros de page**](./page-numbers) : insérez des numéros de page dans votre document.
- [**Ajouter des étiquettes de page**](./add-page-labels) : appliquez des étiquettes de page PDF avec chiffres romains, préfixes et numéros de départ personnalisés.
- [**Numérotation Bates**](./bates-numbering) : ajoutez des numéros Bates séquentiels sur un ou plusieurs fichiers PDF.
- [**Ajouter un filigrane**](./add-watermark) : apposez du texte ou une image sur les pages de votre PDF.
- [**En-tête et pied de page**](./header-footer) : ajoutez du texte en haut et en bas des pages.
- [**Inverser les couleurs**](./invert-colors) : créez une version en mode sombre de votre PDF.
- [**Effet scanner**](./scanner-effect) : donnez à votre PDF l'apparence d'un document numérisé.
- [**Ajuster les couleurs**](./adjust-colors) : affinez la luminosité, le contraste, la saturation et plus encore.
- [**Couleur de fond**](./background-color) : changez la couleur de fond de votre PDF.
- [**Changer la couleur du texte**](./text-color) : changez la couleur du texte de votre PDF.
- [**Signer un PDF**](./sign-pdf) : dessinez, saisissez ou importez votre signature.
- [**Ajouter des tampons**](./add-stamps) : ajoutez des tampons image à votre PDF avec la barre d'outils d'annotation.
- [**Supprimer les annotations**](./remove-annotations) : supprimez les commentaires, surlignages et liens.
- [**Rogner un PDF**](./crop-pdf) : rognez les marges de chaque page de votre PDF.
- [**Remplir un formulaire PDF**](./form-filler) : remplissez des formulaires directement dans le navigateur. Prend aussi en charge les formulaires XFA.
- [**Créer un formulaire PDF**](./form-creator) : créez des formulaires PDF remplissables avec des champs de texte par glisser-déposer.
- [**Supprimer les pages blanches**](./remove-blank-pages) : détectez et supprimez automatiquement les pages blanches.
</div>
---
## Convertir en PDF
Transformez des images, documents, livres numériques et autres formats de fichiers en PDF.
<div class="tool-grid">
- [**Images vers PDF**](./image-to-pdf) : convertissez du JPG, PNG, BMP, GIF, TIFF, SVG, HEIC, WebP et plus en PDF.
- [**JPG vers PDF**](./jpg-to-pdf) : créez un PDF à partir d'une ou plusieurs images JPG.
- [**PNG vers PDF**](./png-to-pdf) : créez un PDF à partir d'une ou plusieurs images PNG.
- [**WebP vers PDF**](./webp-to-pdf) : créez un PDF à partir d'une ou plusieurs images WebP.
- [**SVG vers PDF**](./svg-to-pdf) : créez un PDF à partir d'une ou plusieurs images SVG.
- [**BMP vers PDF**](./bmp-to-pdf) : créez un PDF à partir d'une ou plusieurs images BMP.
- [**HEIC vers PDF**](./heic-to-pdf) : créez un PDF à partir d'une ou plusieurs images HEIC.
- [**TIFF vers PDF**](./tiff-to-pdf) : créez un PDF à partir d'une ou plusieurs images TIFF.
- [**Texte vers PDF**](./txt-to-pdf) : convertissez un fichier texte brut en PDF.
- [**Markdown vers PDF**](./markdown-to-pdf) : convertissez du Markdown en PDF avec aperçu en direct et coloration syntaxique.
- [**JSON vers PDF**](./json-to-pdf) : convertissez des fichiers JSON au format PDF.
- [**ODT vers PDF**](./odt-to-pdf) : convertissez des fichiers ODT (OpenDocument Text) en PDF.
- [**CSV vers PDF**](./csv-to-pdf) : convertissez des feuilles de calcul CSV en PDF.
- [**RTF vers PDF**](./rtf-to-pdf) : convertissez des documents RTF (Rich Text Format) en PDF.
- [**Word vers PDF**](./word-to-pdf) : convertissez des documents Word (DOCX, DOC, ODT) en PDF.
- [**Excel vers PDF**](./excel-to-pdf) : convertissez des feuilles de calcul Excel (XLSX, XLS, ODS) en PDF.
- [**PowerPoint vers PDF**](./powerpoint-to-pdf) : convertissez des présentations PowerPoint (PPTX, PPT, ODP) en PDF.
- [**XPS vers PDF**](./xps-to-pdf) : convertissez des documents XPS/OXPS en PDF.
- [**MOBI vers PDF**](./mobi-to-pdf) : convertissez des livres numériques MOBI en PDF.
- [**EPUB vers PDF**](./epub-to-pdf) : convertissez des livres numériques EPUB en PDF.
- [**FB2 vers PDF**](./fb2-to-pdf) : convertissez des livres numériques FictionBook (FB2) en PDF.
- [**CBZ vers PDF**](./cbz-to-pdf) : convertissez des archives de bandes dessinées (CBZ/CBR) en PDF.
- [**WPD vers PDF**](./wpd-to-pdf) : convertissez des documents WordPerfect (WPD) en PDF.
- [**WPS vers PDF**](./wps-to-pdf) : convertissez des documents WPS Office en PDF.
- [**XML vers PDF**](./xml-to-pdf) : convertissez des documents XML en PDF.
- [**ODG vers PDF**](./odg-to-pdf) : convertissez des fichiers OpenDocument Graphics (ODG) en PDF.
- [**ODS vers PDF**](./ods-to-pdf) : convertissez des feuilles de calcul OpenDocument (ODS) en PDF.
- [**ODP vers PDF**](./odp-to-pdf) : convertissez des présentations OpenDocument (ODP) en PDF.
- [**PUB vers PDF**](./pub-to-pdf) : convertissez des fichiers Microsoft Publisher (PUB) en PDF.
- [**VSD vers PDF**](./vsd-to-pdf) : convertissez des fichiers Microsoft Visio (VSD, VSDX) en PDF.
- [**PSD vers PDF**](./psd-to-pdf) : convertissez des fichiers Adobe Photoshop (PSD) en PDF.
- [**Email vers PDF**](./email-to-pdf) : convertissez des fichiers d'email (EML, MSG) au format PDF.
</div>
---
## Convertir depuis un PDF
Extrayez le contenu des PDF vers des images, des documents et des formats de données.
<div class="tool-grid">
- [**PDF vers JPG**](./pdf-to-jpg) : convertissez chaque page du PDF en image JPG.
- [**PDF vers PNG**](./pdf-to-png) : convertissez chaque page du PDF en image PNG.
- [**PDF vers WebP**](./pdf-to-webp) : convertissez chaque page du PDF en image WebP.
- [**PDF vers BMP**](./pdf-to-bmp) : convertissez chaque page du PDF en image BMP.
- [**PDF vers TIFF**](./pdf-to-tiff) : convertissez chaque page du PDF en image TIFF.
- [**PDF en CBZ**](./pdf-to-cbz) : convertissez un PDF en CBZ (archive de bande dessinée) pour les lecteurs de BD et Calibre.
- [**PDF vers SVG**](./pdf-to-svg) : convertissez chaque page du PDF en graphique vectoriel.
- [**PDF vers CSV**](./pdf-to-csv) : extrayez les tableaux d'un PDF et convertissez-les au format CSV.
- [**PDF vers Excel**](./pdf-to-excel) : extrayez les tableaux d'un PDF et convertissez-les en Excel (XLSX).
- [**PDF en niveaux de gris**](./pdf-to-greyscale) : convertissez toutes les couleurs en noir et blanc.
- [**PDF vers JSON**](./pdf-to-json) : convertissez des fichiers PDF au format JSON.
- [**PDF vers Word**](./pdf-to-word) : convertissez des fichiers PDF en documents Word modifiables.
- [**Extraire les images**](./extract-images) : extrayez toutes les images intégrées de vos fichiers PDF.
- [**PDF vers Markdown**](./pdf-to-markdown) : convertissez le texte et les tableaux d'un PDF au format Markdown.
- [**Préparer le PDF pour l'IA**](./prepare-pdf-for-ai) : extrayez le contenu d'un PDF en JSON LlamaIndex pour les pipelines RAG/LLM.
- [**PDF vers texte**](./pdf-to-text) : extrayez le texte de fichiers PDF et enregistrez-le en texte brut.
- [**Extraire les tableaux PDF**](./extract-tables) : extrayez les tableaux de PDF en CSV, JSON ou Markdown.
</div>
---
## Organiser et gérer
Réorganisez, combinez, scindez et gérez les pages et fichiers de vos PDF.
<div class="tool-grid">
- [**Constructeur de workflow PDF**](./pdf-workflow) : créez des pipelines de traitement PDF personnalisés avec un éditeur de nœuds visuel.
- [**Outil PDF tout-en-un**](./pdf-multi-tool) : éditeur PDF complet avec gestion des pages.
- [**OCR PDF**](./ocr-pdf) : rendez un PDF consultable et copiable.
- [**Fusionner des PDF**](./merge-pdf) : combinez plusieurs PDF en un seul fichier.
- [**Alterner et mélanger les pages**](./alternate-merge) : fusionnez des PDF en alternant les pages de chacun.
- [**Assembler un scan recto/verso**](./duplex-collate) : remettez dans l'ordre correct les blocs de numérisation recto et verso.
- [**Dupliquer et organiser**](./organize-pdf) : dupliquez, réordonnez et supprimez des pages.
- [**Ajouter des pièces jointes**](./add-attachments) : intégrez un ou plusieurs fichiers dans votre PDF.
- [**Extraire les pièces jointes**](./extract-attachments) : extrayez tous les fichiers intégrés d'un ou plusieurs PDF dans un ZIP.
- [**Gérer les pièces jointes**](./edit-attachments) : consultez ou supprimez les pièces jointes de votre PDF.
- [**Calques PDF (OCG)**](./pdf-layers) : affichez, activez, ajoutez et supprimez les calques OCG de votre PDF.
- [**Scinder un PDF**](./split-pdf) : extrayez une plage de pages dans un nouveau PDF.
- [**Diviser les pages**](./divide-pages) : divisez les pages horizontalement ou verticalement.
- [**Extraire des pages**](./extract-pages) : enregistrez une sélection de pages comme nouveaux fichiers.
- [**Supprimer des pages**](./delete-pages) : retirez des pages précises de votre document.
- [**Ajouter une page vierge**](./add-blank-page) : insérez une page vide n'importe où dans votre PDF.
- [**Inverser l'ordre des pages**](./reverse-pages) : inversez l'ordre de toutes les pages de votre document.
- [**Faire pivoter un PDF**](./rotate-pdf) : faites pivoter les pages par incréments de 90 degrés.
- [**Rotation par angle personnalisé**](./rotate-custom) : faites pivoter les pages selon n'importe quel angle.
- [**PDF N-up**](./n-up-pdf) : disposez plusieurs pages sur une même feuille.
- [**Livret PDF**](./pdf-booklet) : réorganisez les pages pour l'impression d'un livret recto verso.
- [**Combiner en une seule page**](./combine-single-page) : assemblez toutes les pages en un seul défilement continu.
- [**Afficher les métadonnées**](./view-metadata) : inspectez les propriétés cachées de votre PDF.
- [**Modifier les métadonnées**](./edit-metadata) : changez l'auteur, le titre et d'autres propriétés.
- [**PDF vers ZIP**](./pdf-to-zip) : regroupez plusieurs fichiers PDF dans une archive ZIP.
- [**Comparer des PDF**](./compare-pdfs) : comparez deux PDF côte à côte.
- [**Posteriser un PDF**](./posterize-pdf) : scindez une grande page en plusieurs pages plus petites.
</div>
---
## Optimiser et réparer
Compressez, corrigez et optimisez vos PDF pour de meilleures performances et une meilleure compatibilité.
<div class="tool-grid">
- [**Compresser un PDF**](./compress-pdf) : réduisez la taille de votre PDF.
- [**PDF vers PDF/A**](./pdf-to-pdfa) : convertissez un PDF en PDF/A pour l'archivage à long terme.
- [**Uniformiser la taille des pages**](./fix-page-size) : uniformisez toutes les pages à une même taille.
- [**Optimiser pour le web**](./linearize-pdf) : optimisez le PDF pour un affichage web rapide.
- [**Dimensions des pages**](./page-dimensions) : analysez la taille, l'orientation et les unités des pages.
- [**Supprimer les restrictions**](./remove-restrictions) : supprimez la protection par mot de passe et les restrictions de sécurité.
- [**Réparer un PDF**](./repair-pdf) : récupérez les données de fichiers PDF corrompus ou endommagés.
- [**Rastériser le PDF**](./rasterize-pdf) : convertissez un PDF en PDF basé sur des images. Aplatit les calques et supprime le texte sélectionnable.
- [**Redresser un PDF**](./deskew-pdf) : redressez automatiquement les pages numérisées inclinées avec OpenCV.
- [**Polices en contours**](./font-to-outline) : convertissez toutes les polices en contours vectoriels pour un rendu cohérent.
</div>
---
## Sécuriser un PDF
Protégez, chiffrez et contrôlez l'accès à vos documents PDF.
<div class="tool-grid">
- [**Protéger un PDF**](./protect-pdf) : verrouillez votre PDF en ajoutant un mot de passe.
- [**Nettoyer un PDF**](./sanitize-pdf) : supprimez les métadonnées, annotations, scripts et plus encore.
- [**Déverrouiller un PDF**](./unlock-pdf) : déverrouillez un PDF en supprimant la protection par mot de passe.
- [**Aplatir le PDF**](./flatten-pdf) : rendez les champs de formulaire et les annotations non modifiables.
- [**Supprimer les métadonnées**](./remove-metadata) : supprimez les données cachées de votre PDF.
- [**Modifier les autorisations**](./change-permissions) : définissez ou modifiez les autorisations utilisateur d'un PDF.
- [**Signature numérique PDF**](./digital-sign-pdf) : ajoutez une signature numérique cryptographique avec des certificats X.509.
- [**Valider la signature PDF**](./validate-signature-pdf) : vérifiez les signatures numériques et consultez les détails des certificats.
</div>
docs/fr/tools/invert-colors.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Inverser les couleurs
description: Inversez toutes les couleurs de votre PDF pour créer une version en mode sombre de n'importe quel document.
---
# Inverser les couleurs
Remplacez chaque couleur de votre PDF par son inverse. Les fonds blancs deviennent noirs, le texte noir devient blanc, et toutes les autres couleurs passent à leur valeur complémentaire. C'est le moyen le plus rapide de créer une version « mode sombre » de n'importe quel PDF.
## Fonctionnement
1. Envoyez votre fichier PDF.
2. Cliquez sur **Inverser les couleurs** pour lancer le traitement.
3. Le PDF inversé se télécharge automatiquement.
Il n'y a aucun réglage supplémentaire. L'outil rend chaque page sous forme d'image, inverse la couleur de tous les pixels et réassemble le résultat dans un nouveau PDF.
## Fonctionnalités
- Inversion des couleurs en un clic pour toutes les pages
- Traitement de chaque page du document
- Conservation des dimensions et de la mise en page d'origine
- Fonctionne avec n'importe quel PDF, quel que soit le type de contenu (texte, images, mixte)
## Cas d'usage
- Créer des versions en mode sombre de manuels ou de livres de cours pour lire confortablement la nuit
- Préparer des versions à fort contraste de documents pour l'accessibilité
- Inverser des documents numérisés avec une mauvaise exposition
- Générer des versions négatives de PDF riches en images pour une analyse visuelle
## Astuces
- L'outil rastérise les pages pour appliquer l'effet : le résultat est donc basé sur des images. Le texte ne sera plus sélectionnable ni consultable. Si vous voulez du texte consultable après l'inversion, passez le résultat dans un outil d'OCR.
- Pour des réglages de couleur plus fins (luminosité, contraste, saturation), utilisez plutôt l'outil [Ajuster les couleurs](./adjust-colors).
- Les PDF volumineux comptant beaucoup de pages peuvent prendre plus de temps, car chaque page est rendue et inversée individuellement.
## Outils associés
- [Ajuster les couleurs](./adjust-colors)
- [Couleur de fond](./background-color)
- [Effet scanner](./scanner-effect)
docs/fr/tools/jpg-to-pdf.md
+48
View File
@@ -0,0 +1,48 @@
---
title: JPG vers PDF
description: Convertissez une ou plusieurs images JPG, JPEG et JPEG 2000 en un seul fichier PDF directement dans votre navigateur.
---
# JPG vers PDF
Transformez des images JPG en un PDF propre. Envoyez un fichier ou plusieurs JPG à la fois : chaque image devient une page pleine taille du document final.
## Formats pris en charge
| Format | Extensions |
| :-------- | :-------------- |
| JPEG | `.jpg`, `.jpeg` |
| JPEG 2000 | `.jp2`, `.jpx` |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez vos fichiers JPG. La sélection multiple est prise en charge.
2. Vérifiez les fichiers envoyés. Utilisez l'icône de corbeille pour retirer un fichier, ou cliquez sur **Ajouter d'autres fichiers** pour en ajouter à la liste.
3. Sélectionnez un niveau de **Qualité du PDF**.
4. Cliquez sur **Convertir en PDF**. L'outil compresse les images selon votre réglage de qualité, les convertit avec le moteur PyMuPDF et télécharge `from_jpgs.pdf`.
## Options
**Qualité du PDF** ajuste la compression appliquée à chaque image avant son intégration au PDF :
- **Haute qualité** : conserve un maximum de détails. À utiliser pour la photographie ou l'impression.
- **Qualité moyenne** (par défaut) : un bon équilibre entre netteté et taille de fichier.
- **Basse qualité** : compression agressive pour le fichier le plus léger.
## Cas d'usage
- Convertir des documents numérisés enregistrés en JPG en un seul PDF à soumettre
- Regrouper des photos de produits dans un catalogue pour des clients
- Transformer des images médicales ou satellites en JPEG 2000 en PDF portable
- Créer un album photo imprimable à partir d'exports d'appareil photo
## Astuces
- Les fichiers JPEG 2000 (`.jp2`, `.jpx`) sont entièrement pris en charge, pas seulement le JPEG standard. C'est utile pour l'imagerie médicale et les données géospatiales.
- Si vos JPG proviennent d'un appareil photo de téléphone, la qualité Moyenne produit généralement un fichier 40 à 60 % plus petit que la qualité Haute, sans différence visible à l'écran.
## Outils associés
- [Images vers PDF](./image-to-pdf)
- [PNG vers PDF](./png-to-pdf)
- [WebP vers PDF](./webp-to-pdf)
docs/fr/tools/json-to-pdf.md
+53
View File
@@ -0,0 +1,53 @@
---
title: JSON vers PDF
description: Reconstituez des fichiers PDF à partir du format JSON de BentoPDF. Reconvertissez des exports JSON en documents PDF d'origine.
---
# JSON vers PDF
Reconstituez des documents PDF à partir de fichiers JSON créés au préalable par l'outil **PDF vers JSON** de BentoPDF. C'est un outil de conversion aller-retour : il prend la représentation JSON structurée d'un PDF et reconstruit le document d'origine.
::: warning
Cet outil n'accepte que les fichiers JSON produits par le convertisseur PDF vers JSON de BentoPDF. Les fichiers JSON standard issus d'API, de bases de données ou d'autres outils ne sont pas pris en charge.
:::
## Formats pris en charge
| Entrée | Description |
| :------ | :----------------------------------------------------------- |
| `.json` | Fichiers JSON exportés par l'outil PDF vers JSON de BentoPDF |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez un ou plusieurs fichiers JSON.
2. La liste affiche chaque fichier sélectionné avec sa taille.
3. Cliquez sur **Convertir en PDF**. L'outil traite tous les fichiers avec un Web Worker et le moteur CPDF.
4. Le résultat est téléchargé sous le nom `jsons-to-pdf.zip`, contenant un PDF par fichier JSON d'entrée.
La conversion s'exécute dans un Web Worker en arrière-plan, de sorte que l'interface reste réactive même avec de gros fichiers.
## Options
Cet outil n'a aucune option configurable. La structure du JSON détermine entièrement le PDF produit.
## Résultat
Lors de la conversion de plusieurs fichiers JSON, les résultats sont livrés dans une archive ZIP. Chaque PDF porte le nom de son fichier JSON source (par ex. `report.json` devient `report.pdf`).
## Cas d'usage
- Restaurer des PDF à partir d'une sauvegarde ou d'une chaîne d'archivage basée sur JSON
- Faire un aller-retour d'un PDF via JSON pour l'inspecter, puis le reconvertir en PDF
- Reconstruire des documents après des modifications programmatiques de la structure JSON
- Vérifier qu'un export PDF vers JSON a capturé tout le contenu du document en le reconvertissant
## Astuces
- Pour convertir des données JSON arbitraires (réponses d'API ou fichiers de configuration) en PDF mis en forme, l'outil [Texte vers PDF](./txt-to-pdf) est mieux adapté. Collez le JSON comme texte et il sera rendu avec une mise en forme correcte.
- Le moteur WebAssembly CPDF doit être disponible pour que cet outil fonctionne. Les instances auto-hébergées doivent avoir les fichiers WASM de CPDF configurés.
## Outils associés
- [Texte vers PDF](./txt-to-pdf)
- [Markdown vers PDF](./markdown-to-pdf)
- [CSV vers PDF](./csv-to-pdf)
docs/fr/tools/linearize-pdf.md
+49
View File
@@ -0,0 +1,49 @@
---
title: Optimiser pour le web
description: Optimisez les fichiers PDF pour un affichage web rapide avec chargement progressif. Aussi appelé optimisation « Fast Web View ».
---
# Optimiser pour le web
La linéarisation restructure un PDF afin que la première page puisse s'afficher avant la fin du téléchargement du fichier complet. Adobe appelle cela « Fast Web View ». Si vous hébergez des PDF sur un site web ou les diffusez via un portail de documents, la linéarisation les rend nettement plus rapides à ouvrir.
## Fonctionnement
1. Envoyez un ou plusieurs fichiers PDF.
2. Cliquez sur **Linéariser le(s) PDF**.
3. Téléchargez les résultats sous forme d'archive ZIP contenant tous les fichiers linéarisés.
Il n'y a aucun réglage à configurer. L'outil utilise l'option `--linearize` de QPDF, qui réorganise la structure interne du PDF sans modifier son contenu visuel.
## Ce que fait la linéarisation
- Réordonne les objets du PDF pour que les données de la première page se trouvent au début du fichier
- Ajoute un dictionnaire de linéarisation et des tables d'indices pour que les lecteurs sachent où trouver chaque page
- Permet les requêtes par plage d'octets : un navigateur peut récupérer uniquement la première page sans télécharger tout le fichier
- Nettoie la table de références croisées pour un accès aléatoire efficace
## Fonctionnalités
- Traitement par lots de plusieurs PDF en une seule opération
- Le résultat conserve tout le contenu, les polices, les images et les éléments interactifs
- Utilise QPDF (WebAssembly) pour une linéarisation fiable et conforme aux normes
- Les résultats sont regroupés dans un ZIP pour un téléchargement facile
## Cas d'usage
- Héberger des rapports PDF sur un site web où les utilisateurs attendent un affichage instantané
- Intégrer des PDF dans des applications web avec des lecteurs dans le navigateur
- Publier des catalogues ou des manuels PDF consultés sur des connexions mobiles lentes
- Préparer des documents pour des réseaux de diffusion de contenu (CDN) qui prennent en charge les plages d'octets
## Astuces
- Linéarisez une fois toutes les autres modifications terminées. Toute modification ultérieure (fusion, ajout de pages) casse la linéarisation.
- Combinez avec Compresser un PDF pour obtenir les PDF les plus légers et les plus rapides à charger.
- La linéarisation ajoute un léger surcoût à la taille du fichier (généralement moins de 1 %).
## Outils associés
- [Compresser un PDF](./compress-pdf) : réduisez la taille du fichier avant de le linéariser
- [Réparer un PDF](./repair-pdf) : corrigez les problèmes de structure qui empêchent la linéarisation
- [Supprimer les métadonnées](./remove-metadata) : retirez les métadonnées avant la publication en ligne
docs/fr/tools/markdown-to-pdf.md
+59
View File
@@ -0,0 +1,59 @@
---
title: Markdown vers PDF
description: Écrivez ou collez du Markdown et exportez-le en PDF professionnel avec aperçu en direct et coloration syntaxique.
---
# Markdown vers PDF
Un éditeur Markdown complet avec aperçu en direct et export PDF en un clic. Écrivez de zéro, envoyez un fichier `.md` existant ou collez du contenu depuis le presse-papiers. L'éditeur affiche votre Markdown en temps réel et exporte un PDF mis en forme grâce au moteur d'impression intégré du navigateur.
## Formats pris en charge
| Entrée | Description |
| :------------- | :----------------------------- |
| Fichiers `.md` | Envoyés avec le bouton Envoyer |
| Saisie directe | Tapez ou collez dans l'éditeur |
## Fonctionnement
1. Ouvrez l'outil Markdown vers PDF. L'éditeur se charge en vue partagée : source Markdown à gauche, aperçu rendu à droite.
2. Écrivez votre Markdown, collez-le ou cliquez sur **Envoyer** pour charger un fichier `.md`.
3. Basculez entre les thèmes clair et sombre avec le curseur de thème de la barre d'outils.
4. Cliquez sur **Exporter en PDF** (ou appuyez sur `Ctrl/Cmd + S`) pour générer un PDF via la boîte de dialogue d'impression du navigateur.
## Fonctionnalités
L'éditeur prend en charge un large éventail de fonctionnalités Markdown au-delà des bases :
- **Markdown standard** : titres, gras, italique, liens, images, listes, citations, filets horizontaux
- **Blocs de code** avec coloration syntaxique pour plus de 15 langages (JavaScript, TypeScript, Python, Go, Rust, SQL, Java, C#, C++, YAML, Bash, et plus)
- **Diagrammes Mermaid** : organigrammes, diagrammes de séquence, diagrammes ER et autres types de graphiques Mermaid s'affichent directement dans l'aperçu
- **Tableaux** avec la syntaxe de tableau Markdown standard
- **Listes de tâches** avec cases à cocher
- **Notes de bas de page**, **indices**, **exposants**
- **Listes de définitions**, **abréviations**
- Prise en charge des **emoji** (`:smile:` s'affiche comme l'emoji)
- **Surlignages** (`==marked text==`) et **insertions** (`++inserted text++`)
- **URL liées automatiquement** : les URL brutes sont converties en liens cliquables
- Génération de **table des matières**
- **Liens d'ancrage** sur les titres
## Cas d'usage
- Rédiger de la documentation de projet et exporter un PDF soigné pour les parties prenantes
- Créer des rapports techniques avec des exemples de code et des diagrammes d'architecture Mermaid
- Convertir un README GitHub en PDF pour une lecture hors ligne ou l'impression
- Rédiger une proposition ou une spécification avec des listes de tâches et des tableaux
- Générer un support mis en forme à partir de notes de cours écrites en Markdown
## Astuces
- Le PDF produit utilise la fonction d'impression en PDF du navigateur. Dans Chrome, vous pouvez personnaliser les marges et l'échelle dans la boîte de dialogue d'impression avant d'enregistrer.
- Les diagrammes Mermaid s'affichent dans l'aperçu mais peuvent nécessiter un instant d'initialisation à la première utilisation.
- Utilisez le raccourci `Ctrl/Cmd + S` pour exporter sans chercher le bouton.
## Outils associés
- [Texte vers PDF](./txt-to-pdf)
- [Word vers PDF](./word-to-pdf)
- [JSON vers PDF](./json-to-pdf)
docs/fr/tools/merge-pdf.md
+54
View File
@@ -0,0 +1,54 @@
---
title: Fusionner des PDF
description: Combinez plusieurs fichiers PDF en un seul document, avec réorganisation par glisser-déposer et contrôle au niveau des pages.
---
# Fusionner des PDF
Combinez plusieurs fichiers PDF en un seul document. Vous pouvez fusionner des fichiers entiers dans un ordre précis, ou passer en Mode Pages pour contrôler finement chaque page de tous les PDF envoyés.
## Fonctionnement
1. Envoyez au moins deux fichiers PDF en cliquant sur la zone de dépôt ou en les y glissant.
2. Choisissez entre le **Mode Fichiers** et le **Mode Pages** avec le commutateur en haut.
3. En Mode Fichiers, faites glisser les fichiers pour les réordonner et, si besoin, indiquez des plages de pages (par ex. `1-3, 5`) pour chaque fichier. Laissez la plage vide pour inclure toutes les pages.
4. En Mode Pages, glissez-déposez les miniatures de pages pour construire précisément votre séquence.
5. Cliquez sur **Fusionner les PDF** pour tout combiner en un seul fichier. Le PDF fusionné se télécharge automatiquement.
## Fonctionnalités
- Deux modes de fusion : le Mode Fichiers pour combiner rapidement des fichiers entiers, le Mode Pages pour un contrôle page par page
- Réorganisation par glisser-déposer dans les deux modes, avec des animations fluides
- La syntaxe de plages de pages (par ex. `1-3, 5, 8-10`) permet de choisir des pages sans passer en Mode Pages
- Les miniatures de pages chargées à la demande gardent l'interface réactive, même avec de gros documents
- Aucune limite sur le nombre de fichiers ou de pages au total
- Conserve la qualité d'origine du PDF, sans réencodage
## Options
| Option | Description |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------- |
| **Mode Fichiers** | Fusionne des fichiers entiers dans un ordre personnalisé, avec des filtres de plages de pages optionnels par fichier |
| **Mode Pages** | Grille visuelle de toutes les pages de tous les fichiers : faites glisser les miniatures pour construire votre séquence |
| **Champ Pages** | Champ de texte par fichier acceptant des plages comme `1-3, 5` pour n'inclure que certaines pages |
## Cas d'usage
- Combiner des PDF de chapitres séparés en un seul livre ou rapport
- Fusionner une lettre de motivation et un CV en un seul dossier de candidature
- Extraire des pages précises de plusieurs documents sources dans un fichier consolidé
- Assembler des reçus ou factures numérisés en un seul PDF d'archive
- Créer un support de présentation à partir de diapositives de plusieurs présentations
## Astuces
- Utilisez le Mode Pages lorsque vous devez intercaler des pages de fichiers différents plutôt que d'ajouter un fichier après l'autre.
- Vous pouvez ajouter d'autres fichiers après l'envoi initial avec le bouton **Ajouter d'autres fichiers**, sans perdre votre organisation actuelle.
- Les plages de pages commencent à 1 : `1` désigne donc la première page du fichier.
## Outils associés
- [Scinder un PDF](./split-pdf)
- [Dupliquer et organiser](./organize-pdf)
- [Alterner et mélanger les pages](./alternate-merge)
- [Supprimer des pages](./delete-pages)
docs/fr/tools/mobi-to-pdf.md
+43
View File
@@ -0,0 +1,43 @@
---
title: MOBI vers PDF
description: Convertissez des livres numériques MOBI en PDF directement dans votre navigateur. Gratuit, privé, sans envoi de fichiers.
---
# MOBI vers PDF
Convertissez des livres numériques MOBI d'Amazon Kindle en documents PDF. Les fichiers MOBI sont liés aux appareils et applications Kindle, ce qui les rend difficiles à lire ailleurs. La conversion en PDF vous donne une version portable que vous pouvez ouvrir sur n'importe quel appareil ou imprimer.
## Formats pris en charge
| Format | Extension | Remarques |
| :----- | :-------- | :-------------------------------------------- |
| MOBI | `.mobi` | Format de livre numérique Kindle (Mobipocket) |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez un ou plusieurs fichiers MOBI.
2. Vérifiez la liste des fichiers. Retirez les fichiers indésirables avec l'icône de corbeille, ou utilisez **Ajouter d'autres fichiers** pour inclure d'autres livres.
3. Cliquez sur **Convertir en PDF**. Le moteur PyMuPDF analyse la structure du MOBI et restitue chaque page en contenu PDF.
4. Un seul fichier est téléchargé en PDF. Pour plusieurs fichiers, vous obtenez une archive ZIP nommée `mobi-converted.zip`.
## Options
Aucun réglage supplémentaire n'est nécessaire. La conversion conserve le contenu textuel, la mise en forme et les images intégrées du fichier MOBI d'origine.
## Cas d'usage
- Lire du contenu acheté sur Kindle sur une liseuse non Kindle qui ne gère que le PDF
- Imprimer des chapitres d'un livre numérique pour étudier ou annoter hors ligne
- Archiver votre bibliothèque personnelle de livres numériques dans un format universel
- Partager des extraits avec quelqu'un qui n'a pas l'application Kindle
## Astuces
- Les fichiers MOBI protégés par DRM ne peuvent pas être convertis. L'outil ne fonctionne qu'avec des fichiers MOBI sans DRM.
- Les gros livres contenant beaucoup d'images intégrées peuvent prendre quelques secondes de plus, car tout se passe dans le navigateur.
## Outils associés
- [EPUB vers PDF](./epub-to-pdf)
- [FB2 vers PDF](./fb2-to-pdf)
- [CBZ vers PDF](./cbz-to-pdf)
docs/fr/tools/n-up-pdf.md
+54
View File
@@ -0,0 +1,54 @@
---
title: PDF N-up
description: Disposez plusieurs pages PDF sur une même feuille en grille pour une impression compacte.
---
# PDF N-up
Placez plusieurs pages sur une même feuille, en grille. Cela réduit le nombre de pages imprimées en faisant tenir 2, 4, 6, 8, 9 ou 16 pages par feuille. L'outil gère la mise à l'échelle, le positionnement et la configuration facultative de la taille de page.
## Fonctionnement
1. Envoyez un fichier PDF.
2. Sélectionnez le nombre de pages par feuille (la valeur « N ») : 2, 4, 6, 8, 9 ou 16.
3. Choisissez la taille de page de sortie (A4 par défaut) et l'orientation.
4. Configurez si besoin l'espacement, la couleur de bordure et la couleur de fond.
5. Cliquez sur le bouton de traitement. L'outil met chaque page à l'échelle et les juxtapose sur de nouvelles feuilles.
## Fonctionnalités
- Dispositions en grille : 2, 4, 6, 8, 9 et 16 pages par feuille
- Taille de page et orientation de sortie configurables
- Espacement facultatif entre les pages juxtaposées
- Réglages de couleur de fond et de bordure
- Conserve le rapport hauteur/largeur des pages d'origine lors de la mise à l'échelle
## Options
| Option | Description |
| ---------------------- | -------------------------------------------------------------------------------- |
| **Pages par feuille** | Nombre de pages d'origine à placer sur chaque page de sortie (2, 4, 6, 8, 9, 16) |
| **Taille de page** | Taille de la feuille de sortie (A4, Letter, Legal, etc.) |
| **Orientation** | Portrait ou Paysage pour la feuille de sortie |
| **Espacement** | Écart en points entre les pages juxtaposées |
| **Couleur de fond** | Couleur de remplissage du fond de la feuille de sortie |
| **Couleur de bordure** | Couleur des bordures autour de chaque page juxtaposée |
## Cas d'usage
- Imprimer des supports avec 4 diapositives par page pour économiser du papier
- Créer des fiches de révision avec plusieurs pages de référence sur une feuille
- Produire des archives de documents compactes pour le classement
- Générer des planches de vignettes donnant un aperçu d'un long document
## Astuces
- L'orientation paysage fonctionne souvent mieux pour les dispositions à 2 pages, tandis que le portrait convient généralement mieux à partir de 4 pages.
- Augmenter l'espacement améliore la lisibilité mais réduit la zone disponible pour chaque page juxtaposée.
- Pour l'opération inverse (scinder une page en plusieurs), consultez [Posteriser un PDF](./posterize-pdf).
## Outils associés
- [Posteriser un PDF](./posterize-pdf)
- [Livret PDF](./pdf-booklet)
- [Combiner en une seule page](./combine-single-page)
docs/fr/tools/ocr-pdf.md
+54
View File
@@ -0,0 +1,54 @@
---
title: OCR PDF
description: Rendez des PDF numérisés consultables et copiables avec l'OCR Tesseract, avec prise en charge multilingue et filtrage des caractères.
---
# OCR PDF
Transformez des documents numérisés en PDF consultables et copiables. L'outil utilise l'OCR Tesseract pour reconnaître le texte dans les images et superpose une couche de texte invisible aux pages d'origine, ce qui préserve leur apparence tout en rendant le contenu entièrement consultable.
## Fonctionnement
1. Envoyez un PDF numérisé ou basé sur des images.
2. Sélectionnez une ou plusieurs langues présentes dans le document grâce à la liste de langues avec recherche.
3. Ajustez si besoin les réglages avancés (résolution, binarisation, liste blanche).
4. Cliquez sur **Lancer l'OCR** et suivez la progression sur la barre en temps réel.
5. Une fois terminé, vérifiez le texte extrait, puis téléchargez le PDF consultable ou un fichier `.txt` brut.
## Fonctionnalités
- OCR multilingue avec sélecteur de langue consultable
- La couche de texte invisible préserve l'apparence d'origine du document
- Barre de progression et journal en temps réel pendant le traitement
- Téléchargement des résultats en PDF consultable ou en fichier texte brut
- Copie du texte extrait directement dans le presse-papiers
- Trois niveaux de résolution pour équilibrer vitesse et précision
## Options
| Réglage | Valeurs | Par défaut | Objectif |
| --------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- | ---------- | ----------------------------------------------------------------------------------------------- |
| **Résolution** | Standard (192 DPI), Élevée (288 DPI), Ultra (384 DPI) | Élevée | Une résolution plus élevée améliore la précision sur les petits textes mais prend plus de temps |
| **Binariser l'image** | Activé / Désactivé | Désactivé | Améliore le contraste des numérisations propres en les convertissant en noir et blanc |
| **Préréglage de liste blanche de caractères** | Aucun, Alphanumérique, Nombres + devises, Lettres uniquement, Nombres uniquement, Facture, Formulaires, Personnalisé | Aucun | Restreint les caractères reconnus pour améliorer la précision sur certains types de documents |
| **Liste blanche de caractères** | Texte libre | Vide | Jeu de caractères manuel lorsque le préréglage est sur Personnalisé |
## Cas d'usage
- Rendre des contrats et factures numérisés consultables pour pouvoir y chercher avec Ctrl+F
- Extraire le texte de documents photographiés ou d'anciens dossiers papier
- Traiter des reçus avec le préréglage Facture pour capturer précisément les montants et les dates
- Créer des PDF accessibles à partir de numérisations en image seule pour des exigences de conformité
- Extraire en lot le contenu textuel de livres ou de manuels numérisés
## Astuces
- Sélectionnez plusieurs langues si votre document mélange les langues (par ex. des titres en anglais avec un corps de texte en japonais).
- Utilisez l'option de binarisation pour les documents au texte pâle ou peu contrasté : elle peut nettement améliorer la précision de la reconnaissance.
- Les préréglages de liste blanche Facture et Formulaires réduisent fortement les faux positifs sur les documents structurés en ignorant les formes de caractères non pertinentes.
## Outils associés
- [Extraire les tableaux PDF](./extract-tables)
- [Fusionner des PDF](./merge-pdf)
- [Compresser un PDF](./compress-pdf)
docs/fr/tools/odg-to-pdf.md
+43
View File
@@ -0,0 +1,43 @@
---
title: ODG vers PDF
description: Convertissez des fichiers LibreOffice Draw (ODG) en PDF dans votre navigateur. Gratuit, sans envoi, entièrement privé.
---
# ODG vers PDF
Convertissez des fichiers OpenDocument Graphics en PDF. L'ODG est le format natif de LibreOffice Draw, utilisé pour les diagrammes, les organigrammes et les illustrations vectorielles. La conversion en PDF facilite le partage, l'impression et l'intégration de ces dessins dans d'autres documents.
## Formats pris en charge
| Format | Extension | Remarques |
| :-------------------- | :-------- | :------------------------------------------ |
| OpenDocument Graphics | `.odg` | Fichiers LibreOffice Draw / OpenOffice Draw |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez vos fichiers ODG. Vous pouvez ajouter plusieurs fichiers à la fois.
2. Vérifiez la liste des fichiers. Retirez un fichier avec l'icône de corbeille, ou cliquez sur **Ajouter d'autres fichiers** pour ajouter d'autres dessins.
3. Cliquez sur **Convertir en PDF**. Un moteur basé sur LibreOffice se charge dans le navigateur et convertit chaque fichier ODG en conservant les graphiques vectoriels, les formes et le texte.
4. Un seul fichier est téléchargé directement en PDF. Plusieurs fichiers produisent une archive ZIP nommée `odg-to-pdf.zip`.
## Options
Aucun réglage supplémentaire n'est nécessaire. La conversion conserve les dimensions de page, les formes, les connecteurs et les zones de texte d'origine du fichier ODG.
## Cas d'usage
- Partager des diagrammes LibreOffice Draw avec des clients qui n'ont pas LibreOffice installé
- Imprimer des organigrammes et des schémas réseau créés dans Draw
- Inclure des illustrations ODG dans un rapport ou une présentation sous forme de PDF intégrés
- Archiver des dessins techniques dans un format qui restera lisible pendant des décennies
## Astuces
- Les éléments vectoriels restent vectoriels dans le PDF produit, le résultat s'adapte donc proprement à toute taille d'impression.
- Le moteur LibreOffice met un moment à s'initialiser à la première utilisation. Les conversions suivantes dans la même session sont plus rapides.
## Outils associés
- [ODS vers PDF](./ods-to-pdf)
- [ODP vers PDF](./odp-to-pdf)
- [VSD vers PDF](./vsd-to-pdf)
docs/fr/tools/odp-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: ODP vers PDF
description: Convertissez des présentations LibreOffice Impress (ODP) en PDF dans votre navigateur. Gratuit, privé, sans envoi.
---
# ODP vers PDF
Convertissez des fichiers OpenDocument Presentation en PDF. L'ODP est le format natif de LibreOffice Impress et un export standard de Google Slides. Transformer des présentations en PDF permet à chacun de les consulter sans logiciel de présentation, et les diapositives s'impriment proprement.
## Formats pris en charge
| Format | Extension | Remarques |
| :------------------------ | :-------- | :----------------------------------------- |
| OpenDocument Presentation | `.odp` | LibreOffice Impress / export Google Slides |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez vos fichiers ODP. Vous pouvez sélectionner plusieurs présentations à la fois.
2. Vérifiez la liste des fichiers. Retirez un fichier avec l'icône de corbeille, ou utilisez **Ajouter d'autres fichiers** pour inclure d'autres présentations.
3. Cliquez sur **Convertir en PDF**. Le moteur basé sur LibreOffice traite chaque présentation et produit un PDF où chaque diapositive devient une page.
4. Un seul fichier est téléchargé en PDF. Plusieurs fichiers sont livrés dans une archive ZIP nommée `odp-to-pdf.zip`.
## Options
Aucun réglage à configurer. Chaque diapositive est rendue à ses dimensions d'origine, en conservant le texte, les images, les formes et les arrière-plans.
## Cas d'usage
- Distribuer une présentation au public sous forme de support PDF
- Partager des exports Google Slides avec des personnes qui préfèrent le PDF à l'ODP
- Archiver des conférences et des cours dans un format en lecture seule
- Imprimer des présentations pour des ateliers en présentiel
## Astuces
- Les transitions et animations de diapositives sont des fonctions purement visuelles qui ne sont pas reprises dans le PDF, mais tout le contenu statique s'affiche correctement.
- Les notes de l'orateur ne sont pas incluses dans le PDF. Si vous en avez besoin, exportez-les séparément depuis votre logiciel de présentation.
- Comme les autres outils basés sur LibreOffice, le moteur se charge à la première utilisation et reste en cache pendant la session.
## Outils associés
- [ODG vers PDF](./odg-to-pdf)
- [ODS vers PDF](./ods-to-pdf)
- [PUB vers PDF](./pub-to-pdf)
docs/fr/tools/ods-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: ODS vers PDF
description: Convertissez des feuilles de calcul LibreOffice Calc (ODS) en PDF dans votre navigateur. Gratuit, privé, sans inscription.
---
# ODS vers PDF
Convertissez des fichiers OpenDocument Spreadsheet en PDF. ODS est le format natif de LibreOffice Calc et un export courant de Google Sheets. Cet outil restitue les données, la mise en forme et les graphiques de votre feuille de calcul dans un PDF paginé, prêt à être imprimé ou partagé.
## Formats pris en charge
| Format | Extension | Remarques |
| :----------------------- | :-------- | :-------------------------------------- |
| OpenDocument Spreadsheet | `.ods` | Export LibreOffice Calc / Google Sheets |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez vos fichiers ODS. Plusieurs fichiers sont pris en charge.
2. Vérifiez la liste des fichiers. Utilisez l'icône de corbeille pour retirer des fichiers, ou cliquez sur **Ajouter des fichiers** pour agrandir le lot.
3. Cliquez sur **Convertir en PDF**. Le moteur basé sur LibreOffice se charge dans le navigateur et convertit chaque feuille de calcul en pages PDF.
4. Une seule feuille de calcul est téléchargée sous forme de PDF. Plusieurs fichiers sont regroupés dans `ods-to-pdf.zip`.
## Options
Aucune configuration n'est nécessaire. Le convertisseur applique au PDF la mise en page d'impression, la mise en forme des cellules et la largeur des colonnes de la feuille de calcul.
## Cas d'usage
- Partager un budget ou un rapport LibreOffice Calc avec quelqu'un qui n'accepte que des PDF
- Imprimer un export Google Sheets téléchargé au format ODS
- Archiver des documents financiers dans un format non modifiable
- Soumettre des formulaires ou feuilles de temps ODS sous forme de documents à mise en page fixe
## Astuces
- Si votre feuille de calcul contient plusieurs feuilles, toutes sont incluses dans le PDF.
- Les feuilles très larges peuvent s'étendre sur plusieurs pages PDF en largeur. Si la mise en page compte, ajustez la largeur des colonnes dans le fichier source avant la conversion.
- Le moteur LibreOffice s'initialise à la première utilisation. Les conversions suivantes de la même session sont plus rapides.
## Outils associés
- [ODG vers PDF](./odg-to-pdf)
- [ODP vers PDF](./odp-to-pdf)
- [XML vers PDF](./xml-to-pdf)
docs/fr/tools/odt-to-pdf.md
+51
View File
@@ -0,0 +1,51 @@
---
title: ODT vers PDF
description: Convertissez des fichiers OpenDocument Text (ODT) en PDF dans votre navigateur avec un moteur basé sur LibreOffice.
---
# ODT vers PDF
Convertissez des fichiers OpenDocument Text en PDF. ODT est le format natif de LibreOffice Writer, d'Apache OpenOffice et d'autres traitements de texte open source. Cet outil utilise un moteur LibreOffice dans le navigateur pour produire des conversions fidèles qui préservent la mise en forme, les tableaux, les images et les styles.
## Formats pris en charge
| Format | Extensions |
| :---------------- | :--------- |
| OpenDocument Text | `.odt` |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez un ou plusieurs fichiers ODT.
2. Vérifiez la liste des fichiers. Ajoutez-en d'autres ou retirez ceux dont vous n'avez pas besoin.
3. Cliquez sur **Convertir en PDF**. Le moteur LibreOffice s'initialise (un indicateur de progression affiche l'état du chargement), puis chaque fichier est converti.
4. Un seul fichier est téléchargé directement sous forme de PDF. Plusieurs fichiers sont regroupés dans `odt-converted.zip`.
## Options
Cet outil n'a aucune configuration supplémentaire. La conversion préserve au plus près la mise en forme du document d'origine.
## Résultat
| Nombre de fichiers | Résultat |
| :----------------- | :------------------------------------------------------------- |
| 1 fichier | Téléchargement d'un seul PDF (par ex. `document.pdf`) |
| 2 fichiers ou plus | Archive ZIP (`odt-converted.zip`) contenant un PDF par fichier |
## Cas d'usage
- Convertir des documents LibreOffice Writer en PDF pour les partager avec des utilisateurs de Microsoft Office
- Produire des PDF prêts à imprimer à partir d'articles universitaires rédigés au format OpenDocument
- Convertir par lots un dossier de modèles ODT en PDF pour les distribuer
- Générer des PDF à partir de fichiers ODT créés par des systèmes automatisés de génération de documents
## Astuces
- Le moteur LibreOffice se charge à la première utilisation et reste en cache pour les conversions suivantes. Le premier chargement prend quelques secondes, ensuite les conversions sont rapides.
- Les documents complexes contenant des objets OLE intégrés ou des polices inhabituelles peuvent s'afficher légèrement différemment de LibreOffice sur ordinateur. Faites un essai avec un échantillon avant de convertir par lots.
- Pour les documents Word (`.doc`, `.docx`), utilisez plutôt l'outil [Word vers PDF](./word-to-pdf), qui utilise aussi le moteur LibreOffice mais accepte directement les formats Microsoft.
## Outils associés
- [Word vers PDF](./word-to-pdf)
- [RTF vers PDF](./rtf-to-pdf)
- [Texte vers PDF](./txt-to-pdf)
docs/fr/tools/organize-pdf.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Dupliquer et organiser
description: Réorganisez, dupliquez et supprimez des pages PDF avec des miniatures en glisser-déposer et une saisie d'ordre de pages personnalisé.
---
# Dupliquer et organiser
Réorganisez, dupliquez et supprimez des pages d'un PDF grâce à une interface visuelle en glisser-déposer. Chaque page apparaît sous forme de miniature que vous pouvez déplacer, cloner ou supprimer avant d'enregistrer le résultat dans un nouveau fichier.
## Fonctionnement
1. Envoyez un seul fichier PDF.
2. L'outil affiche une grille de miniatures présentant chaque page.
3. Faites glisser les miniatures pour réorganiser les pages, cliquez sur le bouton vert de duplication pour cloner une page, ou sur le bouton rouge de suppression pour en retirer une.
4. Vous pouvez aussi saisir un ordre de pages personnalisé dans le champ de texte (par ex. `3, 1, 2, 4`) et cliquer sur **Appliquer** pour réorganiser toutes les pages d'un coup.
5. Cliquez sur le bouton de traitement pour générer et télécharger le PDF réorganisé.
## Fonctionnalités
- Réorganisation des pages par glisser-déposer avec transitions animées
- Boutons de duplication et de suppression sur chaque page
- Saisie d'un ordre de pages personnalisé pour une réorganisation précise
- Numéros de page mis à jour automatiquement après chaque modification
- Impossible de supprimer la dernière page restante
## Cas d'usage
- Déplacer une page mal placée à la bonne position dans un rapport
- Dupliquer une page de formulaire pour obtenir plusieurs copies vierges dans un même fichier
- Retirer les pages de brouillon ou d'espace réservé avant de diffuser un document
- Inverser ou mélanger l'ordre des pages pour préparer l'impression
- Construire une séquence de pages personnalisée sans refusionner des fichiers séparés
## Astuces
- Le champ d'ordre de pages personnalisé attend des numéros de pages d'origine séparés par des virgules. Il doit inclure chaque page exactement une fois, sans omission ni doublon.
- Après la duplication d'une page, les deux copies font référence au même index de page d'origine. Réorganiser l'une ou l'autre fonctionne indépendamment.
- Pour des opérations en masse sur plusieurs fichiers ou des flux plus avancés, essayez plutôt l'[Outil PDF tout-en-un](./pdf-multi-tool).
## Outils associés
- [Fusionner des PDF](./merge-pdf)
- [Supprimer des pages](./delete-pages)
- [Outil PDF tout-en-un](./pdf-multi-tool)
- [Inverser l'ordre des pages](./reverse-pages)
docs/fr/tools/page-dimensions.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Dimensions des pages
description: Analysez les formats, orientations, proportions et rotations des pages PDF. Détectez les documents à formats mixtes et exportez les données en CSV.
---
# Dimensions des pages
Un outil de diagnostic qui lit chaque page de votre PDF et indique ses dimensions exactes, son orientation, le nom de son format standard, ses proportions, sa surface et sa rotation. Utile pour repérer les pages de formats différents avant l'impression ou pour documenter les propriétés d'un PDF reçu.
## Fonctionnement
1. Envoyez un fichier PDF. L'analyse démarre automatiquement, sans bouton à cliquer.
2. Un panneau récapitulatif affiche le nombre total de pages, le nombre de formats uniques et indique si le document contient des formats mixtes.
3. Parcourez le tableau complet des résultats avec le détail de chaque page.
4. Changez l'unité d'affichage : points, pouces, millimètres ou pixels.
5. Cliquez sur **Exporter en CSV** pour enregistrer les données.
## Champs indiqués
| Colonne | Description |
| --------------- | -------------------------------------------------------- |
| N° de page | Numéro de page séquentiel |
| Dimensions | Largeur x Hauteur dans l'unité choisie |
| Format standard | Nom correspondant (A4, Letter, etc.) ou « Personnalisé » |
| Orientation | Portrait ou Paysage |
| Proportions | Rapport largeur/hauteur sous forme décimale |
| Surface | Surface de la page dans l'unité choisie, au carré |
| Rotation | Rotation de la page en degrés |
## Fonctionnalités
- Détection automatique des formats de papier standard (A3, A4, A5, Letter, Legal, Tabloid, etc.)
- Avertissement de formats mixtes avec le détail des formats présents et du nombre de pages pour chacun
- Conversion d'unités entre points, pouces, millimètres et pixels (à 96 PPI)
- Exportation au format CSV pour une utilisation dans des tableurs ou des systèmes de documentation
## Cas d'usage
- Vérifier que toutes les pages sont en A4 avant d'envoyer un document à un imprimeur
- Comprendre pourquoi un PDF fusionné s'imprime avec des marges inattendues sur certaines pages
- Documenter la mise en page d'une grande archive PDF pour des fiches de métadonnées
- Repérer les pages pivotées qui nécessitent une correction
## Astuces
- Si le récapitulatif indique « Formats mixtes », utilisez l'outil Uniformiser la taille des pages pour standardiser avant l'impression.
- Le champ de rotation aide à repérer les pages qui s'affichent correctement mais ont un attribut de rotation non nul, ce qui peut poser problème dans certains flux de travail.
## Outils associés
- [Uniformiser la taille des pages](./fix-page-size) : standardiser les pages après avoir repéré des formats mixtes
- [Compresser un PDF](./compress-pdf) : optimiser le PDF après avoir corrigé les pages
- [Faire pivoter un PDF](./rotate-pdf) : corriger les pages pivotées
docs/fr/tools/page-numbers.md
+48
View File
@@ -0,0 +1,48 @@
---
title: Numéros de page
description: Ajoutez des numéros de page personnalisables à n'importe quelle position sur vos pages PDF, avec police, taille et couleur configurables.
---
# Numéros de page
Ajoutez des numéros de page visibles sur chaque page de votre PDF. Vous choisissez la position, le format, la taille de police et la couleur, l'outil s'occupe du reste.
## Fonctionnement
1. Envoyez votre fichier PDF.
2. Configurez les réglages de numérotation dans le panneau d'options qui apparaît.
3. Cliquez sur **Ajouter les numéros de page** pour lancer le traitement.
4. Le PDF numéroté est téléchargé automatiquement.
## Options
- **Position** : choisissez l'emplacement des numéros : Bas centre, Bas gauche, Bas droite, Haut centre, Haut gauche ou Haut droite.
- **Format** : choisissez entre une numérotation simple (1, 2, 3...) ou le format « page X sur Y » (1 / 5, 2 / 5...).
- **Taille de police** : définissez la taille du texte des numéros de page. 12 par défaut.
- **Couleur** : choisissez la couleur du texte des numéros de page avec le sélecteur de couleur.
## Fonctionnalités
- Six positions couvrant tous les coins et les centres
- Deux formats de numérotation : séquentielle simple ou « page X sur Y »
- Taille de police personnalisable de 6 à 72 points
- Sélecteur de couleur complet pour le texte
- Gestion automatique des marges qui garde les numéros dans les zones sûres quelle que soit la taille de la page
## Cas d'usage
- Préparer des documents à imprimer qui nécessitent des repères de page visibles
- Ajouter des numéros de page à un PDF fusionné créé à partir de plusieurs fichiers sources
- Numéroter des supports de présentation avant leur distribution
- Ajouter une numérotation séquentielle à des documents juridiques ou des contrats
## Astuces
- Le format « page X sur Y » est utile pour les documents où les lecteurs doivent connaître la longueur totale, comme les propositions commerciales ou les rapports.
- Si vous avez besoin de styles de numérotation différents selon les sections (par exemple des chiffres romains pour les pages liminaires), utilisez plutôt l'outil [Ajouter des étiquettes de page](./add-page-labels).
## Outils associés
- [Ajouter des étiquettes de page](./add-page-labels)
- [Numérotation Bates](./bates-numbering)
- [En-tête et pied de page](./header-footer)
docs/fr/tools/pdf-booklet.md
+43
View File
@@ -0,0 +1,43 @@
---
title: Livret PDF
description: Réorganisez les pages d'un PDF dans l'ordre d'un livret (piqûre à cheval) pour le plier et l'agrafer en livret physique.
---
# Livret PDF
Réorganisez les pages d'un PDF dans l'ordre d'imposition d'un livret. Imprimées en recto verso puis pliées en deux, les pages se retrouvent dans le bon ordre de lecture. C'est la mise en page utilisée pour les livrets brochés à cheval et les fanzines.
## Fonctionnement
1. Envoyez un fichier PDF.
2. Configurez les réglages du livret : format et orientation de la page de sortie.
3. Cliquez sur **Générer l'aperçu** pour voir comment les pages seront disposées sur chaque feuille.
4. Examinez l'aperçu, qui montre chaque feuille physique avec les pages affectées au recto et au verso.
5. Cliquez sur **Télécharger** pour enregistrer le PDF imposé en livret.
## Fonctionnalités
- Réorganisation automatique des pages pour une reliure à cheval
- Format de page de sortie configurable
- Aperçu visuel de la mise en page du livret avant le téléchargement
- Gestion des nombres de pages impairs par l'ajout de pages blanches si nécessaire
- Mise à l'échelle des pages sources pour s'adapter au format de la feuille du livret
## Cas d'usage
- Créer des livrets ou fanzines imprimables à partir d'un PDF ordinaire
- Préparer des programmes de conférence ou des guides d'événement pour une impression en interne
- Fabriquer des cartes de vœux pliées ou de petits catalogues
- Produire des recueils ou des plaquettes de poésie pour une reliure manuelle
## Astuces
- Idéalement, le nombre de pages de votre PDF source devrait être un multiple de 4 pour obtenir un livret propre. Sinon, des pages blanches sont ajoutées automatiquement pour compléter la dernière feuille.
- Imprimez le résultat en recto verso avec le réglage « retourner sur le petit côté » de votre imprimante, puis pliez toutes les feuilles ensemble et agrafez sur le dos.
- Pour simplement placer plusieurs pages sur une feuille sans l'ordre de livret, utilisez plutôt [PDF N-up](./n-up-pdf).
## Outils associés
- [PDF N-up](./n-up-pdf)
- [Faire pivoter un PDF](./rotate-pdf)
- [Ajouter une page vierge](./add-blank-page)
docs/fr/tools/pdf-layers.md
+46
View File
@@ -0,0 +1,46 @@
---
title: Calques OCG PDF
description: Affichez, activez, ajoutez et supprimez les calques OCG (Optional Content Group) d'un document PDF.
---
# Calques OCG PDF
Gérez les groupes de contenu facultatif (OCG), communément appelés « calques », d'un PDF. Vous pouvez activer ou masquer des calques, en ajouter de nouveaux (y compris des calques enfants imbriqués), en supprimer et enregistrer le PDF modifié.
## Fonctionnement
1. Envoyez un fichier PDF.
2. Cliquez sur le bouton de traitement pour charger le document avec le moteur PyMuPDF.
3. L'outil affiche tous les calques existants avec leur état de visibilité, leur statut de verrouillage et leur hiérarchie d'imbrication.
4. Cochez ou décochez les cases pour afficher ou masquer les calques. Les calques verrouillés ne peuvent pas être modifiés.
5. Ajoutez de nouveaux calques de premier niveau en saisissant un nom puis en cliquant sur le bouton d'ajout, ou ajoutez des calques enfants sous un parent existant.
6. Supprimez les calques dont vous n'avez plus besoin.
7. Cliquez sur **Enregistrer** pour télécharger le PDF modifié avec vos changements de calques.
## Fonctionnalités
- Affiche la hiérarchie des calques avec une indentation adaptée aux calques imbriqués
- Activation ou désactivation de la visibilité des calques
- Indicateur de verrouillage qui évite les modifications accidentelles
- Ajout de calques de premier niveau ou enfants avec des noms personnalisés
- Suppression de calques individuels
- Enregistrement de toutes les modifications dans un nouveau fichier PDF
## Cas d'usage
- Activer ou masquer des calques d'annotation dans des plans d'architecture ou d'ingénierie
- Ajouter de nouveaux calques d'annotation à un document de conception multicalque
- Retirer les calques obsolètes d'un modèle avant de le distribuer
- Inspecter les calques présents dans un PDF complexe reçu d'un tiers
## Astuces
- Si le PDF n'a aucun calque, l'outil affiche un état vide invitant à en ajouter un. Tous les PDF n'utilisent pas de calques OCG : ils sont surtout courants dans les exports CAO et les fichiers de conception.
- Les calques enfants sont indentés sous leur parent. Vous pouvez imbriquer les calques à n'importe quelle profondeur.
- Les calques verrouillés sont affichés avec une icône de cadenas et leurs cases sont désactivées. Ces verrous sont définis par le créateur du PDF.
## Outils associés
- [Afficher les métadonnées](./view-metadata)
- [Modifier les métadonnées](./edit-metadata)
- [Dupliquer et organiser](./organize-pdf)
docs/fr/tools/pdf-multi-tool.md
+52
View File
@@ -0,0 +1,52 @@
---
title: Outil PDF tout-en-un
description: Un gestionnaire de pages tout-en-un pour fusionner, scinder, faire pivoter, dupliquer, supprimer et réorganiser les pages PDF.
---
# Outil PDF tout-en-un
Un espace de travail unifié pour toutes les opérations au niveau des pages PDF. Envoyez un ou plusieurs PDF et travaillez sur toutes leurs pages dans une seule grille visuelle. Faites pivoter, réorganisez, dupliquez, supprimez, insérez de nouveaux PDF, ajoutez des pages vierges et scindez le résultat, sans quitter l'outil.
## Fonctionnement
1. Cliquez sur **Envoyer des PDF** ou glissez des fichiers sur la zone d'envoi. Plusieurs fichiers sont pris en charge.
2. Toutes les pages de chaque fichier envoyé apparaissent dans une grille défilante avec des miniatures.
3. Utilisez la barre d'outils ou les boutons d'action de chaque page pour manipuler les pages.
4. Sélectionnez des pages avec la case à cocher de chaque carte, puis appliquez des opérations groupées.
5. Marquez des points de scission avec l'icône de ciseaux pour diviser le résultat en plusieurs fichiers.
6. Cliquez sur **Exporter le PDF** pour télécharger le résultat final. S'il y a des marqueurs de scission, le résultat est un ZIP de plusieurs PDF.
## Fonctionnalités
- **Fusion** : envoyez plusieurs PDF et ils sont combinés automatiquement dans un seul espace de travail
- **Réorganisation** : faites glisser les cartes de pages pour modifier la séquence
- **Rotation** : rotation par page ou groupée par pas de 90 degrés (gauche ou droite)
- **Duplication** : clonez n'importe quelle page en un clic
- **Suppression** : retirez des pages individuelles ou supprimez en masse la sélection
- **Insérer un PDF** : ajoutez un nouveau PDF après une page précise
- **Ajouter une page vierge** : ajoutez une page A4 vierge à la fin
- **Scission** : placez des marqueurs de scission entre les pages, puis exportez un ZIP de PDF séparés
- **Tout sélectionner / Tout désélectionner** : sélection rapide pour les opérations groupées
- **Annuler / Rétablir** : historique complet d'annulation et de rétablissement pour chaque opération
- **Télécharger la sélection** : exportez uniquement les pages sélectionnées dans un PDF autonome
- Réparation automatique des PDF corrompus avant le chargement
## Cas d'usage
- Construire un document personnalisé à partir de pages de plusieurs PDF sources
- Nettoyer un document numérisé en supprimant les pages blanches, en redressant les scans couchés et en réordonnant les sections
- Scinder un gros PDF aux limites des chapitres grâce à des marqueurs de scission visuels
- Modifier rapidement des pages sans avoir besoin d'un éditeur PDF complet
## Astuces
- Le système d'annulation et de rétablissement suit chaque opération. Utilisez-le sans crainte : vous ne pouvez pas détruire votre travail par accident.
- Les marqueurs de scission apparaissent sous forme de lignes bleues en pointillés entre les pages. Placez-les visuellement là où vous voulez diviser le document, puis exportez pour obtenir un ZIP.
- Pour de simples tâches de fusion ou de scission, les outils dédiés [Fusionner des PDF](./merge-pdf) ou [Scinder un PDF](./split-pdf) peuvent être plus rapides. L'outil tout-en-un est idéal quand vous avez besoin de plusieurs opérations dans une même session.
## Outils associés
- [Fusionner des PDF](./merge-pdf)
- [Scinder un PDF](./split-pdf)
- [Dupliquer et organiser](./organize-pdf)
- [Faire pivoter un PDF](./rotate-pdf)
docs/fr/tools/pdf-to-bmp.md
+40
View File
@@ -0,0 +1,40 @@
---
title: PDF vers BMP
description: Convertissez des pages PDF en images BMP non compressées. Utile pour les systèmes anciens et les flux d'impression qui exigent une entrée bitmap.
---
# PDF vers BMP
Convertit chaque page d'un PDF en image BMP (Bitmap). BMP est un format non compressé : le résultat est fidèle au pixel près, sans perte de qualité, mais les fichiers sont volumineux.
## Fonctionnement
1. Envoyez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. Cliquez sur **Convertir** pour lancer le traitement.
3. Un fichier `.bmp` unique ou une archive ZIP est téléchargé automatiquement.
## Options
Cet outil n'a aucune option configurable. Les pages sont rendues à une échelle fixe de 2x, ce qui produit des images d'environ le double des dimensions natives de la page PDF.
## Format de sortie
- **Une seule page** : `filename.bmp`
- **Plusieurs pages** : `filename_bmps.zip` contenant `page_1.bmp`, `page_2.bmp`, etc.
## Cas d'usage
- Alimenter des systèmes ou du matériel anciens qui n'acceptent que le BMP en entrée.
- Préparer des images non compressées pour certains flux d'impression.
- Utiliser une sortie bitmap comme entrée d'outils de traitement d'image qui exigent des données de pixels brutes.
## Astuces
- Les fichiers BMP sont très volumineux car ils stockent les pixels bruts sans compression. Dans la plupart des cas, [PDF vers PNG](./pdf-to-png) offre une qualité sans perte avec des fichiers bien plus petits.
- Si votre système cible accepte le PNG ou le TIFF, préférez ces formats pour économiser de l'espace disque.
## Outils associés
- [PDF vers PNG](./pdf-to-png)
- [PDF vers TIFF](./pdf-to-tiff)
- [PDF vers JPG](./pdf-to-jpg)
docs/fr/tools/pdf-to-cbz.md
+77
View File
@@ -0,0 +1,77 @@
---
title: PDF vers CBZ
description: Convertissez un PDF en fichier CBZ (Comic Book Archive) pour les lecteurs de bandes dessinées comme Komga, Kavita, CDisplayEx et Calibre.
---
# PDF vers CBZ
Convertit un PDF en fichier CBZ (Comic Book ZIP), le format standard des bandes dessinées et mangas numériques. Chaque page du PDF devient une image dans l'archive. L'outil génère des métadonnées dans trois formats pour une compatibilité maximale : ComicInfo.xml, metadata.opf et ComicBookInfo JSON.
## Fonctionnement
1. Envoyez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. Choisissez le format d'image, la qualité, l'échelle et les métadonnées facultatives.
3. Cliquez sur **Convertir** pour générer le fichier CBZ.
4. Le fichier `.cbz` est téléchargé automatiquement.
## Options
| Option | Valeurs | Par défaut | Description |
| ----------------------- | ---------------- | ---------- | -------------------------------------------------------------------------------------------------------------- |
| Format d'image | JPEG, PNG, WebP | JPEG | JPEG pour les BD en couleur, PNG pour les mangas noir et blanc sans perte, WebP pour la meilleure compression. |
| Qualité | 50–100 % | 85 % | Contrôle la compression JPEG/WebP. Masquée pour le PNG (toujours sans perte). |
| Échelle | 1,0x–4,0x | 2,0x | Une échelle plus élevée produit des images plus nettes pour les écrans haute résolution. |
| Niveaux de gris | Activé/Désactivé | Désactivé | Convertit les pages en niveaux de gris. Réduit la taille des fichiers pour le contenu noir et blanc. |
| Mode manga | Activé/Désactivé | Désactivé | Définit le sens de lecture de droite à gauche dans les métadonnées. |
| Inclure les métadonnées | Activé/Désactivé | Activé | Intègre ComicInfo.xml, metadata.opf et ComicBookInfo JSON. |
## Champs de métadonnées
Quand les métadonnées sont activées, vous pouvez renseigner :
- **Titre** : détecté automatiquement à partir du nom du fichier PDF.
- **Série** : le nom de la série (par ex. « Naruto »).
- **Numéro (n°)** : numéro du tome ou du numéro dans la série.
- **Volume (Vol.)** : numéro du volume.
- **Auteur(s)** : nom du scénariste ou du créateur.
- **Éditeur** : maison d'édition.
- **Tags / Genre** : tags séparés par des virgules (par ex. « Action, Aventure »).
- **Année de publication** : année de publication (1900–2100).
- **Note** : note de la communauté de 0 à 5.
## Compatibilité des métadonnées
L'outil écrit les métadonnées dans trois formats pour que chaque lecteur puisse les trouver :
| Format | Emplacement | Pris en charge par |
| ------------------ | --------------------------- | ------------------------------------------- |
| ComicInfo.xml | Fichier dans le ZIP | Komga, Kavita, CDisplayEx, Mylar, ComicRack |
| metadata.opf | Fichier dans le ZIP | Calibre |
| ComicBookInfo JSON | Champ de commentaire du ZIP | Calibre (solution de repli) |
## Format de sortie
- `filename.cbz` : une archive ZIP contenant les images des pages numérotées et les fichiers de métadonnées.
Les images des pages sont nommées avec des numéros complétés par des zéros (`01.jpg`, `02.jpg`, etc.) pour que les lecteurs les affichent dans le bon ordre.
## Cas d'usage
- Convertir des mangas ou des BD en PDF pour les utiliser avec des lecteurs de bandes dessinées.
- Constituer une bibliothèque de BD numériques dans Komga, Kavita ou Calibre.
- Convertir des bandes dessinées numérisées dans un format adapté aux lecteurs.
- Partager des BD dans un format qui préserve le sens de lecture et les métadonnées.
## Astuces
- Utilisez **JPEG** pour les BD en couleur et **PNG** pour les mangas en noir et blanc : le PNG compresse très efficacement le contenu noir et blanc.
- Activez **Niveaux de gris** pour les mangas afin de réduire nettement la taille des fichiers.
- Renseignez les champs **Série** et **Numéro** pour que les gestionnaires de bibliothèque (Komga, Calibre) organisent automatiquement votre collection.
- **WebP** offre la meilleure compression, mais les lecteurs de BD plus anciens peuvent ne pas le prendre en charge.
## Outils associés
- [PDF vers JPG](./pdf-to-jpg)
- [PDF vers PNG](./pdf-to-png)
- [PDF vers TIFF](./pdf-to-tiff)
- [Extraire les images](./extract-images)
docs/fr/tools/pdf-to-csv.md
+44
View File
@@ -0,0 +1,44 @@
---
title: PDF vers CSV
description: Extrayez les tableaux de documents PDF et exportez-les dans un seul fichier CSV. Gère les PDF de plusieurs pages avec détection automatique des tableaux.
---
# PDF vers CSV
Extrait les tableaux d'un PDF et les exporte dans un fichier CSV. L'outil analyse chaque page à la recherche de données tabulaires avec le moteur de détection de tableaux de PyMuPDF, puis écrit toutes les lignes trouvées dans une seule sortie séparée par des virgules.
## Fonctionnement
1. Envoyez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. Cliquez sur **Convertir** pour lancer l'extraction des tableaux.
3. L'outil analyse chaque page et identifie automatiquement les tableaux.
4. Un fichier `.csv` contenant toutes les données extraites est téléchargé.
Les tableaux de pages différentes sont séparés par des lignes vides dans la sortie. Les cellules contenant des virgules, des guillemets ou des retours à la ligne sont correctement échappées selon la RFC 4180.
## Options
Cet outil n'a aucune option configurable. Tous les tableaux trouvés dans le document sont extraits et combinés dans un seul CSV.
## Format de sortie
- Un seul fichier `filename.csv` contenant tous les tableaux détectés.
## Cas d'usage
- Récupérer des données financières de relevés bancaires ou de factures PDF dans un tableur.
- Extraire des tableaux de prix de devis fournisseurs pour les comparer.
- Convertir des données de recherche tabulaires issues d'articles PDF dans un format adapté aux outils d'analyse.
- Migrer les données de rapports PDF anciens vers des bases de données.
## Astuces
- Si aucun tableau n'est trouvé, l'outil affiche un message « Aucun tableau trouvé ». Cela signifie généralement que le PDF utilise une mise en page de texte qui ressemble à un tableau sans en être un réellement structuré.
- Pour un meilleur contrôle sur chaque tableau, utilisez [Extraire les tableaux](./extract-tables), qui permet de choisir entre les formats de sortie CSV, JSON et Markdown.
- Si vous avez besoin des données au format Excel avec une feuille distincte par tableau, utilisez [PDF vers Excel](./pdf-to-excel).
## Outils associés
- [PDF vers Excel](./pdf-to-excel)
- [Extraire les tableaux](./extract-tables)
- [PDF vers texte](./pdf-to-text)
docs/fr/tools/pdf-to-excel.md
+44
View File
@@ -0,0 +1,44 @@
---
title: PDF vers Excel
description: Extrayez les tableaux de documents PDF dans une feuille de calcul Excel. Chaque tableau a sa propre feuille avec une référence de page.
---
# PDF vers Excel
Extrait les tableaux d'un PDF et les enregistre dans une feuille de calcul Excel (`.xlsx`). Chaque tableau détecté est placé dans sa propre feuille, nommée d'après son numéro de tableau et sa page source. Propulsé par PyMuPDF pour la détection des tableaux et par la bibliothèque SheetJS pour la génération Excel.
## Fonctionnement
1. Envoyez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. Cliquez sur **Convertir** pour lancer l'extraction des tableaux.
3. L'outil analyse chaque page à la recherche de tableaux, puis construit un classeur Excel.
4. Un fichier `.xlsx` est téléchargé avec une feuille par tableau.
## Options
Cet outil n'a aucune option configurable. Tous les tableaux détectés sont extraits automatiquement.
## Format de sortie
- Un seul fichier `filename.xlsx`.
- **Un tableau** : une seule feuille nommée « Table ».
- **Plusieurs tableaux** : des feuilles nommées « Table 1 (Page 3) », « Table 2 (Page 5) », etc. Les noms de feuille sont tronqués à 31 caractères (la limite d'Excel).
## Cas d'usage
- Convertir des rapports financiers PDF en feuilles de calcul modifiables pour une analyse approfondie.
- Extraire des tableaux d'inventaire ou de commandes de PDF de fournisseurs.
- Récupérer des données structurées de formulaires ou de catalogues PDF dans Excel pour les trier et les filtrer.
- Archiver des données tabulaires PDF dans un format avec lequel des collègues non techniques peuvent travailler.
## Astuces
- Si l'outil indique « Aucun tableau trouvé », le PDF utilise probablement une mise en page de texte libre plutôt que des tableaux structurés. Essayez [PDF vers texte](./pdf-to-text) pour récupérer le contenu brut.
- Pour un format plat plus simple, utilisez [PDF vers CSV](./pdf-to-csv). Pour télécharger chaque tableau dans plusieurs formats, utilisez [Extraire les tableaux](./extract-tables).
- Consultez les noms des feuilles pour identifier la page d'origine de chaque tableau.
## Outils associés
- [PDF vers CSV](./pdf-to-csv)
- [Extraire les tableaux](./extract-tables)
- [PDF vers texte](./pdf-to-text)
docs/fr/tools/pdf-to-greyscale.md
+42
View File
@@ -0,0 +1,42 @@
---
title: PDF en niveaux de gris
description: Convertissez un PDF en couleur en version en niveaux de gris (noir et blanc). Produit un nouveau PDF sans aucune couleur sur chaque page.
---
# PDF en niveaux de gris
Convertit un PDF en couleur en version en niveaux de gris. Chaque page est rendue, désaturée puis réintégrée sous forme d'image JPEG dans un nouveau PDF. Le résultat conserve les dimensions d'origine des pages.
## Fonctionnement
1. Envoyez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. Cliquez sur **Convertir** pour traiter le fichier.
3. Un nouveau fichier `greyscale.pdf` est téléchargé avec toutes les pages converties en noir et blanc.
En coulisses, chaque page est rendue à l'échelle 2x, les données de pixels passent par un filtre de niveaux de gris, puis sont réencodées en JPEG à 90 % de qualité et placées dans un nouveau document PDF.
## Options
Cet outil n'a aucune option configurable. La conversion en niveaux de gris utilise une formule de luminance standard et la qualité JPEG est fixée à 90 %.
## Format de sortie
- Un seul fichier `greyscale.pdf` contenant toutes les pages sous forme d'images JPEG en niveaux de gris.
## Cas d'usage
- Préparer des documents pour une impression en noir et blanc afin d'économiser l'encre couleur.
- Respecter les exigences de dépôt de dossiers juridiques ou administratifs qui imposent les niveaux de gris.
- Réduire la taille de PDF très colorés (les images JPEG en niveaux de gris sont plus légères que celles en couleur).
- Créer un style visuel cohérent pour des documents mêlant pages en couleur et en noir et blanc.
## Astuces
- Comme chaque page est rastérisée puis réintégrée en JPEG, le résultat est basé sur des images. Le texte du PDF d'origine ne sera plus sélectionnable ni consultable. Si vous avez besoin d'un texte recherchable ensuite, passez le résultat dans l'outil OCR.
- Pour un meilleur contrôle des réglages de couleur (luminosité, contraste, saturation), consultez l'outil Ajuster les couleurs ou le nœud Niveaux de gris du [Créateur de flux PDF](./pdf-workflow).
## Outils associés
- [PDF vers JPG](./pdf-to-jpg)
- [PDF vers PNG](./pdf-to-png)
- [Créateur de flux PDF](./pdf-workflow)
docs/fr/tools/pdf-to-jpg.md
+46
View File
@@ -0,0 +1,46 @@
---
title: PDF vers JPG
description: Convertissez des pages PDF en images JPG avec une qualité réglable. Les PDF d'une page se téléchargent directement, ceux de plusieurs pages sont exportés en ZIP.
---
# PDF vers JPG
Convertit chaque page d'un PDF en image JPG. Les documents d'une seule page sont téléchargés sous forme d'un fichier `.jpg` autonome. Les PDF de plusieurs pages produisent une archive ZIP contenant un JPG par page.
## Fonctionnement
1. Envoyez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier. L'outil affiche le nom du fichier, sa taille et son nombre de pages.
2. Réglez le curseur **Qualité** pour contrôler la compression JPG.
3. Cliquez sur **Convertir** pour lancer le traitement.
4. Le résultat est téléchargé automatiquement : un seul JPG pour les PDF d'une page, ou un fichier ZIP pour les documents de plusieurs pages.
## Options
- **Qualité** : un curseur de 0 % à 100 % (90 % par défaut). Des valeurs plus élevées produisent des images plus nettes avec des fichiers plus volumineux. Des valeurs plus basses compressent plus fortement.
Les pages sont rendues en interne à l'échelle 2x, la résolution de sortie est donc le double des dimensions de la page PDF. Une page au format Letter produit une image d'environ 1 224 x 1 584 pixels.
## Format de sortie
- **Une seule page** : `filename.jpg`
- **Plusieurs pages** : `filename_jpgs.zip` contenant `page_1.jpg`, `page_2.jpg`, etc.
## Cas d'usage
- Générer des miniatures d'aperçu pour un système de gestion documentaire.
- Partager une page d'un rapport dans un chat ou un e-mail qui ne prend pas en charge le PDF.
- Créer des ressources d'image à partir de schémas ou d'illustrations PDF.
- Archiver des documents numérisés sous forme d'images individuelles.
## Astuces
- Pour une sortie sans perte, utilisez plutôt [PDF vers PNG](./pdf-to-png).
- Un réglage de qualité de 80 à 90 % offre un bon équilibre entre taille de fichier et fidélité visuelle.
- Si vous avez besoin d'un format précis par page, essayez le [Créateur de flux PDF](./pdf-workflow), qui dispose d'un nœud de sortie PDF vers images.
## Outils associés
- [PDF vers PNG](./pdf-to-png)
- [PDF vers WebP](./pdf-to-webp)
- [PDF vers BMP](./pdf-to-bmp)
- [PDF vers TIFF](./pdf-to-tiff)
docs/fr/tools/pdf-to-json.md
+45
View File
@@ -0,0 +1,45 @@
---
title: PDF vers JSON
description: Convertissez des fichiers PDF en JSON structuré avec CPDF. Exporte la structure interne du PDF sous forme de données JSON lisibles par machine.
---
# PDF vers JSON
Convertit un ou plusieurs fichiers PDF au format JSON. L'outil utilise CPDF (Coherent PDF) pour sérialiser la structure interne de chaque PDF en une représentation JSON lisible par machine. Le résultat est toujours livré sous forme d'archive ZIP.
## Fonctionnement
1. Sélectionnez un ou plusieurs fichiers PDF avec le sélecteur de fichiers.
2. Cliquez sur **Convertir** pour lancer le traitement. La conversion s'exécute dans un web worker en arrière-plan.
3. Une archive ZIP est téléchargée, contenant un fichier JSON pour chaque PDF d'entrée.
La barre d'état indique la progression des étapes de conversion et de création du ZIP.
## Options
Cet outil n'a aucune option configurable. Chaque PDF est converti en sa représentation JSON complète.
## Format de sortie
- Un fichier `pdfs-to-json.zip` contenant `filename.json` pour chaque PDF d'entrée.
La sortie JSON représente la structure interne des objets du PDF, y compris les arbres de pages, les références de polices, les métadonnées et les flux de contenu.
## Cas d'usage
- Inspecter la structure interne d'un PDF pour le débogage ou la validation.
- Extraire par programmation les métadonnées structurées et les propriétés des pages.
- Alimenter des chaînes de traitement personnalisées avec des données de structure PDF.
- Auditer la conformité de documents PDF en analysant leurs arbres d'objets.
## Astuces
- Cet outil produit la structure brute des objets du PDF, pas le texte extrait. Si vous avez besoin du texte des pages au format JSON, utilisez plutôt [Préparer un PDF pour l'IA](./prepare-pdf-for-ai).
- Pour une extraction de texte simple, [PDF vers texte](./pdf-to-text) est plus direct.
- Les gros PDF à la structure complexe produisent des fichiers JSON très volumineux.
## Outils associés
- [PDF vers texte](./pdf-to-text)
- [Préparer un PDF pour l'IA](./prepare-pdf-for-ai)
- [Extraire les tableaux](./extract-tables)
docs/fr/tools/pdf-to-markdown.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF vers Markdown
description: Convertissez des documents PDF au format Markdown avec extraction d'images facultative. Prend en charge la conversion par lots de plusieurs fichiers.
---
# PDF vers Markdown
Convertit des fichiers PDF au format Markdown (`.md`) en préservant les titres, paragraphes, listes et la mise en forme de base. Peut aussi extraire et inclure les images intégrées. Prend en charge la conversion d'un seul fichier ou par lots. Propulsé par PyMuPDF.
## Fonctionnement
1. Envoyez un ou plusieurs PDF en cliquant sur la zone de dépôt ou en y glissant des fichiers.
2. Activez éventuellement **Inclure les images** pour intégrer les images extraites dans la sortie Markdown.
3. Cliquez sur **Convertir** pour lancer le traitement.
4. Un seul fichier est téléchargé sous la forme `filename.md`. Plusieurs fichiers produisent un `markdown-files.zip`.
## Options
- **Inclure les images** : une fois cochée, les images intégrées au PDF sont extraites et référencées dans la sortie Markdown. Une fois décochée, seul le contenu textuel est converti.
## Format de sortie
- **Un seul fichier** : `filename.md`
- **Plusieurs fichiers** : `markdown-files.zip` contenant un `.md` par PDF d'entrée.
## Cas d'usage
- Convertir de la documentation PDF en Markdown pour un générateur de site statique comme VitePress, Hugo ou Jekyll.
- Transformer des articles de recherche PDF en Markdown modifiable pour des applications de prise de notes comme Obsidian.
- Migrer d'anciennes bases de connaissances PDF vers un format texte adapté à Git.
- Extraire le contenu structuré d'ebooks PDF pour le remettre en forme.
## Astuces
- L'option Inclure les images est utile quand le PDF contient des schémas ou des figures essentiels au contenu. Désactivez-la pour les documents riches en texte afin de garder une sortie propre.
- Les mises en page complexes avec barres latérales, notes de bas de page ou texte en plusieurs colonnes peuvent produire un Markdown imparfait. Relisez et ajustez la sortie si nécessaire.
- Pour du texte brut sans aucune mise en forme, utilisez plutôt [PDF vers texte](./pdf-to-text).
## Outils associés
- [PDF vers texte](./pdf-to-text)
- [PDF vers Word](./pdf-to-word)
- [Préparer un PDF pour l'IA](./prepare-pdf-for-ai)
docs/fr/tools/pdf-to-pdfa.md
+50
View File
@@ -0,0 +1,50 @@
---
title: PDF vers PDF/A
description: Convertissez des PDF standard au format PDF/A pour l'archivage à long terme. Prend en charge les niveaux de conformité PDF/A-1b, PDF/A-2b et PDF/A-3b.
---
# PDF vers PDF/A
PDF/A est un sous-ensemble du PDF normalisé par l'ISO, conçu pour la conservation numérique à long terme. Cet outil convertit vos PDF standard en documents conformes PDF/A avec Ghostscript, qui s'exécute directement dans votre navigateur.
## Fonctionnement
1. Envoyez un ou plusieurs fichiers PDF.
2. Sélectionnez une **version PDF/A** dans la liste déroulante.
3. Activez éventuellement **Aplatir le PDF au préalable** pour les fichiers complexes qui échouent à la conversion normale.
4. Cliquez sur **Convertir en PDF/A**. Plusieurs fichiers produisent une archive ZIP.
## Versions PDF/A
| Version | Restrictions | Idéal pour |
| ------------ | ----------------------------------------------------- | ------------------------------------------------------------- |
| **PDF/A-1b** | La plus stricte. Ni transparence ni calques. | Compatibilité maximale avec les anciens systèmes d'archivage |
| **PDF/A-2b** | Autorise la transparence et JPEG2000. | Archivage généraliste (recommandé) |
| **PDF/A-3b** | Autorise les pièces jointes intégrées de tout format. | Archivage de documents avec leurs fichiers de données sources |
PDF/A-2b est sélectionné par défaut et convient à la grande majorité des besoins d'archivage.
## Option d'aplatissement préalable
Certains PDF contiennent des éléments qui empêchent une conversion PDF/A propre : encodages de polices inhabituels, piles de transparence complexes ou structures internes endommagées. Activer **Aplatir au préalable** rastérise le PDF à 300 DPI avant la conversion, ce qui garantit la conformité au prix d'un texte non sélectionnable. Utilisez-la en solution de repli quand la conversion standard produit des erreurs.
L'aplatissement préalable nécessite le moteur WASM PyMuPDF.
## Cas d'usage
- Répondre aux exigences d'archivage administratives ou juridiques (de nombreuses juridictions imposent le PDF/A pour les dépôts judiciaires)
- Soumettre des documents à des dépôts institutionnels ou à des bibliothèques numériques
- Conserver des documents d'entreprise alors que le logiciel d'origine pourrait ne plus exister dans dix ans
- Préparer des factures pour les normes de facturation électronique qui exigent du PDF/A-3b avec des pièces jointes XML
## Astuces
- Essayez d'abord la conversion sans aplatissement préalable. Ne l'activez qu'en cas d'erreur.
- Le PDF/A intègre toutes les polices, les fichiers de sortie sont donc souvent plus volumineux que les originaux.
- Validez le résultat dans un validateur PDF/A dédié si une conformité stricte est nécessaire pour votre flux de travail.
## Outils associés
- [Compresser un PDF](./compress-pdf) : réduire la taille du fichier après la conversion
- [Aplatir le PDF](./flatten-pdf) : aplatir les formulaires avant la conversion en PDF/A
- [Supprimer les métadonnées](./remove-metadata) : retirer les métadonnées avant l'archivage
docs/fr/tools/pdf-to-png.md
+42
View File
@@ -0,0 +1,42 @@
---
title: PDF vers PNG
description: Convertissez des pages PDF en images PNG sans perte avec une échelle réglable. Idéal pour des captures de haute qualité et des fonds transparents.
---
# PDF vers PNG
Convertit chaque page d'un PDF en image PNG. Le PNG utilise une compression sans perte, le résultat conserve donc tous les détails de la page d'origine. Les PDF d'une page sont téléchargés sous forme de fichier `.png`, ceux de plusieurs pages produisent un ZIP.
## Fonctionnement
1. Envoyez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. Réglez le curseur **Échelle** pour contrôler la résolution de sortie.
3. Cliquez sur **Convertir** pour lancer le traitement.
4. Un PNG unique ou une archive ZIP est téléchargé automatiquement.
## Options
- **Échelle** : de 1,0x à 3,0x (2,0x par défaut). À 2,0x, une page au format Letter est rendue à environ 1 224 x 1 584 pixels. Des valeurs d'échelle plus élevées produisent des images plus grandes et plus nettes, au prix d'une taille de fichier et d'un temps de traitement accrus.
## Format de sortie
- **Une seule page** : `filename.png`
- **Plusieurs pages** : `filename_pngs.zip` contenant `page_1.png`, `page_2.png`, etc.
## Cas d'usage
- Capturer des images fidèles de pages PDF pour des présentations.
- Extraire des graphiques ou des schémas qui exigent des contours nets et aucun artefact de compression.
- Préparer des ressources pour le design web à partir de maquettes PDF.
- Créer des images de pages sans perte pour le prétraitement OCR.
## Astuces
- Les fichiers PNG sont nettement plus volumineux que les JPG. Si la taille compte plus que la qualité parfaite, utilisez [PDF vers JPG](./pdf-to-jpg) ou [PDF vers WebP](./pdf-to-webp).
- À l'échelle 1,0x, la sortie correspond à la résolution native du PDF. Passez à 3,0x pour des exports de qualité d'impression.
## Outils associés
- [PDF vers JPG](./pdf-to-jpg)
- [PDF vers WebP](./pdf-to-webp)
- [PDF vers SVG](./pdf-to-svg)
docs/fr/tools/pdf-to-svg.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF vers SVG
description: Convertissez des pages PDF en graphiques vectoriels SVG redimensionnables. Conserve le texte et les formes sous forme de tracés vectoriels pour un redimensionnement infini.
---
# PDF vers SVG
Convertit chaque page d'un PDF en fichier SVG (Scalable Vector Graphics). Contrairement aux formats matriciels, le SVG conserve les tracés vectoriels, le texte et les formes, de sorte que le résultat s'adapte à n'importe quelle taille sans pixellisation. Propulsé par PyMuPDF.
## Fonctionnement
1. Envoyez un ou plusieurs PDF en cliquant sur la zone de dépôt ou en y glissant des fichiers. Vous pouvez ajouter plusieurs fichiers et les gérer individuellement.
2. Cliquez sur **Convertir** pour traiter tous les fichiers envoyés.
3. Les conversions d'un seul fichier d'une seule page sont téléchargées sous forme d'un `.svg` autonome. Tous les autres cas sont téléchargés sous forme d'archive ZIP.
## Options
Cet outil n'a aucune option configurable. Chaque page est convertie en SVG avec l'export vectoriel natif de PyMuPDF.
## Format de sortie
- **Un fichier, une page** : `filename.svg`
- **Un fichier, plusieurs pages** : `filename_svg.zip` contenant `page_1.svg`, `page_2.svg`, etc.
- **Plusieurs fichiers** : `pdf_to_svg.zip` avec des fichiers organisés par nom de document source.
## Cas d'usage
- Extraire des schémas vectoriels, des graphiques ou des illustrations de rapports PDF pour les utiliser dans des pages web.
- Modifier le contenu de pages PDF dans un éditeur vectoriel comme Inkscape ou Illustrator.
- Intégrer des aperçus de pages redimensionnables dans des applications web adaptatives.
- Extraire des logos ou des graphismes de brochures PDF en conservant des contours nets.
## Astuces
- Le SVG fonctionne mieux avec les PDF qui contiennent du contenu vectoriel. Les documents numérisés ou riches en images produiront de gros fichiers SVG contenant des données matricielles intégrées.
- Pour une sortie matricielle de PDF riches en images, utilisez plutôt [PDF vers PNG](./pdf-to-png) ou [PDF vers JPG](./pdf-to-jpg).
- Cet outil prend en charge la conversion par lots : envoyez plusieurs PDF à la fois pour tous les convertir en une seule exécution.
## Outils associés
- [PDF vers PNG](./pdf-to-png)
- [PDF vers JPG](./pdf-to-jpg)
- [PDF vers Markdown](./pdf-to-markdown)
docs/fr/tools/pdf-to-text.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF vers texte
description: Extrayez le texte brut de fichiers PDF. Prend en charge l'extraction par lots de plusieurs PDF avec des fichiers TXT en sortie.
---
# PDF vers texte
Extrait tout le contenu textuel de fichiers PDF et l'enregistre dans des fichiers `.txt` bruts. Prend en charge le traitement par lots : envoyez plusieurs PDF et obtenez le texte de chacun en une seule opération. Propulsé par PyMuPDF.
## Fonctionnement
1. Envoyez un ou plusieurs PDF en cliquant sur la zone de dépôt ou en y glissant des fichiers. Gérez votre liste de fichiers avec les boutons Ajouter et Effacer.
2. Cliquez sur **Extraire** pour lancer le traitement.
3. Un seul fichier est téléchargé sous la forme `filename.txt`. Plusieurs fichiers produisent une archive `pdf-to-text.zip`.
## Options
Cet outil n'a aucune option configurable. Tout le contenu textuel de chaque page est extrait dans l'ordre de lecture.
## Format de sortie
- **Un seul fichier** : `filename.txt`
- **Plusieurs fichiers** : `pdf-to-text.zip` contenant un `.txt` par PDF d'entrée.
## Cas d'usage
- Extraire le texte principal de rapports PDF pour l'indexation en texte intégral.
- Convertir des ebooks ou des articles PDF en texte brut pour les lire sur des liseuses à encre électronique.
- Récupérer le texte de contrats ou de documents juridiques pour une analyse par mots-clés.
- Retirer la mise en forme des PDF pour obtenir un texte propre destiné à des scripts de traitement de données.
- Préparer un corpus de texte à partir d'archives PDF pour le traitement automatique du langage.
## Astuces
- Les PDF numérisés (uniquement des images) produiront des fichiers texte vides, car il n'y a aucune couche de texte à extraire. Passez d'abord les documents numérisés dans l'OCR.
- La sortie conserve l'ordre de lecture tel qu'interprété par PyMuPDF, qui suit généralement de gauche à droite et de haut en bas. Les mises en page à plusieurs colonnes peuvent produire un texte entrelacé.
- Pour une sortie structurée avec titres et mise en forme, essayez [PDF vers Markdown](./pdf-to-markdown). Pour du JSON structuré prêt pour l'IA, utilisez [Préparer un PDF pour l'IA](./prepare-pdf-for-ai).
## Outils associés
- [PDF vers Markdown](./pdf-to-markdown)
- [Préparer un PDF pour l'IA](./prepare-pdf-for-ai)
- [PDF vers Word](./pdf-to-word)
docs/fr/tools/pdf-to-tiff.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF vers TIFF
description: Convertissez des pages PDF en images TIFF, couramment utilisées dans l'impression, le fax et l'archivage. Bascule sur PNG si l'encodage échoue.
---
# PDF vers TIFF
Convertit chaque page d'un PDF en image TIFF. Le TIFF est le format standard de la production d'impression, des systèmes de fax et de l'archivage de documents. L'outil utilise la compression PackBits pour l'encodage TIFF et bascule sur PNG si l'encodage d'une page échoue.
## Fonctionnement
1. Envoyez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. Cliquez sur **Convertir** pour traiter le fichier.
3. Un fichier TIFF unique ou une archive ZIP est téléchargé automatiquement.
## Options
Cet outil n'a aucune option configurable. Les pages sont rendues à une échelle fixe de 2x.
## Format de sortie
- **Une seule page** : `filename.tiff`
- **Plusieurs pages** : `filename_tiffs.zip` contenant `page_1.tiff`, `page_2.tiff`, etc.
Si l'encodage TIFF échoue pour une page précise (à cause de problèmes de compression), cette page est enregistrée en fichier `.png` à la place. Le ZIP contiendra alors un mélange de fichiers TIFF et PNG.
## Cas d'usage
- Soumettre des documents à des administrations ou des systèmes juridiques qui exigent le format TIFF.
- Préparer des pages pour une transmission par fax via des services de fax numériques.
- Archiver des documents numérisés dans un format sans perte largement pris en charge.
- Alimenter des systèmes de gestion documentaire d'entreprise avec des pages.
## Astuces
- Les fichiers TIFF sont volumineux. Si vous n'avez besoin d'une qualité sans perte que pour le web ou l'écran, [PDF vers PNG](./pdf-to-png) est un meilleur choix.
- Vérifiez le contenu du ZIP si certaines pages ont nécessité le repli sur PNG : vous voudrez peut-être les convertir séparément.
## Outils associés
- [PDF vers PNG](./pdf-to-png)
- [PDF vers BMP](./pdf-to-bmp)
- [PDF vers JPG](./pdf-to-jpg)
docs/fr/tools/pdf-to-webp.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF vers WebP
description: Convertissez des pages PDF en images WebP avec une qualité réglable. Des fichiers plus petits que le JPG pour une qualité visuelle comparable.
---
# PDF vers WebP
Convertit chaque page d'un PDF en image WebP. Le WebP produit généralement des fichiers 25 à 35 % plus petits que le JPG pour une qualité perçue identique, ce qui en fait un excellent choix pour le web.
## Fonctionnement
1. Envoyez un PDF en cliquant sur la zone de dépôt ou en y glissant un fichier.
2. Réglez le curseur **Qualité**.
3. Cliquez sur **Convertir** pour traiter le fichier.
4. Un fichier `.webp` unique ou une archive ZIP est téléchargé automatiquement.
## Options
- **Qualité** : un curseur de 0 % à 100 % (85 % par défaut). Contrôle le niveau de compression avec perte. Des valeurs plus élevées conservent plus de détails.
Les pages sont rendues en interne à l'échelle 2x, ce qui produit des images d'environ le double des dimensions natives du PDF.
## Format de sortie
- **Une seule page** : `filename.webp`
- **Plusieurs pages** : `filename_webps.zip` contenant `page_1.webp`, `page_2.webp`, etc.
## Cas d'usage
- Préparer des aperçus de pages pour des sites web où la bande passante compte.
- Générer des versions d'image légères de flyers ou de brochures pour les réseaux sociaux.
- Convertir par lots des documents de plusieurs pages en un ensemble d'images optimisé pour le web.
## Astuces
- Le WebP est pris en charge par tous les navigateurs modernes. Pour la compatibilité avec les anciens, repliez-vous sur [PDF vers JPG](./pdf-to-jpg).
- Une qualité de 80 à 85 % est généralement indiscernable de l'original à l'écran tout en gardant des fichiers légers.
## Outils associés
- [PDF vers JPG](./pdf-to-jpg)
- [PDF vers PNG](./pdf-to-png)
- [PDF vers BMP](./pdf-to-bmp)
docs/fr/tools/pdf-to-word.md
+42
View File
@@ -0,0 +1,42 @@
---
title: PDF vers Word
description: Convertissez des fichiers PDF en documents Word (DOCX) modifiables. Prend en charge la conversion par lots de plusieurs PDF à la fois.
---
# PDF vers Word
Convertit des fichiers PDF en documents Word (`.docx`) modifiables. L'outil utilise PyMuPDF pour reconstruire le contenu du document en préservant le texte, la mise en forme de base et la mise en page. Prend en charge la conversion d'un seul fichier ou par lots.
## Fonctionnement
1. Envoyez un ou plusieurs PDF en cliquant sur la zone de dépôt ou en y glissant des fichiers. Vous pouvez ajouter d'autres fichiers ou retirer des fichiers de la liste.
2. Cliquez sur **Convertir** pour lancer le traitement.
3. Un seul fichier est téléchargé sous la forme `filename.docx`. Plusieurs fichiers sont regroupés dans `converted-documents.zip`.
## Options
Cet outil n'a aucune option configurable. Chaque PDF est converti en DOCX avec le moteur de conversion intégré de PyMuPDF.
## Format de sortie
- **Un seul fichier** : `filename.docx`
- **Plusieurs fichiers** : `converted-documents.zip` contenant un `.docx` par PDF d'entrée.
## Cas d'usage
- Modifier le texte d'un PDF reçu que vous devez retoucher.
- Convertir des rapports PDF archivés dans un format que des collègues peuvent modifier dans Microsoft Word ou Google Docs.
- Reprendre le contenu de contrats ou de propositions PDF dans Word pour le révisionner.
- Migrer d'anciennes documentations PDF vers un format modifiable.
## Astuces
- Les mises en page complexes avec texte en plusieurs colonnes, formulaires intégrés ou beaucoup de graphismes peuvent ne pas se convertir parfaitement. Relisez le résultat et ajustez la mise en forme dans votre traitement de texte.
- Les PDF numérisés (uniquement des images) produiront des fichiers DOCX vides ou presque. Passez-les d'abord dans l'OCR pour ajouter une couche de texte.
- Le mode par lots est efficace pour convertir des dossiers entiers de PDF : envoyez-les tous en une fois.
## Outils associés
- [PDF vers texte](./pdf-to-text)
- [PDF vers Markdown](./pdf-to-markdown)
- [Créateur de flux PDF](./pdf-workflow)
docs/fr/tools/pdf-to-zip.md
+41
View File
@@ -0,0 +1,41 @@
---
title: PDF vers ZIP
description: Regroupez plusieurs fichiers PDF dans une seule archive ZIP pour les partager et les stocker facilement.
---
# PDF vers ZIP
Regroupez plusieurs fichiers PDF dans une seule archive ZIP. C'est un simple outil d'archivage : aucune conversion, compression ni modification des PDF eux-mêmes.
## Fonctionnement
1. Envoyez plusieurs fichiers PDF avec la zone de dépôt.
2. Vérifiez la liste des fichiers. Retirez ceux que vous ne souhaitez pas inclure.
3. Cliquez sur le bouton de traitement.
4. Une archive ZIP contenant tous les PDF envoyés est téléchargée immédiatement.
## Fonctionnalités
- Accepte un nombre quelconque de fichiers PDF
- Retrait de fichiers un par un avant la création de l'archive
- Conserve les noms de fichiers d'origine dans le ZIP
- Aucune modification du contenu des PDF : les fichiers sont archivés tels quels
- Affiche le nom et la taille de chaque PDF envoyé
## Cas d'usage
- Regrouper un ensemble de factures ou de reçus pour une pièce jointe d'e-mail
- Archiver les livrables d'un projet (plusieurs rapports PDF) pour une passation
- Créer un téléchargement unique pour une collection de formulaires ou de modèles
- Archiver un lot de documents dans un seul fichier compressé
## Astuces
- Le fichier ZIP utilise les noms de fichiers PDF d'origine. Si certains fichiers portent le même nom, renommez-les avant l'envoi pour éviter les conflits.
- Cet outil ne compresse pas les PDF eux-mêmes. Pour réduire leur taille, passez-les d'abord dans Compresser un PDF, puis regroupez-les avec cet outil.
## Outils associés
- [Fusionner des PDF](./merge-pdf)
- [Scinder un PDF](./split-pdf)
- [Compresser un PDF](./compress-pdf)
docs/fr/tools/pdf-workflow.md
+95
View File
@@ -0,0 +1,95 @@
---
title: Constructeur de workflow PDF
description: Construisez visuellement des chaînes de traitement PDF personnalisées en reliant des nœuds sur un canevas. Enchaînez des opérations comme la fusion, la compression, le filigrane et l'export.
---
# Constructeur de workflow PDF
Le Créateur de flux vous permet d'enchaîner plusieurs opérations PDF dans une seule chaîne automatisée. Au lieu d'exécuter les outils un par un, vous reliez un graphe visuel de nœuds (entrée, traitement, sortie) et exécutez le tout en un clic. Vos fichiers ne quittent jamais le navigateur.
## Fonctionnement
L'interface est divisée en trois panneaux : une **boîte à outils de nœuds** à gauche, le **canevas** au centre et un **panneau de réglages** à droite qui apparaît quand vous sélectionnez un nœud.
1. **Ajoutez des nœuds** en cliquant dessus dans la barre latérale gauche, ou en les glissant directement sur le canevas. Utilisez la barre de recherche en haut de la boîte à outils pour filtrer par nom.
2. **Reliez les nœuds** en glissant d'une prise de sortie (en bas d'un nœud) vers une prise d'entrée (en haut d'un autre nœud). Les connexions vont de haut en bas.
3. **Configurez les réglages** en cliquant sur un nœud pour ouvrir son panneau de réglages à droite. Chaque type de nœud a ses propres options (plages de pages, curseurs de qualité, mots de passe, etc.).
4. **Exécutez le flux** en cliquant sur le bouton **Exécuter** de la barre d'outils. Le moteur exécute les nœuds dans l'ordre topologique, un par un. Une barre d'état en bas suit la progression.
5. **Téléchargez les résultats** : le nœud Télécharger final enregistre le PDF obtenu (ou un ZIP si plusieurs fichiers sont produits).
## Catégories de nœuds
Les nœuds sont organisés en six catégories, chacune d'une couleur différente sur le canevas :
- **Entrée** (bleu) : Entrée PDF, Entrée image, Word/Excel/PowerPoint vers PDF et plus de 15 autres convertisseurs de formats qui alimentent la chaîne en fichiers.
- **Modifier et annoter** (indigo) : Rogner, Niveaux de gris, Inverser les couleurs, Filigrane, Numéros de page, En-tête et pied de page, Effet scanner, Ajuster les couleurs, Couleur de fond, Supprimer les pages blanches, Supprimer les annotations.
- **Organiser et gérer** (violet) : Fusionner, Scinder, Extraire des pages, Faire pivoter, Supprimer des pages, Inverser, Ajouter une page vierge, Diviser les pages, N-up, Uniformiser la taille des pages, Combiner en une seule page, Livret, Posteriser, Modifier les métadonnées, Table des matières, OCR.
- **Optimiser et réparer** (ambre) : Compresser, Rastériser, Linéariser, Redresser, PDF vers PDF/A, Police en contours, Réparer.
- **Sécuriser le PDF** (rose) : Chiffrer, Déchiffrer, Nettoyer, Aplatir, Signature numérique, Masquer.
- **Sortie** (turquoise) : Télécharger (détecte automatiquement PDF seul ou ZIP), PDF vers images, PDF vers texte, PDF vers DOCX, PDF vers XLSX, PDF vers CSV, PDF vers SVG, PDF vers Markdown, Extraire les images.
## Enregistrer et charger des flux
La barre d'outils propose quatre options de persistance :
- **Enregistrer** : stocke le flux actuel comme modèle nommé dans le stockage local de votre navigateur. Vous pouvez enregistrer plusieurs modèles.
- **Charger** : ouvre une fenêtre listant tous les modèles enregistrés. Cliquez sur Charger pour en restaurer un, ou supprimez les modèles dont vous n'avez plus besoin.
- **Exporter** : télécharge le flux sous forme de fichier `.json` pour le partager ou le sauvegarder.
- **Importer** : charge un fichier de flux `.json` depuis le disque, en restaurant tous les nœuds, positions et connexions.
Les modèles persistent d'une session à l'autre dans le stockage local. Les fichiers JSON exportés sont portables entre navigateurs et machines.
## Modèle d'exécution
Le moteur construit un graphe de dépendances à partir de vos connexions et exécute les nœuds dans l'ordre topologique. Si un nœud échoue, l'exécution s'arrête et le nœud en cause est marqué en rouge. Quelques règles à garder en tête :
- Chaque flux nécessite au moins un nœud **Entrée** et un nœud **Sortie**.
- Le moteur détecte les dépendances circulaires et bloque l'exécution avec une erreur.
- Le nœud **Chiffrer** doit être la dernière étape de traitement avant le nœud de sortie. Le placer plus tôt déclenche un avertissement de validation, car les nœuds suivants ne peuvent pas traiter des données chiffrées.
- Les PDF protégés par mot de passe demandent un mot de passe pendant l'exécution.
- Les entrées multi-PDF sont prises en charge : le nœud Fusionner peut les combiner, ou les nœuds de traitement par lots traiteront chaque PDF individuellement.
## Types de prises
Les connexions utilisent des prises typées pour éviter les branchements invalides :
- **PDF** (indigo) : un seul document PDF.
- **MultiPDF** (ambre) : plusieurs documents PDF regroupés.
- **Image** (vert) : un blob d'image.
## Options
Chaque nœud a sa propre configuration accessible via le panneau de réglages de droite. Parmi les cas courants :
- **Plages de pages** sur les nœuds Scinder, Extraire des pages et Supprimer des pages
- **Curseurs de qualité** sur les nœuds de sortie de conversion d'images
- **Champs de mot de passe** sur les nœuds Chiffrer et Déchiffrer
- **Champs de texte** pour Filigrane, En-tête et pied de page, Modifier les métadonnées
- **Angles de rotation** sur le nœud Faire pivoter
- **Niveau de compression** sur le nœud Compresser
- **Choix de la langue OCR** sur le nœud OCR
## Cas d'usage
- **Chaîne de traitement de factures** : Entrée PDF -> OCR -> Extraire les tableaux -> Télécharger en CSV.
- **Standardisation de rapports** : Word vers PDF -> Uniformiser la taille des pages -> Ajouter les numéros de page -> Filigrane -> Compresser -> Télécharger.
- **Préparation à l'archivage** : Entrée PDF -> Réparer -> Aplatir -> Nettoyer -> PDF vers PDF/A -> Télécharger.
- **Extraction d'images par lots** : Entrée PDF (plusieurs fichiers) -> Extraire les images -> Télécharger le ZIP.
- **Livrets prêts à imprimer** : Entrée PDF -> Livret -> Rogner -> Compresser -> Télécharger.
- **Diffusion sécurisée** : Entrée PDF -> Masquer -> Supprimer les annotations -> Chiffrer -> Télécharger.
## Astuces
- Utilisez **Suppr** ou **Retour arrière** pour retirer le nœud sélectionné du canevas.
- Cliquez sur le bouton **X** de la barre d'état d'un nœud pour le supprimer directement.
- Déplacez le canevas en cliquant et en faisant glisser sur un espace vide. Le curseur devient une main pendant le déplacement.
- Sur mobile, utilisez le bouton **+** de la barre d'outils pour afficher ou masquer la boîte à outils de nœuds.
- Si votre flux produit plusieurs fichiers de sortie, le nœud Télécharger les regroupe automatiquement dans un ZIP.
- Commencez simplement : construisez et testez une chaîne de deux nœuds avant d'ajouter de la complexité.
## Outils associés
- [PDF vers texte](./pdf-to-text)
- [PDF vers Excel](./pdf-to-excel)
- [Extraire les images](./extract-images)
- [PDF vers Markdown](./pdf-to-markdown)
docs/fr/tools/png-to-pdf.md
+49
View File
@@ -0,0 +1,49 @@
---
title: PNG vers PDF
description: Convertissez une ou plusieurs images PNG en document PDF avec une qualité réglable, entièrement dans votre navigateur.
---
# PNG vers PDF
Convertissez des images PNG en PDF en préservant leur pleine résolution. Chaque PNG devient sa propre page, à la taille de l'image d'origine. La transparence est gérée automatiquement.
## Formats pris en charge
| Format | Extensions |
| :----- | :--------- |
| PNG | `.png` |
## Fonctionnement
1. Cliquez sur la zone d'envoi ou glissez-déposez des fichiers PNG. Vous pouvez en sélectionner plusieurs à la fois.
2. Gérez la liste des fichiers : retirez ceux dont vous n'avez pas besoin ou ajoutez-en d'autres.
3. Choisissez un niveau de **Qualité du PDF** dans la liste déroulante.
4. Cliquez sur **Convertir en PDF**. Le résultat est téléchargé sous le nom `from_jpgs.pdf`.
L'outil utilise pdf-lib pour intégrer chaque image directement. Si un PNG ne peut pas être intégré nativement (par exemple à cause d'un profil colorimétrique inhabituel), il est rendu à nouveau via un canevas au format JPEG.
## Options
**Qualité du PDF** contrôle la compression appliquée avant l'intégration :
- **Haute qualité** : compression minimale, taille de fichier maximale.
- **Qualité moyenne** (par défaut) : bon équilibre entre taille et netteté.
- **Basse qualité** : compression maximale, sortie la plus petite.
## Cas d'usage
- Convertir des captures d'écran en PDF de plusieurs pages pour des rapports de bug ou de la documentation
- Regrouper des exports de maquettes d'interface dans un seul fichier pour relecture
- Transformer des exports de diagrammes (draw.io, Excalidraw) en PDF partageable
- Assembler un ensemble d'images de graphiques en rapport
## Astuces
- Les fichiers PNG avec transparence reçoivent un fond blanc dans le PDF. Si vous avez besoin d'un autre fond, modifiez les images au préalable.
- Pour les captures d'écran et les schémas aux contours nets et au texte, la haute qualité évite les artefacts de compression JPEG. La qualité moyenne ou basse peut convertir en JPEG en interne.
## Outils associés
- [Images vers PDF](./image-to-pdf)
- [JPG vers PDF](./jpg-to-pdf)
- [SVG vers PDF](./svg-to-pdf)
docs/fr/tools/posterize-pdf.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Posteriser un PDF
description: Découpez les pages d'un PDF en une grille de pages plus petites pour imprimer en grand format sur plusieurs feuilles.
---
# Posteriser un PDF
Divisez chaque page d'un PDF en une grille de sous-pages plus petites. C'est l'outil idéal pour imprimer une seule page sur plusieurs feuilles de papier, que vous assemblez ensuite pour créer une grande affiche ou une bannière.
## Fonctionnement
1. Importez un fichier PDF.
2. Définissez le nombre de **lignes** et de **colonnes** de la grille (par ex. 2 lignes x 2 colonnes divise chaque page en 4 sous-pages).
3. Indiquez éventuellement une plage de pages pour limiter les pages à posteriser.
4. Le canevas d'aperçu affiche une grille superposée à la page courante pour visualiser les découpes.
5. Naviguez entre les pages pour vérifier la grille sur d'autres pages.
6. Cliquez sur le bouton de traitement. Chaque cellule de la grille devient une page du PDF de sortie.
## Fonctionnalités
- Nombre de lignes et de colonnes configurable pour des grilles flexibles
- Aperçu en direct avec une grille indiquant exactement où les pages seront divisées
- Filtre de plage de pages pour ne posteriser que certaines pages
- Navigation page par page dans l'aperçu
- Instantanés de pages mis en cache pour une navigation rapide dans l'aperçu
- Des lignes de grille rouges en pointillés marquent clairement les limites de découpe
## Options
| Option | Description |
| ------------------ | ------------------------------------------------- |
| **Lignes** | Nombre de divisions horizontales (par défaut : 1) |
| **Colonnes** | Nombre de divisions verticales (par défaut : 1) |
| **Plage de pages** | Pages à posteriser (vide = toutes les pages) |
## Cas d'usage
- Imprimer un PDF au format affiche sur des feuilles A4 ou Letter standard à assembler sur un mur
- Créer de grandes bannières à partir d'un design PDF d'une seule page
- Découper des plans techniques surdimensionnés en tuiles imprimables
- Réaliser des impressions grand format sans accès à une imprimante grand format
## Conseils
- Une grille 2x2 transforme une page en 4 pages. Une grille 3x3 la transforme en 9. Planifiez votre grille selon la taille souhaitée de l'ensemble assemblé.
- L'aperçu avec grille vous aide à vérifier qu'aucun contenu important ne tombe sur une ligne de coupe. Ajustez les lignes et colonnes si nécessaire.
- Pour l'opération inverse (placer plusieurs pages sur une seule feuille), utilisez [PDF N-up](./n-up-pdf).
## Outils associés
- [PDF N-up](./n-up-pdf)
- [Diviser les pages](./divide-pages)
- [Scinder un PDF](./split-pdf)
docs/fr/tools/powerpoint-to-pdf.md
+55
View File
@@ -0,0 +1,55 @@
---
title: PowerPoint vers PDF
description: Convertissez des présentations PowerPoint (PPT, PPTX) et des fichiers ODP en PDF en préservant la mise en forme des diapositives.
---
# PowerPoint vers PDF
Convertissez des fichiers de présentation en PDF. Chaque diapositive devient une page du document de sortie, avec texte, images, formes et transitions rendus par un moteur LibreOffice exécuté dans le navigateur. Les formats PowerPoint modernes et anciens sont pris en charge, ainsi que le format OpenDocument Presentation.
## Formats pris en charge
| Format | Extensions |
| :------------------------ | :--------- |
| PowerPoint (moderne) | `.pptx` |
| PowerPoint (ancien) | `.ppt` |
| OpenDocument Presentation | `.odp` |
## Fonctionnement
1. Cliquez sur la zone d'import ou glissez-déposez vos fichiers de présentation.
2. Vérifiez la liste des fichiers. Ajoutez-en ou retirez-en selon vos besoins.
3. Cliquez sur **Convertir en PDF**. Le moteur LibreOffice se charge à la première utilisation, puis convertit chaque fichier.
4. Un fichier unique est téléchargé directement en PDF. Plusieurs fichiers sont regroupés dans `powerpoint-converted.zip`.
## Options
Cet outil n'a aucun réglage supplémentaire. Les diapositives sont rendues à leurs dimensions d'origine.
## Résultat
| Nombre de fichiers | Résultat |
| :----------------- | :-------------------------------------------------------------------- |
| 1 fichier | Téléchargement d'un seul PDF (nom d'origine avec l'extension `.pdf`) |
| 2 fichiers ou plus | Archive ZIP (`powerpoint-converted.zip`) contenant un PDF par fichier |
## Cas d'usage
- Convertir une présentation en PDF avant de la partager avec un public qui n'a pas forcément PowerPoint
- Créer une version imprimable d'un diaporama pour une conférence ou un atelier
- Archiver des présentations dans un format qui s'affiche de façon identique sur tous les appareils
- Convertir par lots une bibliothèque de présentations ODP de LibreOffice Impress en PDF
- Produire une version PDF d'un pitch deck pour l'envoyer en pièce jointe
## Conseils
- Les animations et transitions des diapositives ne sont pas représentées dans le PDF. Chaque diapositive est capturée comme une page statique.
- Les vidéos intégrées n'apparaissent pas dans le résultat. Remplacez-les par une capture d'écran ou une image de substitution si nécessaire.
- Les notes du présentateur ne sont pas incluses dans l'export PDF par défaut. Si vous avez besoin des notes, exportez d'abord depuis la vue « Imprimer les notes » de PowerPoint.
- Le moteur LibreOffice reste en cache après le premier chargement, la conversion d'une deuxième présentation dans la même session est donc bien plus rapide.
## Outils associés
- [Word vers PDF](./word-to-pdf)
- [Excel vers PDF](./excel-to-pdf)
- [Images vers PDF](./image-to-pdf)
docs/fr/tools/prepare-pdf-for-ai.md
+47
View File
@@ -0,0 +1,47 @@
---
title: Préparer le PDF pour l'IA
description: Extrayez le contenu d'un PDF en JSON structuré, optimisé pour les LLM et les pipelines d'IA comme LlamaIndex. Traitement par lots pris en charge.
---
# Préparer le PDF pour l'IA
Extrait le contenu de fichiers PDF et le structure en JSON optimisé pour l'ingestion par les grands modèles de langage (LLM) et les frameworks d'IA comme LlamaIndex. Le contenu de chaque page est extrait et organisé dans un format structuré, prêt pour des pipelines RAG, des chatbots ou des systèmes de recherche sémantique.
## Fonctionnement
1. Importez un ou plusieurs PDF en cliquant sur la zone de dépôt ou en y glissant des fichiers.
2. Cliquez sur **Extraire** pour lancer le traitement.
3. Un fichier unique est téléchargé sous le nom `filename_llm.json`. Plusieurs fichiers produisent une archive `pdf-for-ai.zip`.
L'outil utilise l'intégration LlamaIndex de PyMuPDF pour extraire le contenu page par page avec ses métadonnées, ce qui donne un résultat directement chargeable dans les frameworks d'IA.
## Options
Cet outil n'a aucune option configurable. Toutes les pages sont extraites avec le texte complet et les métadonnées.
## Format de sortie
- **Fichier unique** : `filename_llm.json`
- **Plusieurs fichiers** : `pdf-for-ai.zip` contenant un fichier `_llm.json` par PDF d'entrée.
Le JSON respecte le schéma de document LlamaIndex, avec le texte de chaque page et des champs de métadonnées.
## Cas d'usage
- Préparer des documents PDF pour des pipelines de génération augmentée par récupération (RAG).
- Construire une base de connaissances interrogeable à partir d'archives PDF pour un chatbot IA.
- Alimenter des workflows d'analyse basés sur des LLM avec des rapports PDF.
- Prétraiter des articles de recherche pour des systèmes de recherche sémantique et de questions-réponses.
- Créer des données d'entraînement structurées à partir de collections de documents PDF.
## Conseils
- Pour une extraction de texte brut sans formatage propre à l'IA, utilisez [PDF vers texte](./pdf-to-text).
- Pour une sortie Markdown qui conserve les titres et la structure, utilisez [PDF vers Markdown](./pdf-to-markdown).
- Les PDF numérisés produiront un résultat vide ou minimal. Passez-les d'abord par l'OCR pour ajouter une couche de texte avant l'extraction.
## Outils associés
- [PDF vers texte](./pdf-to-text)
- [PDF vers Markdown](./pdf-to-markdown)
- [PDF vers JSON](./pdf-to-json)
docs/fr/tools/protect-pdf.md
+64
View File
@@ -0,0 +1,64 @@
---
title: Protéger un PDF
description: Protégez vos fichiers PDF par mot de passe avec un chiffrement AES 256 bits. Définissez des mots de passe utilisateur et propriétaire avec des restrictions d'usage configurables.
---
# Protéger un PDF
Verrouillez votre PDF par un mot de passe pour que seules les personnes autorisées puissent l'ouvrir. BentoPDF utilise le chiffrement AES 256 bits, le même standard que celui des banques et des administrations, appliqué entièrement dans votre navigateur via QPDF.
## Fonctionnement
1. Importez un fichier PDF.
2. Saisissez un **mot de passe utilisateur** (obligatoire). C'est le mot de passe nécessaire pour ouvrir le fichier.
3. Saisissez éventuellement un **mot de passe propriétaire**. Une fois défini, le PDF reçoit des restrictions d'usage qui empêchent l'impression, la modification, la copie et l'annotation.
4. Cliquez sur **Chiffrer le PDF**.
5. Téléchargez le fichier chiffré.
## Types de mots de passe
### Mot de passe utilisateur (obligatoire)
Le mot de passe utilisateur est celui que les destinataires saisissent pour ouvrir le PDF. Sans lui, le document est totalement inaccessible. Tout PDF chiffré doit en avoir un.
### Mot de passe propriétaire (facultatif)
Le mot de passe propriétaire contrôle ce qu'un utilisateur autorisé peut faire après l'ouverture du fichier. Lorsque vous définissez un mot de passe propriétaire distinct, BentoPDF applique automatiquement le jeu de restrictions le plus strict :
- Modification désactivée
- Extraction et copie désactivées
- Impression désactivée
- Annotation désactivée
- Remplissage de formulaires désactivé
- Assemblage du document désactivé
Si vous laissez le mot de passe propriétaire vide, le PDF est chiffré (le mot de passe utilisateur reste requis pour l'ouvrir) mais n'a aucune restriction d'usage une fois ouvert.
## Détails du chiffrement
- **Algorithme** : AES-256 (Advanced Encryption Standard 256 bits)
- **Longueur de clé** : 256 bits
- **Standard** : chiffrement PDF 2.0 (implémentation QPDF)
Avec la technologie actuelle, l'AES-256 est impossible à casser par force brute. La sécurité de votre PDF chiffré dépend entièrement de la robustesse de votre mot de passe.
## Cas d'usage
- Protéger des rapports financiers confidentiels avant de les envoyer par email
- Sécuriser des documents juridiques partagés avec la partie adverse
- Ajouter un mot de passe à des dossiers médicaux ou à des données personnelles identifiables
- Distribuer du contenu payant (e-books, rapports) avec contrôle d'accès
- Respecter des politiques de protection des données qui exigent le chiffrement au repos
## Conseils
- Utilisez un mot de passe fort et unique. Une phrase de passe d'au moins 12 caractères mêlant majuscules, minuscules, chiffres et symboles est idéale.
- Partagez le mot de passe par un canal distinct (téléphone, SMS), jamais dans le même email que le PDF.
- Si vous voulez seulement restreindre des actions (pas d'impression, pas de copie) sans exiger de mot de passe pour ouvrir le fichier, utilisez plutôt l'outil Modifier les autorisations.
## Outils associés
- [Déchiffrer un PDF](./unlock-pdf) : retirer le chiffrement quand vous connaissez le mot de passe
- [Modifier les autorisations](./change-permissions) : modifier des restrictions d'usage précises
- [Supprimer les restrictions](./remove-restrictions) : retirer toute la sécurité d'un PDF
- [Nettoyer un PDF](./sanitize-pdf) : supprimer le contenu masqué avant de chiffrer
docs/fr/tools/psd-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: PSD vers PDF
description: Convertissez des fichiers Photoshop (PSD) en PDF dans votre navigateur. Gratuit, privé, sans logiciel Adobe.
---
# PSD vers PDF
Convertissez des fichiers Adobe Photoshop PSD en documents PDF. Le PSD est le format natif de Photoshop, et l'ouvrir nécessite normalement un logiciel Adobe coûteux. Cet outil restitue l'image composite aplatie de votre fichier PSD sous la forme d'une page PDF en pleine résolution.
## Formats pris en charge
| Format | Extension | Remarques |
| :-------------- | :-------- | :--------------------------------- |
| Adobe Photoshop | `.psd` | Restitue l'image composite aplatie |
## Fonctionnement
1. Cliquez sur la zone d'import ou glissez-déposez vos fichiers PSD. Plusieurs fichiers sont pris en charge.
2. Vérifiez la liste des fichiers. Retirez les fichiers indésirables avec l'icône de corbeille, ou utilisez **Ajouter des fichiers** pour en inclure d'autres.
3. Cliquez sur **Convertir en PDF**. Le moteur PyMuPDF lit le fichier PSD et intègre l'image composite dans une page PDF à la résolution d'origine.
4. Un PSD unique produit un PDF. Si vous importez plusieurs fichiers PSD, ils sont combinés en un seul PDF de plusieurs pages nommé `psd_to_pdf.pdf`, chaque PSD devenant une page.
## Options
Aucun réglage n'est nécessaire. Le convertisseur utilise les données d'image aplaties du fichier PSD.
## Cas d'usage
- Prévisualiser des créations Photoshop sans ouvrir Photoshop
- Envoyer des épreuves de design à des clients qui n'ont pas Adobe Creative Suite
- Imprimer des visuels haute résolution à partir de fichiers PSD
- Créer un portfolio PDF à partir de plusieurs fichiers de design PSD : chacun devient une page d'un même document
## Conseils
- La conversion restitue la vue composite (aplatie) du PSD. Les calques individuels, les calques de réglage et les effets de calque ne sont pas conservés comme éléments séparés dans le PDF.
- Plusieurs fichiers PSD sont fusionnés en un seul PDF de plusieurs pages plutôt qu'en PDF individuels. C'est pratique pour constituer des portfolios ou des lookbooks.
- Les fichiers PSD de très haute résolution (fichiers d'impression à plus de 300 DPI) produisent de gros PDF. L'outil conserve la pleine résolution.
## Outils associés
- [Images vers PDF](./image-to-pdf)
- [PNG vers PDF](./png-to-pdf)
- [VSD vers PDF](./vsd-to-pdf)
Loaded 100 of 3344 files, more files were not shown because too many files have changed in this diff. Show more