lucasw89/bentopdf
1
0 Fork 0
mirror of https://github.com/alam00000/bentopdf.git synced 2026-11-11 17:23:37 +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/it/contributing.md
+136
View File
@@ -0,0 +1,136 @@
# Contribuire
Grazie per l'interesse a contribuire a BentoPDF! Questa guida ti aiuterà a iniziare.
## Per iniziare
### Prerequisiti
- Node.js 18+
- npm 9+
- Git
### Configurazione
```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
```
## Struttura del progetto
```
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
```
## Aggiungere un nuovo strumento
### Passaggio 1: crea il file della logica
Crea `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
});
```
### Passaggio 2: crea la pagina HTML
Crea `src/pages/your-tool.html` seguendo i modelli degli strumenti esistenti.
### Passaggio 3: registra lo strumento
Aggiungi a `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.',
}
```
### Passaggio 4: aggiungi alla configurazione di build
Aggiungi la pagina a `vite.config.ts`:
```typescript
'your-tool': resolve(__dirname, 'src/pages/your-tool.html'),
```
### Passaggio 5: aggiungi le traduzioni
Aggiungi le voci a tutti i file delle lingue in `public/locales/`:
```json
{
"yourTool": {
"name": "Your Tool",
"subtitle": "Description"
}
}
```
## Stile del codice
- Usa TypeScript per tutto il nuovo codice
- Segui i pattern esistenti per coerenza
- Esegui `npm run format` prima del commit
- Nessun commento nel codice di produzione (i commenti vengono rimossi durante la build)
## Processo delle pull request
1. Crea un branch per la funzionalità: `git checkout -b feature/your-feature`
2. Apporta le tue modifiche
3. Testa con attenzione: `npm run build`
4. Invia una PR con una descrizione chiara
## Traduzione
Consulta [TRANSLATION.md](https://github.com/alam00000/bentopdf/blob/main/TRANSLATION.md) per aggiungere nuove lingue.
## Contributor License Agreement
Prima che la tua PR possa essere unita, dovrai firmare la nostra CLA:
- [CLA individuale (ICLA)](https://github.com/alam00000/bentopdf/blob/main/ICLA.md)
- [CLA aziendale (CCLA)](https://github.com/alam00000/bentopdf/blob/main/CCLA.md)
## Ottenere aiuto
- [GitHub Issues](https://github.com/alam00000/bentopdf/issues)
- [Community Discord](https://discord.gg/Bgq3Ay3f2w)
## Licenza
BentoPDF ha una doppia licenza:
- **AGPL-3.0** per i progetti open source in cui condividi pubblicamente tutto il codice sorgente
- **Licenza commerciale** per le applicazioni proprietarie o closed source: [Ottieni la licenza a vita per $79](https://buy.polar.sh/polar_cl_ThDfffbl733x7oAodcIryCzhlO57ZtcWPq6HJ1qMChd)
Contribuendo, accetti che i tuoi contributi siano concessi in licenza secondo questi termini.
docs/it/getting-started.md
+80
View File
@@ -0,0 +1,80 @@
# Per iniziare
Benvenuto in BentoPDF! Questa guida ti aiuterà a metterti in funzione rapidamente.
## Cos'è BentoPDF?
BentoPDF è un kit di strumenti PDF gratuito, open source e pensato per la privacy, che funziona **interamente nel tuo browser**. I tuoi file non lasciano mai il dispositivo: tutta l'elaborazione avviene in locale grazie alla tecnologia WebAssembly (WASM).
## Avvio rapido
### Opzione 1: usa la versione ospitata
Visita [bentopdf.com](https://www.bentopdf.com) per usare BentoPDF subito, senza installare nulla.
### Opzione 2: self-hosting con Docker
> [!IMPORTANT]
> La conversione dei file Office richiede `SharedArrayBuffer`, che necessita di entrambi:
>
> - `Cross-Origin-Opener-Policy: same-origin`
> - `Cross-Origin-Embedder-Policy: require-corp`
> - un contesto sicuro
>
> `http://localhost` funziona per i test in locale perché i browser considerano affidabile il loopback. `http://192.168.x.x` o altri IP di rete locale di solito no, quindi le conversioni di Word/Excel/PowerPoint richiederanno HTTPS quando si accede da altri dispositivi della tua rete.
```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 è disponibile in due build: la **build self-hosted** (`bentopdf-simple`, usata sopra) per installazioni interne, di team o di organizzazioni, e la **build commerciale** (`bentopdf:latest`) usata da bentopdf.com stesso e dai titolari di una licenza commerciale che gestiscono installazioni pubbliche. Entrambe includono gli stessi strumenti PDF: la build commerciale aggiunge hero, FAQ, testimonianze e footer di bentopdf.com. Se hai dubbi, usa la build self-hosted.
Poi apri `http://localhost:3000` nel browser.
> [!NOTE]
> Se stai preparando un'installazione OCR in ambiente air-gapped, devi ospitare internamente anche i font del livello di testo OCR, oltre al worker Tesseract, al runtime core e ai file traineddata. La configurazione completa è descritta in [Self-hosting](/it/self-hosting/), inclusi `VITE_OCR_FONT_BASE_URL` e la cartella inclusa `ocr-fonts/`.
### Opzione 3: compila dai sorgenti
```bash
# Clone the repository
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
# Install dependencies
npm install
# Start development server
npm run dev
```
## Funzionalità in sintesi
| Categoria | Strumenti |
| --------------------- | --------------------------------------------------------------- |
| **Converti in PDF** | Word, Excel, PowerPoint, immagini, Markdown, EPUB, MOBI e altro |
| **Converti da PDF** | JPG, PNG, testo, Excel, SVG e altro |
| **Modifica e annota** | Firma, evidenzia, oscura, compila moduli, aggiungi timbri |
| **Organizza** | Unisci, dividi, ruota, elimina pagine, riordina |
| **Ottimizza** | Comprimi, ripara, appiattisci, OCR |
| **Sicurezza** | Cifra, decifra, rimuovi restrizioni |
## Browser supportati
BentoPDF funziona al meglio sui browser moderni:
- ✅ Chrome/Edge 90+
- ✅ Firefox 90+
- ✅ Safari 15+
## Prossimi passi
- [Esplora tutti gli strumenti](/it/tools/)
- [Installa BentoPDF sul tuo server](/it/self-hosting/)
- [Contribuisci al progetto](/it/contributing)
docs/it/index.md
+42
View File
@@ -0,0 +1,42 @@
---
# https://vitepress.dev/reference/default-theme-home-page
layout: home
hero:
name: 'BentoPDF'
text: 'Strumenti PDF gratuiti e open source'
tagline: Elabora i PDF interamente nel tuo browser. Nessun caricamento. Nessun server. Privacy totale.
actions:
- theme: brand
text: Inizia
link: /it/getting-started
- theme: alt
text: Vedi gli strumenti
link: /it/tools/
- theme: alt
text: Self-hosting
link: /it/self-hosting/
- theme: alt
text: Licenza commerciale
link: /it/licensing
features:
- icon: 🔒
title: 100% privato
details: I tuoi file non lasciano mai il dispositivo. Tutta l'elaborazione avviene in locale nel browser grazie a WebAssembly.
- icon: ⚡
title: Veloce e gratuito
details: Nessuna registrazione, nessun limite, nessuna filigrana. Elabora PDF senza limiti, gratis e per sempre.
- icon: 🛠️
title: Oltre 50 strumenti
details: Converti, modifica, unisci, dividi, comprimi, firma, OCR e altro. Tutto ciò che ti serve in un unico posto.
- icon: 🌐
title: Installabile sul tuo server
details: Distribuiscilo sulla tua infrastruttura. Docker, Vercel, Netlify, AWS o ambienti completamente air-gapped con worker OCR, dati linguistici e font del livello di testo ospitati da te.
---
## OCR offline
Se ospiti BentoPDF in un ambiente air-gapped o offline, l'OCR richiede più del worker Tesseract e dei file traineddata. Per ottenere PDF ricercabili, anche i font del livello di testo OCR devono essere serviti internamente.
Consulta [Self-hosting](/it/self-hosting/) per la configurazione completa, inclusi `VITE_OCR_FONT_BASE_URL`, la cartella inclusa `ocr-fonts/` e il flusso di lavoro air-gap aggiornato.
docs/it/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](/it/self-hosting/#configurazione-wasm-componenti-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/it/self-hosting/apache.md
+275
View File
@@ -0,0 +1,275 @@
# Distribuzione con Apache
Ospita BentoPDF usando Apache HTTP Server.
## Prerequisiti
- Apache 2.4+
- mod_rewrite abilitato
- Certificato SSL (consigliato)
## Passaggio 1: compila il progetto
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
```
Per personalizzare il marchio, imposta le variabili d'ambiente prima della build:
```bash
VITE_BRAND_NAME="AcmePDF" VITE_BRAND_LOGO="images/acme-logo.svg" npm run build
```
## Passaggio 2: copia i file
```bash
sudo mkdir -p /var/www/bentopdf
sudo cp -r dist/* /var/www/bentopdf/
sudo chown -R www-data:www-data /var/www/bentopdf
```
## Passaggio 3: configurazione di Apache
Crea `/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>
```
## Passaggio 4: .htaccess per il routing
Crea `/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
```
## Passaggio 5: abilita i moduli necessari
```bash
sudo a2enmod rewrite
sudo a2enmod ssl
sudo a2enmod headers
sudo a2enmod expires
sudo a2enmod deflate
```
## Passaggio 6: abilita il sito
```bash
sudo a2ensite bentopdf.conf
sudo apache2ctl configtest
sudo systemctl reload apache2
```
## Distribuzione in una sottodirectory
Per ospitarlo in `/pdf/`:
1. Compila con l'URL di base:
```bash
BASE_URL=/pdf/ npm run build
```
2. Aggiorna `.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
```
## Risoluzione dei problemi
### Errori 404 sui file WASM
Assicurati che il tipo MIME sia configurato:
```apache
AddType application/wasm .wasm
```
### Firma PDF o Compilazione moduli mostra un visualizzatore vuoto (errore MIME `.mjs`)
Se la console del browser mostra:
```
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.
```
…e la richiesta che fallisce termina in `.mjs`, nella tua configurazione di Apache manca la mappatura `.mjs → application/javascript`. Il visualizzatore PDF incluso usa file ES module con estensione `.mjs`, che il `mime.types` predefinito di Apache non contiene.
Aggiungi al tuo VirtualHost o a `.htaccess`:
```apache
AddType application/javascript .mjs
```
Poi ricarica Apache:
```bash
sudo apache2ctl configtest && sudo systemctl reload apache2
```
Per verificare: negli DevTools del browser, scheda Network, trova la richiesta `.mjs` che falliva e controlla l'header di risposta `Content-Type`. Ora dovrebbe essere `application/javascript`, non `application/octet-stream`.
### Le regole di rewrite non funzionano
Verifica che mod_rewrite sia abilitato:
```bash
sudo a2enmod rewrite
```
### La conversione da Word/ODT/Excel a PDF non funziona
LibreOffice WASM richiede `SharedArrayBuffer`, che necessita di questi header:
```apache
Header always set Cross-Origin-Embedder-Policy "require-corp"
Header always set Cross-Origin-Opener-Policy "same-origin"
```
Serve anche un contesto sicuro. `http://localhost` funziona per i test in locale, ma `http://192.168.x.x` o altri IP di rete locale di solito richiedono HTTPS. Se gli header sono presenti ma `window.crossOriginIsolated` è ancora `false`, controlla se la pagina viene aperta tramite HTTP semplice su un'origine diversa dal loopback.
Anche i file precompressi `.wasm.gz` e `.data.gz` richiedono un `Content-Encoding` corretto:
```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>
```
Assicurati che `mod_headers` sia abilitato: `sudo a2enmod headers`
### Permesso negato
```bash
sudo chown -R www-data:www-data /var/www/bentopdf
sudo chmod -R 755 /var/www/bentopdf
```
docs/it/self-hosting/aws.md
+200
View File
@@ -0,0 +1,200 @@
# Distribuzione su AWS S3 + CloudFront
Ospita BentoPDF su AWS per il massimo controllo e la massima scalabilità.
## Architettura
```
User → CloudFront (CDN) → S3 (Static Files)
```
## Passaggio 1: crea il 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
```
## Passaggio 2: compila e carica
```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
```
## Passaggio 3: crea la distribuzione CloudFront
```bash
aws cloudfront create-distribution \
--origin-domain-name your-bentopdf-bucket.s3.amazonaws.com \
--default-root-object index.html
```
Oppure usa la console AWS:
1. Vai su CloudFront → Create distribution
2. Origin domain: seleziona il tuo bucket S3
3. Abilita "Origin Access Control"
4. Default root object: `index.html`
5. Crea la distribuzione
## Passaggio 3b: policy degli header di risposta (necessaria per LibreOffice WASM)
Le conversioni basate su LibreOffice (da Word, Excel, PowerPoint a PDF) richiedono `SharedArrayBuffer`, che necessita di specifici header di risposta. Crea una Response Headers Policy di CloudFront:
1. Vai su CloudFront → Policies → Response headers
2. Crea una policy personalizzata con questi header:
| Header | Valore |
| ------------------------------ | -------------- |
| `Cross-Origin-Embedder-Policy` | `require-corp` |
| `Cross-Origin-Opener-Policy` | `same-origin` |
| `Cross-Origin-Resource-Policy` | `cross-origin` |
3. Associa la policy al default cache behavior della tua distribuzione
Oppure tramite 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}
]
}
}'
```
## Passaggio 3c: metadati S3 per i file WASM precompressi
I file WASM di LibreOffice sono precompressi (`.wasm.gz`, `.data.gz`). Imposta Content-Type e Content-Encoding corretti in modo che i browser li decomprimano:
```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 Importante
Senza la policy degli header di risposta, `SharedArrayBuffer` non è disponibile e le conversioni LibreOffice WASM si bloccheranno intorno al 55%. Senza il Content-Encoding corretto sui file `.gz`, il browser riceve i byte gzip grezzi e la compilazione WASM fallisce.
:::
## Passaggio 4: policy del bucket S3
Consenti a CloudFront di accedere al 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"
}
}
}
]
}
```
## Passaggio 5: pagine di errore personalizzate
Configura il 404 in modo che restituisca `index.html` per il routing SPA:
1. CloudFront → Error pages
2. Crea una risposta di errore personalizzata:
- HTTP error code: 404
- Response page path: `/index.html`
- HTTP response code: 200
## Stima dei costi
| Risorsa | Costo stimato |
| -------------------------- | ------------- |
| S3 Storage (~500MB) | ~$0,01/mese |
| CloudFront (1TB transfer) | ~$85/mese |
| CloudFront (10GB transfer) | ~$0,85/mese |
::: tip
Usa S3 Intelligent Tiering per ottimizzare i costi dei file a cui si accede di rado.
:::
## Automazione con 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/it/self-hosting/cloudflare.md
+154
View File
@@ -0,0 +1,154 @@
# Distribuzione su Cloudflare Pages
[Cloudflare Pages](https://pages.cloudflare.com) offre hosting di siti statici veloce e globale con banda illimitata.
## Distribuzione rapida
1. Vai su [Cloudflare Pages](https://dash.cloudflare.com/?to=/:account/pages)
2. Clicca su "Create a project"
3. Collega il tuo repository GitHub
## Configurazione della build
| Impostazione | Valore |
| ---------------------- | --------------- |
| Framework preset | None |
| Build command | `npm run build` |
| Build output directory | `dist` |
| Root directory | `/` |
## Variabili d'ambiente
Aggiungile in Settings → Environment variables:
| Variabile | Valore |
| ----------------------- | ----------------------------------------------------------- |
| `NODE_VERSION` | `18` |
| `SIMPLE_MODE` | `false` (facoltativo) |
| `VITE_BRAND_NAME` | Nome del marchio personalizzato (facoltativo) |
| `VITE_BRAND_LOGO` | Percorso del logo relativo a `public/` (facoltativo) |
| `VITE_FOOTER_TEXT` | Testo personalizzato del footer/copyright (facoltativo) |
| `VITE_DEFAULT_LANGUAGE` | Lingua predefinita dell'interfaccia, es. `fr` (facoltativo) |
## File di configurazione
Crea `_headers` nella tua cartella `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 Importante
Gli header `Cross-Origin-Embedder-Policy` e `Cross-Origin-Opener-Policy` sono necessari per le conversioni da Word/ODT/Excel/PowerPoint a PDF. Senza di essi, `SharedArrayBuffer` non è disponibile e il motore LibreOffice WASM non riesce a inizializzarsi.
:::
Crea `_redirects` per il routing SPA:
```
/* /index.html 200
```
## Dominio personalizzato
1. Vai al tuo progetto Pages
2. Clicca su "Custom domains"
3. Aggiungi il tuo dominio
4. Cloudflare configurerà automaticamente il DNS se il dominio è su Cloudflare
## Vantaggi
- **Banda illimitata gratuita**
- **CDN globale** con oltre 300 sedi edge
- **HTTPS automatico**
- **Anteprime di distribuzione** per le pull request
- **Build veloci**
## Risoluzione dei problemi
### Caricamento di file di grandi dimensioni
Cloudflare Pages supporta file fino a 25 MB. I moduli WASM dovrebbero andare bene, ma se raggiungi i limiti, valuta:
```bash
# Split large files during build
npm run build
```
### Limiti di dimensione dei Worker
Se usi Cloudflare Workers per un routing avanzato, tieni presente il limite di 1 MB dei piani gratuiti.
## Worker proxy CORS (per le firme digitali)
Lo strumento di firma digitale richiede un proxy CORS per recuperare le catene di certificati. Distribuisci il worker incluso:
```bash
cd cloudflare
npx wrangler login
npx wrangler deploy
```
### Funzionalità di sicurezza
| Funzionalità | Descrizione |
| ---------------------------- | ---------------------------------- |
| **Restrizioni sugli URL** | Consentiti solo URL di certificati |
| **Limite di dimensione** | Max 10MB per richiesta |
| **Limitazione di frequenza** | 60 richieste/IP/min (richiede KV) |
| **Blocco degli IP privati** | Blocca localhost e IP interni |
### Abilitare la limitazione di frequenza
```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
```
### Compilare con l'URL del proxy
```bash
VITE_CORS_PROXY_URL=https://your-worker.workers.dev npm run build
```
Oppure con 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 .
```
> **Nota:** consulta il [README](https://github.com/alam00000/bentopdf#digital-signature-cors-proxy-required) per la configurazione della firma HMAC.
docs/it/self-hosting/cors-proxy.md
+180
View File
@@ -0,0 +1,180 @@
# Proxy CORS per il recupero dei certificati
Lo strumento di firma digitale usa un proxy CORS per recuperare i certificati degli emittenti da Certificate Authority (CA) esterne. È necessario perché molti server delle CA non includono header CORS nelle risposte, il che impedisce il recupero diretto dal browser.
Inoltre, molti server delle CA distribuiscono i certificati tramite HTTP semplice. Quando la tua istanza di BentoPDF è ospitata su HTTPS, i browser bloccano queste richieste HTTP (policy sui contenuti misti). Il proxy CORS risolve entrambi i problemi instradando le richieste attraverso un endpoint HTTPS con gli header corretti.
## Come funziona
Quando firmi un PDF con un certificato:
1. La libreria `zgapdfsigner` cerca di costruire una catena di certificati completa
2. Recupera i certificati degli emittenti dagli URL incorporati nell'estensione AIA (Authority Information Access) del tuo certificato
3. Queste richieste passano attraverso un proxy CORS che aggiunge gli header `Access-Control-Allow-Origin` necessari
4. Il proxy restituisce al browser i dati del certificato
## Self-hosting del proxy CORS
Se ospiti BentoPDF in autonomia, dovrai distribuire un tuo proxy CORS affinché le firme digitali funzionino con i certificati che richiedono il recupero della catena.
### Opzione 1: Cloudflare Workers (consigliata)
1. **Installa la CLI di Wrangler**:
```bash
npm install -g wrangler
```
2. **Accedi a Cloudflare**:
```bash
wrangler login
```
3. **Clona BentoPDF e aggiorna le origini consentite**:
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf/cloudflare
```
Apri `cors-proxy-worker.js` e modifica l'array `ALLOWED_ORIGINS` con il tuo dominio:
```js
const ALLOWED_ORIGINS = [
'https://your-domain.com',
'https://www.your-domain.com',
];
```
::: warning Importante
Senza questa modifica, il proxy rifiuterà tutte le richieste dal tuo sito con un errore **403 Forbidden**. L'impostazione predefinita consente solo le richieste da `bentopdf.com`.
:::
4. **Distribuisci il proxy**:
```bash
wrangler deploy
```
Annota l'URL del tuo worker (es. `https://bentopdf-cors-proxy.your-subdomain.workers.dev`).
5. **Ricompila BentoPDF con l'URL del proxy**:
Se usi 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 .
```
Se compili dai sorgenti:
```bash
VITE_CORS_PROXY_URL=https://your-worker.workers.dev npm run build
```
### Opzione 2: proxy backend personalizzato
Puoi anche creare un tuo endpoint proxy. I requisiti sono:
1. Accettare richieste GET con un parametro di query `url`
2. Recuperare l'URL dal tuo server (nessuna restrizione CORS lato server)
3. Restituire la risposta con questi header:
- `Access-Control-Allow-Origin: https://your-domain.com`
- `Access-Control-Allow-Methods: GET, OPTIONS`
- `X-Content-Type-Options: nosniff`
Esempio di implementazione con 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' });
}
});
```
## Considerazioni sulla sicurezza
Il Cloudflare Worker incluso adotta diverse misure di sicurezza:
| Funzionalità | Descrizione |
| ------------------------------ | -------------------------------------------------------------------------------------------------- |
| **Convalida dell'origine** | Consente solo richieste dai domini elencati in `ALLOWED_ORIGINS` |
| **Restrizioni sugli URL** | Consente solo URL di certificati (`.crt`, `.cer`, `.pem`, `/certs/`, `/ocsp`, `/crl`) |
| **Blocco degli IP privati** | Blocca intervalli privati IPv4/IPv6, link-local, loopback, IP decimali e metadati cloud |
| **Sicurezza del Content-Type** | Restituisce solo tipi MIME di certificati sicuri, blocca l'iniezione di content-type dall'upstream |
| **Limite di dimensione** | Trasmette la risposta in streaming con limite di 10MB, interrompe il download se superato |
| **Limitazione di frequenza** | 60 richieste al minuto per IP o IPv6 /64 (richiede KV, nessun blocco in caso di errori di KV) |
| **Firme HMAC** | Firma facoltativa lato client (scoraggia gli abusi occasionali) |
### DNS rebinding (self-hosting fuori da Cloudflare)
Il worker rifiuta qualsiasi URL che si risolve in un IP privato o interno. Non può usare un elenco fisso di host consentiti, perché gli URL della catena di certificati puntano a qualunque CA abbia emesso il certificato (FNMT, CA aziendali e così via), quindi le destinazioni non sono note in anticipo. Resta così una piccola finestra di rebinding: chi gestisce il DNS del proprio dominio potrebbe restituire un IP pubblico al controllo di sicurezza e uno privato alla richiesta vera e propria un istante dopo.
Su Cloudflare non è sfruttabile: i Workers non possono raggiungere IP privati né l'endpoint di metadati `169.254.169.254`, quindi un rebind non porta a nulla. Basta non dare al worker una via d'accesso: non associare un Tunnel, un Service o un binding di rete privata (gli serve solo `RATE_LIMIT_KV`).
Se lo esegui fuori da Cloudflare (workerd, Node e simili) all'interno di una VPC, il runtime _può_ raggiungere gli IP interni. Metti davanti un firewall in uscita e blocca gli intervalli privati: `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` e i rispettivi equivalenti IPv6. Il codice dell'app non può imporlo una volta fuori da Cloudflare.
## Disattivare il proxy
Se non vuoi usare un proxy CORS, imposta la variabile d'ambiente su una stringa vuota:
```
VITE_CORS_PROXY_URL=
```
**Nota**: senza il proxy, la firma con certificati che richiedono il recupero esterno della catena (come FNMT o alcune CA aziendali) fallirà con l'errore "Failed to fetch".
## Risoluzione dei problemi
### "Signing error: TypeError: Failed to fetch"
Di solito significa una di queste cose:
1. **Nessun proxy CORS configurato**: imposta `VITE_CORS_PROXY_URL` e ricompila
2. **Contenuti misti bloccati**: il tuo sito è in HTTPS ma l'URL dell'emittente del certificato è in HTTP. Il proxy CORS risolve il problema.
3. **Il proxy CORS rifiuta la tua origine**: verifica che il tuo dominio sia nell'array `ALLOWED_ORIGINS` in `cors-proxy-worker.js`
### "403 Forbidden" dal proxy
Il tuo dominio non è nell'elenco `ALLOWED_ORIGINS`. Modifica `cors-proxy-worker.js`:
```js
const ALLOWED_ORIGINS = ['https://your-domain.com'];
```
Poi ridistribuisci: `npx wrangler deploy`
### Testare il proxy
```bash
curl -H "Origin: https://your-domain.com" \
"https://your-proxy.workers.dev?url=http://www.cert.fnmt.es/certs/ACUSU.crt"
```
### Certificati che funzionano senza proxy
Alcuni certificati includono la catena completa nel file P12/PFX e non richiedono recuperi esterni:
- Certificati autofirmati
- Alcune CA commerciali che includono i certificati intermedi
- Certificati che hai assemblato manualmente con la catena completa
docs/it/self-hosting/docker.md
+622
View File
@@ -0,0 +1,622 @@
# Distribuzione con Docker / Podman
Il modo più semplice per ospitare BentoPDF in autonomia in un ambiente di produzione.
> [!IMPORTANT]
> **Header richiesti per la conversione dei file Office**
>
> Gli strumenti basati su LibreOffice (conversione di Word, Excel, PowerPoint) richiedono questi header HTTP per il supporto a `SharedArrayBuffer`:
>
> - `Cross-Origin-Opener-Policy: same-origin`
> - `Cross-Origin-Embedder-Policy: require-corp`
>
> La pagina deve inoltre essere servita da un contesto sicuro. `http://localhost` funziona per i test in locale, ma `http://192.168.x.x` o altri IP di rete locale di solito non lo qualificano, quindi la conversione Office tramite HTTP semplice fallirà anche se gli header sono presenti.
>
> Le immagini container ufficiali includono questi header. Se usi un reverse proxy (Traefik, Caddy, ecc.), assicurati che gli header vengano mantenuti o aggiunti e usa HTTPS per gli accessi diversi dal loopback.
> [!TIP]
> **Utenti Podman:** tutti i comandi `docker` funzionano con Podman sostituendo `docker` con `podman` e `docker-compose` con `podman-compose`.
## Avvio rapido
> [!TIP]
> BentoPDF è disponibile in due build:
>
> - **Build self-hosted**: `ghcr.io/alam00000/bentopdf-simple:latest`. Tutti gli strumenti PDF, **senza** la parte di marketing (niente hero, FAQ, testimonianze, footer). Usala per installazioni interne, di team o di organizzazioni. **Non** è una versione "lite" con meno funzionalità.
> - **Build commerciale**: `ghcr.io/alam00000/bentopdf:latest`. Il sito di marketing completo, usato da bentopdf.com stesso e dai titolari di una licenza commerciale che gestiscono installazioni pubbliche.
>
> Se hai dubbi: scarica la build self-hosted.
```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
Crea `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
```
Esegui:
```bash
# Docker Compose
docker compose up -d
# Podman Compose
podman-compose up -d
```
## Crea la tua immagine
```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;"]
```
Compila ed esegui:
```bash
docker build -t bentopdf:custom .
docker run -d -p 3000:8080 bentopdf:custom
```
## Variabili d'ambiente
| Variabile | Descrizione | Predefinito |
| ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
| `SIMPLE_MODE` | Compila la variante self-hosted (nasconde la parte di marketing di bentopdf.com: hero, FAQ, testimonianze, footer). Tutti gli strumenti PDF restano. | `false` |
| `BASE_URL` | Distribuzione in una sottodirectory | `/` |
| `VITE_WASM_PYMUPDF_URL` | URL del modulo WASM di PyMuPDF | `https://cdn.jsdelivr.net/npm/@bentopdf/pymupdf-wasm@0.11.16/` |
| `VITE_WASM_GS_URL` | URL del modulo WASM di Ghostscript | `https://cdn.jsdelivr.net/npm/@bentopdf/gs-wasm@0.1.1/assets/` |
| `VITE_WASM_CPDF_URL` | URL del modulo WASM di CoherentPDF | `https://cdn.jsdelivr.net/npm/coherentpdf@2.5.5/dist/` |
| `VITE_TESSERACT_WORKER_URL` | URL dello script worker OCR | _(vuoto; usa la CDN predefinita di Tesseract.js)_ |
| `VITE_TESSERACT_CORE_URL` | Directory del runtime core OCR | _(empty; use Tesseract.js default CDN)_ |
| `VITE_TESSERACT_LANG_URL` | Directory dei traineddata OCR | _(empty; use Tesseract.js default CDN)_ |
| `VITE_TESSERACT_AVAILABLE_LANGUAGES` | Lingue OCR separate da virgole mostrate nell'interfaccia | _(vuoto; mostra il catalogo completo)_ |
| `VITE_OCR_FONT_BASE_URL` | Directory dei font del livello di testo OCR | _(vuoto; usa gli URL remoti dei font Noto)_ |
| `VITE_DEFAULT_LANGUAGE` | Lingua predefinita dell'interfaccia | `en` |
| `VITE_BRAND_NAME` | Nome del marchio personalizzato | `BentoPDF` |
| `VITE_BRAND_LOGO` | Percorso del logo relativo a `public/` | `images/favicon-no-bg.svg` |
| `VITE_FOOTER_TEXT` | Testo personalizzato del footer/copyright | `© 2026 BentoPDF. All rights reserved.` |
| `DISABLE_TOOLS` | ID degli strumenti da nascondere, separati da virgole | _(vuoto; tutti gli strumenti abilitati)_ |
| `DISABLE_GITHUB_STARS` | Salta il recupero del numero di stelle GitHub al caricamento della pagina e rimuove `api.github.com` dalla CSP. Le build in Simple Mode lo saltano sempre. | `false` |
| `SITE_URL` | URL pubblico scritto nei link canonical, hreflang e sitemap. Lascia il valore predefinito, a meno che tu non voglia che i motori di ricerca trattino la tua installazione come un sito a sé. | `https://www.bentopdf.com` |
| `ALLOW_INDEXING` | Con un `SITE_URL` personalizzato, ogni pagina è marcata `noindex` così la tua copia non compete con bentopdf.com nei risultati di ricerca. Imposta `true` per permettere ai motori di ricerca di indicizzarla. | `false` |
Gli URL dei moduli WASM sono preconfigurati con i valori CDN predefiniti: tutte le funzionalità avanzate funzionano subito. Sostituiscili per installazioni air-gapped o self-hosted.
### Motori di ricerca
Per impostazione predefinita, ogni pagina indica ai motori di ricerca bentopdf.com come originale, così la tua installazione non appare come duplicato. Non devi cambiare nulla per un'istanza privata o interna.
- **Tieni la tua istanza fuori dai risultati di ricerca:** esegui il container con `-e ROBOTS_NOINDEX=true`. Basta un riavvio, non serve ricompilare.
- **Rendi la tua istanza un sito a sé nei risultati di ricerca:** compila con `--build-arg SITE_URL=https://your-domain.example --build-arg ALLOW_INDEXING=true`. Senza `ALLOW_INDEXING=true`, un `SITE_URL` personalizzato marca ogni pagina `noindex`.
### Content-Security-Policy
L'immagine nginx include un header `Content-Security-Policy` in modalità enforcing. Le direttive `script-src`, `connect-src` e `font-src` della CSP sono **generate in fase di build** a partire dalle variabili URL `VITE_*` qui sopra: tutti gli host che passi con `--build-arg` vengono aggiunti automaticamente alla policy.
Di conseguenza:
- Se sovrascrivi `VITE_CORS_PROXY_URL` o `VITE_WASM_*_URL` in fase di build, la CSP consente automaticamente quelle origini, senza configurazioni aggiuntive.
- Per gli URL su `cdn.jsdelivr.net`, `script-src` consente solo l'esatta cartella del pacchetto con versione, ad esempio `https://cdn.jsdelivr.net/npm/@bentopdf/pymupdf-wasm@0.11.16/`, non l'intera CDN. jsDelivr serve qualsiasi pacchetto npm pubblico o repository GitHub, quindi consentire l'intero host permetterebbe a ciascuno di essi di essere eseguito sulla tua istanza. Gli URL su qualsiasi altro host sono consentiti per origine.
- Se configuri URL WASM personalizzati in _runtime_ dalla pagina Impostazioni avanzate dell'app, quelle origini **non** sono nella CSP e il browser bloccherà le richieste verso di esse. Vale anche per una versione diversa dello stesso pacchetto su `cdn.jsdelivr.net`, perché è consentita solo la versione impostata in fase di build. La configurazione in runtime serve per sperimentare; per URL personalizzati permanenti imposta il corrispondente build arg `VITE_*`.
- Nelle installazioni air-gapped che sovrascrivono tutti e tre i valori `VITE_WASM_*_URL`, anche le cartelle dei pacchetti su `cdn.jsdelivr.net` vengono rimosse dalla CSP (ogni valore predefinito viene sostituito, non aggiunto). I valori predefiniti di Tesseract OCR su `cdn.jsdelivr.net` restano nella policy finché non imposti anche i tre valori `VITE_TESSERACT_*`. Allo stesso modo, impostare `VITE_CORS_PROXY_URL` sostituisce il valore pubblico predefinito `bentopdf-cors-proxy.bentopdf.workers.dev`.
La CSP include `'unsafe-eval'` in `script-src` perché il runtime LibreOffice WASM (usato dagli strumenti di conversione Word/Excel/PowerPoint) e la libreria di immagini wasm-vips (usata da PDF in TIFF) compilano codice di dispatch interno tramite `new Function()`. Rimuoverlo renderebbe inutilizzabili quegli strumenti. Se compili in `SIMPLE_MODE` (senza LibreOffice) e non ti serve PDF in TIFF, puoi modificare a mano il file generato `security-headers.conf` per eliminare `'unsafe-eval'` e ottenere una policy più restrittiva.
Per l'OCR, lascia vuote le variabili `VITE_TESSERACT_*` per usare le risorse online predefinite, oppure impostale tutte e tre insieme per un OCR self-hosted/offline. Le sostituzioni parziali dell'OCR vengono rifiutate perché worker, runtime core e directory dei traineddata devono corrispondere. Per un output PDF ricercabile completamente offline, imposta anche `VITE_OCR_FONT_BASE_URL` in modo che i font del livello di testo OCR vengano caricati dal tuo server interno invece che dagli URL pubblici dei font Noto.
`VITE_DEFAULT_LANGUAGE` imposta la lingua dell'interfaccia per i nuovi visitatori. Valori supportati: `en`, `ar`, `be`, `fr`, `de`, `es`, `zh`, `zh-TW`, `vi`, `tr`, `id`, `it`, `pt`, `nl`, `da`. Gli utenti possono comunque cambiare lingua: questo modifica solo il valore predefinito.
Esempio:
```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
```
### Marchio personalizzato
Sostituisci il logo, il nome e il testo del footer predefiniti di BentoPDF con i tuoi. Metti il file del logo nella cartella `public/` (o usa un'immagine esistente), poi passa le variabili del marchio in fase di build:
```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 personalizzazione del marchio funziona sia in modalità completa sia in Simple Mode e si può combinare con tutte le altre opzioni di build.
### Disattivare strumenti specifici
Nascondi strumenti dall'interfaccia per esigenze di conformità o sicurezza. Gli strumenti disattivati vengono rimossi dalla homepage, dai risultati di ricerca, dalle scorciatoie da tastiera e dal workflow builder. L'accesso diretto tramite URL mostra una pagina "strumento non disponibile".
Gli ID degli strumenti sono l'URL della pagina senza `.html`. Ad esempio, se lo strumento si trova in `bentopdf.com/edit-pdf.html`, l'ID è `edit-pdf`.
#### Trovare gli ID degli strumenti
Il modo più semplice: apri uno strumento qualsiasi in BentoPDF e guarda l'URL. L'ultima parte del percorso (senza `.html`) è l'ID dello strumento.
<details>
<summary>Elenco completo degli ID degli strumenti</summary>
**Modifica e annota:** `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`
**Converti in 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`
**Converti da 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`
**Organizza e gestisci:** `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`
**Ottimizza e ripara:** `compress-pdf`, `pdf-to-pdfa`, `fix-page-size`, `linearize-pdf`, `remove-restrictions`, `repair-pdf`, `rasterize-pdf`, `deskew-pdf`, `font-to-outline`
**Sicurezza:** `encrypt-pdf`, `sanitize-pdf`, `decrypt-pdf`, `flatten-pdf`, `remove-metadata`, `change-permissions`, `digital-sign-pdf`, `validate-signature-pdf`, `timestamp-pdf`
</details>
#### Opzione 1: in fase di build (build arg di Docker)
```bash
docker build \
--build-arg DISABLE_TOOLS="edit-pdf,sign-pdf,encrypt-pdf" \
-t bentopdf .
```
Questo incorpora l'elenco degli strumenti disattivati nel bundle JavaScript. Per modificarlo serve ricompilare.
#### Opzione 2: in runtime (config.json)
Monta un file `config.json` nella directory servita, senza bisogno di ricompilare:
```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
```
Oppure con 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
```
I due metodi si possono combinare: gli elenchi vengono uniti. Se uno strumento compare in uno dei due, viene disattivato.
#### Disattivare le funzionalità dell'editor
Puoi anche disattivare funzionalità specifiche all'interno dell'editor PDF (ad es. oscuramento, annotazioni, moduli) senza disattivare l'intero strumento. Aggiungi `editorDisabledCategories` al tuo `config.json`:
```json
{
"editorDisabledCategories": ["redaction", "annotation-stamp"]
}
```
<details>
<summary>Elenco completo delle categorie dell'editor</summary>
**Zoom:** `zoom`, `zoom-in`, `zoom-out`, `zoom-fit-page`, `zoom-fit-width`, `zoom-marquee`, `zoom-level`
**Annotazioni:** `annotation`, `annotation-markup`, `annotation-highlight`, `annotation-underline`, `annotation-strikeout`, `annotation-squiggly`, `annotation-ink`, `annotation-text`, `annotation-stamp`
**Forme:** `annotation-shape`, `annotation-rectangle`, `annotation-circle`, `annotation-line`, `annotation-arrow`, `annotation-polygon`, `annotation-polyline`
**Moduli:** `form`, `form-textfield`, `form-checkbox`, `form-radio`, `form-select`, `form-listbox`, `form-fill-mode`
**Oscuramento:** `redaction`, `redaction-area`, `redaction-text`, `redaction-apply`, `redaction-clear`
**Documento:** `document`, `document-open`, `document-close`, `document-print`, `document-capture`, `document-export`, `document-fullscreen`, `document-protect`
**Pagina:** `page`, `spread`, `rotate`, `scroll`, `navigation`
**Pannelli:** `panel`, `panel-sidebar`, `panel-search`, `panel-comment`
**Strumenti:** `tools`, `pan`, `pointer`, `capture`
**Selezione:** `selection`, `selection-copy`
**Cronologia:** `history`, `history-undo`, `history-redo`
</details>
Le categorie sono gerarchiche: disattivando una categoria padre (ad es. `annotation`) si disattivano tutte le sue figlie.
### Disattivare il contatore di stelle GitHub
La barra di navigazione mostra il numero di stelle GitHub in tempo reale, recuperato da `api.github.com` al caricamento della pagina. È l'unica richiesta esterna che non serve a una funzionalità PDF. Disattivalo in fase di build per rimuovere il codice di recupero dal bundle ed eliminare `api.github.com` dalla Content-Security-Policy:
```bash
docker build --build-arg DISABLE_GITHUB_STARS=true -t bentopdf .
```
Le build in Simple Mode (`bentopdf-simple`) saltano sempre il contatore di stelle: questo flag serve solo sulla build commerciale o sulle build complete personalizzate.
### URL WASM personalizzati (air-gapped / self-hosted)
> [!IMPORTANT]
> Gli URL WASM sono incorporati nel JavaScript in **fase di build**. I file WASM vengono scaricati dal **browser dell'utente** in runtime: Docker non li scarica durante la build. Per le reti air-gapped, devi ospitare i file WASM su un server interno raggiungibile dai browser.
**Flusso di lavoro air-gapped completo:**
```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
```
Usa i codici stampati da `bash scripts/prepare-airgap.sh --list-ocr-languages`, oppure cercali per nome con `bash scripts/prepare-airgap.sh --search-ocr-language <term>`, per `--ocr-languages`. Quando compili con un sottoinsieme limitato di lingue OCR, passa gli stessi codici a `VITE_TESSERACT_AVAILABLE_LANGUAGES` in modo che l'app mostri solo le lingue incluse. Per un output OCR completamente offline, ospita anche la cartella inclusa `ocr-fonts/` e punta `VITE_OCR_FONT_BASE_URL` verso di essa.
Imposta una variabile su stringa vuota per disattivare quel modulo (gli utenti dovranno configurarlo manualmente da Impostazioni avanzate).
## Porta personalizzata
Per impostazione predefinita, BentoPDF è in ascolto sulla porta `8080` all'interno del container. Per cambiarla, imposta la variabile d'ambiente `PORT` in runtime:
```bash
docker run -p 3000:9090 -e PORT=9090 ghcr.io/alam00000/bentopdf-simple:latest
```
| Variabile | Descrizione | Predefinito |
| --------- | --------------------------------------- | ----------- |
| `PORT` | Porta di ascolto di Nginx nel container | `8080` |
Funziona sia con il Dockerfile standard sia con quello nonroot.
## ID utente personalizzato (PUID/PGID)
Per gli ambienti che richiedono l'esecuzione come utente non root specifico (dispositivi NAS, Kubernetes con security context, policy organizzative), BentoPDF fornisce un Dockerfile separato con supporto PUID/PGID in stile LSIO.
### Compila ed esegui
```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
```
### Variabili d'ambiente
| Variabile | Descrizione | Predefinito |
| -------------- | -------------------------- | ----------- |
| `PUID` | ID utente con cui eseguire | `1000` |
| `PGID` | ID gruppo con cui eseguire | `1000` |
| `PORT` | Porta di ascolto di Nginx | `8080` |
| `DISABLE_IPV6` | Disattiva il listener 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
```
### Come funziona
Il container si avvia come root, crea un utente con il PUID/PGID specificato, regola la proprietà di tutte le directory scrivibili e poi abbassa i privilegi con `su-exec`. Il processo nginx viene eseguito interamente come l'utente specificato.
> [!NOTE]
> Il `Dockerfile` standard usa `nginx-unprivileged` (UID 101) ed è consigliato per la maggior parte delle installazioni. Usa `Dockerfile.nonroot` solo quando ti serve un UID/GID specifico.
> [!WARNING]
> PUID/PGID non possono essere `0` (root). L'entrypoint convalida i valori e termina con un errore se non sono validi.
## Con 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
```
## Con 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"
}
```
## Limiti di risorse
```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 (integrazione con systemd)
[Quadlet](https://docs.podman.io/en/latest/markdown/podman-systemd.unit.5.html) permette di eseguire i container Podman come servizi systemd. È ideale per le installazioni di produzione su sistemi Linux.
### Configurazione base di Quadlet
Crea un file di unità container in `~/.config/containers/systemd/bentopdf.container` (utente) oppure `/etc/containers/systemd/bentopdf.container` (sistema):
```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
```
### Abilita e avvia
```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]
> Per un'installazione a livello di sistema, usa `systemctl` senza il flag `--user` e metti il file in `/etc/containers/systemd/`.
### Quadlet con health check
```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
```
### Aggiornamento automatico con Quadlet
Podman può aggiornare automaticamente i container quando sono disponibili nuove immagini:
```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
```
### Configurazione di rete di Quadlet
Per una configurazione di rete personalizzata, crea un file di rete `bentopdf.network`:
```ini
[Network]
Subnet=10.89.0.0/24
Gateway=10.89.0.1
```
Poi fai riferimento ad esso nel tuo file container:
```ini
[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
Network=bentopdf.network
```
## Aggiornamento
```bash
# Pull latest image
docker compose pull
# Recreate container
docker compose up -d
```
docs/it/self-hosting/hostinger.md
+266
View File
@@ -0,0 +1,266 @@
# Distribuzione su Hostinger
[Hostinger](https://hostinger.com) è un diffuso provider di hosting condiviso. Questa guida spiega come distribuire BentoPDF sull'hosting condiviso di Hostinger.
## Prerequisiti
- Piano di hosting Hostinger con accesso al file manager
- Node.js installato in locale per la build
## Passaggio 1: compila il progetto
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
```
I file compilati saranno nella cartella `dist`.
## Passaggio 2: carica su Hostinger
### Distribuzione sul dominio principale
1. Accedi al tuo account Hostinger
2. Vai su **File Manager** → **public_html**
3. **Elimina** tutti i file esistenti (fai prima un backup se serve)
4. **Carica** tutto il contenuto della tua cartella locale `dist` in `public_html`
### Distribuzione in una sottodirectory
Se distribuisci in una sottodirectory (es. `yourdomain.com/pdf-tools/`):
1. Compila con l'URL di base corretto:
```bash
BASE_URL=/pdf-tools/ npm run build
```
2. Crea la cartella in Hostinger:
- Vai su **File Manager** → **public_html**
- Crea una nuova cartella: `pdf-tools`
3. Carica tutto il contenuto di `dist` in `public_html/pdf-tools/`
## Passaggio 3: crea il file .htaccess
Crea un file `.htaccess` nella radice della cartella di distribuzione (`public_html` o `public_html/pdf-tools/`):
::: warning Importante
Per la distribuzione in una sottodirectory, cambia `RewriteBase /` in `RewriteBase /pdf-tools/` (o il nome della tua cartella).
:::
```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
```
## Esempio di .htaccess per sottodirectory
Per `yourdomain.com/pdf-tools/`, aggiorna queste righe:
```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
```
## Risoluzione dei problemi
### I file WASM non si caricano
Assicurati che i tipi MIME siano impostati correttamente in `.htaccess`:
```apache
AddType application/wasm .wasm
```
### Gli strumenti LibreOffice non funzionano
Gli header di sicurezza sono fondamentali per SharedArrayBuffer:
```apache
Header always set Cross-Origin-Opener-Policy "same-origin"
Header always set Cross-Origin-Embedder-Policy "require-corp"
```
Se gli header non vengono applicati, contatta il supporto di Hostinger per abilitare `mod_headers`.
### Errori 404 all'aggiornamento della pagina
Verifica che la regola per l'estensione `.html` e le route delle lingue siano configurate correttamente. BentoPDF usa file HTML statici, non il routing 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]
```
### Limiti di caricamento dei file
Hostinger può avere limiti sulla dimensione dei file. Carica i file WASM separatamente se il caricamento in blocco fallisce.
docs/it/self-hosting/index.md
+538
View File
@@ -0,0 +1,538 @@
# Guida all'self-hosting
BentoPDF può essere ospitato sulla tua infrastruttura. Questa guida illustra le varie opzioni di deploy.
## Avvio rapido con Docker / Podman
Il modo più rapido per ospitare BentoPDF:
> [!TIP]
> BentoPDF è disponibile in due build:
>
> - **Build Self-Hosted**: `ghcr.io/alam00000/bentopdf-simple:latest`. Tutti gli strumenti PDF, **senza** gli elementi di marketing (niente hero, FAQ, testimonianze, footer). Usala per deploy interni, di team o di organizzazione. **Non** è una versione "lite" con meno funzionalità.
> - **Build Commercial**: `ghcr.io/alam00000/bentopdf:latest`. Il sito di marketing completo, usato da bentopdf.com stesso e dai titolari di licenza commerciale che gestiscono deploy pubblici.
>
> Nel dubbio: scarica la build Self-Hosted.
> [!IMPORTANT]
> La conversione dei file Office richiede `SharedArrayBuffer`, il che significa che l'app deve essere sia isolata cross-origin sia servita da un contesto sicuro. L'immagine ufficiale invia già gli header COOP/COEP necessari, ma i browser disabilitano comunque `SharedArrayBuffer` sulle origini HTTP semplici della rete locale, come `http://192.168.x.x`.
>
> Usa `http://localhost` solo per test sullo stesso dispositivo. Se gli utenti accedono a BentoPDF tramite un IP o un hostname della LAN, termina la connessione con 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
```
Oppure con 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 (Linux systemd)
Esegui BentoPDF come servizio systemd. Crea `~/.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
```
Consulta la [guida al deploy con Docker](/it/self-hosting/docker) per la documentazione completa di Quadlet.
## Compilazione dal codice sorgente
```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
```
## Opzioni di configurazione
### Build Self-Hosted (Simple Mode)
La build Self-Hosted (l'immagine `bentopdf-simple`, detta anche Simple Mode) è **funzionalmente identica** alla build Commercial: ogni strumento PDF è presente e si comporta allo stesso modo. Nasconde solo gli elementi di marketing che hanno senso soltanto su bentopdf.com o in un deploy commerciale pubblico. **Non è una versione "lite" con meno funzionalità.**
**Cosa nasconde la build Self-Hosted** (solo aspetto estetico, nessuna funzionalità PDF viene rimossa):
- Barra di navigazione, sezione hero, sezione delle funzionalità, FAQ, testimonianze, footer
- Aggiorna il titolo della pagina in "Strumenti PDF"
**Cosa mantiene la build Self-Hosted** (tutto ciò che lavora davvero sui PDF):
- Ogni strumento PDF (unione, divisione, modifica, firma, OCR, conversione Office, ecc.)
- Supporto al branding personalizzato, tutta la configurazione di build e di runtime
La build Commercial (`ghcr.io/alam00000/bentopdf:latest`) è quella che alimenta bentopdf.com stesso ed è usata dai titolari di licenza commerciale che gestiscono deploy pubblici: aggiunge hero, FAQ, testimonianze e footer che non avrebbero senso in uno strumento interno.
Se ospiti BentoPDF per il tuo team, la tua organizzazione o come strumento interno, scarica la build Self-Hosted:
```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
```
Consulta [SIMPLE_MODE.md](https://github.com/alam00000/bentopdf/blob/main/SIMPLE_MODE.md) per tutti i dettagli.
### Build Commercial (deploy pubblici con il tuo brand)
La build Commercial (l'immagine `bentopdf`, senza il suffisso `-simple`) è quella che alimenta bentopdf.com stesso. Include il sito di marketing completo (hero, funzionalità, FAQ, testimonianze, footer) oltre a ogni strumento PDF. Usa questa build quando vuoi **distribuire BentoPDF come servizio PDF pubblico con il tuo brand**, ad esempio:
- Gestisci BentoPDF come SaaS ospitato per gli utenti finali sul tuo dominio
- Vuoi l'esperienza della landing page (sezioni di marketing + strumenti), non solo l'interfaccia essenziale degli strumenti
- Sei un titolare di licenza commerciale e integri BentoPDF in un prodotto commerciale
**Eseguila così com'è** (brand BentoPDF, utile per vedere un'anteprima della build):
```bash
docker run -p 3000:8080 ghcr.io/alam00000/bentopdf:latest
```
**Compila con il tuo brand** (il tipico flusso commerciale):
```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
```
Ogni altra opzione di build (`BASE_URL`, `VITE_DEFAULT_LANGUAGE`, `DISABLE_TOOLS`, override degli URL WASM, ecc.) funziona come nella build Self-Hosted.
::: warning Licenze
L'esecuzione della build Commercial è consentita con una qualsiasi delle due opzioni di licenza di BentoPDF:
- **AGPL-3.0** (gratuita): consentita se il tuo deploy pubblica tutto il proprio codice sorgente sotto AGPL, comprese le modifiche al brand e la logica di business circostante.
- **Licenza commerciale** ($79 a vita): necessaria per deploy proprietari o a codice chiuso in cui non rendi open source il tuo fork di branding o il tuo codice di business.
Consulta la [pagina delle licenze](https://www.bentopdf.com/licensing) per il confronto completo. I moduli WASM con licenza AGPL (PyMuPDF, Ghostscript, CoherentPDF) vengono caricati da una CDN a runtime, quindi non entrano nella tua immagine e non cambiano la tua situazione di licenza.
:::
### Base URL
Deploy in una sottodirectory:
```bash
BASE_URL=/pdf-tools/ npm run build
```
### Branding personalizzato
Sostituisci il logo, il nome e il testo del footer predefiniti di BentoPDF con i tuoi durante la build:
| Variabile | Descrizione | Predefinito |
| ------------------ | ------------------------------------------ | --------------------------------------- |
| `VITE_BRAND_NAME` | Nome del brand mostrato in header e footer | `BentoPDF` |
| `VITE_BRAND_LOGO` | Percorso del logo relativo a `public/` | `images/favicon-no-bg.svg` |
| `VITE_FOOTER_TEXT` | Testo personalizzato del footer/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
```
Oppure tramite 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 .
```
Il branding funziona sia in modalità completa sia in Simple Mode e può essere combinato con tutte le altre opzioni di build (`BASE_URL`, `SIMPLE_MODE`, `VITE_DEFAULT_LANGUAGE`).
### Disabilitare strumenti specifici
Nascondi singoli strumenti per motivi di conformità o sicurezza. Gli strumenti disabilitati vengono rimossi dalla homepage, dalla ricerca, dalle scorciatoie, dal workflow builder e dall'accesso diretto tramite URL.
Gli ID degli strumenti sono l'URL della pagina senza `.html`: apri uno strumento qualsiasi e guarda l'URL (ad es. `edit-pdf`, `sign-pdf`, `encrypt-pdf`).
**In fase di build** (incorporata nel bundle):
```bash
DISABLE_TOOLS="edit-pdf,sign-pdf" npm run build
```
**A runtime** (nessuna ricompilazione necessaria: monta 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
```
I due metodi possono essere combinati: gli elenchi vengono uniti.
Puoi anche disabilitare funzionalità specifiche dell'Editor PDF (ad es. la redazione) senza disabilitare l'intero strumento, aggiungendo `editorDisabledCategories` a `config.json`. Consulta la [guida Docker](/it/self-hosting/docker#disattivare-le-funzionalita-dell-editor) per l'elenco completo delle categorie.
## Guide al deploy
Scegli la tua piattaforma:
- [Vercel](/it/self-hosting/vercel)
- [Netlify](/it/self-hosting/netlify)
- [Cloudflare Pages](/it/self-hosting/cloudflare)
- [AWS S3 + CloudFront](/it/self-hosting/aws)
- [Hostinger](/it/self-hosting/hostinger)
- [Nginx](/it/self-hosting/nginx)
- [Apache](/it/self-hosting/apache)
- [Docker](/it/self-hosting/docker)
- [Kubernetes](/it/self-hosting/kubernetes)
- [CORS Proxy](/it/self-hosting/cors-proxy) - Necessario per le firme digitali
## Problemi comuni
### La conversione da Word / ODT / Excel / PowerPoint a PDF si blocca (SharedArrayBuffer non disponibile)
**Sintomo**: le conversioni di documenti basate su LibreOffice (da Word, ODT, Excel, PowerPoint a PDF) si bloccano intorno al 55% o non partono. La console del browser può mostrare:
> `ReferenceError: SharedArrayBuffer is not defined`
…oppure `window.crossOriginIsolated` restituisce `false`, o la compilazione WASM segnala `expected magic word 00 61 73 6d, found 1f 8b 08 08`.
**Causa**: LibreOffice WASM richiede `SharedArrayBuffer`, che il browser abilita solo quando la pagina è **isolata cross-origin** E servita da un **contesto sicuro**. Ciò significa che devono valere due condizioni:
1. Ogni risposta include entrambi gli header:
- `Cross-Origin-Embedder-Policy: require-corp`
- `Cross-Origin-Opener-Policy: same-origin`
2. La pagina è servita da `https://...` o da `http://localhost`. Un semplice HTTP su un IP della LAN (ad es. `http://192.168.x.x`) NON conta come sicuro: i browser disabilitano lì `SharedArrayBuffer`.
La discrepanza `00 61 73 6d / 1f 8b 08 08` è un sotto-sintomo distinto: ai file precompressi `.wasm.gz` / `.data.gz` manca l'header di risposta `Content-Encoding: gzip`, quindi il browser riceve byte gzip grezzi invece di WASM decompresso.
**Soluzione**: consulta la guida al deploy specifica della tua piattaforma per la configurazione esatta:
- [Nginx →](/it/self-hosting/nginx#conversione-da-word-odt-excel-a-pdf-non-funzionante)
- [Apache →](/it/self-hosting/apache#la-conversione-da-word-odt-excel-a-pdf-non-funziona)
- [AWS S3 + CloudFront →](/it/self-hosting/aws#passaggio-3b-policy-degli-header-di-risposta-necessaria-per-libreoffice-wasm)
- [Cloudflare Pages →](/it/self-hosting/cloudflare#file-di-configurazione) (`_headers` file)
- [Netlify →](/it/self-hosting/netlify#conversione-da-word-odt-excel-a-pdf-bloccata-al-55) (`netlify.toml`)
- [Vercel →](/it/self-hosting/vercel#conversione-da-word-odt-excel-a-pdf-non-funzionante) (`vercel.json`)
- [Hostinger →](/it/self-hosting/hostinger#gli-strumenti-libreoffice-non-funzionano) (`.htaccess`)
- [Kubernetes →](/it/self-hosting/kubernetes#verificare-che-gli-header-sharedarraybuffer-funzionino-ancora-ingress-gateway)
- **Docker**: gestito automaticamente dalla configurazione nginx inclusa, nessuna azione necessaria.
**Verifica**: apri la Console di DevTools su una qualsiasi pagina di BentoPDF ed esegui:
```js
console.log(window.crossOriginIsolated); // should be true
console.log(typeof SharedArrayBuffer); // should be "function"
```
Se la pagina è in HTTPS o su `http://localhost` E entrambi gli header COEP/COOP sono presenti in ogni risposta, entrambi i controlli passano. Se sei su `http://192.168.x.x` o su un'altra origine HTTP non di loopback, termina la connessione con HTTPS: non esiste una soluzione basata solo sugli header.
### File `.mjs` serviti come `application/octet-stream`
**Sintomo**: Firma PDF / Compilazione moduli / alcuni altri strumenti mostrano un visualizzatore vuoto o non si caricano. La console del browser segnala:
> `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.`
**Causa**: il tuo web server o reverse proxy non ha una mappatura del tipo MIME per i file `.mjs` (il visualizzatore PDF incluso distribuisce ES module con quell'estensione). Molte configurazioni di server predefinite usano `application/octet-stream` per le estensioni non riconosciute, e i browser rifiutano di eseguirlo come ES module.
**Soluzione**: consulta la guida al deploy specifica della tua piattaforma per lo snippet esatto:
- [Nginx →](/it/self-hosting/nginx#firma-pdf-o-compilazione-moduli-mostra-un-visualizzatore-vuoto-errore-mime-mjs)
- [Apache →](/it/self-hosting/apache#firma-pdf-o-compilazione-moduli-mostra-un-visualizzatore-vuoto-errore-mime-mjs)
- [AWS S3 + CloudFront →](/it/self-hosting/aws#passaggio-2-compila-e-carica) (vedi `aws s3 cp ... --include "*.mjs"`)
- [Kubernetes →](/it/self-hosting/kubernetes#errori-di-tipo-mime-per-mjs-iframe-di-firma-pdf-compilazione-moduli-vuoto)
- **Docker, Vercel, Netlify, Cloudflare Pages, Hostinger**: gestito automaticamente, nessuna azione necessaria.
**Verifica**: apri DevTools → scheda Network, trova la richiesta `.mjs` che fallisce e controlla l'header di risposta `Content-Type`. Dovrebbe essere `application/javascript`. Se è ancora `application/octet-stream`, un reverse proxy o una CDN esterna potrebbe riconoscere di nuovo il tipo: controlla ogni livello della catena di servizio.
## Configurazione WASM (componenti AGPL)
BentoPDF **non include** nel proprio codice sorgente le librerie di elaborazione con licenza AGPL, ma **preconfigura gli URL della CDN** in modo che tutte le funzionalità funzionino subito, senza alcuna configurazione manuale.
::: tip Zero-config per impostazione predefinita
Dalla v2.0.0, i moduli WASM sono preconfigurati per caricarsi dalla CDN jsDelivr tramite variabili d'ambiente. Tutte le funzionalità avanzate funzionano subito senza alcuna configurazione da parte dell'utente.
:::
| Componente | Licenza | Funzionalità |
| --------------- | -------- | ---------------------------------------------------------------------------- |
| **PyMuPDF** | AGPL-3.0 | Conversione EPUB/MOBI/FB2/XPS, estrazione di immagini, estrazione di tabelle |
| **Ghostscript** | AGPL-3.0 | Conversione PDF/A, compressione, raddrizzamento, rasterizzazione |
| **CoherentPDF** | AGPL-3.0 | Indice, allegati, unione di PDF con segnalibri |
### Variabili d'ambiente predefinite
Sono impostate in `.env.production` e incorporate nella 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=
```
### Sovrascrivere gli URL WASM
Puoi sovrascrivere i valori predefiniti in fase di build per deploy personalizzati:
```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
```
Per disabilitare completamente un modulo (richiedendo la configurazione manuale dell'utente tramite le Impostazioni avanzate), imposta la sua variabile su una stringa vuota.
Per l'OCR, lascia vuote tutte le variabili `VITE_TESSERACT_*` e mantieni gli asset online predefiniti, oppure imposta insieme gli URL di worker/core/lang per un OCR self-hosted/offline. Se includi solo alcune lingue OCR, imposta anche `VITE_TESSERACT_AVAILABLE_LANGUAGES` con gli stessi codici separati da virgola, così l'interfaccia offre solo le lingue installate e le selezioni non supportate falliscono con un errore descrittivo. Per un output PDF ricercabile completamente offline, imposta anche `VITE_OCR_FONT_BASE_URL` sulla directory interna che serve i font OCR inclusi.
Gli utenti possono anche sovrascrivere questi valori predefiniti in qualsiasi momento tramite le **Impostazioni avanzate** nell'interfaccia: le sovrascritture dell'utente salvate nel browser hanno la priorità sui valori predefiniti dell'ambiente.
### Deploy air-gapped / offline
Per le reti senza accesso a internet (enti pubblici, sanità, finanza, ecc.). Gli URL WASM sono incorporati nel JavaScript **in fase di build**, mentre i file WASM veri e propri vengono scaricati dal **browser dell'utente** a runtime. Quindi devi preparare tutto su una macchina con accesso a internet e poi trasferirlo nella rete isolata.
#### Script automatico (consigliato)
Lo script `prepare-airgap.sh` incluso automatizza l'intero processo: scarica i pacchetti WASM, compila l'immagine Docker e produce un bundle autonomo con uno script di setup.
```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
```
Questo produce una directory 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
```
Trasferisci il bundle nella rete air-gapped tramite USB, repository di artefatti interno o altro metodo approvato. Poi esegui lo script di setup incluso:
```bash
cd bentopdf-airgap-bundle
bash setup.sh
```
Lo script di setup carica l'immagine Docker, estrae i file WASM e, facoltativamente, avvia il container.
**Opzioni dello script:**
| Flag | Descrizione | Predefinito |
| ------------------------------ | ------------------------------------------------------- | ------------------------------------ |
| `--wasm-base-url <url>` | Dove verranno ospitati internamente i WASM | _(obbligatorio, richiesto se manca)_ |
| `--image-name <name>` | Tag dell'immagine Docker | `bentopdf` |
| `--output-dir <path>` | Directory di output del bundle | `./bentopdf-airgap-bundle` |
| `--simple-mode` | Abilita Simple Mode | off |
| `--base-url <path>` | Base URL della sottodirectory (ad es. `/pdf/`) | `/` |
| `--language <code>` | Lingua predefinita dell'interfaccia (ad es. `fr`, `de`) | _(nessuno)_ |
| `--brand-name <name>` | Nome del brand personalizzato | _(nessuno)_ |
| `--brand-logo <path>` | Percorso del logo relativo a `public/` | _(nessuno)_ |
| `--footer-text <text>` | Testo personalizzato del piè di pagina | _(nessuno)_ |
| `--ocr-languages <list>` | Lingue OCR da includere, separate da virgola | `eng` |
| `--list-ocr-languages` | Stampa i codici e i nomi OCR supportati, poi esce | off |
| `--search-ocr-language <term>` | Cerca i codici OCR per nome o abbreviazione | off |
| `--dockerfile <path>` | Dockerfile da usare | `Dockerfile` |
| `--skip-docker` | Salta la build e l'esportazione di Docker | off |
| `--skip-wasm` | Salta il download WASM (riusa i file `.tgz` esistenti) | off |
Il prompt interattivo accetta anche `list` per stampare l'elenco completo dei codici Tesseract supportati e `search <term>` per trovare corrispondenze come `search german` o `search chi`.
::: warning Requisito di stessa origine
I file WASM devono essere serviti dalla **stessa origine** dell'app BentoPDF. I Web Worker usano `importScripts()`, che non può caricare script cross-origin. Ad esempio, se BentoPDF gira su `https://internal.example.com`, anche il base URL WASM deve essere `https://internal.example.com/wasm`.
:::
#### Passaggi manuali
<details>
<summary>Se preferisci procedere manualmente senza lo script</summary>
**Passaggio 1: scarica i pacchetti WASM e OCR** (su una macchina con accesso a 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
```
**Passaggio 2: compila l'immagine Docker con gli URL interni**
```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 .
```
**Passaggio 3: esporta l'immagine Docker**
```bash
docker save bentopdf -o bentopdf.tar
```
**Passaggio 4: trasferisci nella rete air-gapped**
Copia tramite USB, repository di artefatti interno o altro metodo di trasferimento approvato:
- `bentopdf.tar`: l'immagine Docker
- I cinque pacchetti `.tgz` WASM/OCR del Passaggio 1
- La directory `tesseract-langdata/` del Passaggio 1
- La directory `ocr-fonts/` del Passaggio 1
**Passaggio 5: configura all'interno della rete air-gapped**
```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
```
Assicurati che i file siano accessibili agli URL configurati nel Passaggio 2, inclusi `.../ocr/worker.min.js`, `.../ocr/core`, `.../ocr/lang-data`, and `.../ocr/fonts`.
</details>
::: info Compili dal sorgente invece di usare Docker?
Imposta le variabili in `.env.production` prima di eseguire `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
```
:::
### Ospitare il tuo proxy WASM
Se devi servire i file WASM AGPL con gli header CORS corretti, puoi distribuire un semplice proxy. Consulta la [guida al proxy WASM di Cloudflare](https://github.com/alam00000/bentopdf/blob/main/cloudflare/WASM-PROXY.md) per un esempio di implementazione.
::: tip Perché separati?
Questa separazione garantisce:
- Chiara conformità legale per gli utenti commerciali
- Il nucleo di BentoPDF resta sotto la sua doppia licenza (AGPL-3.0 / Commercial)
- I file WASM vengono caricati a runtime, non inclusi nel sorgente
:::
## Requisiti di sistema
| Requisito | Minimo |
| --------- | ---------------------------------- |
| Spazio | ~100 MB (nucleo senza moduli AGPL) |
| RAM | 512 MB |
| CPU | Qualsiasi processore moderno |
::: tip
BentoPDF è un sito statico: non servono database né server backend!
:::
docs/it/self-hosting/kubernetes.md
+211
View File
@@ -0,0 +1,211 @@
# Deploy con Kubernetes
Kubernetes può essere eccessivo per un sito statico, ma è un'ottima scelta se usi già Helm + GitOps come standard.
> [!IMPORTANT]
> **Header necessari per la conversione dei file Office**
>
> Gli strumenti basati su LibreOffice (conversione di Word, Excel, PowerPoint) richiedono questi header HTTP per il supporto a `SharedArrayBuffer`:
>
> - `Cross-Origin-Opener-Policy: same-origin`
> - `Cross-Origin-Embedder-Policy: require-corp`
>
> Le immagini nginx ufficiali di BentoPDF includono questi header. In Kubernetes, **anche i controller Ingress/Gateway sono reverse proxy**, quindi assicurati che questi header vengano preservati (oppure aggiungili al livello edge).
## Prerequisiti
- Cluster Kubernetes
- Helm v3
- Un'immagine nginx di BentoPDF (ad es. `ghcr.io/alam00000/bentopdf:<tag>`) che serve sulla **porta 8080**
## Deploy con Helm
### Installazione da questo repository (chart locale)
```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
```
### Installazione da GHCR (chart OCI)
Se il chart è pubblicato su GHCR come artefatto 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
```
## Esporre il servizio
### Port-forward (test rapido)
```bash
kubectl -n bentopdf port-forward deploy/bentopdf 8080:8080
```
### Ingress (facoltativo)
Abilita Ingress (esempio per nginx-ingress):
```yaml
ingress:
enabled: true
className: nginx
hosts:
- host: pdf.example.com
paths:
- path: /
pathType: Prefix
```
### Gateway API (facoltativo)
Questo chart supporta `Gateway` + `HTTPRoute` della Gateway API.
Esempio (operatore Gateway API di 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
```
## Verificare che gli header SharedArrayBuffer funzionino ancora (Ingress/Gateway)
### Cosa "dovrebbe" succedere
La configurazione nginx di BentoPDF imposta gli header di risposta necessari. La maggior parte dei controller Ingress/Gateway **inoltra invariati gli header di risposta dell'upstream**.
### Cosa può romperlo
- Una policy del controller o dell'edge che **sovrascrive** o **rimuove** gli header di risposta
- Un middleware di "security headers" che imposta valori COOP/COEP diversi
### Come verificare
Esegui questo comando sul tuo endpoint pubblico:
```bash
curl -I https://pdf.example.com/ | egrep -i 'cross-origin-opener-policy|cross-origin-embedder-policy'
```
Dovresti vedere:
- `Cross-Origin-Opener-Policy: same-origin`
- `Cross-Origin-Embedder-Policy: require-corp`
### Se il tuo controller Ingress non li preserva
Aggiungi gli header al livello edge (dipende dal controller). Esempio per **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;
```
## Errori di tipo MIME per `.mjs` (iframe di Firma PDF / Compilazione moduli vuoto)
Se la console del browser mostra `Failed to load module script: ... non-JavaScript MIME type "application/octet-stream"` su una richiesta `.mjs`, un controller Ingress/Gateway davanti all'nginx di BentoPDF sta sostituendo l'header `Content-Type` dell'upstream con `application/octet-stream`.
L'nginx dell'immagine di BentoPDF serve già i file `.mjs` come `application/javascript`. La soluzione è impedire al controller di rimuoverlo o sostituirlo. Per nginx-ingress:
```yaml
ingress:
annotations:
nginx.ingress.kubernetes.io/configuration-snippet: |
location ~* \.mjs$ {
types {} default_type application/javascript;
}
```
Oppure usa un filtro `ResponseHeaderModifier` nella Gateway API per impostare `Content-Type: application/javascript` sui percorsi `.mjs`. Verifica con DevTools → scheda Network: la richiesta `.mjs` che falliva dovrebbe ora mostrare `content-type: application/javascript`.
### Se usi la Gateway API e vuoi aggiungere gli header in modo forzato
La Gateway API supporta un filtro `ResponseHeaderModifier`. Puoi associarlo in `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
```
Il supporto per filtri specifici dipende dal tuo controller Gateway; se un filtro viene ignorato, aggiungi gli header al livello edge/controller.
## Disabilitare strumenti specifici
Usa una ConfigMap per disabilitare gli strumenti a runtime senza ricostruire l'immagine:
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: bentopdf-config
namespace: bentopdf
data:
config.json: |
{
"disabledTools": ["edit-pdf", "sign-pdf", "encrypt-pdf"]
}
```
Montala nella directory servita:
```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
```
Gli ID degli strumenti sono l'URL della pagina senza `.html`: apri uno strumento qualsiasi e guarda l'URL (ad es. `edit-pdf`, `merge-pdf`, `compress-pdf`). Gli strumenti disabilitati sono nascosti dalla homepage, dalla ricerca, dalle scorciatoie, dal workflow builder e dall'accesso diretto tramite URL. Consulta la [guida Docker](/it/self-hosting/docker#disattivare-strumenti-specifici) per l'elenco completo delle opzioni.
docs/it/self-hosting/netlify.md
+139
View File
@@ -0,0 +1,139 @@
# Deploy su Netlify
[Netlify](https://netlify.com) offre un ottimo hosting per siti statici con un generoso piano gratuito.
## Deploy con 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)
## Deploy manuale
### Passaggio 1: collega il repository
1. Accedi a [Netlify](https://app.netlify.com)
2. Fai clic su "Add new site" → "Import an existing project"
3. Collega il tuo account GitHub
4. Seleziona il tuo fork di BentoPDF
### Passaggio 2: configura le impostazioni di build
| Impostazione | Valore |
| -------------------------- | --------------- |
| Comando di build | `npm run build` |
| Directory di pubblicazione | `dist` |
| Versione di Node | 18+ |
### Passaggio 3: esegui il deploy
Fai clic su "Deploy site" e attendi il completamento della build.
## File di configurazione
Crea `netlify.toml` nella radice del tuo progetto:
```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 Importante
Gli header `Cross-Origin-Embedder-Policy` e `Cross-Origin-Opener-Policy` sono necessari per le conversioni da Word/ODT/Excel/PowerPoint a PDF. Senza di essi, `SharedArrayBuffer` non è disponibile e il motore WASM di LibreOffice non riesce a inizializzarsi.
Gli header `Content-Encoding: gzip` sui file `.wasm.gz` e `.data.gz` indicano al browser di decomprimerli automaticamente. Senza di essi, il browser riceve byte gzip grezzi e la compilazione WASM fallisce.
:::
## Variabili d'ambiente
Impostale in Site settings → Environment variables:
| Variabile | Descrizione |
| ----------------------- | -------------------------------------------------------------------- |
| `SIMPLE_MODE` | Imposta su `true` per una build minimale |
| `VITE_BRAND_NAME` | Nome del brand personalizzato (sostituisce "BentoPDF") |
| `VITE_BRAND_LOGO` | Percorso del logo relativo a `public/` (ad es. `images/my-logo.svg`) |
| `VITE_FOOTER_TEXT` | Testo personalizzato del footer/copyright |
| `VITE_DEFAULT_LANGUAGE` | Lingua predefinita dell'interfaccia (ad es. `fr`, `de`, `es`) |
## Dominio personalizzato
1. Vai su Site settings → Domain management
2. Fai clic su "Add custom domain"
3. Segui le istruzioni per la configurazione DNS
## Large Media
Per i file WASM di grandi dimensioni, valuta di abilitare [Netlify Large Media](https://docs.netlify.com/large-media/overview/):
```bash
netlify lm:setup
git lfs track "*.wasm"
```
## Risoluzione dei problemi
### Conversione da Word/ODT/Excel a PDF bloccata al 55%
Se le conversioni dei documenti si bloccano al 55%, apri la Console di DevTools e controlla:
```js
console.log(window.crossOriginIsolated); // should be true
console.log(typeof SharedArrayBuffer); // should be "function"
```
Se `crossOriginIsolated` è `false`, gli header COEP/COOP del tuo `netlify.toml` non vengono applicati. Assicurati che il file sia nella radice del progetto e ripeti il deploy.
Se nella console vedi `expected magic word 00 61 73 6d, found 1f 8b 08 08`, ai file `.wasm.gz` mancano gli header `Content-Encoding: gzip`. Assicurati che i blocchi `[[headers]]` per `soffice.wasm.gz` e `soffice.data.gz` siano presenti nel tuo `netlify.toml`.
### La build fallisce
Controlla la compatibilità della versione di Node:
```toml
[build.environment]
NODE_VERSION = "20"
```
### Caricamento iniziale lento
Abilita l'ottimizzazione degli asset in Site settings → Build & deploy → Asset optimization.
docs/it/self-hosting/nginx.md
+232
View File
@@ -0,0 +1,232 @@
# Deploy con Nginx
Ospita BentoPDF sul tuo server usando Nginx.
## Prerequisiti
- Server Ubuntu/Debian
- Nginx installato
- Certificato SSL (consigliato: Let's Encrypt)
## Passaggio 1: compila il progetto
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
```
Per personalizzare il brand, imposta le variabili d'ambiente prima della build:
```bash
VITE_BRAND_NAME="AcmePDF" VITE_BRAND_LOGO="images/acme-logo.svg" npm run build
```
## Passaggio 2: copia i file
```bash
sudo mkdir -p /var/www/bentopdf
sudo cp -r dist/* /var/www/bentopdf/
sudo chown -R www-data:www-data /var/www/bentopdf
```
## Passaggio 3: configurazione di Nginx
Crea `/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;
}
}
```
## Passaggio 4: abilita il sito
```bash
sudo ln -s /etc/nginx/sites-available/bentopdf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```
## Passaggio 5: SSL con Let's Encrypt
```bash
sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d your-domain.com
```
## Deploy in una sottodirectory
Per ospitarlo su `/pdf/`:
```nginx
location /pdf/ {
alias /var/www/bentopdf/;
try_files $uri $uri/ /pdf/index.html;
}
```
Compila con:
```bash
BASE_URL=/pdf/ npm run build
```
## Ottimizzazione delle prestazioni
Aggiungi a `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;
}
```
## Risoluzione dei problemi
### WASM non si carica
Assicurati che il tipo MIME sia impostato:
```nginx
types {
application/wasm wasm;
}
```
### Firma PDF o Compilazione moduli mostra un visualizzatore vuoto (errore MIME `.mjs`)
Se la console del browser mostra:
```
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.
```
…e la richiesta che fallisce termina con `.mjs`, al tuo nginx manca la mappatura `.mjs → application/javascript`. Il visualizzatore PDF incluso (usato da Firma PDF, Compilazione moduli e altri strumenti) distribuisce file ES module con estensione `.mjs`, e il `mime.types` predefinito di nginx non li include.
Risolvi aggiungendo `mjs` alla riga `application/javascript` esistente in `/etc/nginx/mime.types`:
```nginx
application/javascript js mjs;
```
> NON aggiungere una _seconda_ riga `application/javascript`: nginx legge `mime.types` riga per riga e vince una sola mappatura tipo-estensione, quindi una seconda riga viene ignorata in silenzio su alcune versioni. Modifica la riga esistente aggiungendo `mjs` accanto a `js`.
Oppure sovrascrivi localmente nel tuo blocco server (senza modificare il file globale):
```nginx
types {
application/javascript js mjs;
application/wasm wasm;
}
```
Ricarica nginx dopo la modifica:
```bash
sudo nginx -t && sudo systemctl reload nginx
```
Per confermare: in DevTools del browser → scheda Network, trova la richiesta `.mjs` che falliva e controlla l'header di risposta `Content-Type`. Ora dovrebbe essere `application/javascript`, non `application/octet-stream`.
### Conversione da Word/ODT/Excel a PDF non funzionante
LibreOffice WASM richiede `SharedArrayBuffer`, che necessita degli header `Cross-Origin-Embedder-Policy` e `Cross-Origin-Opener-Policy`. Serve anche un contesto sicuro: `http://localhost` funziona per i test in locale, ma `http://192.168.x.x` o altri IP della LAN di solito richiedono HTTPS. Nota che le direttive `add_header` di nginx in un blocco `location` **sovrascrivono** quelle a livello di server, non si uniscono. Ogni blocco `location` con il proprio `add_header` deve includere gli header COEP/COOP.
Verifica con:
```bash
curl -I https://your-domain.com/ | grep -i cross-origin
```
Se usi un reverse proxy davanti a nginx, assicurati che preservi questi header.
### 502 Bad Gateway
Controlla i log degli errori di Nginx:
```bash
sudo tail -f /var/log/nginx/error.log
```
docs/it/self-hosting/vercel.md
+122
View File
@@ -0,0 +1,122 @@
# Deploy su Vercel
[Vercel](https://vercel.com) offre l'esperienza di deploy più semplice per i siti statici.
## Deploy con un clic
[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https://github.com/alam00000/bentopdf)
## Deploy manuale
### Passaggio 1: fai il fork del repository
Fai il fork di [bentopdf/bentopdf](https://github.com/alam00000/bentopdf) sul tuo account GitHub.
### Passaggio 2: importa su Vercel
1. Vai su [vercel.com/new](https://vercel.com/new)
2. Seleziona il tuo repository forkato
3. Configura il progetto:
| Impostazione | Valore |
| ---------------- | --------------- |
| Framework Preset | Vite |
| Build Command | `npm run build` |
| Output Directory | `dist` |
| Install Command | `npm install` |
### Passaggio 3: variabili d'ambiente (facoltativo)
Aggiungile se necessario:
| Variabile | Descrizione |
| ----------------------- | -------------------------------------------------------------------- |
| `SIMPLE_MODE` | Imposta su `true` per un'interfaccia minimale |
| `VITE_BRAND_NAME` | Nome del brand personalizzato (sostituisce "BentoPDF") |
| `VITE_BRAND_LOGO` | Percorso del logo relativo a `public/` (ad es. `images/my-logo.svg`) |
| `VITE_FOOTER_TEXT` | Testo personalizzato del footer/copyright |
| `VITE_DEFAULT_LANGUAGE` | Lingua predefinita dell'interfaccia (ad es. `fr`, `de`, `es`) |
### Passaggio 4: esegui il deploy
Fai clic su "Deploy" e attendi il completamento della build.
## Dominio personalizzato
1. Vai alle impostazioni del progetto
2. Apri "Domains"
3. Aggiungi il tuo dominio personalizzato
4. Configura il DNS come indicato
## Limitazioni
::: warning File di grandi dimensioni
Le funzioni serverless di Vercel hanno un limite di 50MB. Poiché BentoPDF è un sito statico, questo non dovrebbe riguardarti, ma i moduli WASM sono grandi (~100MB in totale). Assicurati che vengano serviti dalla cartella `/public`.
:::
## Risoluzione dei problemi
### Timeout della build
Se le build vanno in timeout, prova:
```json
// vercel.json
{
"buildCommand": "npm run build",
"outputDirectory": "dist"
}
```
### 404 al ricaricamento
Aggiungi un `vercel.json` per il routing SPA:
```json
{
"rewrites": [{ "source": "/(.*)", "destination": "/index.html" }]
}
```
### Conversione da Word/ODT/Excel a PDF non funzionante
Le conversioni WASM di LibreOffice richiedono `SharedArrayBuffer`, che necessita di questi header di risposta su tutte le pagine:
- `Cross-Origin-Embedder-Policy: require-corp`
- `Cross-Origin-Opener-Policy: same-origin`
Anche i file precompressi `.wasm.gz` e `.data.gz` richiedono `Content-Encoding: gzip`, così il browser li decomprime.
Aggiungili al tuo `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" }
]
}
]
}
```
Per verificare, apri la Console di DevTools ed esegui `console.log(window.crossOriginIsolated)`: dovrebbe restituire `true`.
docs/it/tools/add-attachments.md
+49
View File
@@ -0,0 +1,49 @@
---
title: Aggiungi allegati
description: Incorpora file di qualsiasi tipo in un PDF a livello di documento o allegati a pagine specifiche.
---
# Aggiungi allegati
Incorpora uno o più file direttamente all'interno di un documento PDF. Gli allegati possono essere aggiunti a livello di documento (visibili nel pannello degli allegati di qualsiasi lettore PDF) oppure associati a pagine specifiche.
## Come funziona
1. Carica il PDF a cui vuoi allegare i file.
2. Usa l'area di rilascio degli allegati per selezionare i file da incorporare (di qualsiasi tipo).
3. Scegli il livello dell'allegato: **Documento** (predefinito) o **Pagina**.
4. Se scegli il livello Pagina, inserisci un intervallo di pagine (ad es. `1-3` o `5`).
5. Fai clic sul pulsante di elaborazione. Il PDF modificato viene scaricato con i tuoi file incorporati.
## Funzionalità
- Allega qualsiasi tipo di file: immagini, fogli di calcolo, archivi, eseguibili, qualunque cosa
- Posizionamento dell'allegato a livello di documento o di pagina
- È possibile allegare più file in una sola operazione
- Mostra nomi e dimensioni di tutti gli allegati selezionati
- L'output conserva il contenuto originale del PDF con l'aggiunta dei file incorporati
## Opzioni
| Opzione | Descrizione |
| --------------------- | ----------------------------------------------------------------------------- |
| **Livello documento** | Allega i file al PDF nel suo insieme, accessibili dal pannello degli allegati |
| **Livello pagina** | Allega i file a pagine specifiche, indicate tramite un intervallo di pagine |
## Casi d'uso
- Unire i dati di origine (file Excel, CSV) a un report in PDF
- Allegare i file immagine originali al PDF del portfolio di un fotografo
- Incorporare documenti di supporto in un contratto o in una proposta
- Aggiungere materiali integrativi a pagine specifiche di un manuale di formazione
## Suggerimenti
- Gli allegati a livello di documento sono i più supportati dai lettori PDF. Gli allegati a livello di pagina potrebbero non essere visibili in tutti i visualizzatori.
- Non c'è un limite alla dimensione degli allegati, ma file incorporati molto grandi aumenteranno proporzionalmente le dimensioni del PDF.
## Strumenti correlati
- [Estrai Allegati](./extract-attachments)
- [Modifica Allegati](./edit-attachments)
- [Unisci PDF](./merge-pdf)
docs/it/tools/add-blank-page.md
+40
View File
@@ -0,0 +1,40 @@
---
title: Aggiungi pagina vuota
description: Inserisci una o più pagine vuote in qualsiasi posizione di un documento PDF.
---
# Aggiungi pagina vuota
Inserisci pagine vuote in un PDF nella posizione che indichi. Decidi tu dove vanno le pagine vuote e quante aggiungerne.
## Come funziona
1. Carica un file PDF. Lo strumento mostra il numero di pagine.
2. Inserisci la **posizione** in cui inserire le pagine vuote. Usa `0` per inserirle all'inizio, oppure il numero totale di pagine per aggiungerle alla fine.
3. Inserisci il **numero** di pagine vuote da aggiungere (il valore predefinito è 1).
4. Fai clic sul pulsante di elaborazione. Il PDF modificato viene scaricato con le pagine vuote inserite.
## Funzionalità
- Inserimento in qualsiasi posizione: all'inizio, nel mezzo o alla fine del documento
- Aggiunta di più pagine vuote in una sola operazione
- Il suggerimento sulla posizione si aggiorna dinamicamente in base al numero di pagine del PDF caricato
- Pagine vuote in formato A4 standard
## Casi d'uso
- Aggiungere una pagina vuota di separazione tra le sezioni di un documento composito
- Inserire pagine vuote per allineare la stampa fronte/retro
- Lasciare spazio per appunti scritti a mano in una guida allo studio stampata
- Riempire un documento per raggiungere un numero minimo di pagine
## Suggerimenti
- La posizione `0` inserisce prima della prima pagina. Una posizione pari al numero totale di pagine aggiunge dopo l'ultima pagina.
- Se devi inserire contenuto (non solo pagine vuote) in una posizione specifica, usa [Strumento PDF multifunzione](./pdf-multi-tool) per inserire un altro PDF dopo una determinata pagina.
## Strumenti correlati
- [Duplica e Organizza](./organize-pdf)
- [Strumento PDF multifunzione](./pdf-multi-tool)
- [Unisci PDF](./merge-pdf)
docs/it/tools/add-page-labels.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Aggiungi etichette di pagina
description: Aggiungi etichette di pagina PDF con numeri romani, prefissi alfabetici, numerazione personalizzata e più regole per documento.
---
# Aggiungi etichette di pagina
Le etichette di pagina controllano come vengono mostrati i numeri di pagina nei visualizzatori PDF (il numero nella barra degli strumenti, non quello stampato sulla pagina). Questo strumento ti permette di assegnare schemi di etichettatura diversi a intervalli di pagine diversi: numeri romani per le pagine iniziali, numeri decimali per il corpo del testo, appendici con lettere e altro ancora.
## Come funziona
1. Carica il tuo file PDF.
2. Compare il pannello delle opzioni con una regola di etichetta predefinita.
3. Configura ogni regola con un intervallo di pagine, uno stile, un prefisso facoltativo e un valore iniziale.
4. Fai clic su **Aggiungi regola** per creare regole aggiuntive per sezioni diverse.
5. Fai clic su **Aggiungi Etichette di Pagina** per applicare tutte le regole e scaricare il risultato.
## Opzioni
Ogni regola di etichetta ha queste impostazioni:
- **Intervallo di pagine**: le pagine a cui si applica la regola. Lascia vuoto per tutte le pagine. Supporta intervalli come `1-4`, `7`, `odd` o `1-9,30-40`.
- **Stile etichetta**: Arabo decimale, Romano minuscolo (i, ii, iii), Romano maiuscolo (I, II, III), Lettere minuscole (a, b, c), Lettere maiuscole (A, B, C) o Nessuna etichetta (solo prefisso).
- **Prefisso etichetta**: testo facoltativo anteposto a ogni etichetta, ad esempio "A-" per creare etichette come A-1, A-2, A-3.
- **Valore iniziale**: il numero da cui iniziare il conteggio. Il valore predefinito è 1. Imposta 0 per una numerazione che parte da zero.
- **Continua la numerazione tra intervalli non contigui**: attivalo quando una regola riguarda pagine non contigue (come `1-9,30-40` o `odd`) e vuoi che la numerazione prosegua in sequenza.
- **Rimuovi le etichette di pagina esistenti**: selezionato per impostazione predefinita. Cancella le etichette precedenti prima di applicare le nuove regole.
## Funzionalità
- Più regole di etichetta per documento, per schemi di numerazione complessi
- Sei stili di etichetta che coprono tutti i sistemi di numerazione standard
- Supporto di prefissi personalizzati per l'etichettatura per sezioni
- Supporto di intervalli non contigui con numerazione progressiva
- Possibilità di mantenere o rimuovere le etichette esistenti
## Casi d'uso
- Impostare etichette con numeri romani (i, ii, iii) per la prefazione di un libro e numeri decimali per il testo principale
- Etichettare le pagine delle appendici con prefissi alfabetici come "A-1", "A-2", "B-1", "B-2"
- Correggere le etichette di pagina in un documento scansionato in cui i numeri di pagina fisici non corrispondono all'ordine delle pagine del PDF
- Aggiungere una numerazione che parte da zero per documenti tecnici
## Suggerimenti
- Le etichette di pagina sono metadati che i visualizzatori PDF mostrano nella barra di navigazione. Non vengono stampate sulla pagina. Per numeri visibili, usa [Numeri di Pagina](./page-numbers).
- Questo strumento richiede che CoherentPDF (CPDF) sia configurato nelle tue Impostazioni WASM. Se non è configurato, ti verrà chiesto di farlo.
## Strumenti correlati
- [Numeri di Pagina](./page-numbers)
- [Numerazione Bates](./bates-numbering)
- [Modifica Segnalibri](./bookmark)
docs/it/tools/add-stamps.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Aggiungi timbri
description: Aggiungi timbri immagine alle pagine del tuo PDF con una barra degli strumenti di annotazione integrata e attribuzione con nome utente.
---
# Aggiungi timbri
Applica timbri immagine alle pagine del tuo PDF usando un visualizzatore integrato con una barra degli strumenti di annotazione per timbri. I timbri possono includere il tuo nome come attribuzione, il che è utile per flussi di approvazione, processi di revisione e contrassegno dei documenti.
## Come funziona
1. Inserisci il tuo nome nel campo **Nome utente del timbro**. Questo nome comparirà sui timbri che crei.
2. Carica il tuo file PDF facendo clic o trascinandolo nell'area di rilascio.
3. L'editor dei timbri si apre con il tuo documento caricato in un visualizzatore.
4. Usa lo strumento timbro immagine della barra degli strumenti per selezionare e posizionare i timbri su qualsiasi pagina.
5. Posiziona e ridimensiona i timbri come necessario.
6. Fai clic su **Salva PDF con timbri** per scaricare il risultato.
## Funzionalità
- Visualizzatore PDF integrato con una barra degli strumenti di annotazione specifica per i timbri
- Attribuzione con nome utente sui timbri creati
- Posizionamento di timbri immagine su qualsiasi pagina
- Posizionamento e ridimensionamento con trascinamento
- Dimensionamento automatico del visualizzatore in base alle proporzioni della pagina
- Visualizzazione del file con nome e dimensioni
## Casi d'uso
- Aggiungere timbri immagine "APPROVATO" o "REVISIONATO" ai documenti in un flusso di revisione
- Applicare immagini di sigilli aziendali o timbri notarili su documenti ufficiali
- Contrassegnare le pagine con timbri "RICEVUTO" che includono il nome del revisore
- Aggiungere timbri di controllo qualità ai rapporti di ispezione
## Suggerimenti
- Imposta il nome utente del timbro prima di caricare il PDF. Il nome utente viene incorporato nei metadati del timbro.
- Il visualizzatore adatta la propria altezza alle proporzioni della prima pagina del PDF per una visualizzazione ottimale.
- Per filigrane testuali invece di timbri immagine, usa lo strumento [Aggiungi Filigrana](./add-watermark).
## Strumenti correlati
- [Firma PDF](./sign-pdf)
- [Aggiungi Filigrana](./add-watermark)
- [Editor PDF](./edit-pdf)
docs/it/tools/add-watermark.md
+79
View File
@@ -0,0 +1,79 @@
---
title: Aggiungi filigrana
description: Applica filigrane di testo o immagine alle pagine PDF con un editor visivo a trascinamento e anteprima in tempo reale.
---
# Aggiungi filigrana
Aggiungi filigrane di testo o immagine alle pagine del tuo PDF usando un editor visivo. Puoi posizionare la filigrana trascinandola direttamente sull'anteprima, ridimensionarla con le maniglie agli angoli e configurare opacità, rotazione, font e colore. Ogni pagina può avere la propria posizione della filigrana, oppure puoi applicare la stessa filigrana a tutte le pagine in una volta.
## Come funziona
1. Carica il tuo file PDF.
2. L'editor si apre con un'anteprima in tempo reale della prima pagina e una filigrana sovrapposta trascinabile.
3. Scegli tra la modalità filigrana **Testo** o **Immagine** con i pulsanti di selezione.
4. Configura le impostazioni della filigrana nel pannello laterale.
5. Trascina la filigrana sull'anteprima per posizionarla esattamente dove vuoi. Usa le maniglie agli angoli per ridimensionarla.
6. Passa da una pagina all'altra per impostare filigrane per singola pagina, oppure lascia selezionato **Applica a tutte le pagine**.
7. Fai clic su **Aggiungi Filigrana** per elaborare e scaricare.
## Opzioni
**Impostazioni della filigrana di testo:**
- **Testo**: il testo della filigrana (ad es. "RISERVATO", "BOZZA").
- **Dimensione del font**: da 10 a 200 punti. Il valore predefinito è 72.
- **Colore**: qualsiasi colore tramite il selettore di colori.
- **Opacità**: controlla la trasparenza da completamente trasparente a completamente opaco.
- **Rotazione**: ruota il testo della filigrana da -180 a 180 gradi.
**Impostazioni della filigrana immagine:**
- **Caricamento immagine**: carica un file PNG, JPG o altra immagine da usare come filigrana.
- **Opacità**: controlla la trasparenza dell'immagine.
- **Scala**: ridimensiona la filigrana immagine.
**Impostazioni di layout:**
- **Singola**: una filigrana per pagina, posizionata trascinandola o con i preset di posizione.
- **A mosaico**: ripete la filigrana su tutta la pagina in una griglia diagonale che segue l'angolo di rotazione, in modo che il segno copra il documento da un bordo all'altro.
- **Spaziatura orizzontale**: spazio tra le tessere lungo la direzione del testo, come percentuale della larghezza della filigrana (solo in modalità a mosaico).
- **Spaziatura verticale**: spazio tra le righe di tessere, come percentuale dell'altezza della filigrana (solo in modalità a mosaico).
**Impostazioni generali:**
- **Applica a tutte le pagine**: quando è selezionato, la stessa filigrana viene applicata a ogni pagina. Deseleziona per impostare filigrane individuali per pagina.
- **Intervallo di pagine**: indica quali pagine ricevono la filigrana (ad es. "1-3, 5, 7-9" oppure "all").
## Funzionalità
- Posizionamento visivo tramite trascinamento su un'anteprima PDF in tempo reale
- Filigrana ridimensionabile con maniglie agli angoli
- Modalità filigrana di testo e di immagine
- Layout singolo o a mosaico (ripetuto) su tutta la pagina con spaziatura regolabile
- Applicazione della filigrana per singola pagina o globale
- Navigazione pagina per pagina nell'anteprima
- Controlli di opacità e rotazione
- Filtro per intervallo di pagine
## Casi d'uso
- Contrassegnare i documenti in bozza con "BOZZA" prima di farli circolare per la revisione
- Aggiungere filigrane "RISERVATO" a report finanziari sensibili
- Personalizzare i documenti con una filigrana immagine del logo aziendale
- Applicare "CAMPIONE" alla documentazione di prodotto condivisa con potenziali clienti
- Aggiungere avvisi di copyright ai materiali PDF distribuiti
## Suggerimenti
- Per filigrane diagonali sulla pagina, imposta una rotazione di circa 45 gradi e aumenta la dimensione del font.
- La modalità a mosaico rende il documento molto più difficile da riutilizzare dopo un ritaglio, perché rimuovere un segno ne lascia comunque dozzine. Riduci l'opacità quando usi il mosaico, così il testo sottostante resta leggibile.
- Le filigrane immagine con sfondo trasparente (formato PNG) si fondono più naturalmente con il contenuto del documento.
- Se ti servono testi di filigrana diversi su pagine diverse, deseleziona "Applica a tutte le pagine" e passa da una pagina all'altra.
## Strumenti correlati
- [Intestazione e Piè di Pagina](./header-footer)
- [Aggiungi Timbri](./add-stamps)
- [Numerazione Bates](./bates-numbering)
- [Firma PDF](./sign-pdf)
docs/it/tools/adjust-colors.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Regola colori
description: Regola con precisione luminosità, contrasto, saturazione, tonalità, temperatura, tinta, gamma e seppia nel tuo PDF.
---
# Regola colori
Un set completo di strumenti di color grading per i PDF. Regola otto parametri indipendenti (luminosità, contrasto, saturazione, variazione di tonalità, temperatura, tinta, gamma e seppia) con un'anteprima in tempo reale che si aggiorna mentre muovi ogni cursore.
## Come funziona
1. Carica il tuo file PDF.
2. L'editor si apre mostrando un'anteprima della prima pagina e un pannello delle impostazioni colore.
3. Muovi i cursori per regolare ogni parametro colore. L'anteprima si aggiorna in tempo reale.
4. Fai clic su **Reimposta** per riportare tutti i cursori alle posizioni predefinite.
5. Fai clic su **Applica** per elaborare tutte le pagine e scaricare il PDF regolato.
## Opzioni
- **Luminosità**: schiarisce o scurisce l'intera pagina (da -100 a +100).
- **Contrasto**: aumenta o riduce la differenza tra le aree chiare e scure (da -100 a +100).
- **Saturazione**: aumenta o riduce l'intensità dei colori (da -100 a +100). Impostando -100 si ottiene un risultato in scala di grigi.
- **Variazione di tonalità**: ruota la ruota dei colori per spostare uniformemente tutti i colori.
- **Temperatura**: sposta i colori verso toni più caldi (giallo/arancione) o più freddi (blu).
- **Tinta**: aggiunge una dominante verde o magenta.
- **Gamma**: regola la luminosità dei mezzitoni con una curva gamma. Valori inferiori a 1.0 scuriscono i mezzitoni, valori superiori a 1.0 li schiariscono.
- **Seppia**: applica il classico effetto seppia. Valori più alti producono una tinta marrone più intensa.
## Funzionalità
- Otto parametri colore regolabili in modo indipendente
- Anteprima in tempo reale che risponde subito alle modifiche dei cursori
- Pulsante di reimpostazione per tornare rapidamente ai valori predefiniti
- Elabora tutte le pagine del documento
- Funziona con qualsiasi contenuto PDF (testo, immagini, grafica)
## Casi d'uso
- Schiarire una scansione scura o correggere pagine sovraesposte
- Desaturare un documento colorato per ridurre il consumo di inchiostro prima della stampa
- Applicare un tono seppia per dare un aspetto antico a certificati o riconoscimenti
- Correggere la temperatura colore di foto incorporate in un PDF
- Aumentare il contrasto di documenti scansionati sbiaditi o di bassa qualità
## Suggerimenti
- Per una rapida conversione in scala di grigi, trascina il cursore della saturazione fino a -100.
- Il cursore gamma è particolarmente utile per migliorare la leggibilità dei documenti scansionati in cui i mezzitoni sono troppo scuri o troppo chiari.
- Come gli altri strumenti di effetti immagine, questo rasterizza ogni pagina. L'output sarà basato su immagini, quindi il testo non sarà selezionabile.
## Strumenti correlati
- [Inverti Colori](./invert-colors)
- [Effetto scanner](./scanner-effect)
- [Colore di Sfondo](./background-color)
docs/it/tools/alternate-merge.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Alterna e mescola pagine
description: Unisci i PDF alternando le pagine di ciascun file, con conservazione dei segnalibri.
---
# Alterna e mescola pagine
Alterna le pagine di più file PDF in modo che si susseguano tra un documento e l'altro. È lo strumento giusto quando un'unione standard accoderebbe semplicemente i file uno dopo l'altro, ma a te serve la pagina 1 del File A, poi la pagina 1 del File B, poi la pagina 2 del File A, e così via.
## Come funziona
1. Carica almeno due file PDF usando l'area di rilascio.
2. Lo strumento mostra ogni file con il numero di pagine e la dimensione.
3. Trascina le maniglie per riordinare quale file fornisce per primo le pagine nella sequenza di alternanza.
4. Fai clic su **Mescola pagine** per produrre l'output alternato.
5. Il risultato viene scaricato come `alternated-mixed.pdf`.
## Funzionalità
- Alterna le pagine di un numero qualsiasi di PDF (minimo due)
- Riordino dei file con trascinamento per controllare la priorità di alternanza
- Conserva i segnalibri dei documenti di origine
- Mostra il numero di pagine e la dimensione di ogni file caricato
- Elaborazione tramite un web worker dedicato per un'interfaccia reattiva
## Casi d'uso
- Ricomporre scansioni fronte/retro in cui le pagine dispari e pari sono state scansionate separatamente
- Combinare fogli di domande con le chiavi di risposta, in modo che ogni domanda sia seguita dalla sua risposta
- Unire documenti bilingue pagina per pagina (ad es. inglese su un lato, traduzione sul successivo)
- Alternare le scansioni di fronte e retro ottenute da uno scanner a facciata singola
## Suggerimenti
- Se i PDF di origine hanno un numero di pagine diverso, le pagine del documento più corto finiranno per prime e le pagine rimanenti del documento più lungo appariranno alla fine.
- L'ordine dei file conta: il primo file dell'elenco fornisce la prima pagina dell'output. Trascina per riordinare se necessario.
## Strumenti correlati
- [Unisci PDF](./merge-pdf)
- [Duplica e Organizza](./organize-pdf)
- [Dividi PDF](./split-pdf)
docs/it/tools/background-color.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Colore di sfondo
description: Cambia il colore di sfondo di ogni pagina del tuo PDF mantenendo tutto il contenuto in primo piano.
---
# Colore di sfondo
Imposta un colore di sfondo uniforme dietro tutto il contenuto esistente del tuo PDF. Lo strumento crea un rettangolo colorato su ogni pagina e sovrappone il contenuto originale, così testo, immagini e grafica restano pienamente visibili sul nuovo sfondo.
## Come funziona
1. Carica il tuo file PDF.
2. Scegli un colore di sfondo con il selettore di colori. Il valore predefinito è un giallo chiaro (#FFFFCC).
3. Fai clic su **Cambia Colore di Sfondo** per elaborare.
4. Il PDF aggiornato viene scaricato automaticamente.
## Opzioni
- **Colore di Sfondo**: un selettore di colori standard per scegliere qualsiasi colore a tinta unita. Il valore predefinito è il giallo chiaro.
## Funzionalità
- Applica un colore di sfondo uniforme a ogni pagina
- Conserva tutto il contenuto originale (testo, immagini, grafica vettoriale) sopra lo strato colorato
- Mantiene le dimensioni originali delle pagine
- Funziona con documenti di qualsiasi numero di pagine
## Casi d'uso
- Aggiungere uno sfondo crema o avorio chiaro per dare ai documenti un aspetto più morbido, simile alla carta
- Codificare con i colori gruppi di documenti applicando sfondi diversi a categorie diverse
- Creare versioni visivamente distinte dello stesso documento per pubblici diversi
- Aggiungere una leggera tinta di sfondo per migliorare la leggibilità quando si proiettano i documenti sullo schermo
## Suggerimenti
- I colori chiari e tenui funzionano meglio. Uno sfondo molto scuro può rendere il testo difficile da leggere, a meno che il testo non sia già di colore chiaro.
- Se vuoi cambiare sia lo sfondo sia il colore del testo, applica prima il colore di sfondo, poi usa [Cambia Colore Testo](./text-color) sul risultato.
- Questo strumento lavora a livello strutturale del PDF (senza rasterizzazione), quindi il testo resta selezionabile e ricercabile nell'output.
## Strumenti correlati
- [Cambia Colore Testo](./text-color)
- [Inverti Colori](./invert-colors)
- [Regola colori](./adjust-colors)
docs/it/tools/bates-numbering.md
+62
View File
@@ -0,0 +1,62 @@
---
title: Numerazione Bates
description: Applica numeri Bates a uno o più PDF con modelli personalizzabili, riempimento, font e posizionamento.
---
# Numerazione Bates
La numerazione Bates applica identificatori sequenziali a ogni pagina dei tuoi PDF. È il metodo standard per etichettare i documenti nei procedimenti legali, negli audit e nei flussi di conformità. Questo strumento supporta più file e modelli personalizzabili, e produce PDF numerati singolarmente oppure un unico archivio ZIP.
## Come funziona
1. Carica uno o più file PDF. Puoi trascinare più file contemporaneamente.
2. Scegli un preset di stile o crea un modello personalizzato.
3. Configura posizione, font, dimensione, colore e numeri iniziali.
4. Fai clic su **Applica Numeri Bates** per elaborare.
5. Un singolo file viene scaricato direttamente. Più file vengono scaricati come archivio ZIP.
## Opzioni
- **Preset di stile**: scegli tra i formati integrati:
- Esibito + Caso + Bates + Pagina (ad es. "Exhibit 1 Case XYZ 000001 Page 1")
- Esibito + Caso + Bates (senza numero di pagina)
- Caso + Bates
- Solo numero Bates (ad es. "000001")
- Personalizzato (scrivi il tuo modello)
- **Personalizza stile**: una stringa modello che usa i segnaposto: `[BATES]`, `[PAGE]`, `[FILE]`, `[FILENAME]`.
- **Riempimento Bates**: numero di cifre (da 3 a 6) per i numeri Bates con zeri iniziali. Visibile solo in modalità personalizzata.
- **Posizione**: intestazione o piè di pagina, a sinistra, al centro o a destra.
- **Il Bates inizia da**: il primo numero Bates. Il valore predefinito è 1. La numerazione prosegue tra i file.
- **Il contatore file inizia da**: il numero iniziale per il segnaposto `[FILE]`.
- **Font**: Helvetica, Times New Roman o Courier.
- **Dimensione del font**: dimensione del testo applicato.
- **Colore**: selettore di colori per il testo del numero Bates.
## Funzionalità
- Anteprima in tempo reale che mostra come appariranno i numeri Bates in tutti i file caricati
- Supporto di più file con numerazione continua tra i documenti
- Riordino dei file con trascinamento per controllare la sequenza di numerazione
- Sei opzioni di posizione (intestazione/piè di pagina, sinistra/centro/destra)
- Calcolo adattivo dei margini che rispetta i diversi formati di pagina
- Output ZIP per lotti di più file
- Segnaposto nei modelli per la massima flessibilità
## Casi d'uso
- Applicare numeri di esibito sequenziali ai documenti di discovery per le cause legali
- Numerare pacchetti di prove di audit che comprendono decine di file
- Applicare numeri di riferimento normativi alla documentazione di conformità
- Etichettare gli allegati di una domanda di brevetto con identificatori specifici del caso
## Suggerimenti
- Trascina i file nell'elenco per riordinarli prima dell'elaborazione. La sequenza di numerazione Bates segue questo ordine.
- Usa il segnaposto `[FILENAME]` per includere il nome del file originale nel timbro, così è più facile risalire dalle pagine ai documenti di origine.
- Il riquadro di anteprima si aggiorna in tempo reale mentre cambi le impostazioni, così puoi verificare il formato prima di elaborare.
## Strumenti correlati
- [Numeri di Pagina](./page-numbers)
- [Aggiungi Etichette di Pagina](./add-page-labels)
- [Intestazione e Piè di Pagina](./header-footer)
docs/it/tools/bmp-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: BMP in PDF
description: Converti le immagini bitmap BMP in formato PDF direttamente nel tuo browser, senza caricare nulla su alcun server.
---
# BMP in PDF
Converti i file Windows Bitmap (BMP) in PDF. BMP è un formato immagine non compresso ancora presente nei sistemi legacy, nell'imaging medico e negli scanner industriali. Questo strumento li converte in PDF senza bisogno di installare nulla.
## Formati supportati
| Formato | Estensioni |
| :------ | :--------- |
| BMP | `.bmp` |
## Come funziona
1. Fai clic sull'area di caricamento oppure trascina i tuoi file BMP.
2. Controlla l'elenco dei file. Aggiungi altri file o rimuovi quelli che non vuoi.
3. Fai clic su **Converti in PDF**. L'output viene scaricato come `from_bmps.pdf`.
Ogni BMP viene disegnato su un canvas, esportato come PNG e poi incorporato nel PDF tramite pdf-lib. Le dimensioni della pagina corrispondono a quelle dell'immagine originale.
## Opzioni
Questo strumento non offre impostazioni di qualità aggiuntive. Le immagini vengono incorporate alla loro risoluzione originale come PNG senza perdita all'interno del PDF.
## Casi d'uso
- Convertire documenti scansionati legacy salvati come BMP in PDF per l'archiviazione
- Trasformare screenshot BMP di vecchie applicazioni Windows in documenti condivisibili
- Elaborare l'output di scanner medicali o industriali che usano BMP per impostazione predefinita
- Migrare vecchi archivi di immagini verso un formato più portabile
## Suggerimenti
- I file BMP non sono compressi, quindi tendono a essere grandi. Il PDF risultante sarà molto più piccolo, perché internamente le immagini vengono ricodificate come PNG.
- Se hai file BMP insieme ad altri formati di immagine, usa lo strumento [Immagini in PDF](./image-to-pdf) per convertire tutto in un unico lotto.
## Strumenti correlati
- [Immagini in PDF](./image-to-pdf)
- [PNG in PDF](./png-to-pdf)
- [TIFF in PDF](./tiff-to-pdf)
docs/it/tools/bookmark.md
+57
View File
@@ -0,0 +1,57 @@
---
title: Modifica segnalibri
description: Aggiungi, modifica, importa, esporta ed elimina i segnalibri dei PDF con un editor visuale e supporto CSV/JSON.
---
# Modifica segnalibri
L'editor di segnalibri ti dà il pieno controllo sui segnalibri di navigazione del PDF (detti anche struttura o outline). Puoi aggiungere nuovi segnalibri, modificare quelli esistenti, riorganizzare la gerarchia e importare o esportare i dati dei segnalibri in formato CSV e JSON.
## Come funziona
1. Carica il tuo PDF facendo clic o trascinando un file nell'area di rilascio.
2. Facoltativamente, seleziona **Estrai automaticamente segnalibri esistenti** per importare l'albero dei segnalibri attuale del documento.
3. L'editor si apre con una vista divisa: il visualizzatore PDF a sinistra, il pannello dei segnalibri a destra.
4. Digita il titolo di un segnalibro e fai clic su **Aggiungi alla pagina** per crearne uno che punta alla pagina corrente.
5. Usa i pulsanti della barra degli strumenti per riordinare, formattare o eliminare i segnalibri.
6. Fai clic su **Salva PDF con segnalibri** per scaricare il file aggiornato.
## Funzionalità
- Visualizzatore PDF con navigazione tra le pagine, controlli dello zoom e campo per andare a una pagina
- Aggiungi segnalibri a qualsiasi pagina con un solo clic
- Fai clic direttamente sul PDF per impostare una destinazione precisa del segnalibro (modalità selezione)
- Gerarchia di segnalibri annidati con riordinamento tramite trascinamento
- Operazioni in blocco: seleziona più segnalibri per cambiarne colore e stile o eliminarli in una volta
- Ricerca dei segnalibri per trovare rapidamente le voci in alberi grandi
- Annulla e ripeti per tutte le modifiche
- Importa segnalibri da file CSV (titolo, pagina, livello) o JSON
- Esporta i segnalibri in CSV o JSON per modificarli all'esterno
- Stile dei segnalibri: colore (rosso, blu, verde, giallo, viola) e stile del carattere (grassetto, corsivo, grassetto corsivo)
- Navigazione rapida: scorri le pagine con i tasti Pag su/giù
## Opzioni
- **Estrai automaticamente segnalibri esistenti**: se selezionata, lo strumento legge e mostra i segnalibri attuali del PDF al caricamento.
- **Modalità batch**: attivala per selezionare più segnalibri e applicare in blocco colore, stile o eliminazione.
- **Espandi tutto / Comprimi tutto**: mostra o nascondi rapidamente i segnalibri figli annidati.
## Casi d'uso
- Aggiungere un indice a un manuale o a un libro di testo privo di segnalibri
- Ristrutturare i segnalibri in un documento scansionato dopo l'elaborazione OCR
- Esportare i segnalibri in CSV, modificarli in un foglio di calcolo e reimportarli
- Ripulire segnalibri generati automaticamente con riferimenti di pagina errati
- Aggiungere segnalibri colorati per evidenziare le sezioni importanti in una memoria legale
## Suggerimenti
- Usa l'importazione CSV per creare segnalibri in massa. Il formato è semplice: `title,page,level`, dove il livello 1 è il livello principale.
- La modalità selezione ti permette di fare clic su un punto esatto della pagina PDF per impostare la destinazione del segnalibro, in modo più preciso rispetto al solo numero di pagina.
- Esporta i segnalibri prima di apportare modifiche importanti, così avrai un backup.
## Strumenti correlati
- [Indice](./table-of-contents)
- [Editor PDF](./edit-pdf)
- [Aggiungi etichette di pagina](./add-page-labels)
docs/it/tools/cbz-to-pdf.md
+47
View File
@@ -0,0 +1,47 @@
---
title: CBZ in PDF
description: Converti gli archivi di fumetti CBZ e CBR in PDF nel tuo browser. Gratuito, privato, senza caricamenti.
---
# CBZ in PDF
Trasforma gli archivi di fumetti in PDF. CBZ e CBR sono i formati standard per i fumetti digitali: sono semplici archivi ZIP o RAR pieni di immagini. Questo strumento estrae ogni pagina, mantiene l'ordine di lettura e produce un PDF pulito in cui ogni immagine diventa una pagina a dimensione intera.
## Formati supportati
| Formato | Estensione | Note |
| :------ | :--------- | :---------------------------------------------------------------------- |
| CBZ | `.cbz` | Archivio di fumetti basato su ZIP (elaborato in locale con pdf-lib) |
| CBR | `.cbr` | Archivio di fumetti basato su RAR (elaborato tramite il motore PyMuPDF) |
Il convertitore CBZ riconosce le immagini JPEG, PNG, GIF, BMP, WebP, AVIF, TIFF, HEIC e JXL contenute nell'archivio. I formati non standard vengono convertiti automaticamente in PNG prima di essere incorporati.
## Come funziona
1. Fai clic sull'area di caricamento o trascina i tuoi file CBZ o CBR. Puoi mescolare entrambi i formati in un unico lotto.
2. Controlla i file elencati. Rimuovi quelli che non ti servono oppure fai clic su **Aggiungi altri file** per aggiungerne altri.
3. Fai clic su **Converti in PDF**. Per i file CBZ, lo strumento decomprime l'archivio, ordina le immagini per nome in ordine naturale, rileva il formato reale di ogni immagine e le incorpora in un PDF con pdf-lib. I file CBR passano invece dal motore PyMuPDF.
4. Un singolo file viene scaricato come PDF. Più file producono un archivio ZIP chiamato `comic-converted.zip`.
## Opzioni
Non serve alcuna configurazione. Ogni immagine diventa una pagina con le stesse dimensioni dell'originale, quindi le doppie pagine restano larghe e le pagine singole restano strette.
## Casi d'uso
- Leggere i fumetti su un tablet o su un'app per smartphone che supporta il PDF ma non CBZ/CBR
- Stampare pagine specifiche da un fumetto digitale
- Archiviare una collezione di fumetti in un formato che qualsiasi visualizzatore di file può aprire
- Condividere un fumetto con chi non ha un lettore di fumetti dedicato
## Suggerimenti
- Le immagini all'interno dell'archivio sono ordinate in ordine naturale (quindi `page2.jpg` viene prima di `page10.jpg`). Assegna ai file una numerazione coerente per ottenere la sequenza di pagine corretta.
- Il convertitore rileva i formati delle immagini dalle firme binarie, non dalle estensioni dei file. Un PNG chiamato per errore `.jpg` verrà comunque incorporato correttamente.
- I file CBZ vengono elaborati interamente nel browser senza caricare il motore PyMuPDF, quindi si convertono più velocemente dei file CBR.
## Strumenti correlati
- [EPUB in PDF](./epub-to-pdf)
- [MOBI in PDF](./mobi-to-pdf)
- [Immagini in PDF](./image-to-pdf)
docs/it/tools/change-permissions.md
+61
View File
@@ -0,0 +1,61 @@
---
title: Modifica permessi
description: Imposta o modifica i permessi di utilizzo del PDF per stampa, copia, modifica e annotazione. Usa la crittografia AES a 256 bit.
---
# Modifica permessi
Definisci con precisione cosa possono fare i destinatari con il tuo PDF. A differenza della semplice crittografia che si limita a bloccare il file con una password, questo strumento ti permette di consentire o negare selettivamente stampa, copia, modifica, annotazione, compilazione dei moduli, assemblaggio del documento ed estrazione delle pagine, il tutto applicato tramite crittografia AES a 256 bit.
## Come funziona
1. Carica un file PDF.
2. Se il PDF è già crittografato, inserisci la **Password attuale**.
3. Imposta una **Nuova password utente** (necessaria per aprire il file) e/o una **Nuova password proprietario** (controlla i permessi).
4. Attiva o disattiva i singoli permessi con le caselle di controllo.
5. Fai clic su **Modifica permessi**.
6. Scarica il PDF aggiornato.
Se lasci vuoti entrambi i campi delle nuove password, lo strumento decrittografa completamente il PDF, rimuovendo ogni crittografia e restrizione.
## Controlli dei permessi
| Permesso | Cosa controlla |
| ----------------------------------------- | ------------------------------------------------------------ |
| **Consenti la stampa** | Se il documento può essere stampato |
| **Consenti la copia del testo** | Se testo e immagini possono essere selezionati e copiati |
| **Consenti la modifica** | Se il contenuto del documento può essere modificato |
| **Consenti le annotazioni** | Se possono essere aggiunti commenti, evidenziazioni e timbri |
| **Consenti la compilazione dei moduli** | Se i campi modulo interattivi possono essere compilati |
| **Consenti l'assemblaggio del documento** | Se le pagine possono essere inserite, eliminate o ruotate |
| **Consenti l'estrazione di pagine** | Se le singole pagine possono essere estratte |
Tutti i permessi richiedono una password del proprietario per essere applicati. Senza una password del proprietario, i flag dei permessi vengono ignorati dalla maggior parte dei lettori PDF.
## Come funzionano i permessi nel PDF
I permessi del PDF fanno parte della specifica di crittografia. Sono memorizzati come flag di bit nel dizionario di crittografia e applicati dai lettori PDF conformi. La distinzione fondamentale:
- **Password utente**: necessaria per aprire il file.
- **Password del proprietario**: necessaria per cambiare i permessi o rimuovere le restrizioni. Senza di essa, i flag dei permessi controllano quali operazioni può eseguire l'utente.
Se imposti solo una password del proprietario (senza password utente), chiunque può aprire il file ma è limitato alle operazioni consentite. Se le imposti entrambe, il file richiede una password per essere aperto ed è limitato dopo l'autenticazione.
## Casi d'uso
- Distribuire un report che può essere visualizzato e stampato ma non modificato né copiato
- Condividere un modello di contratto che i destinatari possono compilare ma non modificare
- Pubblicare un catalogo PDF in cui la copia delle immagini è disabilitata
- Consentire le annotazioni su una bozza in revisione impedendo modifiche strutturali
## Suggerimenti
- Per essere efficace, imposta sempre una password del proprietario. I permessi senza password del proprietario non possono essere fatti rispettare.
- Alcuni strumenti PDF di terze parti ignorano i flag dei permessi. Per una protezione più forte, valuta di rasterizzare il PDF o di usare il DRM.
- Usa questo strumento per aggiornare i vecchi PDF crittografati con RC4 ad AES-256.
## Strumenti correlati
- [Proteggi PDF](./protect-pdf): protezione semplice con password, senza permessi granulari
- [Sblocca PDF](./unlock-pdf): rimuove completamente la crittografia
- [Rimuovi Restrizioni](./remove-restrictions): elimina tutte le restrizioni quando hai la password del proprietario
docs/it/tools/combine-single-page.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Combina in una pagina
description: Unisci tutte le pagine di un PDF in un unico scorrimento continuo verticale o orizzontale.
---
# Combina in una pagina
Unisci ogni pagina di un PDF in un'unica pagina lunga. Le pagine vengono affiancate in verticale (come un rotolo) o in orizzontale (una accanto all'altra), producendo una sola pagina continua in uscita.
## Come funziona
1. Carica un file PDF.
2. Seleziona la direzione del layout: **Verticale** (pagine impilate dall'alto in basso) oppure **Orizzontale** (pagine affiancate).
3. Imposta la spaziatura tra le pagine in punti.
4. Scegli un colore di sfondo per gli spazi tra le pagine.
5. Facoltativamente, attiva i separatori (linee sottili tra le pagine) e configurane spessore e colore.
6. Fai clic sul pulsante di elaborazione. Il risultato è un PDF di una sola pagina.
## Funzionalità
- Unione delle pagine in verticale o in orizzontale
- Spaziatura configurabile tra le pagine
- Selettore del colore di sfondo per le aree di spazio
- Linee di separazione facoltative con spessore e colore regolabili
- Rende ogni pagina originale a piena risoluzione sul canvas combinato
## Opzioni
| Opzione | Descrizione |
| --------------------------------- | ----------------------------------------------- |
| **Direzione del layout** | Verticale (impilate) o orizzontale (affiancate) |
| **Spaziatura** | Spazio tra le pagine in punti |
| **Colore di sfondo** | Colore dell'area tra le pagine |
| **Aggiungi linee di separazione** | Attiva le linee sottili tra le pagine |
| **Spessore del separatore** | Spessore della linea in punti |
| **Colore del separatore** | Colore delle linee di separazione |
## Casi d'uso
- Creare un'unica immagine lunga da un wireframe o un mockup di design su più pagine
- Generare una vista continua e scorrevole di un documento da incorporare nel web
- Unire un fumetto o uno storyboard di più pagine in un'unica striscia
- Produrre una vista panoramica di pagine in sequenza per la revisione
## Suggerimenti
- L'orientamento verticale funziona meglio per i documenti con pagine verticali. Quello orizzontale è migliore per i contenuti in formato orizzontale.
- I documenti grandi con molte pagine producono un risultato molto alto o molto largo. Alcuni visualizzatori PDF potrebbero avere difficoltà con pagine singole estremamente grandi.
- Aggiungere separatori di un colore a contrasto rende facile capire dove finisce una pagina originale e inizia la successiva.
## Strumenti correlati
- [N-Up PDF](./n-up-pdf)
- [Unisci PDF](./merge-pdf)
- [Dividi Pagine](./divide-pages)
docs/it/tools/compare-pdfs.md
+60
View File
@@ -0,0 +1,60 @@
---
title: Confronta PDF
description: Confronta due documenti PDF affiancati o in modalità sovrapposizione, con rilevamento e classificazione dettagliati delle modifiche.
---
# Confronta PDF
Carica due PDF e scopri esattamente cosa è cambiato tra l'uno e l'altro. Lo strumento abbina le pagine in modo intelligente, rileva le differenze in testo, immagini, annotazioni, intestazioni e formattazione e le presenta in una vista affiancata o sovrapposta.
## Come funziona
1. Carica due file PDF: l'originale (a sinistra) e la versione rivista (a destra).
2. Lo strumento abbina le pagine tra i documenti usando le firme del contenuto.
3. Seleziona una modalità di visualizzazione: **Fianco a fianco** oppure **Sovrapposizione**.
4. Spostati tra le coppie di pagine con i controlli di paginazione.
5. Le differenze vengono evidenziate e classificate. Usa il pannello dei filtri per concentrarti su tipi di modifica specifici.
6. Facoltativamente, esporta il confronto come report PDF.
## Funzionalità
- Abbinamento automatico delle pagine in base alla somiglianza del contenuto
- Viste di confronto affiancata e sovrapposta
- Classificazione delle modifiche: testo, immagine, intestazione/piè di pagina, annotazione, formattazione, sfondo
- Filtri per categoria per mostrare o nascondere tipi di modifica specifici
- Ricerca nelle modifiche di testo con filtro per query
- Supporto OCR per confrontare documenti scansionati
- Controlli dello zoom per un'ispezione dettagliata
- Scorrimento sincronizzato tra i pannelli nella vista affiancata
- Esporta i risultati del confronto come PDF
## Opzioni
| Opzione | Descrizione |
| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| **Modalità di visualizzazione** | Fianco a fianco o Sovrapposizione |
| **OCR** | Attiva/disattiva l'OCR per il confronto di documenti scansionati |
| **Lingua OCR** | Lingua per l'estrazione del testo con OCR |
| **Filtri per categoria** | Attiva o disattiva la visibilità delle modifiche a testo, immagini, intestazioni/piè di pagina, annotazioni, formattazione e sfondo |
| **Ambito delle modifiche** | Nella modalità sovrapposizione, filtra tra tutte le modifiche o solo il contenuto |
| **Zoom** | Regola il livello di ingrandimento per un'ispezione dettagliata |
## Casi d'uso
- Rivedere le revisioni di un contratto per trovare esattamente cosa è cambiato tra le versioni
- Confrontare mockup di design per verificare che le esportazioni PDF corrispondano alle aspettative
- Verificare le modifiche ai documenti nei settori regolamentati, dove ogni modifica deve essere tracciata
- Controllare che un processo di conversione PDF abbia preservato fedelmente il contenuto originale
- Confrontare i documenti tradotti con l'originale per individuare cambiamenti di layout
## Suggerimenti
- La vista sovrapposta impila i due documenti uno sull'altro, rendendo subito visibili le differenze spaziali (elementi spostati, immagini ridimensionate).
- Attiva l'OCR quando confronti documenti scansionati privi di livello di testo. Il motore di confronto estrarrà il testo dalle immagini delle pagine.
- Usa i filtri per categoria per concentrarti su ciò che conta. Ad esempio, nascondi le modifiche di formattazione quando ti interessano solo le differenze di testo.
## Strumenti correlati
- [Visualizza Metadati](./view-metadata)
- [OCR PDF](./ocr-pdf)
- [Unisci PDF](./merge-pdf)
docs/it/tools/compress-pdf.md
+73
View File
@@ -0,0 +1,73 @@
---
title: Comprimi PDF
description: Riduci le dimensioni dei PDF fino al 90% con il motore Hyper Compress. Supporta dimensioni di destinazione, elaborazione in blocco e impostazioni di qualità personalizzate.
---
# Comprimi PDF
Riduci i tuoi file PDF senza rovinarli. Comprimi PDF è basato su [Hyper Compress](https://www.bentopdf.com/hyper-compress), il motore di compressione di BentoPDF. Ricomprime le immagini, crea sottoinsiemi e unisce i font ed elimina il peso inutile, come le miniature incorporate e i dati privati delle applicazioni. Il PDF resta pienamente funzionante: il testo rimane selezionabile, i link e i campi modulo continuano a funzionare.
Hyper Compress è compilato in WebAssembly e viene distribuito con BentoPDF, quindi la compressione funziona offline e nelle installazioni isolate dalla rete (air-gapped), senza alcuna configurazione aggiuntiva.
## Come funziona
1. Carica uno o più PDF facendo clic sull'area di rilascio o trascinando i file.
2. Scegli un **Livello di compressione**: Basso, Medio, Alto o Senza perdita.
3. Facoltativamente, inserisci una **Dimensione file di destinazione**, oppure espandi **Impostazioni personalizzate** per un controllo più preciso, inclusa l'opzione **Converti in scala di grigi**.
4. Fai clic su **Comprimi PDF**. Con più file, ottieni un unico download ZIP.
## Documenti particolari
- **I PDF firmati digitalmente** vengono restituiti invariati, perché qualsiasi modifica invaliderebbe la firma. Attiva **Ignora la protezione dei contenuti** in Impostazioni personalizzate per rimuovere le firme e comprimerli; la firma visibile resta sulla pagina, ma il file non è più firmato.
- **I file PDF/A** perdono l'etichetta PDF/A dopo la compressione, così il file non dichiara mai una conformità che non rispetta più. Attiva **Mantieni PDF/A** in Impostazioni personalizzate per mantenere invece la conformità del file.
- **I PDF protetti da password** mostrano un campo password nella scheda del file. Inserisci lì la password e Hyper Compress apre il file da solo, senza un passaggio di sblocco separato. Con due o più file bloccati, un unico campo condiviso sblocca tutti i file che usano la stessa password. La copia compressa non ha password; usa [Proteggi PDF](./protect-pdf) per aggiungerne di nuovo una.
- **Le scansioni senza livello di testo** possono ridursi ulteriormente con **Rasterizza le pagine in immagini** in Impostazioni personalizzate, che sostituisce ogni pagina con un'unica immagine ottimizzata. Viene saltata per qualsiasi documento con testo selezionabile, comprese le scansioni con OCR, a meno che **Ignora la protezione dei contenuti** non sia attivo. In tal caso anche le pagine di testo diventano immagini, quindi il testo non è più selezionabile e i link smettono di funzionare.
## Livelli di compressione
| Livello | Qualità immagine | Risoluzione max | Ideale per |
| ----------------- | ---------------- | --------------- | ----------------------------------- |
| **Basso** | 80 | 200 DPI | Preservare la qualità visiva |
| **Medio** | 50 | 150 DPI | Documenti di uso quotidiano |
| **Alto** | 20 | 72 DPI | Allegati email, caricamenti sul web |
| **Senza perdita** | Immagini intatte | Invariata | Copie d'archivio |
Alto rimuove anche l'incorporamento dei 14 font PDF standard, oltre a quelli simili come Arial quando è sicuro farlo.
## Dimensione di destinazione
Inserisci una dimensione in KB o MB e Hyper Compress cerca la migliore qualità d'immagine che rientri comunque nel limite, partendo dal livello che hai scelto. Se il documento non può diventare così piccolo, ottieni la versione più piccola possibile e un messaggio che lo segnala. Le pagine dedicate, come [Comprimi PDF a 1MB](https://www.bentopdf.com/compress-pdf-to-1mb), si aprono con la dimensione di destinazione già compilata.
## Impostazioni personalizzate
Espandi il pannello Impostazioni personalizzate per regolare direttamente Hyper Compress. Scegliere un livello di compressione ripristina questi valori a quelli del livello, e modificarne uno qualsiasi porta il livello su Personalizzato.
- **Ignora la protezione dei contenuti**: per impostazione predefinita Hyper Compress lascia intatti i PDF firmati e non rasterizza le pagine che contengono testo. Attivandola, aggira entrambi i controlli. Resta attiva quando cambi livello.
- **Immagini**: qualità dell'immagine, risoluzione massima, ricampionamento forzato, riduzione dei colori, ritaglio delle aree invisibili delle immagini, rimozione delle immagini alternative, semplificazione dei profili colore, JPEG 2000 e modalità lossless
- **Font**: creazione di sottoinsiemi, unione dei duplicati e rimozione dell'incorporamento dei font standard e di quelli simili
- **Contenuto**: appiattimento di annotazioni, campi modulo o link
- **Pulizia**: rimozione di miniature, dati delle applicazioni, article thread, informazioni di acquisizione web, albero della struttura o output intent
- **Rasterizza**: sostituzione delle pagine con immagini, per scansioni solo immagine; viene saltata quando il documento ha testo selezionabile
- **Output**: Mantieni PDF/A e compressione Brotli per i lettori PDF 2.0 che la supportano
## Casi d'uso
- Portare un report da 50 MB sotto il limite degli allegati email
- Far rientrare una scansione nel rigido limite di caricamento di un portale con una dimensione di destinazione
- Ottimizzare i PDF di marketing per download più rapidi dal sito web
- Archiviare grandi insiemi di documenti quando i costi di archiviazione contano
- Ridurre il consumo di dati mobili condividendo PDF tramite app di messaggistica
## Suggerimenti
- Inizia con Medio. Se il risultato è ancora troppo grande, imposta una dimensione di destinazione o passa ad Alto.
- Per una scansione senza livello di testo, attiva Rasterizza le pagine in immagini in Impostazioni personalizzate.
- Converti in scala di grigi, in Impostazioni personalizzate, può ridurre le dimensioni dei documenti ricchi di colore.
## Strumenti correlati
- [Linearizza PDF](./linearize-pdf): ottimizza il PDF compresso per una visualizzazione web veloce
- [Rasterizza PDF](./rasterize-pdf): converte le pagine in immagini a un DPI specifico, comprese le pagine con testo
- [Ripara PDF](./repair-pdf): ripara un PDF danneggiato da una compressione eseguita altrove
- [Rimuovi Metadati](./remove-metadata): elimina i dati nascosti per la privacy
docs/it/tools/crop-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: Ritaglia PDF
description: Ritaglia visivamente le pagine PDF disegnando un'area di ritaglio su ciascuna pagina con un editor basato su Cropper.js.
---
# Ritaglia PDF
Rifila i margini delle pagine PDF con un'interfaccia di ritaglio visuale. Disegna un rettangolo di ritaglio direttamente su ogni pagina, controlla l'anteprima e applica il ritaglio. Puoi impostare aree di ritaglio diverse per pagine diverse oppure applicare lo stesso ritaglio all'intero documento.
## Come funziona
1. Carica il tuo file PDF.
2. Si apre l'editor di ritaglio, che mostra la prima pagina con una sovrapposizione di ritaglio trascinabile.
3. Regola il rettangolo di ritaglio trascinandone i bordi o gli angoli.
4. Usa i pulsanti di navigazione tra le pagine per spostarti e impostare le aree di ritaglio di ognuna.
5. Fai clic su **Ritaglia e scarica** per applicare il ritaglio e scaricare il risultato.
## Funzionalità
- Editor di ritaglio visuale basato su Cropper.js, con maniglie per una regolazione precisa
- Navigazione pagina per pagina per impostare aree di ritaglio individuali
- Memorizza le impostazioni di ritaglio per pagina, così puoi definire ritagli diversi per pagine diverse
- Anteprima in tempo reale dell'area di ritaglio selezionata
- Supporta PDF di qualsiasi dimensione o orientamento di pagina
## Casi d'uso
- Rimuovere i margini ampi dai documenti scansionati per concentrarsi sull'area del contenuto
- Eliminare i crocini di taglio o i segni di registro dai PDF di prestampa
- Ritagliare le slide di una lezione per eliminare l'area delle note del relatore
- Rimuovere intestazioni o piè di pagina da ogni pagina prima di condividere un estratto del documento
- Ridimensionare le pagine per adattarle a uno specifico display o layout di stampa
## Suggerimenti
- La sovrapposizione di ritaglio può essere ridimensionata e riposizionata liberamente. Trascina gli angoli per un ridimensionamento proporzionale o i bordi per una regolazione su un solo asse.
- Per i documenti in cui ogni pagina richiede lo stesso ritaglio, impostalo sulla prima pagina: lo strumento ricorda l'area di ritaglio mentre ti sposti tra le pagine.
- Se devi uniformare le dimensioni delle pagine anziché ritagliarle visivamente, lo strumento Correggi dimensione pagina potrebbe essere più adatto.
## Strumenti correlati
- [Editor PDF](./edit-pdf)
- [Numeri di Pagina](./page-numbers)
- [Rimuovi Pagine Vuote](./remove-blank-pages)
docs/it/tools/csv-to-pdf.md
+51
View File
@@ -0,0 +1,51 @@
---
title: CSV in PDF
description: Converti i file di foglio di calcolo CSV in tabelle PDF formattate direttamente nel tuo browser.
---
# CSV in PDF
Trasforma i file CSV in documenti PDF puliti e formattati. Ogni CSV viene analizzato e reso come tabella nel PDF di output. È utile quando devi stampare o condividere dati tabellari senza richiedere al destinatario un software per fogli di calcolo.
## Formati supportati
| Formato | Estensioni |
| :------ | :--------- |
| CSV | `.csv` |
## Come funziona
1. Fai clic sull'area di caricamento o trascina uno o più file CSV.
2. Controlla l'elenco dei file. Aggiungine altri o rimuovi quelli indesiderati.
3. Fai clic su **Converti in PDF**. Un indicatore di avanzamento mostra lo stato della conversione.
4. Un singolo file viene scaricato direttamente come PDF. Più file vengono raccolti in `csv-converted.zip`.
## Opzioni
Questo strumento non ha configurazioni aggiuntive. Il CSV viene analizzato e formattato automaticamente come tabella.
## Output
| Numero di input | Output |
| :-------------- | :---------------------------------------------------------- |
| 1 file | Download di un singolo PDF (ad es. `data.pdf`) |
| 2+ file | Archivio ZIP (`csv-converted.zip`) con un PDF per ogni file |
## Casi d'uso
- Convertire i report esportati da database in tabelle PDF stampabili
- Condividere dati finanziari o elenchi di inventario con chi non ha Excel
- Creare versioni PDF dei file di log CSV per la documentazione di conformità
- Stampare elenchi di indirizzi, registri dei voti o qualsiasi dato tabellare salvato come CSV
## Suggerimenti
- Per risultati ottimali, assicurati che il CSV usi i delimitatori standard a virgola. Lo strumento segue le convenzioni comuni di analisi dei CSV.
- Se il CSV ha molte colonne, la tabella potrebbe essere compressa per adattarsi alla larghezza della pagina. Valuta di dividere i set di dati molto larghi in più file.
- Per i file Excel (`.xls`, `.xlsx`), usa lo strumento [Excel in PDF](./excel-to-pdf), che preserva la formattazione del foglio di calcolo e i fogli multipli.
## Strumenti correlati
- [Excel in PDF](./excel-to-pdf)
- [Testo in PDF](./txt-to-pdf)
- [JSON in PDF](./json-to-pdf)
docs/it/tools/delete-pages.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Elimina pagine
description: Rimuovi pagine specifiche da un PDF per numero di pagina, intervallo o selezione visuale tramite miniature.
---
# Elimina pagine
Rimuovi le pagine indesiderate da un documento PDF. Indica le pagine da eliminare digitando numeri di pagina o intervalli, oppure fai clic direttamente sulle miniature per contrassegnarle per la rimozione.
## Come funziona
1. Carica un file PDF. Lo strumento genera le anteprime in miniatura di ogni pagina.
2. Inserisci nel campo di testo le pagine da eliminare usando la sintassi degli intervalli (ad es. `2, 5-8`), oppure fai clic sulle miniature per selezionarle o deselezionarle.
3. Le pagine contrassegnate vengono evidenziate visivamente, così puoi confermare la selezione.
4. Fai clic sul pulsante di elaborazione. Viene creato un nuovo PDF senza le pagine selezionate.
## Funzionalità
- Selezione delle pagine tramite testo con sintassi degli intervalli (`2, 5-8, 12`)
- Griglia di miniature per eliminare con un clic
- Evidenziazione in tempo reale delle pagine contrassegnate per l'eliminazione
- Validazione dell'input rispetto al numero effettivo di pagine
- Mantiene tutte le pagine non eliminate nel loro ordine originale
## Casi d'uso
- Rimuovere pagine vuote o di riempimento da un documento scansionato
- Eliminare copertine o appendici prima di condividere un documento
- Ripulire pagine di bozza rimaste per errore in un PDF finale
- Rimuovere le pagine con informazioni sensibili prima della distribuzione
## Suggerimenti
- Eliminare le pagine non influisce sul contenuto o sulla formattazione di quelle rimanenti. Il risultato è una copia fedele dell'originale meno le pagine rimosse.
- Se vuoi conservare solo determinate pagine anziché rimuoverne alcune, [Estrai Pagine](./extract-pages) è la scelta migliore.
- La vista a miniature si carica in modo progressivo, quindi i documenti grandi restano reattivi.
## Strumenti correlati
- [Estrai Pagine](./extract-pages)
- [Duplica e Organizza](./organize-pdf)
- [Dividi PDF](./split-pdf)
docs/it/tools/deskew-pdf.md
+46
View File
@@ -0,0 +1,46 @@
---
title: Raddrizza PDF
description: Raddrizza automaticamente le pagine inclinate dei PDF scansionati con il rilevamento dell'inclinazione di OpenCV. Soglia e DPI regolabili.
---
# Raddrizza PDF
I documenti scansionati raramente sono perfettamente dritti. Anche una leggera inclinazione rende l'OCR meno accurato e la stampa poco curata. Questo strumento usa gli algoritmi di elaborazione delle immagini di OpenCV per rilevare l'angolo di inclinazione di ogni pagina e ruotarla fino a riportarla in piano.
## Come funziona
1. Carica uno o più PDF scansionati.
2. Imposta la **Soglia di inclinazione**: le pagine con un'inclinazione rilevata inferiore a questo valore restano invariate.
3. Scegli una **Qualità di elaborazione (DPI)**: un DPI più alto migliora la precisione del rilevamento ma richiede più tempo.
4. Fai clic su **Raddrizza PDF**.
5. Al termine dell'elaborazione, un pannello dei risultati mostra l'angolo rilevato per ogni pagina e se è stata corretta.
## Opzioni
| Impostazione | Valori | Predefinito |
| --------------------------------- | ------------------------ | ----------- |
| **Soglia di inclinazione** | 0.1, 0.5, 1.0, 2.0 gradi | 0.5 |
| **Qualità di elaborazione (DPI)** | 100, 150, 200, 300 | 150 |
## Come funziona il rilevamento dell'inclinazione
Lo strumento rende ogni pagina come immagine al DPI selezionato, poi usa OpenCV per rilevare gli angoli delle linee dominanti nel contenuto. Se l'inclinazione rilevata supera la soglia, la pagina viene ruotata dell'angolo inverso per raddrizzarla. Le pagine sotto la soglia passano invariate.
## Casi d'uso
- Ripulire contratti o documenti legali scansionati in blocco
- Preparare ricevute o fatture scansionate per l'elaborazione OCR
- Raddrizzare le pagine di uno scanner piano con posizionamento della carta irregolare
- Migliorare la qualità visiva di materiali d'archivio digitalizzati
## Suggerimenti
- Abbassa la soglia a 0.1 gradi se ti serve un allineamento perfetto al pixel per l'OCR.
- 150 DPI è veloce e preciso per la maggior parte dei documenti. Usa 300 DPI per testo molto piccolo o pagine con dettagli fini.
- Il raddrizzamento funziona meglio sui documenti con linee di testo orizzontali nitide. Può avere difficoltà con pagine composte soprattutto da immagini o con elementi di design diagonali.
## Strumenti correlati
- [Rasterizza PDF](./rasterize-pdf): converte il risultato raddrizzato in un PDF piatto basato su immagini
- [Comprimi PDF](./compress-pdf): riduce le dimensioni del file dopo il raddrizzamento
- [Ripara PDF](./repair-pdf): risolve problemi strutturali nei PDF scansionati
docs/it/tools/digital-sign-pdf.md
+65
View File
@@ -0,0 +1,65 @@
---
title: Firma Digitale
description: Aggiungi firme digitali crittografiche ai PDF usando certificati X.509. Supporta i formati PKCS#12 e PEM con opzioni di firma visibile.
---
# Firma Digitale
Una firma digitale è una prova crittografica che una persona specifica ha firmato un documento e che il documento non è stato alterato da allora. A differenza di una firma disegnata (che è solo un'immagine), una firma digitale usa certificati X.509 e gli standard PKCS#7 per garantire autenticità e integrità verificabili.
BentoPDF applica le firme digitali interamente nel tuo browser. La tua chiave privata non lascia mai il tuo dispositivo.
## Come funziona
1. Carica un file PDF.
2. Carica il file del tuo certificato (.pfx, .p12 o .pem).
3. Inserisci la password del certificato per sbloccarlo. Lo strumento mostra il soggetto, l'emittente e il periodo di validità del certificato.
4. Facoltativamente, configura i metadati della firma (motivo, luogo, contatti).
5. Facoltativamente, attiva una **firma visibile** con personalizzazione di posizione, dimensioni, immagine e testo.
6. Fai clic su **Firma PDF**.
## Formati di certificato supportati
| Formato | Estensioni | Descrizione |
| ----------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| **PKCS#12** | .pfx, .p12 | Pacchetto standard del settore che contiene la chiave privata e la catena di certificati. È il formato più comune. |
| **PEM** | .pem | Formato testuale. Deve contenere sia il certificato sia la chiave privata in un unico file. Supporta chiavi private crittografate. |
## Opzioni della firma visibile
Quando è attiva, sulla pagina PDF viene reso un blocco di firma visibile:
- **Posizione**: coordinate X/Y e larghezza/altezza in punti
- **Pagina**: prima pagina, ultima pagina, tutte le pagine o un numero di pagina specifico
- **Immagine**: carica un'immagine PNG, JPG o WebP (la tua firma autografa, il sigillo aziendale, ecc.)
- **Testo**: testo personalizzato con colore e dimensione del carattere configurabili. Se non vengono forniti né immagine né testo, lo strumento genera automaticamente il testo dal nome comune del certificato e dalla data corrente.
## Metadati della firma
- **Motivo**: perché il documento è stato firmato (ad es. "Approvato", "Rivisto")
- **Luogo**: dove è avvenuta la firma (ad es. "New York, NY")
- **Contatti**: come raggiungere il firmatario (ad es. indirizzo email)
## Nota sulla connessione a Internet
La firma può richiedere una connessione a Internet. La libreria di firma recupera la catena di certificati dagli URL incorporati nell'estensione Authority Information Access (AIA) del tuo certificato. Se quei server non sono raggiungibili, la firma fallirà per i certificati che richiedono la validazione della catena.
## Casi d'uso
- Firmare contratti, proposte e accordi con firme digitali giuridicamente vincolanti
- Certificare documenti ufficiali in flussi di lavoro che richiedono l'autenticazione basata su PKI
- Firmare fatture PDF per la conformità normativa (molti paesi dell'UE richiedono e-fatture firmate digitalmente)
- Aggiungere l'approvazione organizzativa a disegni tecnici o documenti di qualità
## Suggerimenti
- I certificati autofirmati vanno bene per i test, ma mostreranno avvisi in Adobe Reader. Per i documenti di produzione usa un certificato di un'autorità di certificazione attendibile.
- La firma visibile è puramente grafica. La firma crittografica viene incorporata indipendentemente dal fatto che il blocco visibile sia attivo.
- Verifica il PDF firmato con lo strumento Convalida Firma per confermare che la firma sia integra.
## Strumenti correlati
- [Convalida Firma](./validate-signature-pdf): verifica le firme digitali nei PDF firmati
- [Appiattisci PDF](./flatten-pdf): appiattisci i moduli prima della firma per impedire modifiche
- [Proteggi PDF](./protect-pdf): aggiungi la protezione con password sopra la firma digitale
- [Rimuovi Metadati](./remove-metadata): elimina i metadati prima di firmare
docs/it/tools/divide-pages.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Dividi pagine
description: Dividi le pagine PDF in orizzontale o in verticale in sotto-pagine più piccole.
---
# Dividi pagine
Taglia le singole pagine PDF a metà dividendole in orizzontale o in verticale. È utile quando una singola pagina contiene contenuti che dovrebbero stare in pagine distinte, ad esempio un layout a due colonne scansionato come un'unica pagina larga.
## Come funziona
1. Carica un file PDF.
2. Seleziona la direzione di divisione: **Verticale** (metà sinistra/destra) oppure **Orizzontale** (metà superiore/inferiore).
3. Facoltativamente, specifica un intervallo di pagine per limitare quali pagine vengono divise. Lascia vuoto per dividere tutte le pagine.
4. Fai clic sul pulsante di elaborazione per generare il PDF diviso.
## Funzionalità
- Divisione verticale: divide ogni pagina in metà sinistra e destra
- Divisione orizzontale: divide ogni pagina in metà superiore e inferiore
- Filtro per intervallo di pagine per dividere solo pagine specifiche
- Le pagine non selezionate passano invariate
- Preserva la qualità del contenuto senza ripetere il rendering
## Casi d'uso
- Separare pagine scansionate affiancate (ad es. la scansione di un libro con pagina sinistra e destra su un unico foglio)
- Dividere un PDF orizzontale con contenuti affiancati in singole pagine verticali
- Dividere infografiche o poster alti in sezioni superiore e inferiore separate
- Preparare documenti in formato largo per la stampa su carta standard
## Suggerimenti
- Se le pagine hanno un contenuto distribuito in modo non uniforme, la divisione avviene comunque nel punto esatto di metà. Per divisioni asimmetriche, usa piuttosto [Ritaglia PDF](./crop-pdf).
- Combina questo strumento con [Ruota PDF](./rotate-pdf) se le pagine devono essere ruotate prima o dopo la divisione.
## Strumenti correlati
- [Dividi PDF](./split-pdf)
- [Ritaglia PDF](./crop-pdf)
- [N-Up PDF](./n-up-pdf)
- [Posterizza PDF](./posterize-pdf)
docs/it/tools/duplex-collate.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Fascicola scansione fronte/retro
description: Riordina i PDF scansionati in fronte/retro che contengono le pagine anteriori e posteriori in blocchi separati, mettendole nell'ordine corretto.
---
# Fascicola scansione fronte/retro
Fascicola Fronte/Retro è pensato per i flussi di scansione con alimentatore automatico (ADF) in cui un PDF contiene due blocchi di pagine:
- prima tutti i fronti
- poi tutti i retro
Invece di dividere e riassemblare a mano, questo strumento intercala i due blocchi nel naturale ordine di lettura: fronte1, retro1, fronte2, retro2 e così via.
## Come funziona
1. Carica un singolo PDF creato dalla scansione di una pila fronte/retro.
2. Imposta il punto di divisione in cui termina il blocco dei fronti.
3. Scegli come gestire il blocco dei retro:
- **Inverti il blocco dei retri** (comune quando la pila viene capovolta prima di scansionare i retro)
- **Mantieni il blocco dei retri così com'è**
4. Fai clic su **Fascicola PDF** per scaricare il risultato riordinato.
## Opzioni
- **Rileva divisione automaticamente (metà)**: imposta il punto di divisione a `ceil(totalPages / 2)`.
- **Avviso pagine dispari**: avvisa quando il totale delle pagine è dispari (spesso indica una scansione non corrispondente).
- **Conferma blocchi non uniformi**: chiede conferma quando le dimensioni dei blocchi fronte/retro differiscono.
- **Esportazione raggruppata**: divide l'output fascicolato in PDF separati in base al numero di pagine del documento originale e li scarica come ZIP.
## Comportamento dell'output
- **Predefinito**: un solo PDF in uscita (un PDF in ingresso, un PDF in uscita).
- **Modalità raggruppata**: l'output viene suddiviso in base al valore di pagine per documento; se vengono prodotti più blocchi, vengono scaricati come un unico ZIP, altrimenti viene scaricato un singolo PDF.
Se le dimensioni dei blocchi sono diverse, le pagine in coppia vengono fascicolate per prime e le pagine rimaste senza coppia vengono aggiunte in fondo.
## Casi d'uso comuni
- Ripristinare l'ordine dopo aver scansionato una pila di moduli fronte/retro in due passate.
- Ricostruire i fascicoli fronte/retro da scanner d'ufficio che restituiscono prima tutti i fronti e poi tutti i retro.
- Post-elaborare le scansioni d'archivio prima di dividerle in file per documento.
## Suggerimenti
- La maggior parte dei lotti fronte/retro dovrebbe avere un numero totale di pagine pari.
- Se i retro risultano invertiti, passa da **Inverti il blocco dei retri** a **Mantieni il blocco dei retri così com'è** o viceversa.
- Per originali di 2 pagine (fronte+retro), usa l'esportazione raggruppata con `2` pagine per documento.
## Strumenti correlati
- [Alterna e Riordina Pagine](./alternate-merge)
- [Dividi PDF](./split-pdf)
- [Unisci PDF](./merge-pdf)
- [Duplica e Organizza](./organize-pdf)
docs/it/tools/edit-attachments.md
+43
View File
@@ -0,0 +1,43 @@
---
title: Modifica allegati
description: Visualizza e rimuovi in modo selettivo i file allegati incorporati in un documento PDF.
---
# Modifica allegati
Ispeziona e gestisci i file allegati all'interno di un PDF. Lo strumento elenca ogni file incorporato con il suo nome e il livello di allegato, poi ti permette di contrassegnare singoli allegati per la rimozione o di eliminarli tutti in una volta.
## Come funziona
1. Carica un file PDF.
2. Lo strumento cerca automaticamente gli allegati e li mostra in un elenco.
3. Ogni allegato mostra il nome del file e se è un allegato a livello di documento o di pagina.
4. Fai clic sull'icona del cestino accanto a un allegato per contrassegnarlo per la rimozione (fai di nuovo clic per annullare).
5. Usa il pulsante **Rimuovi tutti gli allegati** per selezionare tutto in una volta, oppure **Deseleziona tutto** per azzerare le selezioni.
6. Fai clic sul pulsante di elaborazione per salvare un nuovo PDF senza gli allegati selezionati.
## Funzionalità
- Elenca tutti gli allegati a livello di documento e di pagina
- Rimozione singola o in blocco degli allegati
- Selezione attivabile e disattivabile prima di confermare le modifiche
- Testo barrato e opacità ridotta sugli elementi contrassegnati per la rimozione
- Scarica il PDF modificato senza gli allegati selezionati
## Casi d'uso
- Rimuovere file obsoleti o errati incorporati in un documento prima di ridistribuirlo
- Eliminare allegati sensibili (dati finanziari, informazioni personali) da un PDF prima di condividerlo
- Ridurre le dimensioni del PDF rimuovendo grandi file incorporati non più necessari
- Verificare i contenuti incorporati e ripulire un documento prima di archiviarlo
## Suggerimenti
- Gli allegati contrassegnati per la rimozione vengono mostrati barrati. Puoi riattivarli prima dell'elaborazione se cambi idea.
- Se non vengono trovati allegati, lo strumento mostra un chiaro messaggio "Nessun allegato trovato": il PDF semplicemente non contiene file incorporati.
## Strumenti correlati
- [Aggiungi Allegati](./add-attachments)
- [Estrai Allegati](./extract-attachments)
- [Visualizza Metadati](./view-metadata)
docs/it/tools/edit-metadata.md
+58
View File
@@ -0,0 +1,58 @@
---
title: Modifica metadati
description: Visualizza e modifica i campi dei metadati del PDF, tra cui titolo, autore, parole chiave, date e proprietà personalizzate.
---
# Modifica metadati
Modifica i metadati incorporati in un file PDF. Lo strumento precompila un modulo con i metadati esistenti del documento, ti permette di modificare qualsiasi campo e salva le modifiche in un nuovo PDF.
## Come funziona
1. Carica un file PDF. Lo strumento legge i metadati attuali e compila il modulo.
2. Modifica uno qualsiasi dei campi standard: Titolo, Autore, Oggetto, Parole chiave, Creatore, Produttore.
3. Regola Data di creazione e Data di modifica con i selettori di data e ora.
4. Aggiungi campi di metadati personalizzati facendo clic sul pulsante di aggiunta e inserendo una coppia chiave-valore.
5. Fai clic sul pulsante di elaborazione per salvare il PDF modificato.
## Funzionalità
- Precompila tutti i metadati esistenti del PDF caricato
- Campi standard: Titolo, Autore, Oggetto, Parole chiave, Creatore, Produttore
- Selettori di data e ora per Data di creazione e Data di modifica
- Campi di metadati personalizzati chiave-valore per proprietà arbitrarie
- Salva le modifiche direttamente nel dizionario delle informazioni del documento PDF
## Campi modificabili
| Campo | Descrizione |
| ------------------------ | ---------------------------------------------------------------- |
| **Titolo** | Il titolo del documento mostrato nei lettori PDF |
| **Autore** | La persona o l'organizzazione che ha creato il documento |
| **Oggetto** | Una breve descrizione dell'argomento del documento |
| **Parole chiave** | Termini separati da virgole per la ricerca e la categorizzazione |
| **Creatore** | L'applicazione che ha creato originariamente il contenuto |
| **Produttore** | L'applicazione che ha generato il PDF |
| **Data di creazione** | Quando il documento è stato creato originariamente |
| **Data di modifica** | Quando il documento è stato modificato l'ultima volta |
| **Campi personalizzati** | Qualsiasi coppia chiave-valore aggiuntiva che definisci |
## Casi d'uso
- Impostare un titolo e un autore corretti prima di pubblicare un documento
- Aggiungere parole chiave per migliorare la reperibilità nei sistemi di gestione documentale
- Aggiornare la data di modifica per riflettere la revisione corrente
- Aggiungere campi di metadati personalizzati come Reparto, ID progetto o Classificazione
- Ripulire i metadati lasciati dal software di creazione originale
## Suggerimenti
- I campi personalizzati vengono scritti direttamente nel dizionario delle informazioni del PDF. Alcuni lettori PDF potrebbero non mostrarli, ma vengono conservati nel file.
- Lascia un campo vuoto per cancellarlo dai metadati. Il pulsante di elaborazione salva ciò che si trova nel modulo.
- Per visualizzare i metadati senza modificarli, usa [Visualizza Metadati](./view-metadata). Per rimuovere del tutto i metadati, usa Rimuovi Metadati.
## Strumenti correlati
- [Visualizza Metadati](./view-metadata)
- [Livelli OCG del PDF](./pdf-layers)
- [Comprimi PDF](./compress-pdf)
docs/it/tools/edit-pdf.md
+48
View File
@@ -0,0 +1,48 @@
---
title: Editor PDF
description: Annota, evidenzia, oscura, aggiungi forme e immagini, cerca e visualizza i PDF direttamente nel tuo browser.
---
# Editor PDF
L'Editor PDF di BentoPDF ti permette di annotare, evidenziare, oscurare, commentare, aggiungere forme e immagini e cercare nei tuoi PDF. Carica un editor completo direttamente nel browser, senza alcun caricamento su server.
## Come funziona
1. Carica il tuo PDF facendo clic sull'area di rilascio o trascinandoci sopra un file.
2. L'editor PDF integrato si apre automaticamente con il documento caricato.
3. Usa la barra degli strumenti per annotare, evidenziare, oscurare, aggiungere testo, disegnare forme o inserire immagini.
4. Fai clic su **Scarica il PDF modificato** per salvare le modifiche.
## Funzionalità
- Barra degli strumenti di annotazione completa con evidenziazione, sottolineatura, testo barrato e disegno a mano libera
- Inserimento di testo e commenti
- Strumenti di oscuramento che rimuovono definitivamente il contenuto contrassegnato una volta applicato l'oscuramento. Se alcuni contrassegni non sono stati applicati quando fai clic su **Scarica il PDF modificato**, l'editor ti propone di applicarli prima.
- Strumenti per forme: rettangoli, cerchi, linee e frecce
- Inserimento di immagini nelle pagine PDF
- Ricerca del testo integrata in tutto il documento
- Supporto multi-documento con schede (fino a 10 documenti aperti contemporaneamente)
- Caricamento dei file tramite trascinamento
## Casi d'uso
- Rivedere contratti e segnare le modifiche con evidenziazioni e commenti
- Oscurare informazioni riservate come codici fiscali o dati finanziari prima della condivisione
- Aggiungere annotazioni a piante architettoniche o disegni tecnici
- Inserire loghi aziendali o timbri nelle pagine del documento
- Cercare termini specifici in lunghi documenti legali
## Suggerimenti
- Puoi aprire più PDF contemporaneamente e passare dall'uno all'altro con la barra delle schede in alto nell'editor.
- L'editor preserva la struttura originale del PDF, quindi font, layout e campi modulo restano intatti.
- Contrassegnare un testo o un'area per l'oscuramento non rimuove nulla finché l'oscuramento non viene applicato. Quando oscuri un testo selezionato, vengono rimosse dal download anche le sue copie nelle proprietà del file, nei segnalibri, nei commenti e negli allegati, a meno che il file non sia crittografato.
- Per filigrane o numerazione di pagina in blocco, usa gli strumenti dedicati, che offrono più controllo sulla formattazione.
## Strumenti correlati
- [Aggiungi Filigrana](./add-watermark)
- [Firma PDF](./sign-pdf)
- [Aggiungi Timbri](./add-stamps)
- [Rimuovi Annotazioni](./remove-annotations)
docs/it/tools/email-to-pdf.md
+50
View File
@@ -0,0 +1,50 @@
---
title: Email in PDF
description: Converti i file email EML e MSG in PDF nel tuo browser. Preserva intestazioni, corpo ed elenco degli allegati.
---
# Email in PDF
Converti le email salvate in PDF puliti e stampabili. Lo strumento analizza i file EML e MSG, estrae il messaggio completo (intestazioni, corpo e metadati degli allegati) e rende tutto in un PDF strutturato. Utile per la raccolta di prove legali, l'archiviazione o semplicemente per stampare un'email importante.
## Formati supportati
| Formato | Estensione | Note |
| :------ | :--------- | :------------------------------------------------------------------------------ |
| EML | `.eml` | Formato email MIME standard (esportato dalla maggior parte dei client di posta) |
| MSG | `.msg` | Formato proprietario di Microsoft Outlook |
## Come funziona
1. Fai clic sull'area di caricamento o trascina i tuoi file EML o MSG. Puoi mescolare entrambi i formati in un unico lotto.
2. Controlla l'elenco dei file. Rimuovi le voci indesiderate con l'icona del cestino, oppure fai clic su **Aggiungi altri file** per includere altre email.
3. Configura le opzioni di conversione (vedi sotto).
4. Fai clic su **Converti in PDF**. Lo strumento analizza ogni email, rende il contenuto come HTML formattato e lo converte in PDF tramite il motore PyMuPDF.
5. Una singola email viene scaricata direttamente come PDF. Più email vengono raccolte in `emails-converted.zip`.
## Opzioni
| Opzione | Predefinito | Descrizione |
| :--------------------------------------------------- | :---------- | :------------------------------------------------------------------------------------------------------- |
| **Formato pagina** | A4 | Scegli tra le dimensioni di pagina A4, Letter o Legal. |
| **Includi i destinatari CC e CCN nell'intestazione** | Attivo | Se attiva, gli elenchi dei destinatari CC e CCN compaiono nella sezione intestazione dell'email nel PDF. |
| **Includi l'elenco degli allegati dell'email** | Attivo | Se attiva, nel PDF compare l'elenco degli allegati dell'email (con nomi dei file e dimensioni). |
## Casi d'uso
- Archiviare in PDF la corrispondenza aziendale importante per conformità o audit
- Stampare conversazioni email per procedimenti legali o richieste di produzione di documenti
- Creare una registrazione permanente di conferme d'ordine, ricevute o contratti ricevuti via email
- Fare il backup dei file MSG di Outlook in un formato che non richiede Outlook per essere letto
- Documentare le interazioni con l'assistenza clienti a partire da file EML esportati
## Suggerimenti
- Sono supportati sia i file EML (usati da Thunderbird, Apple Mail e dalla maggior parte dei client di posta) sia i file MSG di Outlook. Esporta le email dal tuo client e trascinale direttamente nello strumento.
- Le email in formato HTML mantengono lo stile nel PDF. Le email in testo semplice vengono rese con una formattazione pulita e leggibile.
- L'elenco degli allegati mostra nomi e dimensioni dei file ma non incorpora i file allegati veri e propri nel PDF.
## Strumenti correlati
- [XML in PDF](./xml-to-pdf)
- [XPS in PDF](./xps-to-pdf)
docs/it/tools/epub-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: EPUB in PDF
description: Converti gli ebook EPUB in PDF nel tuo browser. Gratuito, senza caricamenti, conversione orientata alla privacy.
---
# EPUB in PDF
Converti gli ebook EPUB in file PDF senza uscire dal browser. EPUB è lo standard aperto per i libri digitali, ma a volte serve un PDF a layout fisso per stampare, annotare o condividere con chi non ha un lettore di ebook.
## Formati supportati
| Formato | Estensione | Note |
| :------ | :--------- | :-------------------- |
| EPUB | `.epub` | File EPUB 2 ed EPUB 3 |
## Come funziona
1. Fai clic sull'area di caricamento o trascina i tuoi file EPUB. È supportata la selezione multipla.
2. Controlla i file caricati. Rimuovi le voci indesiderate con l'icona del cestino, oppure fai clic su **Aggiungi altri file** per ampliare il lotto.
3. Fai clic su **Converti in PDF**. Il motore PyMuPDF rende il contenuto dell'EPUB (testo, immagini e formattazione) in un PDF impaginato.
4. Un singolo EPUB viene scaricato direttamente come PDF. Più file vengono raccolti in un archivio ZIP chiamato `epub-converted.zip`.
## Opzioni
La conversione usa impostazioni predefinite sensate e non richiede alcuna configurazione. Il testo si adatta alle dimensioni di pagina standard, mentre font e immagini incorporati vengono mantenuti nel PDF.
## Casi d'uso
- Stampare un ebook privo di DRM per leggerlo lontano dagli schermi
- Inviare un manoscritto EPUB come PDF a layout fisso per la revisione
- Archiviare libri digitali in un formato che ogni sistema operativo può aprire in modo nativo
- Condividere un capitolo con un collega che non ha un lettore EPUB
- Convertire la documentazione tecnica distribuita in EPUB in PDF annotabili
## Suggerimenti
- Le funzionalità di EPUB 3 come audio e video incorporati non vengono trasferite nel PDF, ma tutto il testo, le immagini e le tabelle si convertono correttamente.
- Per ottenere i migliori risultati con EPUB molto stilizzati, controlla le prime pagine dell'output per verificare la fedeltà del layout.
## Strumenti correlati
- [MOBI in PDF](./mobi-to-pdf)
- [FB2 in PDF](./fb2-to-pdf)
- [CBZ in PDF](./cbz-to-pdf)
docs/it/tools/excel-to-pdf.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Excel in PDF
description: Converti fogli di calcolo Excel (XLS, XLSX), ODS e file CSV in PDF preservando la formattazione.
---
# Excel in PDF
Converti i file di fogli di calcolo in PDF. Lo strumento gestisce i file Excel moderni, il vecchio formato XLS, i fogli di calcolo OpenDocument e persino i CSV, il tutto reso tramite un motore LibreOffice nel browser che preserva la formattazione delle celle, le formule (come valori calcolati), i grafici e i layout a più fogli.
## Formati supportati
| Formato | Estensioni |
| :----------------------- | :--------- |
| Excel (moderno) | `.xlsx` |
| Excel (legacy) | `.xls` |
| OpenDocument Spreadsheet | `.ods` |
| CSV | `.csv` |
## Come funziona
1. Fai clic sull'area di caricamento o trascina i tuoi file di fogli di calcolo.
2. Controlla l'elenco dei file. Aggiungine altri o rimuovi quelli indesiderati.
3. Fai clic su **Converti in PDF**. Il motore LibreOffice si inizializza al primo utilizzo, poi elabora ogni file.
4. Un singolo file viene scaricato direttamente come PDF. Più file vengono consegnati come `excel-converted.zip`.
## Opzioni
Questo strumento non ha configurazioni aggiuntive. Il motore LibreOffice determina layout di pagina, scala e area di stampa in base alle impostazioni integrate del foglio di calcolo.
## Output
| Numero di input | Output |
| :-------------- | :--------------------------------------------------------------------- |
| 1 file | Download di un singolo PDF (nome file originale con estensione `.pdf`) |
| 2+ file | Archivio ZIP (`excel-converted.zip`) con un PDF per ogni file |
## Casi d'uso
- Convertire report finanziari o budget da Excel a PDF per la distribuzione
- Creare PDF pronti per la stampa da fogli di calcolo di inventario o cataloghi prodotti
- Condividere i risultati di analisi dei dati con persone che non hanno Excel installato
- Archiviare i report trimestrali in un formato non modificabile
- Convertire in PDF i file ODS di LibreOffice Calc
## Suggerimenti
- I grafici incorporati nel foglio di calcolo vengono resi nel PDF. Assicurati che siano corretti nel file di origine prima di convertire.
- Se il foglio di calcolo ha più fogli, tutti i fogli sono inclusi nel PDF di output.
- Per semplici dati CSV senza formattazione, lo strumento [CSV in PDF](./csv-to-pdf) offre una conversione più leggera. Usa Excel in PDF quando ti serve preservare formattazione, grafici o più fogli.
## Strumenti correlati
- [CSV in PDF](./csv-to-pdf)
- [Word in PDF](./word-to-pdf)
- [PowerPoint in PDF](./powerpoint-to-pdf)
docs/it/tools/extract-attachments.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Estrai allegati
description: Estrai tutti gli allegati incorporati da uno o più PDF e scaricali come archivio ZIP.
---
# Estrai allegati
Estrai ogni allegato incorporato da uno o più file PDF. Tutti i file estratti vengono raccolti in un unico archivio ZIP da scaricare.
## Come funziona
1. Carica uno o più file PDF che contengono allegati incorporati.
2. Fai clic su **Estrai allegati**.
3. Lo strumento analizza ogni PDF alla ricerca di allegati a livello di documento e di pagina.
4. Tutti i file trovati vengono inseriti in un archivio ZIP e scaricati automaticamente.
5. Un messaggio di stato conferma quanti allegati sono stati trovati e la loro dimensione totale.
## Funzionalità
- Estrazione in blocco da più PDF contemporaneamente
- Estrae sia gli allegati a livello di documento sia quelli a livello di pagina
- Produce un unico file ZIP con tutti i file estratti
- Mostra il numero totale di allegati e la dimensione complessiva dei file
- Messaggi di stato chiari se non viene trovato alcun allegato
## Casi d'uso
- Recuperare file di dati incorporati in un PDF di report
- Estrarre risorse di immagini da un portfolio o da un documento di specifiche
- Estrarre materiali supplementari da PDF di formazione o conformità
- Verificare quali file sono incorporati in un lotto di PDF
## Suggerimenti
- Se lo strumento segnala che non ci sono allegati, il PDF potrebbe contenere immagini incorporate o dati di moduli, che non sono allegati di file. Usa [Estrai Immagini](./extract-images) per le immagini incorporate.
- Quando elabori più PDF, tutti gli allegati di ogni file finiscono in un unico ZIP. I nomi dei file originali vengono mantenuti.
## Strumenti correlati
- [Aggiungi Allegati](./add-attachments)
- [Modifica Allegati](./edit-attachments)
- [Estrai Immagini](./extract-images)
docs/it/tools/extract-images.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Estrai immagini
description: Estrai tutte le immagini incorporate dai file PDF. Visualizzale in anteprima in una griglia e scaricale singolarmente o come archivio ZIP.
---
# Estrai immagini
Estrae ogni immagine incorporata da uno o più file PDF. Le immagini estratte vengono mostrate in una griglia di anteprima dove puoi scaricarle singolarmente oppure prenderle tutte insieme in un ZIP. Basato su PyMuPDF.
## Come funziona
1. Carica uno o più PDF facendo clic sull'area di rilascio o trascinandoci sopra i file. Aggiungi altri file o rimuovi quelli singoli secondo necessità.
2. Fai clic su **Estrai immagini** per avviare l'elaborazione.
3. Lo strumento analizza ogni pagina di ogni PDF caricato, trovando ed estraendo le immagini incorporate.
4. Le immagini estratte appaiono in una griglia con le miniature. Ogni immagine ha un pulsante di download.
5. Fai clic su **Scarica tutto** per salvare tutto come archivio ZIP.
## Opzioni
Questo strumento non ha opzioni configurabili. Tutte le immagini incorporate vengono estratte nel loro formato originale (in genere PNG, JPEG o qualunque formato fosse usato quando l'immagine è stata incorporata nel PDF).
## Formato di output
- Le immagini nella griglia di anteprima hanno nomi come `image_1.png`, `image_2.jpg`, ecc.
- **Scarica tutto** produce `extracted-images.zip` con tutte le immagini.
- Le singole immagini possono essere scaricate una alla volta dalla griglia.
## Casi d'uso
- Recuperare foto o grafiche da un PDF per riutilizzarle in un altro progetto.
- Estrarre le immagini dei prodotti da un catalogo PDF per un annuncio di e-commerce.
- Prendere diagrammi dalla documentazione tecnica da usare nelle presentazioni.
- Verificare quali immagini sono incorporate in un documento prima di condividerlo.
## Suggerimenti
- Lo strumento estrae le immagini esattamente come sono memorizzate nel PDF. Non esegue il rendering delle pagine come immagini: per quello usa [PDF in PNG](./pdf-to-png) o [PDF in JPG](./pdf-to-jpg).
- Se lo strumento segnala "Nessuna immagine trovata", il PDF potrebbe usare grafica vettoriale anziché immagini raster incorporate, oppure potrebbe essere un documento scansionato in cui l'intera pagina è una grande immagine.
- L'elaborazione in blocco funziona su più PDF. Tutte le immagini di tutti i file vengono riunite in un'unica griglia e in un unico ZIP.
## Strumenti correlati
- [PDF in PNG](./pdf-to-png)
- [PDF in JPG](./pdf-to-jpg)
- [Workflow Builder PDF](./pdf-workflow)
docs/it/tools/extract-pages.md
+41
View File
@@ -0,0 +1,41 @@
---
title: Estrai pagine
description: Salva un intervallo specifico di pagine di un PDF come nuovo documento.
---
# Estrai pagine
Estrai un insieme di pagine da un PDF e salvale come nuovo file. Indica esattamente quali pagine vuoi usando la sintassi degli intervalli e lo strumento crea un PDF pulito contenente solo quelle pagine.
## Come funziona
1. Carica un file PDF. Lo strumento mostra il nome del file, la dimensione e il numero totale di pagine.
2. Inserisci le pagine da estrarre usando la sintassi degli intervalli (ad es. `1-5`, `3, 7, 10-12`).
3. Facoltativamente, scegli di scaricare ogni intervallo come PDF separato in un archivio ZIP.
4. Fai clic sul pulsante di elaborazione. Le pagine estratte vengono scaricate come nuovo PDF (o ZIP).
## Funzionalità
- Sintassi flessibile degli intervalli: pagine singole, intervalli o combinazioni separate da virgole
- Mostra il numero totale di pagine dopo il caricamento per un facile riferimento
- Opzione per ottenere un unico PDF combinato o file separati in un ZIP
- Preserva il contenuto e la formattazione originali delle pagine
## Casi d'uso
- Estrarre il riepilogo esecutivo (le prime pagine) da un report lungo
- Estrarre un singolo capitolo da un PDF di un libro di testo
- Salvare pagine specifiche di un pacchetto di moduli come documenti autonomi
- Creare un documento di esempio da pagine selezionate di un file più grande
## Suggerimenti
- I numeri di pagina partono da 1. Usa `1` per la prima pagina, non `0`.
- Per rimuovere pagine anziché estrarle, usa [Elimina Pagine](./delete-pages): è l'operazione inversa.
- Se ti serve la selezione visuale delle pagine con le miniature, usa [Dividi PDF](./split-pdf) nella modalità Visual Select.
## Strumenti correlati
- [Dividi PDF](./split-pdf)
- [Elimina Pagine](./delete-pages)
- [Unisci PDF](./merge-pdf)
docs/it/tools/extract-tables.md
+46
View File
@@ -0,0 +1,46 @@
---
title: Estrai Tabelle
description: Rileva ed estrai le tabelle dai documenti PDF. Esporta in CSV, JSON o Markdown con granularità per singola tabella.
---
# Estrai Tabelle
Rileva tutte le tabelle in un PDF e ti permette di esportarle nel formato che preferisci: CSV, JSON o Markdown. Ogni tabella viene estratta singolarmente con metadati di pagina e posizione. Basato sul motore di rilevamento delle tabelle di PyMuPDF.
## Come funziona
1. Carica un PDF facendo clic sull'area di rilascio o trascinandoci sopra un file.
2. Seleziona il **formato di esportazione** preferito: CSV, JSON o Markdown.
3. Fai clic su **Estrai tabelle** per avviare l'elaborazione.
4. Se viene trovata una sola tabella, viene scaricata come singolo file. Più tabelle producono un archivio ZIP con un file per tabella.
## Opzioni
- **Formato di esportazione**: scegli tra:
- **CSV**: valori separati da virgole con le corrette virgolette per i campi che contengono virgole, virgolette o a capo. Adatto a fogli di calcolo e database.
- **JSON**: struttura ad array di array, formattata con indentazione di 2 spazi. Adatto all'uso programmatico.
- **Markdown**: formato di tabella delimitato da barre verticali, generato da PyMuPDF. Adatto a documentazione e file README.
## Formato di output
- **Tabella singola**: `filename_table.csv` (oppure `.json` / `.md`)
- **Più tabelle**: `filename_tables.zip` con file chiamati `table_1_page3.csv`, `table_2_page5.csv`, ecc.
## Casi d'uso
- Estrarre tabelle specifiche da report PDF lunghi senza prelevare i dati dell'intero documento.
- Ottenere le tabelle in formato Markdown da incollare direttamente in issue di GitHub, wiki o documentazione.
- Ricavare dati JSON strutturati dalle tabelle PDF per integrazioni API o script.
- Confrontare le tabelle di versioni PDF diverse esportando entrambe in CSV e confrontandole con un diff.
## Suggerimenti
- Questo strumento offre il controllo per singola tabella. Se vuoi tutte le tabelle in un unico CSV, usa [PDF in CSV](./pdf-to-csv). Per una cartella di lavoro Excel completa, usa [PDF in Excel](./pdf-to-excel).
- Le tabelle che si estendono su più pagine potrebbero essere rilevate come tabelle separate per ogni pagina. Potrebbe essere necessario concatenarle manualmente.
- Se non vengono rilevate tabelle, il PDF potrebbe essere un'immagine scansionata. Esegui prima l'OCR per aggiungere un livello di testo.
## Strumenti correlati
- [PDF in CSV](./pdf-to-csv)
- [PDF in Excel](./pdf-to-excel)
- [PDF in Testo](./pdf-to-text)
docs/it/tools/fb2-to-pdf.md
+43
View File
@@ -0,0 +1,43 @@
---
title: FB2 in PDF
description: Converti gli ebook FictionBook (FB2) in PDF direttamente nel browser. Gratis, privato, senza caricamento su server.
---
# FB2 in PDF
Converti i file FictionBook 2 (FB2) in documenti PDF. FB2 è un formato di ebook basato su XML, popolare in Russia e nell'Europa orientale. Mentre su alcune piattaforme è ben supportato, su altre è praticamente sconosciuto: convertirlo in PDF rende i tuoi libri leggibili ovunque.
## Formati supportati
| Formato | Estensione | Note |
| :------------ | :--------- | :-------------------------- |
| FictionBook 2 | `.fb2` | Formato ebook basato su XML |
## Come funziona
1. Clicca sull'area di caricamento o trascina i tuoi file FB2. La selezione multipla è supportata.
2. Controlla l'elenco dei file. Usa l'icona del cestino per rimuovere singole voci, oppure **Aggiungi altri file** per includerne altri.
3. Clicca su **Converti in PDF**. Il motore PyMuPDF analizza la struttura XML dell'FB2 e la rende come contenuto PDF paginato.
4. Un singolo file viene scaricato direttamente come PDF. Più conversioni vengono raggruppate in `fb2-converted.zip`.
## Opzioni
Non serve alcuna configurazione. Il convertitore gestisce automaticamente la struttura XML dell'FB2, conservando interruzioni di capitolo, formattazione e immagini incorporate.
## Casi d'uso
- Leggere ebook FB2 su dispositivi o app che supportano solo il PDF
- Stampare letteratura in lingua russa distribuita in formato FB2
- Archiviare una libreria FB2 in un formato supportato universalmente
- Condividere un libro con chi ha un lettore che non supporta FictionBook
## Suggerimenti
- I file FB2 sono semplice XML, quindi tendono a essere piccoli e a convertirsi in fretta anche nel browser.
- Se i tuoi file FB2 sono compressi come `.fb2.zip`, estraili prima di caricarli.
## Strumenti correlati
- [EPUB in PDF](./epub-to-pdf)
- [MOBI in PDF](./mobi-to-pdf)
- [XML in PDF](./xml-to-pdf)
docs/it/tools/fix-page-size.md
+44
View File
@@ -0,0 +1,44 @@
---
title: Correggi dimensione pagina
description: Uniforma tutte le pagine di un PDF alla stessa dimensione. Scegli tra i formati carta standard o imposta dimensioni personalizzate.
---
# Correggi dimensione pagina
I PDF assemblati da più fonti hanno spesso pagine di dimensioni diverse: alcune Letter, altre A4, altre del tutto non standard. Questo strumento porta ogni pagina a un'unica dimensione di destinazione, scalando il contenuto per adattarlo o riempire la pagina.
## Come funziona
1. Carica un file PDF.
2. Seleziona una **Dimensione pagina di destinazione** dal menu a tendina (A4, Letter, Legal, A3, A5, Tabloid o Personalizzata).
3. Scegli un **Orientamento**: Automatico mantiene l'orientamento originale di ogni pagina, oppure puoi forzare Verticale o Orizzontale.
4. Scegli una modalità di **Scala del contenuto**: Adatta (conserva tutto il contenuto, può aggiungere margini) o Riempi (riempie la pagina, può tagliare i bordi).
5. Facoltativamente, imposta un **Colore di sfondo** per gli eventuali margini aggiunti.
6. Clicca su **Correggi Dimensione Pagina**.
## Opzioni
- **Dimensioni standard**: A4, Letter, Legal, A3, A5, Tabloid
- **Dimensioni personalizzate**: inserisci larghezza e altezza in pollici o millimetri
- **Orientamento**: Automatico, Verticale, Orizzontale
- **Modalità di scala**: Adatta o Riempi (Ritaglia)
- **Colore di sfondo**: qualsiasi colore per i margini aggiunti
## Casi d'uso
- Normalizzare un PDF unito in cui le pagine provengono da scanner diversi
- Convertire un documento US Letter in A4 per la distribuzione internazionale
- Preparare PDF pronti per la stampa che richiedono un formato di taglio coerente
- Correggere pagine leggermente fuori standard (ad es. 8,49 x 11,02 pollici invece di 8,5 x 11)
## Suggerimenti
- Usa la modalità Adatta per essere certo di non perdere contenuto. La modalità Riempi ha un aspetto più pulito ma può tagliare i bordi.
- Controlla il risultato con lo strumento Dimensioni Pagina per verificare che ogni pagina corrisponda alla dimensione di destinazione.
- Il bianco è il colore di sfondo predefinito; passa a un colore scuro se il tuo documento ha margini scuri.
## Strumenti correlati
- [Dimensioni Pagina](./page-dimensions): controlla le dimensioni delle pagine prima e dopo la correzione
- [Comprimi PDF](./compress-pdf): riduci la dimensione del file dopo l'uniformazione
- [Ritaglia PDF](./crop-pdf): ritaglia le pagine manualmente invece di scalarle automaticamente
docs/it/tools/flatten-pdf.md
+51
View File
@@ -0,0 +1,51 @@
---
title: Appiattisci PDF
description: Appiattisci moduli interattivi e annotazioni in contenuto statico. Rende i campi dei moduli non modificabili e fonde le annotazioni nella pagina.
---
# Appiattisci PDF
L'appiattimento fonde gli elementi interattivi (campi dei moduli, menu a tendina, caselle di controllo, annotazioni, evidenziazioni, note adesive) direttamente nel contenuto della pagina. L'aspetto visivo resta lo stesso, ma nulla è più modificabile o estraibile. È l'equivalente PDF di stampare un modulo compilato e scansionarlo di nuovo, con la differenza che la qualità resta perfetta.
## Come funziona
1. Carica uno o più file PDF.
2. Clicca su **Appiattisci PDF**.
3. Un singolo file viene scaricato direttamente. Più file producono un archivio ZIP.
Lo strumento usa pdf-lib per appiattire i campi dei moduli (tramite `form.flatten()`) e un apposito appiattitore di annotazioni per fondere le annotazioni nel flusso della pagina. Entrambe le operazioni avvengono in un unico passaggio.
## Cosa viene appiattito
- **Campi dei moduli**: campi di testo, caselle di controllo, pulsanti di opzione, menu a tendina, campi firma
- **Annotazioni**: commenti, evidenziazioni, testo barrato, sottolineato, note adesive, timbri, annotazioni a mano libera
- **Elementi interattivi**: pulsanti, azioni attivabili
## Cosa resta invariato
- Il contenuto testuale (resta selezionabile e ricercabile)
- Immagini e grafica
- Layout e dimensioni delle pagine
- Segnalibri e indice
- Collegamenti ipertestuali (a meno che non siano basati su annotazioni)
## Casi d'uso
- Bloccare un modulo compilato in modo che i destinatari non possano modificare le risposte inviate
- Preparare un PDF per l'archiviazione dove gli elementi interattivi non servono
- Risolvere problemi di visualizzazione causati da annotazioni rese in modo diverso dai vari lettori
- Garantire che un documento firmato non possa essere modificato dopo l'applicazione della firma
- Ridurre la dimensione del file eliminando le definizioni dei campi e gli oggetti annotazione
## Suggerimenti
- Appiattisci dopo aver completato tutte le modifiche. Non c'è modo di annullare l'appiattimento di un PDF.
- Se devi appiattire e anche rimuovere metadati, JavaScript e allegati, usa invece lo strumento Sanitizza PDF, che include l'appiattimento tra le sue opzioni.
- Alcuni PDF segnalano "nessun modulo trovato": è normale se il documento ha solo annotazioni e nessun campo di modulo.
## Strumenti correlati
- [Sanitizza PDF](./sanitize-pdf): appiattisci i moduli e rimuovi metadati, script e altro
- [Rasterizza PDF](./rasterize-pdf): converti in un PDF basato su immagini per il massimo appiattimento
- [Font in Contorni](./font-to-outline): appiattisci i font in tracciati vettoriali
- [Cripta PDF](./protect-pdf): proteggi con password il PDF appiattito
docs/it/tools/font-to-outline.md
+52
View File
@@ -0,0 +1,52 @@
---
title: Font in contorni
description: Converti tutti i font del PDF in contorni vettoriali per una resa coerente su ogni dispositivo. Elimina i problemi di dipendenza dai font.
---
# Font in contorni
Convertire i font in contorni trasforma ogni carattere di testo da glifo basato su font a tracciato vettoriale. Il PDF non dipende più da alcun font installato: si visualizza in modo identico su ogni dispositivo, ogni sistema operativo e ogni stampante. È un passaggio standard nei flussi di prestampa.
## Come funziona
1. Carica uno o più file PDF.
2. Clicca su **Converti in Contorni**.
3. Ghostscript converte tutto il testo in tracciati vettoriali.
4. Scarica il risultato. Più file producono un archivio ZIP.
Non ci sono impostazioni da configurare. Lo strumento usa Ghostscript (WebAssembly) per convertire tutti i riferimenti ai font in tracciati a contorno in un unico passaggio.
## Cosa cambia
- I caratteri di testo diventano curve vettoriali (tracciati bezier)
- L'incorporamento dei font non è più necessario: il PDF è autosufficiente a livello di glifo
- La dimensione del file può aumentare perché i tracciati vettoriali sono in genere più grandi dei riferimenti ai font
- L'aspetto visivo viene preservato esattamente
## Cosa perdi
- Selezione e copia-incolla del testo
- Ricercabilità del testo (Ctrl+F smette di funzionare)
- La possibilità di modificare il contenuto testuale
- Accessibilità per i lettori di schermo
## Casi d'uso
- Inviare PDF a una tipografia che richiede font convertiti in contorni
- Condividere documenti che usano font personalizzati o con licenza con persone che non hanno quei font
- Evitare la sostituzione dei font che cambia l'aspetto del documento su altri sistemi
- Preparare PDF per flussi di incisione laser o taglio CNC che richiedono input vettoriale
- Garantire che un PDF ricco di loghi si visualizzi correttamente su tutte le piattaforme
## Suggerimenti
- Conserva il PDF originale. La conversione in contorni è irreversibile: non puoi riconvertire i tracciati in testo modificabile.
- Se hai bisogno che il testo resti ricercabile, valuta invece lo strumento Rasterizza PDF seguito dall'OCR.
- I PDF con contorni tendono a essere più grandi. Esegui Comprimi PDF in seguito se la dimensione conta.
## Strumenti correlati
- [Appiattisci PDF](./flatten-pdf): appiattisci moduli e annotazioni senza toccare i font
- [Rasterizza PDF](./rasterize-pdf): converti in un PDF basato su immagini invece che in contorni vettoriali
- [Comprimi PDF](./compress-pdf): riduci la dimensione del file dopo la conversione in contorni
- [PDF in PDF/A](./pdf-to-pdfa): converti per l'archiviazione dopo aver garantito l'indipendenza dai font
docs/it/tools/form-creator.md
+76
View File
@@ -0,0 +1,76 @@
---
title: Crea modulo PDF
description: Crea moduli PDF compilabili con campi di testo, caselle di controllo, menu a tendina, pulsanti di opzione e altro, con il trascinamento.
---
# Crea modulo PDF
Progetta moduli PDF compilabili professionali da zero o aggiungendo campi a un PDF esistente. L'editor visuale ti permette di trascinare gli elementi del modulo (campi di testo, caselle di controllo, menu a tendina, pulsanti di opzione, campi firma e altro) direttamente sulle anteprime delle pagine. Configura le proprietà dei campi, imposta regole di visibilità condizionale ed esporta un modulo PDF completamente interattivo.
## Come funziona
1. Carica un PDF esistente **oppure** clicca su **Crea PDF vuoto** per iniziare da zero.
2. Se crei un PDF vuoto, seleziona un formato di pagina (Letter, A4, A5, Legal, Tabloid, A3 o dimensioni personalizzate).
3. Si apre l'editor del modulo con una barra degli strumenti dei tipi di campo e un'area di anteprima della pagina.
4. Seleziona un tipo di campo dalla barra degli strumenti, poi clicca sulla pagina per posizionarlo.
5. Trascina i campi per riposizionarli. Usa le maniglie di ridimensionamento per regolare le dimensioni.
6. Clicca su un campo per aprire il pannello delle proprietà, dove puoi impostare nome del campo, valore predefinito, dimensione del carattere, allineamento e altro.
7. Naviga tra le pagine con i controlli di pagina.
8. Clicca su **Salva** per scaricare il PDF compilabile finito.
## Funzionalità
- Posizionamento dei campi con trascinamento e maniglie visive per il ridimensionamento
- Tipi di campo: input di testo, testo su più righe, casella di controllo, menu a tendina, pulsante di opzione, firma, data, numero e codice a barre
- Pannello delle proprietà per configurare nome, etichetta, valore predefinito, dimensione del carattere, colore, allineamento e validazione di ogni campo
- Azioni sui campi e regole di visibilità condizionale (mostra/nascondi campi in base ai valori di altri campi)
- Navigazione tra le pagine per moduli su più pagine
- Estrazione dei campi esistenti: rileva e importa automaticamente i campi dei moduli dai PDF caricati
- Supporto sia per PDF caricati sia per pagine vuote come tela del modulo
- Diversi formati di pagina predefiniti più dimensioni personalizzate
- Generazione di codici a barre con bwip-js
- Gestione dei gruppi di pulsanti di opzione
## Opzioni
**Formati di pagina predefiniti (per PDF vuoti):**
- Letter (8.5" x 11")
- A4 (210mm x 297mm)
- A5 (148mm x 210mm)
- Legal (8.5" x 14")
- Tabloid (11" x 17")
- A3 (297mm x 420mm)
- Personalizzato (specifica larghezza e altezza)
**Proprietà dei campi (variano in base al tipo di campo):**
- Nome, etichetta e testo segnaposto
- Valore predefinito
- Famiglia, dimensione e colore del carattere
- Allineamento del testo (sinistra, centro, destra)
- Interruttore campo obbligatorio
- Interruttore sola lettura
- Lunghezza massima per i campi di testo
- Elenco di opzioni per menu a tendina e pulsanti di opzione
- Azioni di visibilità condizionale
## Casi d'uso
- Creare moduli di inserimento dei dipendenti con campi di testo per i dati personali e caselle di controllo per l'accettazione delle policy
- Creare questionari di accoglienza clienti con menu a tendina per la scelta del servizio
- Progettare moduli d'ordine con campi calcolati e identificatori a codice a barre
- Creare checklist di ispezione con pulsanti di opzione per le valutazioni superato/non superato
- Creare moduli di sondaggio con domande di approfondimento condizionali che compaiono in base alle risposte
## Suggerimenti
- Se carichi un PDF esistente, lo strumento tenta di estrarre i campi del modulo già presenti, così puoi modificarli o aggiungerne altri.
- Usa la funzione dei gruppi di pulsanti di opzione per creare selezioni mutuamente esclusive. I campi dello stesso gruppo condividono un nome di gruppo.
- Testa il tuo modulo scaricandolo e aprendolo nel [Compilatore Moduli PDF](./form-filler) per verificare il comportamento dei campi.
## Strumenti correlati
- [Compilatore Moduli PDF](./form-filler)
- [Firma PDF](./sign-pdf)
- [Editor PDF](./edit-pdf)
docs/it/tools/form-filler.md
+47
View File
@@ -0,0 +1,47 @@
---
title: Compilatore moduli PDF
description: Compila moduli PDF, inclusi i moduli XFA, direttamente nel browser con un visualizzatore integrato.
---
# Compilatore moduli PDF
Apri un PDF con campi di modulo e compilalo direttamente in un visualizzatore integrato. Lo strumento supporta sia i campi AcroForm standard sia i moduli XFA (XML Forms Architecture) legacy. Una volta completato il modulo, scarica la versione compilata con un solo clic.
## Come funziona
1. Carica un PDF che contiene campi di modulo.
2. Il documento si apre in un visualizzatore PDF integrato che mostra i campi del modulo come input interattivi.
3. Clicca su campi di testo, caselle di controllo, menu a tendina e pulsanti di opzione per compilarli.
4. Clicca su **Salva e scarica il modulo compilato** per ottenere il PDF completato.
## Funzionalità
- Visualizzatore PDF.js integrato con piena interazione con i campi del modulo
- Supporto per i campi AcroForm standard (input di testo, caselle di controllo, menu a tendina, pulsanti di opzione)
- Supporto dei moduli XFA per i moduli legacy basati su XML
- Dimensionamento automatico del visualizzatore in base alle dimensioni della pagina
- Visualizzazione del file con nome e dimensione
## Opzioni
Non ci sono opzioni di configurazione aggiuntive. Carica il modulo, compilalo e scaricalo.
## Casi d'uso
- Compilare moduli fiscali, richieste assicurative o pratiche burocratiche
- Compilare moduli di candidatura ricevuti come allegati PDF
- Completare moduli di inserimento fornitori o questionari per fornitori
- Approvare checklist di conformità con campi a casella di controllo
- Compilare moduli di accettazione medica prima di un appuntamento
## Suggerimenti
- I moduli XFA sono un formato legacy supportato solo da alcuni visualizzatori PDF. Se apri un PDF XFA in Chrome o nella maggior parte degli altri strumenti e vedi pagine vuote, significa che quei visualizzatori non supportano XFA. Il Compilatore Moduli di BentoPDF e Firefox gestiscono correttamente XFA.
- Per i PDF senza campi di modulo esistenti, usa lo strumento [Crea Modulo PDF](./form-creator) per aggiungere prima i campi, poi compilali qui.
- Il visualizzatore adatta automaticamente le proprie dimensioni a quelle della pagina del PDF.
## Strumenti correlati
- [Crea Modulo PDF](./form-creator)
- [Firma PDF](./sign-pdf)
- [Editor PDF](./edit-pdf)
docs/it/tools/header-footer.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Intestazione e piè di pagina
description: Aggiungi testo personalizzabile di intestazione e piè di pagina alle pagine PDF con variabili dinamiche per i numeri di pagina.
---
# Intestazione e piè di pagina
Aggiungi testo in sei posizioni delle pagine del tuo PDF: intestazione a sinistra, al centro e a destra, piè di pagina a sinistra, al centro e a destra. Lo strumento supporta variabili dinamiche per il numero di pagina e il totale delle pagine, così puoi creare modelli come "Pagina 3 di 10" che si aggiornano automaticamente per ogni pagina.
## Come funziona
1. Carica il tuo file PDF.
2. Compare il pannello delle opzioni con i controlli di formattazione e sei campi di testo.
3. Inserisci il testo desiderato in una qualsiasi posizione di intestazione o piè di pagina.
4. Usa i segnaposto `{page}` e `{total}` per la numerazione dinamica.
5. Regola dimensione e colore del carattere e, se vuoi, limita l'operazione a un intervallo di pagine.
6. Clicca su **Aggiungi Intestazione e Piè di Pagina** per elaborare e scaricare.
## Opzioni
- **Intervallo di pagine**: limita facoltativamente le pagine che ricevono intestazioni e piè di pagina. Lascia vuoto per applicarlo a tutte le pagine. Formato: "1-3, 5" (intervalli separati da virgole).
- **Dimensione del carattere**: tra 6 e 24 punti. Il valore predefinito è 10.
- **Colore del carattere**: scegli qualsiasi colore con il selettore di colore.
- **Intestazione sinistra / centro / destra**: campi di testo per la parte alta di ogni pagina.
- **Piè di pagina sinistra / centro / destra**: campi di testo per la parte bassa di ogni pagina.
## Funzionalità
- Sei posizioni di testo indipendenti per pagina
- Variabile dinamica `{page}` che inserisce il numero della pagina corrente
- Variabile dinamica `{total}` che inserisce il numero totale di pagine
- Filtro per intervallo di pagine per scegliere pagine specifiche
- Dimensione e colore del carattere personalizzabili
- Font Helvetica per un risultato pulito e professionale
## Casi d'uso
- Aggiungere "Pagina {page} di {total}" al centro del piè di pagina di una relazione
- Inserire il nome dell'azienda nell'intestazione a sinistra e la data del documento nell'intestazione a destra
- Aggiungere avvisi di riservatezza al piè di pagina dei documenti legali
- Applicare i numeri di revisione del documento a specifici intervalli di pagine
## Suggerimenti
- Combina `{page}` e `{total}` in un unico campo per formati come "Pagina {page} di {total}" o "{page}/{total}".
- Puoi lasciare vuota la maggior parte dei campi e compilare solo le posizioni che ti servono. I campi vuoti vengono semplicemente ignorati.
- Per intestazioni più complesse con immagini o loghi, valuta lo strumento [Aggiungi Filigrana](./add-watermark) posizionato nella parte alta della pagina.
## Strumenti correlati
- [Numeri di Pagina](./page-numbers)
- [Aggiungi Filigrana](./add-watermark)
- [Numerazione Bates](./bates-numbering)
docs/it/tools/heic-to-pdf.md
+46
View File
@@ -0,0 +1,46 @@
---
title: HEIC in PDF
description: Converti le immagini HEIC e HEIF di iPhone e iPad in PDF direttamente nel browser.
---
# HEIC in PDF
Converti le immagini HEIC/HEIF in PDF. HEIC è il formato foto predefinito di iPhone e iPad da iOS 11. Questo strumento ti permette di trasformare quelle foto in PDF senza installare software desktop né caricare file su un server.
## Formati supportati
| Formato | Estensioni |
| :------ | :--------- |
| HEIC | `.heic` |
| HEIF | `.heif` |
## Come funziona
1. Clicca sull'area di caricamento o trascina i tuoi file HEIC/HEIF.
2. Controlla l'elenco dei file e rimuovi quelli che non ti servono.
3. Clicca su **Converti in PDF**. Il risultato viene scaricato come `from_heic.pdf`.
Ogni file HEIC viene decodificato con la libreria heic2any, che lo converte in PNG con qualità al 92%. Il PNG viene poi incorporato nel PDF con pdf-lib, con ogni immagine su una pagina a sé alla risoluzione piena.
## Opzioni
Questo strumento non offre impostazioni aggiuntive. Le immagini HEIC vengono convertite in PNG ad alta qualità (0,92) prima dell'incorporamento.
## Casi d'uso
- Creare un PDF dalle foto dell'iPhone da allegare a una richiesta di risarcimento assicurativo o a una relazione
- Convertire le foto HEIC per un annuncio immobiliare in un unico documento stampabile
- Trasformare gli screenshot dell'iPad (formato HEIF) in un PDF condivisibile
- Convertire in blocco le foto delle vacanze per un diario di viaggio
## Suggerimenti
- La decodifica HEIC avviene interamente nel browser con WebAssembly. La prima conversione può richiedere un momento mentre il decodificatore si carica.
- Se devi mescolare HEIC con altri formati di immagine (JPG, PNG, ecc.), usa lo strumento [Immagini in PDF](./image-to-pdf), che gestisce HEIC insieme a tutti gli altri formati.
- I file HEIC degli iPhone contengono spesso dati EXIF, comprese le coordinate GPS. Il PDF risultante non conserva questi metadati.
## Strumenti correlati
- [Immagini in PDF](./image-to-pdf)
- [JPG in PDF](./jpg-to-pdf)
- [PNG in PDF](./png-to-pdf)
docs/it/tools/image-to-pdf.md
+65
View File
@@ -0,0 +1,65 @@
---
title: Immagini in PDF
description: Converti JPG, PNG, BMP, GIF, TIFF, SVG, HEIC, WebP, PSD e più di 10 altri formati di immagine in un unico file PDF.
---
# Immagini in PDF
Il convertitore universale da immagini a PDF. Carica immagini in praticamente qualsiasi formato e uniscile in un unico documento PDF. Ogni immagine ottiene una pagina propria, delle stesse dimensioni dell'originale.
## Formati supportati
| Formato | Estensioni |
| :-------------- | :------------------------------------- |
| 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` |
È il supporto di formati più ampio tra tutti i convertitori di immagini di BentoPDF. Se ti serve un solo formato, usa invece uno degli strumenti dedicati.
## Come funziona
1. Clicca sull'area di caricamento o trascina i tuoi file immagine. Puoi selezionare più file contemporaneamente.
2. Controlla l'elenco dei file. Rimuovi quelli che non ti servono con l'icona del cestino, oppure clicca su **Aggiungi altri file** per includere altre immagini.
3. Scegli un livello di **Qualità PDF** dal menu a tendina.
4. Clicca su **Converti in PDF**. Lo strumento elabora le immagini con il motore PyMuPDF e scarica il risultato come `images_to_pdf.pdf`.
## Opzioni
**Qualità PDF** controlla la compressione applicata alle immagini quando vengono incorporate nel PDF:
- **Alta qualità**: compressione minima, file più grande. Ideale per la stampa o l'archiviazione.
- **Qualità media** (predefinita): compressione bilanciata. Va bene per la maggior parte degli usi.
- **Bassa qualità**: compressione aggressiva, file più piccolo. Adatta a email o condivisioni rapide.
I file HEIC e WebP vengono convertiti automaticamente in PNG prima dell'incorporamento. Questo avviene in modo trasparente e non richiede passaggi extra.
## Casi d'uso
- Unire in un unico PDF ricevute o documenti scansionati con la fotocamera del telefono
- Creare un portfolio fotografico o un lookbook da immagini in formati misti
- Convertire le foto dell'iPhone (HEIC) in un PDF condivisibile senza installare software desktop
- Assemblare mockup di design da esportazioni PSD e screenshot in un documento da consegnare al cliente
- Archiviare una cartella di formati di immagine datati (PNM, JXR, JP2) come un unico PDF
## Suggerimenti
- L'ordine delle immagini nel PDF corrisponde all'ordine in cui compaiono nell'elenco dei file. Caricale nella sequenza che desideri.
- Per ottenere il file più piccolo possibile, scegli Bassa qualità. La differenza visiva è spesso trascurabile per scansioni ricche di testo.
- Se hai un solo formato di immagine, i convertitori dedicati (JPG in PDF, PNG in PDF, ecc.) offrono lo stesso risultato con un'interfaccia più semplice.
## Strumenti correlati
- [JPG in PDF](./jpg-to-pdf)
- [PNG in PDF](./png-to-pdf)
- [HEIC in PDF](./heic-to-pdf)
- [WebP in PDF](./webp-to-pdf)
docs/it/tools/index.md
+183
View File
@@ -0,0 +1,183 @@
# Riferimento degli strumenti
BentoPDF offre **più di 130 strumenti** per lavorare con i PDF. Tutti gli strumenti vengono eseguiti interamente nel tuo browser: i tuoi file non lasciano mai il dispositivo.
---
## Modifica e annota
Modifica, annota e migliora i tuoi documenti PDF con un'ampia suite di strumenti di modifica.
<div class="tool-grid">
- [**Editor PDF**](./edit-pdf): annota, evidenzia, oscura, commenta, aggiungi forme/immagini, cerca e visualizza i PDF.
- [**Modifica Segnalibri**](./bookmark): aggiungi, modifica, importa, elimina ed estrai i segnalibri del PDF.
- [**Indice**](./table-of-contents): genera una pagina di indice dai segnalibri del PDF.
- [**Numeri di Pagina**](./page-numbers): inserisci i numeri di pagina nel documento.
- [**Aggiungi etichette di pagina**](./add-page-labels): applica etichette di pagina PDF con numeri romani, prefissi e inizi personalizzati.
- [**Numerazione Bates**](./bates-numbering): aggiungi numeri Bates sequenziali su uno o più file PDF.
- [**Aggiungi Filigrana**](./add-watermark): sovrapponi testo o un'immagine alle pagine del PDF.
- [**Intestazione e Piè di Pagina**](./header-footer): aggiungi testo nella parte alta e bassa delle pagine.
- [**Inverti Colori**](./invert-colors): crea una versione in modalità scura del tuo PDF.
- [**Effetto scanner**](./scanner-effect): fai sembrare il tuo PDF un documento scansionato.
- [**Regola colori**](./adjust-colors): regola con precisione luminosità, contrasto, saturazione e altro.
- [**Colore di Sfondo**](./background-color): cambia il colore di sfondo del tuo PDF.
- [**Cambia Colore Testo**](./text-color): cambia il colore del testo nel tuo PDF.
- [**Firma PDF**](./sign-pdf): disegna, digita o carica la tua firma.
- [**Aggiungi Timbri**](./add-stamps): aggiungi timbri immagine al tuo PDF con la barra degli strumenti delle annotazioni.
- [**Rimuovi Annotazioni**](./remove-annotations): elimina commenti, evidenziazioni e link.
- [**Ritaglia PDF**](./crop-pdf): rifila i margini di ogni pagina del tuo PDF.
- [**Compilatore Moduli PDF**](./form-filler): compila i moduli direttamente nel browser. Supporta anche i moduli XFA.
- [**Crea Modulo PDF**](./form-creator): crea moduli PDF compilabili con campi di testo trascinabili.
- [**Rimuovi Pagine Vuote**](./remove-blank-pages): rileva ed elimina automaticamente le pagine vuote.
</div>
---
## Converti in PDF
Trasforma immagini, documenti, e-book e altri formati di file in PDF.
<div class="tool-grid">
- [**Immagini in PDF**](./image-to-pdf): converti JPG, PNG, BMP, GIF, TIFF, SVG, HEIC, WebP e altri in PDF.
- [**JPG in PDF**](./jpg-to-pdf): crea un PDF da una o più immagini JPG.
- [**PNG in PDF**](./png-to-pdf): crea un PDF da una o più immagini PNG.
- [**WebP in PDF**](./webp-to-pdf): crea un PDF da una o più immagini WebP.
- [**SVG in PDF**](./svg-to-pdf): crea un PDF da una o più immagini SVG.
- [**BMP in PDF**](./bmp-to-pdf): crea un PDF da una o più immagini BMP.
- [**HEIC in PDF**](./heic-to-pdf): crea un PDF da una o più immagini HEIC.
- [**TIFF in PDF**](./tiff-to-pdf): crea un PDF da una o più immagini TIFF.
- [**Testo in PDF**](./txt-to-pdf): converti un file di testo semplice in PDF.
- [**Markdown in PDF**](./markdown-to-pdf): converti Markdown in PDF con anteprima dal vivo ed evidenziazione della sintassi.
- [**JSON in PDF**](./json-to-pdf): converti file JSON in formato PDF.
- [**ODT in PDF**](./odt-to-pdf): converti file ODT (OpenDocument Text) in PDF.
- [**CSV in PDF**](./csv-to-pdf): converti fogli di calcolo CSV in PDF.
- [**RTF in PDF**](./rtf-to-pdf): converti documenti RTF (Rich Text Format) in PDF.
- [**Word in PDF**](./word-to-pdf): converti documenti Word (DOCX, DOC, ODT) in PDF.
- [**Excel in PDF**](./excel-to-pdf): converti fogli di calcolo Excel (XLSX, XLS, ODS) in PDF.
- [**PowerPoint in PDF**](./powerpoint-to-pdf): converti presentazioni PowerPoint (PPTX, PPT, ODP) in PDF.
- [**XPS in PDF**](./xps-to-pdf): converti documenti XPS/OXPS in PDF.
- [**MOBI in PDF**](./mobi-to-pdf): converti e-book MOBI in PDF.
- [**EPUB in PDF**](./epub-to-pdf): converti e-book EPUB in PDF.
- [**FB2 in PDF**](./fb2-to-pdf): converti e-book FictionBook (FB2) in PDF.
- [**CBZ in PDF**](./cbz-to-pdf): converti archivi di fumetti (CBZ/CBR) in PDF.
- [**WPD in PDF**](./wpd-to-pdf): converti documenti WordPerfect (WPD) in PDF.
- [**WPS in PDF**](./wps-to-pdf): converti documenti WPS Office in PDF.
- [**XML in PDF**](./xml-to-pdf): converti documenti XML in PDF.
- [**ODG in PDF**](./odg-to-pdf): converti OpenDocument Graphics (ODG) in PDF.
- [**ODS in PDF**](./ods-to-pdf): converti OpenDocument Spreadsheet (ODS) in PDF.
- [**ODP in PDF**](./odp-to-pdf): converti OpenDocument Presentation (ODP) in PDF.
- [**PUB in PDF**](./pub-to-pdf): converti Microsoft Publisher (PUB) in PDF.
- [**VSD in PDF**](./vsd-to-pdf): converti Microsoft Visio (VSD, VSDX) in PDF.
- [**PSD in PDF**](./psd-to-pdf): converti file Adobe Photoshop (PSD) in PDF.
- [**Email in PDF**](./email-to-pdf): converti file email (EML, MSG) in formato PDF.
</div>
---
## Converti da PDF
Estrai il contenuto dei PDF in immagini, documenti e formati di dati.
<div class="tool-grid">
- [**PDF in JPG**](./pdf-to-jpg): converti ogni pagina del PDF in un'immagine JPG.
- [**PDF in PNG**](./pdf-to-png): converti ogni pagina del PDF in un'immagine PNG.
- [**PDF in WebP**](./pdf-to-webp): converti ogni pagina del PDF in un'immagine WebP.
- [**PDF in BMP**](./pdf-to-bmp): converti ogni pagina del PDF in un'immagine BMP.
- [**PDF in TIFF**](./pdf-to-tiff): converti ogni pagina del PDF in un'immagine TIFF.
- [**PDF in CBZ**](./pdf-to-cbz): converti un PDF in un CBZ (archivio di fumetti) per lettori di fumetti e Calibre.
- [**PDF in SVG**](./pdf-to-svg): converti ogni pagina del PDF in una grafica vettoriale scalabile.
- [**PDF in CSV**](./pdf-to-csv): estrai le tabelle dal PDF e convertile in formato CSV.
- [**PDF in Excel**](./pdf-to-excel): estrai le tabelle dal PDF e convertile in Excel (XLSX).
- [**PDF in scala di grigi**](./pdf-to-greyscale): converti tutti i colori in bianco e nero.
- [**PDF in JSON**](./pdf-to-json): converti file PDF in formato JSON.
- [**PDF in Word**](./pdf-to-word): converti file PDF in documenti Word modificabili.
- [**Estrai immagini**](./extract-images): estrai tutte le immagini incorporate dai tuoi file PDF.
- [**PDF in Markdown**](./pdf-to-markdown): converti testo e tabelle del PDF in formato Markdown.
- [**Prepara PDF per IA**](./prepare-pdf-for-ai): estrai il contenuto del PDF come JSON LlamaIndex per pipeline RAG/LLM.
- [**PDF in Testo**](./pdf-to-text): estrai il testo dai file PDF e salvalo come testo semplice.
- [**Estrai tabelle PDF**](./extract-tables): estrai le tabelle dai PDF come CSV, JSON o Markdown.
</div>
---
## Organizza e gestisci
Riorganizza, combina, dividi e gestisci le pagine e i file PDF.
<div class="tool-grid">
- [**Costruttore di workflow PDF**](./pdf-workflow): crea pipeline di elaborazione PDF personalizzate con un editor visuale a nodi.
- [**Strumento PDF multifunzione**](./pdf-multi-tool): editor PDF completo con gestione delle pagine.
- [**OCR PDF**](./ocr-pdf): rendi un PDF ricercabile e copiabile.
- [**Unisci PDF**](./merge-pdf): combina più PDF in un unico file.
- [**Alterna e Riordina Pagine**](./alternate-merge): unisci i PDF alternando le pagine di ciascuno.
- [**Fascicola scansione fronte/retro**](./duplex-collate): riordina i blocchi di scansione fronte/retro nella sequenza di pagine corretta.
- [**Duplica e Organizza**](./organize-pdf): duplica, riordina ed elimina pagine.
- [**Aggiungi Allegati**](./add-attachments): incorpora uno o più file nel tuo PDF.
- [**Estrai Allegati**](./extract-attachments): estrai tutti i file incorporati dai PDF come ZIP.
- [**Modifica Allegati**](./edit-attachments): visualizza o rimuovi gli allegati nel tuo PDF.
- [**Livelli PDF (OCG)**](./pdf-layers): visualizza, attiva/disattiva, aggiungi ed elimina i livelli OCG nel tuo PDF.
- [**Dividi PDF**](./split-pdf): estrai un intervallo di pagine in un nuovo PDF.
- [**Dividi Pagine**](./divide-pages): dividi le pagine in orizzontale o in verticale.
- [**Estrai Pagine**](./extract-pages): salva una selezione di pagine come nuovi file.
- [**Elimina Pagine**](./delete-pages): rimuovi pagine specifiche dal documento.
- [**Aggiungi Pagina Vuota**](./add-blank-page): inserisci una pagina vuota in qualsiasi punto del tuo PDF.
- [**Inverti Pagine**](./reverse-pages): inverti l'ordine di tutte le pagine del documento.
- [**Ruota PDF**](./rotate-pdf): ruota le pagine a incrementi di 90 gradi.
- [**Ruota di Gradi Personalizzati**](./rotate-custom): ruota le pagine di qualsiasi angolo personalizzato.
- [**N-Up PDF**](./n-up-pdf): disponi più pagine su un unico foglio.
- [**Opuscolo PDF**](./pdf-booklet): riordina le pagine per la stampa di opuscoli fronte/retro.
- [**Combina in Una Pagina**](./combine-single-page): unisci tutte le pagine in un unico scorrimento continuo.
- [**Visualizza Metadati**](./view-metadata): ispeziona le proprietà nascoste del tuo PDF.
- [**Modifica Metadati**](./edit-metadata): cambia autore, titolo e altre proprietà.
- [**PDF in ZIP**](./pdf-to-zip): raggruppa più file PDF in un archivio ZIP.
- [**Confronta PDF**](./compare-pdfs): confronta due PDF affiancati.
- [**Posterizza PDF**](./posterize-pdf): dividi una pagina grande in più pagine più piccole.
</div>
---
## Ottimizza e ripara
Comprimi, correggi e ottimizza i tuoi PDF per prestazioni e compatibilità migliori.
<div class="tool-grid">
- [**Comprimi PDF**](./compress-pdf): riduci la dimensione del file del tuo PDF.
- [**PDF in PDF/A**](./pdf-to-pdfa): converti il PDF in PDF/A per l'archiviazione a lungo termine.
- [**Correggi Dimensione Pagina**](./fix-page-size): uniforma tutte le pagine a una dimensione comune.
- [**Linearizza PDF**](./linearize-pdf): ottimizza il PDF per una visualizzazione web rapida.
- [**Dimensioni Pagina**](./page-dimensions): analizza dimensione, orientamento e unità della pagina.
- [**Rimuovi Restrizioni**](./remove-restrictions): rimuovi la protezione con password e le restrizioni di sicurezza.
- [**Ripara PDF**](./repair-pdf): recupera i dati da file PDF corrotti o danneggiati.
- [**Rasterizza PDF**](./rasterize-pdf): converti il PDF in un PDF basato su immagini. Appiattisci i livelli e rimuovi il testo selezionabile.
- [**Raddrizza PDF**](./deskew-pdf): raddrizza automaticamente le pagine scansionate inclinate con OpenCV.
- [**Font in Contorni**](./font-to-outline): converti tutti i font in contorni vettoriali per una resa coerente.
</div>
---
## Proteggi il PDF
Proteggi, cripta e controlla l'accesso ai tuoi documenti PDF.
<div class="tool-grid">
- [**Cripta PDF**](./protect-pdf): proteggi il tuo PDF aggiungendo una password.
- [**Sanitizza PDF**](./sanitize-pdf): rimuovi metadati, annotazioni, script e altro.
- [**Decrittografa PDF**](./unlock-pdf): sblocca il PDF rimuovendo la protezione con password.
- [**Appiattisci PDF**](./flatten-pdf): rendi non modificabili i campi dei moduli e le annotazioni.
- [**Rimuovi metadati**](./remove-metadata): elimina i dati nascosti dal tuo PDF.
- [**Modifica permessi**](./change-permissions): imposta o cambia i permessi utente su un PDF.
- [**Firma digitale PDF**](./digital-sign-pdf): aggiungi una firma digitale crittografica con certificati X.509.
- [**Verifica firma PDF**](./validate-signature-pdf): verifica le firme digitali e visualizza i dettagli del certificato.
</div>
docs/it/tools/invert-colors.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Inverti colori
description: Inverti tutti i colori del tuo PDF per creare una versione in modalità scura di qualsiasi documento.
---
# Inverti colori
Trasforma ogni colore del tuo PDF nel suo inverso. Gli sfondi bianchi diventano neri, il testo nero diventa bianco e tutti gli altri colori passano ai rispettivi complementari. È il modo più rapido per creare una versione "modalità scura" di qualsiasi PDF.
## Come funziona
1. Carica il tuo file PDF.
2. Clicca su **Inverti Colori** per elaborare.
3. Il PDF invertito viene scaricato automaticamente.
Non ci sono impostazioni aggiuntive. Lo strumento renderizza ogni pagina come immagine, inverte tutti i colori dei pixel e riassembla il risultato in un nuovo PDF.
## Funzionalità
- Inversione dei colori con un clic per tutte le pagine
- Elabora ogni pagina del documento
- Mantiene dimensioni e layout originali delle pagine
- Funziona con qualsiasi PDF, indipendentemente dal contenuto (testo, immagini, misto)
## Casi d'uso
- Creare versioni in modalità scura di libri di testo o manuali per una lettura notturna più comoda
- Preparare versioni ad alto contrasto dei documenti per scopi di accessibilità
- Invertire documenti scansionati acquisiti con un'esposizione errata
- Generare versioni in negativo di PDF ricchi di immagini per l'analisi visiva
## Suggerimenti
- Poiché lo strumento rasterizza le pagine per applicare l'effetto, il risultato è basato su immagini. Il testo non sarà più selezionabile né ricercabile. Se ti serve testo ricercabile dopo l'inversione, passa il risultato in uno strumento OCR.
- Per regolazioni dei colori più precise (luminosità, contrasto, saturazione), usa invece lo strumento [Regola Colori](./adjust-colors).
- I PDF grandi con molte pagine possono richiedere più tempo, perché ogni pagina viene renderizzata e invertita singolarmente.
## Strumenti correlati
- [Regola Colori](./adjust-colors)
- [Colore di Sfondo](./background-color)
- [Effetto Scanner](./scanner-effect)
docs/it/tools/jpg-to-pdf.md
+48
View File
@@ -0,0 +1,48 @@
---
title: JPG in PDF
description: Converti una o più immagini JPG, JPEG e JPEG 2000 in un unico file PDF direttamente nel browser.
---
# JPG in PDF
Trasforma le immagini JPG in un PDF pulito. Carica un file o più JPG insieme: ogni immagine diventa una pagina a dimensione piena nel documento finale.
## Formati supportati
| Formato | Estensioni |
| :-------- | :-------------- |
| JPEG | `.jpg`, `.jpeg` |
| JPEG 2000 | `.jp2`, `.jpx` |
## Come funziona
1. Clicca sull'area di caricamento o trascina i tuoi file JPG. La selezione multipla è supportata.
2. Controlla i file caricati. Usa l'icona del cestino per rimuovere singoli file, oppure clicca su **Aggiungi altri file** per aggiungerne all'elenco.
3. Seleziona un livello di **Qualità PDF**.
4. Clicca su **Converti in PDF**. Lo strumento comprime le immagini in base all'impostazione di qualità, le converte con il motore PyMuPDF e scarica `from_jpgs.pdf`.
## Opzioni
**Qualità PDF** regola la compressione applicata a ogni immagine prima che venga incorporata nel PDF:
- **Alta qualità**: conserva il massimo dettaglio. Da usare per fotografia o stampa.
- **Qualità media** (predefinita): un buon equilibrio tra nitidezza e dimensione del file.
- **Bassa qualità**: compressione aggressiva per il file più piccolo.
## Casi d'uso
- Convertire documenti scansionati salvati come JPG in un unico PDF da inviare
- Raccogliere foto di prodotto in un catalogo per i clienti
- Trasformare immagini mediche o satellitari JPEG 2000 in un PDF portabile
- Creare un album fotografico stampabile dalle esportazioni della fotocamera
## Suggerimenti
- I file JPEG 2000 (`.jp2`, `.jpx`) sono pienamente supportati, non solo il JPEG standard. È utile per l'imaging medico e i dati geospaziali.
- Se i tuoi JPG provengono dalla fotocamera di un telefono, la qualità Media di solito produce un file più piccolo del 40-60% rispetto ad Alta, senza differenze visibili a schermo.
## Strumenti correlati
- [Immagini in PDF](./image-to-pdf)
- [PNG in PDF](./png-to-pdf)
- [WebP in PDF](./webp-to-pdf)
docs/it/tools/json-to-pdf.md
+53
View File
@@ -0,0 +1,53 @@
---
title: JSON in PDF
description: Ricostruisci i file PDF dal formato JSON di BentoPDF. Riconverti le esportazioni JSON nei documenti PDF originali.
---
# JSON in PDF
Ricostruisci documenti PDF a partire da file JSON creati in precedenza con lo strumento **PDF in JSON** di BentoPDF. È uno strumento di conversione di andata e ritorno: prende la rappresentazione strutturata in JSON di un PDF e ricostruisce il documento originale.
::: warning
Questo strumento accetta solo file JSON prodotti dal convertitore PDF in JSON di BentoPDF. I file JSON standard provenienti da API, database o altri strumenti non sono supportati.
:::
## Formati supportati
| Input | Descrizione |
| :------ | :---------------------------------------------------------- |
| `.json` | File JSON esportati dallo strumento PDF in JSON di BentoPDF |
## Come funziona
1. Clicca sull'area di caricamento o trascina uno o più file JSON.
2. L'elenco dei file mostra ogni file selezionato con la sua dimensione.
3. Clicca su **Converti in PDF**. Lo strumento elabora tutti i file con un Web Worker e il motore CPDF.
4. Il risultato viene scaricato come `jsons-to-pdf.zip`, contenente un PDF per ogni file JSON in ingresso.
La conversione viene eseguita in un Web Worker in background, quindi l'interfaccia resta reattiva anche con file di grandi dimensioni.
## Opzioni
Questo strumento non ha opzioni configurabili. La struttura del JSON determina interamente il PDF risultante.
## Output
Quando converti più file JSON, i risultati vengono consegnati come archivio ZIP. Ogni PDF prende il nome del file JSON di origine (ad es. `report.json` diventa `report.pdf`).
## Casi d'uso
- Ripristinare PDF da un backup o da una pipeline di archiviazione basati su JSON
- Far passare un PDF attraverso il JSON per ispezionarlo e poi riconvertirlo in PDF
- Ricostruire documenti dopo modifiche programmatiche alla struttura JSON
- Verificare che un'esportazione da PDF a JSON abbia catturato tutto il contenuto del documento riconvertendola
## Suggerimenti
- Se devi convertire dati JSON arbitrari (come risposte di API o file di configurazione) in un PDF formattato, lo strumento [Testo in PDF](./txt-to-pdf) è più adatto. Incolla il JSON come testo e verrà reso con una formattazione adeguata.
- Il motore WebAssembly CPDF deve essere disponibile perché questo strumento funzioni. Le istanze self-hosted richiedono la configurazione dei file WASM di CPDF.
## Strumenti correlati
- [Testo in PDF](./txt-to-pdf)
- [Markdown in PDF](./markdown-to-pdf)
- [CSV in PDF](./csv-to-pdf)
docs/it/tools/linearize-pdf.md
+49
View File
@@ -0,0 +1,49 @@
---
title: Linearizza PDF
description: Ottimizza i file PDF per una visualizzazione web rapida con caricamento progressivo. Noto anche come ottimizzazione "Fast Web View".
---
# Linearizza PDF
La linearizzazione ristruttura un PDF in modo che la prima pagina possa essere mostrata prima che l'intero file sia stato scaricato. Adobe la chiama "Fast Web View". Se ospiti PDF su un sito web o li servi tramite un portale documentale, la linearizzazione li fa aprire in modo molto più rapido.
## Come funziona
1. Carica uno o più file PDF.
2. Clicca su **Linearizza PDF**.
3. Scarica i risultati come archivio ZIP contenente tutti i file linearizzati.
Non ci sono impostazioni da configurare. Lo strumento usa il flag `--linearize` di QPDF, che riorganizza la struttura interna del PDF senza alterarne il contenuto visivo.
## Cosa fa la linearizzazione
- Riordina gli oggetti del PDF in modo che i dati della prima pagina compaiano all'inizio del file
- Aggiunge un dizionario di linearizzazione e tabelle di suggerimento, così i visualizzatori sanno dove trovare ogni pagina
- Abilita le richieste byte-range: un browser può scaricare solo la prima pagina senza scaricare l'intero file
- Ripulisce la tabella dei riferimenti incrociati per un accesso casuale efficiente
## Funzionalità
- Elaborazione in blocco di più PDF in una sola operazione
- Il risultato conserva tutti i contenuti, i font, le immagini e gli elementi interattivi
- Usa QPDF (WebAssembly) per una linearizzazione affidabile e conforme agli standard
- I risultati vengono raggruppati in un file ZIP per un download comodo
## Casi d'uso
- Ospitare report PDF su un sito web dove gli utenti si aspettano la visualizzazione immediata delle pagine
- Incorporare PDF in applicazioni web con visualizzatori nel browser
- Pubblicare cataloghi o manuali PDF consultati su connessioni mobili lente
- Preparare documenti per le reti di distribuzione dei contenuti (CDN) che supportano il servizio byte-range
## Suggerimenti
- Linearizza dopo aver completato tutte le altre modifiche. Qualsiasi modifica successiva (unione, aggiunta di pagine) interrompe la linearizzazione.
- Combinala con Comprimi PDF per ottenere PDF il più piccoli e veloci da caricare possibile.
- La linearizzazione aggiunge un piccolo sovraccarico alla dimensione del file (in genere meno dell'1%).
## Strumenti correlati
- [Comprimi PDF](./compress-pdf): riduci la dimensione del file prima di linearizzare
- [Ripara PDF](./repair-pdf): correggi i problemi strutturali che impediscono la linearizzazione
- [Rimuovi Metadati](./remove-metadata): elimina i metadati prima di pubblicare online
docs/it/tools/markdown-to-pdf.md
+59
View File
@@ -0,0 +1,59 @@
---
title: Markdown in PDF
description: Scrivi o incolla Markdown ed esportalo come PDF formattato in modo professionale, con anteprima dal vivo ed evidenziazione della sintassi.
---
# Markdown in PDF
Un editor Markdown completo con anteprima dal vivo ed esportazione in PDF con un clic. Scrivi da zero, carica un file `.md` esistente o incolla il contenuto dagli appunti. L'editor rende il tuo Markdown in tempo reale ed esporta un PDF con stile usando il motore di stampa integrato nel browser.
## Formati supportati
| Input | Descrizione |
| :------------ | :------------------------------ |
| File `.md` | Caricali con il pulsante Carica |
| Input diretto | Scrivi o incolla nell'editor |
## Come funziona
1. Apri lo strumento Markdown in PDF. L'editor si carica con una vista divisa: sorgente Markdown a sinistra, anteprima renderizzata a destra.
2. Scrivi il tuo Markdown, incollalo oppure clicca su **Carica** per caricare un file `.md`.
3. Passa dal tema chiaro a quello scuro con il cursore del tema nella barra degli strumenti.
4. Clicca su **Esporta PDF** (oppure premi `Ctrl/Cmd + S`) per generare un PDF tramite la finestra di stampa del browser.
## Funzionalità
L'editor supporta un ampio insieme di funzionalità Markdown oltre alle basi:
- **Markdown standard**: titoli, grassetto, corsivo, link, immagini, elenchi, citazioni, linee orizzontali
- **Blocchi di codice** con evidenziazione della sintassi per più di 15 linguaggi (JavaScript, TypeScript, Python, Go, Rust, SQL, Java, C#, C++, YAML, Bash e altri)
- **Diagrammi Mermaid**: diagrammi di flusso, diagrammi di sequenza, diagrammi ER e altri tipi di grafici Mermaid vengono resi direttamente nell'anteprima
- **Tabelle** con la sintassi standard delle tabelle Markdown
- **Elenchi di attività** con caselle di controllo
- **Note a piè di pagina**, **pedici**, **apici**
- **Elenchi di definizioni**, **abbreviazioni**
- Supporto per le **emoji** (`:smile:` viene reso come emoji)
- **Evidenziazioni** (`==marked text==`) e **inserimenti** (`++inserted text++`)
- **URL con link automatico**: gli URL semplici vengono convertiti in link cliccabili
- Generazione dell'**indice**
- **Link di ancoraggio** sui titoli
## Casi d'uso
- Scrivere la documentazione di un progetto ed esportare un PDF curato per gli stakeholder
- Creare report tecnici con esempi di codice e diagrammi di architettura Mermaid
- Convertire un README di GitHub in PDF per l'uso offline o la stampa
- Redigere una proposta o una specifica con elenchi di attività e tabelle
- Generare una dispensa con stile a partire da appunti di lezione scritti in Markdown
## Suggerimenti
- L'output PDF usa la funzione di stampa in PDF del browser. In Chrome puoi personalizzare margini e scala nella finestra di stampa prima di salvare.
- I diagrammi Mermaid vengono resi nell'anteprima, ma al primo utilizzo possono richiedere un momento per inizializzarsi.
- Usa `Ctrl/Cmd + S` come scorciatoia da tastiera per esportare senza cercare il pulsante.
## Strumenti correlati
- [Testo in PDF](./txt-to-pdf)
- [Word in PDF](./word-to-pdf)
- [JSON in PDF](./json-to-pdf)
docs/it/tools/merge-pdf.md
+54
View File
@@ -0,0 +1,54 @@
---
title: Unisci PDF
description: Combina più file PDF in un unico documento con riordinamento tramite trascinamento e controllo a livello di pagina.
---
# Unisci PDF
Combina più file PDF in un unico documento. Puoi unire file interi in un ordine specifico, oppure passare alla Modalità Pagina per avere un controllo preciso sulle singole pagine di ogni PDF caricato.
## Come funziona
1. Carica due o più file PDF cliccando sull'area di rilascio o trascinandoli.
2. Scegli tra **Modalità File** e **Modalità Pagina** con l'interruttore in alto.
3. In Modalità File, trascina i file per riordinarli e, se vuoi, specifica gli intervalli di pagine (ad es. `1-3, 5`) per ciascun file. Lascia l'intervallo vuoto per includere tutte le pagine.
4. In Modalità Pagina, trascina le miniature delle singole pagine per costruire l'esatta sequenza di pagine.
5. Clicca su **Unisci PDF** per combinare tutto in un unico file. Il PDF unito viene scaricato automaticamente.
## Funzionalità
- Due modalità di unione: Modalità File per combinare rapidamente file interi, Modalità Pagina per il controllo pagina per pagina
- Riordinamento con trascinamento in entrambe le modalità, con animazioni fluide
- La sintassi degli intervalli di pagine (ad es. `1-3, 5, 8-10`) permette di scegliere le pagine senza passare alla Modalità Pagina
- Le miniature delle pagine vengono caricate al bisogno, così l'interfaccia resta reattiva anche con documenti grandi
- Nessun limite al numero di file o al totale delle pagine
- Conserva la qualità originale del PDF senza ricodifica
## Opzioni
| Opzione | Descrizione |
| ------------------- | --------------------------------------------------------------------------------------------------------- |
| **Modalità File** | Unisci file interi in un ordine personalizzato, con filtri facoltativi per intervallo di pagine per file |
| **Modalità Pagina** | Griglia visiva di tutte le pagine di tutti i file: trascina le miniature per costruire la sequenza esatta |
| **Campo Pagine** | Campo di testo per file che accetta intervalli come `1-3, 5` per includere solo pagine specifiche |
## Casi d'uso
- Combinare PDF di capitoli separati in un unico libro o relazione
- Unire una lettera di presentazione e un curriculum in un unico documento di candidatura
- Estrarre pagine specifiche da più documenti di origine in un file consolidato
- Raccogliere ricevute o fatture scansionate in un unico PDF d'archivio
- Creare una dispensa di presentazione con diapositive provenienti da più presentazioni
## Suggerimenti
- Usa la Modalità Pagina quando devi alternare pagine di file diversi invece di accodare un file dopo l'altro.
- Puoi aggiungere altri file dopo il caricamento iniziale con il pulsante **Aggiungi altri file** senza perdere la disposizione attuale.
- Gli intervalli di pagine partono da 1, quindi `1` indica la prima pagina di quel file.
## Strumenti correlati
- [Dividi PDF](./split-pdf)
- [Duplica e Organizza](./organize-pdf)
- [Alterna e Riordina Pagine](./alternate-merge)
- [Elimina Pagine](./delete-pages)
docs/it/tools/mobi-to-pdf.md
+43
View File
@@ -0,0 +1,43 @@
---
title: MOBI in PDF
description: Converti i file ebook MOBI in PDF direttamente nel browser. Gratis, privato, senza caricamento di file.
---
# MOBI in PDF
Converti gli ebook MOBI di Amazon Kindle in documenti PDF. I file MOBI sono legati ai dispositivi e alle app Kindle, quindi è difficile leggerli altrove. Convertirli in PDF ti dà una versione portabile che puoi aprire su qualsiasi dispositivo o stampare.
## Formati supportati
| Formato | Estensione | Note |
| :------ | :--------- | :-------------------------------- |
| MOBI | `.mobi` | Formato ebook Kindle (Mobipocket) |
## Come funziona
1. Clicca sull'area di caricamento o trascina uno o più file MOBI.
2. Controlla l'elenco dei file. Rimuovi quelli che non ti servono con l'icona del cestino, oppure usa **Aggiungi altri file** per includere altri ebook.
3. Clicca su **Converti in PDF**. Il motore PyMuPDF analizza la struttura del MOBI e rende ogni pagina come contenuto PDF.
4. Un singolo file viene scaricato come PDF. Se converti più file, ottieni un archivio ZIP chiamato `mobi-converted.zip`.
## Opzioni
Non servono impostazioni aggiuntive. La conversione conserva il contenuto testuale, la formattazione e le immagini incorporate del file MOBI originale.
## Casi d'uso
- Leggere contenuti acquistati su Kindle su un e-reader non Kindle che supporta solo il PDF
- Stampare capitoli di un ebook per lo studio o le annotazioni offline
- Archiviare la tua libreria personale di ebook in un formato universale
- Condividere estratti con chi non ha l'app Kindle installata
## Suggerimenti
- I file MOBI protetti da DRM non possono essere convertiti. Lo strumento funziona solo con file MOBI senza DRM.
- Gli ebook grandi con molte immagini incorporate possono richiedere qualche secondo in più, perché tutto avviene nel browser.
## Strumenti correlati
- [EPUB in PDF](./epub-to-pdf)
- [FB2 in PDF](./fb2-to-pdf)
- [CBZ in PDF](./cbz-to-pdf)
docs/it/tools/n-up-pdf.md
+54
View File
@@ -0,0 +1,54 @@
---
title: N-Up PDF
description: Disponi più pagine PDF su un unico foglio in una griglia per una stampa compatta.
---
# N-Up PDF
Posiziona più pagine su un unico foglio in una disposizione a griglia. Questo riduce il numero di pagine stampate inserendo 2, 4, 6, 8, 9 o 16 pagine per foglio. Lo strumento gestisce scala, posizionamento e configurazione facoltativa del formato di pagina.
## Come funziona
1. Carica un file PDF.
2. Seleziona il numero di pagine per foglio (il valore "N"): 2, 4, 6, 8, 9 o 16.
3. Scegli il formato della pagina di output (il predefinito è A4) e l'orientamento.
4. Facoltativamente, configura spaziatura, colore del bordo e colore di sfondo.
5. Clicca sul pulsante di elaborazione. Lo strumento scala ogni pagina e le dispone a mosaico su nuovi fogli.
## Funzionalità
- Disposizioni a griglia: 2-up, 4-up, 6-up, 8-up, 9-up e 16-up
- Formato e orientamento della pagina di output configurabili
- Spaziatura facoltativa tra le pagine affiancate
- Impostazioni di colore di sfondo e bordo
- Mantiene le proporzioni delle pagine originali durante il ridimensionamento
## Opzioni
| Opzione | Descrizione |
| --------------------- | ----------------------------------------------------------------------------------- |
| **Pagine per foglio** | Numero di pagine originali da inserire in ogni pagina di output (2, 4, 6, 8, 9, 16) |
| **Formato pagina** | Dimensione del foglio di output (A4, Letter, Legal, ecc.) |
| **Orientamento** | Verticale o Orizzontale per il foglio di output |
| **Spaziatura** | Distanza in punti tra le pagine affiancate |
| **Colore di sfondo** | Colore di riempimento dello sfondo del foglio di output |
| **Colore del bordo** | Colore dei bordi attorno a ogni pagina affiancata |
## Casi d'uso
- Stampare dispense con 4 diapositive per pagina per risparmiare carta
- Creare fogli di studio con più pagine di riferimento su un solo foglio
- Produrre archivi di documenti compatti da archiviare
- Generare fogli panoramici con miniature di un documento lungo
## Suggerimenti
- L'orientamento orizzontale funziona spesso meglio per le disposizioni 2-up, mentre quello verticale è di solito ideale da 4-up in su.
- Aumentare la spaziatura migliora la leggibilità ma riduce l'area disponibile per ogni pagina affiancata.
- Per l'operazione inversa (dividere una pagina in più pagine), vedi [Posterizza PDF](./posterize-pdf).
## Strumenti correlati
- [Posterizza PDF](./posterize-pdf)
- [Opuscolo PDF](./pdf-booklet)
- [Combina in Una Pagina](./combine-single-page)
docs/it/tools/ocr-pdf.md
+54
View File
@@ -0,0 +1,54 @@
---
title: OCR PDF
description: Rendi ricercabili e copiabili i PDF scansionati con Tesseract OCR, con supporto multilingue e filtro dei caratteri.
---
# OCR PDF
Trasforma i documenti scansionati in PDF ricercabili e copiabili. Lo strumento usa Tesseract OCR per riconoscere il testo nelle immagini e sovrappone un livello di testo invisibile alle pagine originali, preservandone l'aspetto visivo e rendendo il contenuto completamente ricercabile.
## Come funziona
1. Carica un PDF scansionato o basato su immagini.
2. Seleziona una o più lingue presenti nel documento dall'elenco delle lingue con ricerca.
3. Facoltativamente, regola le impostazioni avanzate (risoluzione, binarizzazione, whitelist).
4. Clicca su **Avvia OCR** e segui l'avanzamento nella barra di progresso in tempo reale.
5. Al termine, controlla il testo estratto, poi scarica il PDF ricercabile o un semplice file `.txt`.
## Funzionalità
- OCR multilingue con selettore di lingua ricercabile
- Il livello di testo invisibile preserva l'aspetto originale del documento
- Barra di progresso e log in tempo reale durante l'elaborazione
- Scarica i risultati come PDF ricercabile o file di testo semplice
- Copia il testo estratto direttamente negli appunti
- Tre livelli di risoluzione per bilanciare velocità e precisione
## Opzioni
| Impostazione | Valori | Predefinito | Scopo |
| ---------------------------------- | -------------------------------------------------------------------------------------------------- | ----------- | ------------------------------------------------------------------------------------------- |
| **Risoluzione** | Standard (192 DPI), Alta (288 DPI), Ultra (384 DPI) | Alta | Una risoluzione maggiore migliora la precisione sul testo piccolo ma richiede più tempo |
| **Binarizza immagine** | Sì / No | No | Migliora il contrasto per scansioni pulite convertendo in bianco e nero |
| **Preset whitelist dei caratteri** | Nessuno, Alfanumerico, Numeri + Valuta, Solo lettere, Solo numeri, Fattura, Moduli, Personalizzato | Nessuno | Limita i caratteri riconosciuti per migliorare la precisione su tipi di documento specifici |
| **Whitelist dei caratteri** | Testo libero | Vuoto | Insieme di caratteri manuale quando il preset è impostato su Personalizzato |
## Casi d'uso
- Rendere ricercabili contratti e fatture scansionati, così puoi usare Ctrl+F al loro interno
- Estrarre il testo da documenti fotografati o vecchie carte
- Elaborare ricevute con il preset Fattura per catturare con precisione importi e date
- Creare PDF accessibili da scansioni di sole immagini per requisiti di conformità
- Estrarre in blocco il contenuto testuale da libri o manuali scansionati
## Suggerimenti
- Seleziona più lingue se il documento contiene testo in lingue miste (ad es. intestazioni in inglese con testo in giapponese).
- Usa l'opzione di binarizzazione per documenti con testo sbiadito o a basso contrasto: può migliorare in modo significativo la precisione del riconoscimento.
- I preset di whitelist Fattura e Moduli riducono drasticamente i falsi positivi sui documenti strutturati ignorando le forme di caratteri irrilevanti.
## Strumenti correlati
- [Estrai tabelle PDF](./extract-tables)
- [Unisci PDF](./merge-pdf)
- [Comprimi PDF](./compress-pdf)
docs/it/tools/odg-to-pdf.md
+43
View File
@@ -0,0 +1,43 @@
---
title: ODG in PDF
description: Converti i file LibreOffice Draw (ODG) in PDF nel browser. Gratis, senza caricamento, completamente privato.
---
# ODG in PDF
Converti i file OpenDocument Graphics in PDF. ODG è il formato nativo di LibreOffice Draw ed è usato per diagrammi, diagrammi di flusso e illustrazioni vettoriali. Convertire in PDF rende questi disegni facili da condividere, stampare e incorporare in altri documenti.
## Formati supportati
| Formato | Estensione | Note |
| :-------------------- | :--------- | :----------------------------------------- |
| OpenDocument Graphics | `.odg` | File di LibreOffice Draw / OpenOffice Draw |
## Come funziona
1. Clicca sull'area di caricamento o trascina i tuoi file ODG. Puoi aggiungere più file contemporaneamente.
2. Controlla l'elenco dei file. Rimuovi singole voci con l'icona del cestino, oppure clicca su **Aggiungi altri file** per aggiungere altri disegni.
3. Clicca su **Converti in PDF**. Un motore basato su LibreOffice si carica nel browser e converte ogni file ODG, preservando grafica vettoriale, forme e testo.
4. Un singolo file viene scaricato direttamente come PDF. Più file producono un archivio ZIP chiamato `odg-to-pdf.zip`.
## Opzioni
Non sono richieste impostazioni aggiuntive. La conversione preserva le dimensioni originali della pagina, le forme, i connettori e le caselle di testo del sorgente ODG.
## Casi d'uso
- Condividere diagrammi di LibreOffice Draw con clienti che non hanno LibreOffice installato
- Stampare diagrammi di flusso e diagrammi di rete creati in Draw
- Includere illustrazioni ODG in una relazione o presentazione come PDF incorporati
- Archiviare disegni tecnici in un formato che resterà leggibile per decenni
## Suggerimenti
- Gli elementi vettoriali restano vettoriali nel PDF risultante, quindi il risultato si scala in modo pulito a qualsiasi dimensione di stampa.
- Il motore LibreOffice richiede un momento per inizializzarsi al primo utilizzo. Le conversioni successive nella stessa sessione sono più rapide.
## Strumenti correlati
- [ODS in PDF](./ods-to-pdf)
- [ODP in PDF](./odp-to-pdf)
- [VSD in PDF](./vsd-to-pdf)
docs/it/tools/odp-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: ODP in PDF
description: Converti le presentazioni LibreOffice Impress (ODP) in PDF nel browser. Gratis, privato, senza caricamento.
---
# ODP in PDF
Converti i file OpenDocument Presentation in PDF. ODP è il formato nativo di LibreOffice Impress ed è un'esportazione standard di Google Slides. Trasformare le presentazioni in PDF permette a chiunque di visualizzarle senza software di presentazione, e le diapositive si stampano in modo pulito.
## Formati supportati
| Formato | Estensione | Note |
| :------------------------ | :--------- | :-------------------------------------------------- |
| OpenDocument Presentation | `.odp` | LibreOffice Impress / esportazione di Google Slides |
## Come funziona
1. Clicca sull'area di caricamento o trascina i tuoi file ODP. Puoi selezionare più presentazioni contemporaneamente.
2. Controlla l'elenco dei file. Rimuovi le voci con l'icona del cestino, oppure usa **Aggiungi altri file** per includere altre presentazioni.
3. Clicca su **Converti in PDF**. Il motore basato su LibreOffice elabora ogni presentazione e produce un PDF in cui ogni diapositiva diventa una pagina.
4. Un singolo file viene scaricato come PDF. Più file vengono consegnati in un archivio ZIP chiamato `odp-to-pdf.zip`.
## Opzioni
Nessuna impostazione da configurare. Ogni diapositiva viene resa alle sue dimensioni originali, preservando testo, immagini, forme e sfondi.
## Casi d'uso
- Distribuire una presentazione al pubblico come dispensa in PDF
- Condividere le esportazioni di Google Slides con chi preferisce il PDF all'ODP
- Archiviare interventi a conferenze e lezioni in un formato di sola lettura
- Stampare presentazioni per workshop in presenza
## Suggerimenti
- Le transizioni e le animazioni delle diapositive sono funzioni solo visive che non passano nel PDF, ma tutto il contenuto statico viene reso correttamente.
- Le note del relatore non sono incluse nel PDF. Se ti servono le note, esportale separatamente dal tuo software di presentazione.
- Come gli altri strumenti basati su LibreOffice, il motore si carica al primo utilizzo e resta in cache per la sessione.
## Strumenti correlati
- [ODG in PDF](./odg-to-pdf)
- [ODS in PDF](./ods-to-pdf)
- [PUB in PDF](./pub-to-pdf)
docs/it/tools/ods-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: ODS in PDF
description: Converti i fogli di calcolo LibreOffice Calc (ODS) in PDF nel browser. Gratis, privato, senza registrazione.
---
# ODS in PDF
Converti i file OpenDocument Spreadsheet in PDF. ODS è il formato nativo di LibreOffice Calc e un'esportazione comune di Google Sheets. Questo strumento trasforma i dati, la formattazione e i grafici del tuo foglio di calcolo in un PDF impaginato, pronto da stampare o condividere.
## Formati supportati
| Formato | Estensione | Note |
| :----------------------- | :--------- | :----------------------------------------------- |
| OpenDocument Spreadsheet | `.ods` | Esportazione da LibreOffice Calc / Google Sheets |
## Come funziona
1. Clicca sull'area di caricamento o trascina i tuoi file ODS. Sono supportati più file.
2. Controlla l'elenco dei file. Usa l'icona del cestino per rimuovere i file, oppure clicca su **Aggiungi altri file** per ampliare il gruppo.
3. Clicca su **Converti in PDF**. Il motore basato su LibreOffice si carica nel browser e trasforma ogni foglio di calcolo in pagine PDF.
4. Un singolo foglio di calcolo viene scaricato come PDF. Più file vengono raccolti in `ods-to-pdf.zip`.
## Opzioni
Non è richiesta alcuna configurazione. Il convertitore applica al PDF il layout di stampa, la formattazione delle celle e la larghezza delle colonne già presenti nel foglio di calcolo.
## Casi d'uso
- Condividere un budget o un report di LibreOffice Calc con chi accetta solo PDF
- Stampare un'esportazione di Google Sheets scaricata come ODS
- Archiviare documenti finanziari in un formato non modificabile
- Inviare moduli o fogli presenze in formato ODS come documenti a layout fisso
## Suggerimenti
- Se il foglio di calcolo contiene più fogli, tutti vengono inclusi nel PDF.
- I fogli di calcolo molto larghi possono estendersi su più pagine PDF in orizzontale. Se il layout è importante, valuta di regolare la larghezza delle colonne nel file di origine prima di convertire.
- Il motore LibreOffice si inizializza al primo utilizzo. Le conversioni successive nella stessa sessione sono più veloci.
## Strumenti correlati
- [ODG in PDF](./odg-to-pdf)
- [ODP in PDF](./odp-to-pdf)
- [XML in PDF](./xml-to-pdf)
docs/it/tools/odt-to-pdf.md
+51
View File
@@ -0,0 +1,51 @@
---
title: ODT in PDF
description: Converti i file OpenDocument Text (ODT) in PDF nel browser con un motore basato su LibreOffice.
---
# ODT in PDF
Converti i file OpenDocument Text in PDF. ODT è il formato nativo di LibreOffice Writer, Apache OpenOffice e di altri elaboratori di testo open source. Questo strumento usa un motore LibreOffice che gira nel browser per ottenere conversioni accurate, che mantengono formattazione, tabelle, immagini e stili.
## Formati supportati
| Formato | Estensioni |
| :---------------- | :--------- |
| OpenDocument Text | `.odt` |
## Come funziona
1. Clicca sull'area di caricamento o trascina uno o più file ODT.
2. Controlla l'elenco dei file. Aggiungi altri file o rimuovi quelli indesiderati.
3. Clicca su **Converti in PDF**. Il motore LibreOffice si inizializza (un indicatore di avanzamento mostra lo stato del caricamento), poi ogni file viene convertito.
4. Un singolo file viene scaricato direttamente come PDF. Più file vengono raccolti in `odt-converted.zip`.
## Opzioni
Questo strumento non ha configurazioni aggiuntive. La conversione mantiene la formattazione del documento originale il più fedelmente possibile.
## Output
| Numero di file | Output |
| :------------- | :---------------------------------------------------------- |
| 1 file | Download di un singolo PDF (ad es. `document.pdf`) |
| 2 o più file | Archivio ZIP (`odt-converted.zip`) con un PDF per ogni file |
## Casi d'uso
- Convertire documenti di LibreOffice Writer in PDF da condividere con chi usa Microsoft Office
- Produrre PDF pronti per la stampa da articoli accademici scritti in formato OpenDocument
- Convertire in blocco una cartella di modelli ODT in PDF da distribuire
- Generare PDF da file ODT creati da sistemi automatici di generazione di documenti
## Suggerimenti
- Il motore LibreOffice si carica al primo utilizzo e viene memorizzato nella cache per le conversioni successive. Il primo caricamento richiede alcuni secondi, poi le conversioni sono veloci.
- I documenti complessi con oggetti OLE incorporati o font insoliti possono apparire in modo leggermente diverso rispetto a LibreOffice desktop. Prova con un campione prima di convertire in blocco.
- Per i documenti Word (`.doc`, `.docx`), usa invece lo strumento [Word in PDF](./word-to-pdf), che usa lo stesso motore LibreOffice ma accetta direttamente i formati Microsoft.
## Strumenti correlati
- [Word in PDF](./word-to-pdf)
- [RTF in PDF](./rtf-to-pdf)
- [Testo in PDF](./txt-to-pdf)
docs/it/tools/organize-pdf.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Duplica e Organizza
description: Riordina, duplica ed elimina le pagine PDF con miniature trascinabili e un ordine pagine personalizzato.
---
# Duplica e Organizza
Riorganizza, duplica e rimuovi le pagine di un PDF con un'interfaccia visiva a trascinamento. Ogni pagina appare come una miniatura che puoi spostare, clonare o eliminare prima di salvare il risultato come nuovo file.
## Come funziona
1. Carica un singolo file PDF.
2. Lo strumento mostra una griglia di miniature con tutte le pagine.
3. Trascina le miniature per riordinare le pagine, clicca sul pulsante verde di duplicazione per clonare una pagina o sul pulsante rosso di eliminazione per rimuoverla.
4. In alternativa, inserisci un ordine di pagine personalizzato nel campo di testo (ad es. `3, 1, 2, 4`) e clicca su **Applica** per riorganizzare tutte le pagine in una volta.
5. Clicca sul pulsante di elaborazione per creare e scaricare il PDF riorganizzato.
## Funzionalità
- Riordino delle pagine con trascinamento e transizioni animate
- Pulsanti di duplicazione ed eliminazione per ogni pagina
- Ordine di pagine personalizzato per una disposizione precisa
- Etichette con il numero di pagina che si aggiornano automaticamente dopo ogni modifica
- Impedisce di eliminare l'ultima pagina rimasta
## Casi d'uso
- Spostare nella posizione corretta una pagina fuori posto in un report
- Duplicare la pagina di un modulo per avere più copie vuote in un unico file
- Rimuovere pagine di bozza o segnaposto prima di distribuire un documento
- Invertire o rimescolare l'ordine delle pagine per preparare la stampa
- Creare una sequenza di pagine personalizzata senza dover unire di nuovo file separati
## Suggerimenti
- Il campo dell'ordine personalizzato richiede i numeri delle pagine originali separati da virgole. Deve includere ogni pagina esattamente una volta: nessuna omissione e nessun duplicato.
- Dopo aver duplicato una pagina, entrambe le copie fanno riferimento allo stesso indice di pagina originale. Puoi riordinare ciascuna copia in modo indipendente.
- Per operazioni in blocco su più file o flussi di lavoro più avanzati, valuta lo [Strumento PDF multifunzione](./pdf-multi-tool).
## Strumenti correlati
- [Unisci PDF](./merge-pdf)
- [Elimina Pagine](./delete-pages)
- [Strumento PDF multifunzione](./pdf-multi-tool)
- [Inverti Pagine](./reverse-pages)
docs/it/tools/page-dimensions.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Dimensioni pagina
description: Analizza dimensioni, orientamento, proporzioni e rotazione delle pagine PDF. Rileva i documenti con pagine di formati diversi ed esporta i dati in CSV.
---
# Dimensioni pagina
Uno strumento diagnostico che legge ogni pagina del tuo PDF e ne riporta le dimensioni esatte, l'orientamento, il nome del formato standard, le proporzioni, l'area e la rotazione. Utile per individuare pagine di formati diversi prima della stampa o per documentare le proprietà di un PDF ricevuto.
## Come funziona
1. Carica un file PDF. L'analisi parte automaticamente: non c'è nessun pulsante da premere.
2. Un riquadro di riepilogo mostra il totale delle pagine, il numero di formati di pagina unici e se il documento contiene formati misti.
3. Consulta la tabella completa dei risultati con i dettagli di ogni pagina.
4. Cambia l'unità di misura tra punti, pollici, millimetri o pixel.
5. Clicca su **Esporta in CSV** per salvare i dati.
## Campi riportati
| Colonna | Descrizione |
| ---------------- | --------------------------------------------------------- |
| N. pagina | Numero progressivo della pagina |
| Dimensioni | Larghezza x Altezza nell'unità selezionata |
| Formato standard | Nome corrispondente (A4, Letter, ecc.) o "Personalizzato" |
| Orientamento | Verticale o Orizzontale |
| Proporzioni | Rapporto larghezza/altezza in formato decimale |
| Area | Area della pagina nell'unità selezionata al quadrato |
| Rotazione | Rotazione della pagina in gradi |
## Funzionalità
- Rilevamento automatico dei formati di carta standard (A3, A4, A5, Letter, Legal, Tabloid e altri)
- Avviso per documenti con formati misti, con il dettaglio dei formati presenti e di quante pagine usano ciascuno
- Conversione tra punti, pollici, millimetri e pixel (a 96 PPI)
- Esportazione in CSV da usare in fogli di calcolo o sistemi di documentazione
## Casi d'uso
- Verificare che tutte le pagine siano A4 prima di inviare un documento a una tipografia
- Capire perché un PDF unito viene stampato con margini inattesi su alcune pagine
- Documentare il layout delle pagine di un grande archivio PDF per i record di metadati
- Individuare le pagine ruotate che richiedono una correzione
## Suggerimenti
- Se il riepilogo mostra "Formati misti", usa lo strumento Correggi Dimensione Pagina per uniformare prima di stampare.
- Il campo della rotazione aiuta a individuare le pagine che si vedono correttamente ma hanno un attributo di rotazione diverso da zero, cosa che può causare problemi in alcuni flussi di lavoro.
## Strumenti correlati
- [Correggi Dimensione Pagina](./fix-page-size): uniforma le pagine dopo aver individuato i formati misti
- [Comprimi PDF](./compress-pdf): ottimizza il PDF dopo aver corretto i problemi delle pagine
- [Ruota PDF](./rotate-pdf): correggi le pagine ruotate
docs/it/tools/page-numbers.md
+48
View File
@@ -0,0 +1,48 @@
---
title: Numeri di pagina
description: Aggiungi numeri di pagina personalizzabili in qualsiasi posizione delle pagine PDF, con font, dimensione e colore configurabili.
---
# Numeri di pagina
Aggiungi numeri di pagina visibili a ogni pagina del tuo PDF. Scegli tu posizione, formato, dimensione del carattere e colore: al resto pensa lo strumento.
## Come funziona
1. Carica il tuo file PDF.
2. Configura le impostazioni dei numeri di pagina nel pannello delle opzioni che compare.
3. Clicca su **Aggiungi numeri di pagina** per elaborare.
4. Il PDF numerato viene scaricato automaticamente.
## Opzioni
- **Posizione**: scegli dove compaiono i numeri di pagina: in basso al centro, in basso a sinistra, in basso a destra, in alto al centro, in alto a sinistra o in alto a destra.
- **Formato**: scegli tra la numerazione semplice (1, 2, 3...) e il formato "pagina X di Y" (1 / 5, 2 / 5...).
- **Dimensione del carattere**: imposta la dimensione del testo del numero di pagina. Il valore predefinito è 12.
- **Colore**: scegli qualsiasi colore per il testo del numero di pagina con il selettore colore.
## Funzionalità
- Sei posizioni disponibili, che coprono tutti gli angoli e le posizioni centrali
- Due formati di numerazione: sequenziale semplice o "pagina X di Y"
- Dimensione del carattere personalizzabile da 6 a 72 punti
- Selettore colore completo per il colore del testo
- Gestione automatica dei margini che mantiene i numeri in aree sicure, qualunque sia la dimensione della pagina
## Casi d'uso
- Preparare per la stampa documenti che richiedono riferimenti di pagina visibili
- Aggiungere i numeri di pagina a un PDF unito da più file di origine
- Numerare le dispense di una presentazione prima di distribuirle
- Aggiungere una numerazione progressiva a documenti legali o contratti
## Suggerimenti
- Il formato "pagina X di Y" è utile per i documenti in cui i lettori devono conoscere la lunghezza totale, come proposte o report.
- Se hai bisogno di stili di numerazione diversi per sezioni diverse (ad esempio numeri romani per le pagine iniziali), usa invece lo strumento [Aggiungi etichette di pagina](./add-page-labels).
## Strumenti correlati
- [Aggiungi etichette di pagina](./add-page-labels)
- [Numerazione Bates](./bates-numbering)
- [Intestazione e Piè di Pagina](./header-footer)
docs/it/tools/pdf-booklet.md
+43
View File
@@ -0,0 +1,43 @@
---
title: Opuscolo PDF
description: Riorganizza le pagine PDF nell'ordine da opuscolo (con graffatura a sella) per piegarle e pinzarle in un opuscolo fisico.
---
# Opuscolo PDF
Riorganizza le pagine di un PDF nell'ordine di imposizione da opuscolo. Stampate fronte e retro e piegate a metà, le pagine risulteranno nella sequenza di lettura corretta. È il layout usato per opuscoli con graffatura a sella e zine.
## Come funziona
1. Carica un file PDF.
2. Configura le impostazioni dell'opuscolo: dimensione e orientamento della pagina di output.
3. Clicca su **Genera anteprima** per vedere come verranno disposte le pagine su ogni foglio.
4. Controlla l'anteprima, che mostra ogni foglio fisico con l'assegnazione delle pagine di fronte e retro.
5. Clicca su **Scarica** per salvare il PDF con l'imposizione da opuscolo.
## Funzionalità
- Riordino automatico delle pagine per la legatura a sella
- Dimensione della pagina di output configurabile
- Anteprima visiva del layout dell'opuscolo prima del download
- Gestisce un numero dispari di pagine inserendo pagine vuote dove serve
- Adatta le pagine di origine alla dimensione del foglio dell'opuscolo
## Casi d'uso
- Creare opuscoli o zine stampabili da un normale PDF
- Preparare programmi di conferenze o guide di eventi per la stampa interna
- Realizzare biglietti d'auguri piegati o piccoli cataloghi
- Produrre plaquette o raccolte di poesie da rilegare a mano
## Suggerimenti
- Il numero di pagine del PDF di origine dovrebbe idealmente essere un multiplo di 4 per ottenere un opuscolo ordinato. In caso contrario, vengono aggiunte automaticamente pagine vuote per completare l'ultimo foglio.
- Stampa l'output fronte e retro con l'impostazione "capovolgi sul lato corto" della stampante, poi piega tutti i fogli insieme e pinza sul dorso.
- Per disporre più pagine su un foglio senza l'ordine da opuscolo, usa invece [N-Up PDF](./n-up-pdf).
## Strumenti correlati
- [N-Up PDF](./n-up-pdf)
- [Ruota PDF](./rotate-pdf)
- [Aggiungi Pagina Vuota](./add-blank-page)
docs/it/tools/pdf-layers.md
+46
View File
@@ -0,0 +1,46 @@
---
title: Livelli PDF (OCG)
description: Visualizza, attiva o disattiva, aggiungi ed elimina i livelli Optional Content Group (OCG) in un documento PDF.
---
# Livelli PDF (OCG)
Gestisci gli Optional Content Group (OCG), comunemente chiamati "livelli", all'interno di un PDF. Puoi attivare o disattivare la visibilità dei livelli, aggiungere nuovi livelli (anche livelli figli annidati), eliminare livelli e salvare il PDF modificato.
## Come funziona
1. Carica un file PDF.
2. Clicca sul pulsante di elaborazione per caricare il documento con il motore PyMuPDF.
3. Lo strumento mostra tutti i livelli esistenti con il loro stato di visibilità, lo stato di blocco e la gerarchia di annidamento.
4. Usa le caselle di controllo per mostrare o nascondere i livelli. I livelli bloccati non possono essere attivati o disattivati.
5. Aggiungi nuovi livelli di primo livello digitando un nome e cliccando sul pulsante di aggiunta, oppure aggiungi livelli figli sotto un livello padre esistente.
6. Elimina i livelli che non ti servono più.
7. Clicca su **Salva** per scaricare il PDF modificato con le modifiche ai livelli applicate.
## Funzionalità
- Mostra la gerarchia dei livelli con la giusta rientranza per i livelli annidati
- Attiva o disattiva la visibilità dei livelli
- L'indicatore di livello bloccato evita modifiche accidentali
- Aggiungi livelli di primo livello o figli con nomi personalizzati
- Elimina i singoli livelli
- Salva tutte le modifiche in un nuovo file PDF
## Casi d'uso
- Attivare o disattivare la visibilità dei livelli di annotazione in disegni architettonici o tecnici
- Aggiungere nuovi livelli di annotazione a un documento di progettazione a più livelli
- Rimuovere i livelli obsoleti da un modello prima di distribuirlo
- Controllare quali livelli esistono in un PDF complesso ricevuto da terzi
## Suggerimenti
- Se il PDF non ha livelli, lo strumento mostra uno stato vuoto con l'invito ad aggiungerne uno. Non tutti i PDF usano i livelli OCG: sono più comuni nelle esportazioni CAD e nei file di progettazione.
- I livelli figli sono visivamente rientrati sotto il loro padre. Puoi annidare i livelli a qualsiasi profondità.
- I livelli bloccati sono mostrati con un'icona di lucchetto e le loro caselle di controllo sono disabilitate. Questi blocchi sono impostati dal creatore del PDF.
## Strumenti correlati
- [Visualizza Metadati](./view-metadata)
- [Modifica Metadati](./edit-metadata)
- [Duplica e Organizza](./organize-pdf)
docs/it/tools/pdf-multi-tool.md
+52
View File
@@ -0,0 +1,52 @@
---
title: Strumento PDF multifunzione
description: Un gestore di pagine tutto in uno per unire, dividere, ruotare, duplicare, eliminare e riordinare le pagine PDF.
---
# Strumento PDF multifunzione
Uno spazio di lavoro unificato per ogni operazione sulle pagine di un PDF. Carica uno o più PDF e lavora con tutte le loro pagine in un'unica griglia visiva. Ruota, riordina, duplica, elimina, inserisci nuovi PDF, aggiungi pagine vuote e dividi il risultato, il tutto senza uscire dallo strumento.
## Come funziona
1. Clicca su **Carica PDF** o trascina i file sull'area di caricamento. Sono supportati più file.
2. Tutte le pagine di ogni file caricato compaiono in una griglia scorrevole con le miniature.
3. Usa la barra degli strumenti o i pulsanti di azione di ogni pagina per modificare le pagine.
4. Seleziona le pagine con la casella di controllo su ogni scheda, poi applica le operazioni in blocco.
5. Segna i punti di divisione con l'icona delle forbici per suddividere l'output in file separati.
6. Clicca su **Esporta PDF** per scaricare il risultato finale. Se sono presenti segni di divisione, l'output è uno ZIP con più PDF.
## Funzionalità
- **Unisci**: carica più PDF e vengono combinati automaticamente in un unico spazio di lavoro
- **Riordina**: trascina le schede delle pagine per cambiare la sequenza
- **Ruota**: rotazione per pagina o in blocco a passi di 90 gradi (a sinistra o a destra)
- **Duplica**: clona qualsiasi pagina con un clic
- **Elimina**: rimuovi singole pagine o elimina in blocco quelle selezionate
- **Inserisci PDF**: aggiungi un nuovo PDF dopo una pagina specifica
- **Aggiungi pagina vuota**: aggiungi in fondo una pagina A4 vuota
- **Dividi**: posiziona segni di divisione tra le pagine, poi esporta come ZIP di PDF separati
- **Seleziona tutto / Deseleziona tutto**: selezione rapida per le operazioni in blocco
- **Annulla / Ripeti**: cronologia completa di annullamento e ripristino per ogni operazione
- **Scarica selezionate**: esporta solo le pagine selezionate come PDF autonomo
- Ripara automaticamente i PDF danneggiati prima del caricamento
## Casi d'uso
- Creare un documento personalizzato con pagine prese da più PDF di origine
- Ripulire un documento scansionato eliminando le pagine vuote, ruotando le scansioni di lato e riordinando le sezioni
- Dividere un PDF di grandi dimensioni ai confini dei capitoli con segni di divisione visivi
- Modificare rapidamente le pagine senza bisogno di un editor PDF completo
## Suggerimenti
- Il sistema di annullamento e ripristino tiene traccia di ogni operazione. Usalo liberamente: non puoi distruggere il tuo lavoro per sbaglio.
- I segni di divisione appaiono come linee blu tratteggiate tra le pagine. Posizionali visivamente dove vuoi dividere il documento, poi esporta per ottenere uno ZIP.
- Per semplici operazioni di unione o divisione, gli strumenti dedicati [Unisci PDF](./merge-pdf) o [Dividi PDF](./split-pdf) possono essere più rapidi. Lo strumento multifunzione dà il meglio quando servono più operazioni in una sola sessione.
## Strumenti correlati
- [Unisci PDF](./merge-pdf)
- [Dividi PDF](./split-pdf)
- [Duplica e Organizza](./organize-pdf)
- [Ruota PDF](./rotate-pdf)
docs/it/tools/pdf-to-bmp.md
+40
View File
@@ -0,0 +1,40 @@
---
title: PDF in BMP
description: Converti le pagine PDF in immagini BMP non compresse. Utile per sistemi legacy e flussi di stampa che richiedono input bitmap.
---
# PDF in BMP
Converte ogni pagina di un PDF in un'immagine BMP (Bitmap). BMP è un formato non compresso, quindi l'output è perfetto al pixel e senza perdita di qualità, ma i file sono pesanti.
## Come funziona
1. Carica un PDF cliccando sull'area di rilascio o trascinandovi sopra un file.
2. Clicca su **Converti** per elaborare il file.
3. Un singolo file `.bmp` o un archivio ZIP viene scaricato automaticamente.
## Opzioni
Questo strumento non ha opzioni configurabili. Le pagine vengono renderizzate a una scala fissa di 2x, producendo immagini di circa il doppio delle dimensioni native della pagina PDF.
## Formato di output
- **Pagina singola**: `filename.bmp`
- **Più pagine**: `filename_bmps.zip` contenente `page_1.bmp`, `page_2.bmp`, ecc.
## Casi d'uso
- Passare le pagine PDF a sistemi legacy o hardware che accettano solo input BMP.
- Preparare immagini non compresse per specifici flussi di stampa.
- Usare l'output bitmap come input per strumenti di elaborazione delle immagini che richiedono dati pixel grezzi.
## Suggerimenti
- I file BMP sono molto grandi perché memorizzano dati pixel grezzi senza compressione. Per la maggior parte degli usi, [PDF in PNG](./pdf-to-png) offre una qualità senza perdita con file molto più piccoli.
- Se il sistema di destinazione accetta PNG o TIFF, preferisci questi formati per risparmiare spazio su disco.
## Strumenti correlati
- [PDF in PNG](./pdf-to-png)
- [PDF in TIFF](./pdf-to-tiff)
- [PDF in JPG](./pdf-to-jpg)
docs/it/tools/pdf-to-cbz.md
+77
View File
@@ -0,0 +1,77 @@
---
title: PDF in CBZ
description: Converti un PDF in un file CBZ (Comic Book Archive) per lettori di fumetti come Komga, Kavita, CDisplayEx e Calibre.
---
# PDF in CBZ
Converte un PDF in un file CBZ (Comic Book ZIP), il formato standard per fumetti e manga digitali. Ogni pagina del PDF diventa un'immagine all'interno dell'archivio. Lo strumento genera i metadati in tre formati per la massima compatibilità: ComicInfo.xml, metadata.opf e ComicBookInfo JSON.
## Come funziona
1. Carica un PDF cliccando sull'area di rilascio o trascinandovi sopra un file.
2. Scegli formato immagine, qualità, scala ed eventuali metadati.
3. Clicca su **Converti** per generare il file CBZ.
4. Il file `.cbz` viene scaricato automaticamente.
## Opzioni
| Opzione | Valori | Predefinito | Descrizione |
| ---------------- | --------------- | ----------- | ----------------------------------------------------------------------------------------------------------- |
| Formato immagine | JPEG, PNG, WebP | JPEG | JPEG per fumetti a colori, PNG per manga in bianco e nero senza perdita, WebP per la migliore compressione. |
| Qualità | 50–100% | 85% | Controlla la compressione JPEG/WebP. Nascosta per PNG (sempre senza perdita). |
| Scala | 1.0x–4.0x | 2.0x | Una scala maggiore produce immagini più nitide per schermi ad alta risoluzione. |
| Scala di grigi | Sì/No | No | Converte le pagine in scala di grigi. Riduce le dimensioni del file per i contenuti in bianco e nero. |
| Modalità manga | Sì/No | No | Imposta nei metadati la direzione di lettura da destra a sinistra. |
| Includi metadati | Sì/No | Sì | Incorpora ComicInfo.xml, metadata.opf e ComicBookInfo JSON. |
## Campi dei metadati
Quando i metadati sono attivi, puoi compilare:
- **Titolo**: rilevato automaticamente dal nome del file PDF.
- **Serie**: il nome della serie (ad es. "Naruto").
- **Numero (#)**: numero dell'albo all'interno della serie.
- **Volume (Vol.)**: numero del volume.
- **Autore/i**: nome dello scrittore o del creatore.
- **Editore**: casa editrice.
- **Tag / Genere**: tag separati da virgole (ad es. "Azione, Avventura").
- **Anno di pubblicazione**: anno di pubblicazione (1900–2100).
- **Valutazione**: valutazione della community da 0 a 5.
## Compatibilità dei metadati
Lo strumento scrive i metadati in tre formati, così ogni lettore può trovarli:
| Formato | Posizione | Supportato da |
| ------------------ | -------------------------- | ------------------------------------------- |
| ComicInfo.xml | File all'interno dello ZIP | Komga, Kavita, CDisplayEx, Mylar, ComicRack |
| metadata.opf | File all'interno dello ZIP | Calibre |
| ComicBookInfo JSON | Campo commento dello ZIP | Calibre (alternativa) |
## Formato di output
- `filename.cbz`: un archivio ZIP contenente le immagini delle pagine numerate e i file dei metadati.
Le immagini delle pagine sono nominate con numeri riempiti con zeri (`01.jpg`, `02.jpg`, ecc.) in modo che i lettori le mostrino nell'ordine corretto.
## Casi d'uso
- Convertire PDF di manga o fumetti da usare con i lettori di fumetti.
- Creare una libreria di fumetti digitali in Komga, Kavita o Calibre.
- Convertire fumetti scansionati in un formato adatto ai lettori.
- Condividere fumetti in un formato che conserva direzione di lettura e metadati.
## Suggerimenti
- Usa **JPEG** per i fumetti a colori e **PNG** per i manga in bianco e nero: PNG comprime in modo molto efficiente i contenuti in bianco e nero.
- Attiva **Scala di grigi** per i manga per ridurre in modo significativo le dimensioni del file.
- Compila i campi **Serie** e **Numero** così i gestori di librerie (Komga, Calibre) possono organizzare automaticamente la tua collezione.
- **WebP** offre la migliore compressione, ma i lettori di fumetti più vecchi potrebbero non supportarlo.
## Strumenti correlati
- [PDF in JPG](./pdf-to-jpg)
- [PDF in PNG](./pdf-to-png)
- [PDF in TIFF](./pdf-to-tiff)
- [Estrai immagini](./extract-images)
docs/it/tools/pdf-to-csv.md
+44
View File
@@ -0,0 +1,44 @@
---
title: PDF in CSV
description: Estrai le tabelle dai documenti PDF ed esportale in un unico file CSV. Gestisce i PDF multipagina con rilevamento automatico delle tabelle.
---
# PDF in CSV
Estrae le tabelle da un PDF e le esporta come file CSV. Lo strumento analizza ogni pagina alla ricerca di dati tabulari con il motore di rilevamento delle tabelle di PyMuPDF, poi scrive tutte le righe trovate in un unico output separato da virgole.
## Come funziona
1. Carica un PDF cliccando sull'area di rilascio o trascinandovi sopra un file.
2. Clicca su **Converti** per avviare l'estrazione delle tabelle.
3. Lo strumento analizza ogni pagina e identifica automaticamente le tabelle.
4. Viene scaricato un file `.csv` con tutti i dati delle tabelle estratte.
Le tabelle di pagine diverse sono separate da righe vuote nell'output. Le celle che contengono virgole, virgolette o ritorni a capo vengono correttamente protette secondo la RFC 4180.
## Opzioni
Questo strumento non ha opzioni configurabili. Tutte le tabelle trovate nel documento vengono estratte e combinate in un unico CSV.
## Formato di output
- Un unico file `filename.csv` contenente tutte le tabelle rilevate.
## Casi d'uso
- Portare in un foglio di calcolo i dati finanziari di estratti conto o fatture in PDF.
- Estrarre le tabelle dei prezzi dai preventivi dei fornitori per confrontarli.
- Convertire dati di ricerca tabulari da articoli in PDF in un formato adatto agli strumenti di analisi.
- Migrare in database i dati di vecchi report in PDF.
## Suggerimenti
- Se non vengono trovate tabelle, lo strumento mostra il messaggio "Nessuna tabella trovata". Di solito significa che il PDF usa un layout di testo che sembra tabulare ma non è strutturato come una vera tabella.
- Per un controllo maggiore sulle singole tabelle, usa [Estrai tabelle PDF](./extract-tables), che permette di scegliere tra i formati di output CSV, JSON e Markdown.
- Se ti servono i dati in formato Excel con fogli separati per ogni tabella, usa [PDF in Excel](./pdf-to-excel).
## Strumenti correlati
- [PDF in Excel](./pdf-to-excel)
- [Estrai tabelle PDF](./extract-tables)
- [PDF in Testo](./pdf-to-text)
docs/it/tools/pdf-to-excel.md
+44
View File
@@ -0,0 +1,44 @@
---
title: PDF in Excel
description: Estrai le tabelle dai documenti PDF in un foglio di calcolo Excel. Ogni tabella ha il suo foglio di lavoro con i riferimenti alla pagina.
---
# PDF in Excel
Estrae le tabelle da un PDF e le salva come foglio di calcolo Excel (`.xlsx`). Ogni tabella rilevata viene collocata in un foglio di lavoro dedicato, con il numero della tabella e la pagina di origine. Usa PyMuPDF per il rilevamento delle tabelle e la libreria SheetJS per generare il file Excel.
## Come funziona
1. Carica un PDF cliccando sull'area di rilascio o trascinandovi sopra un file.
2. Clicca su **Converti** per avviare l'estrazione delle tabelle.
3. Lo strumento analizza ogni pagina alla ricerca di tabelle, poi costruisce una cartella di lavoro Excel.
4. Viene scaricato un file `.xlsx` con un foglio per ogni tabella.
## Opzioni
Questo strumento non ha opzioni configurabili. Tutte le tabelle rilevate vengono estratte automaticamente.
## Formato di output
- Un unico file `filename.xlsx`.
- **Una tabella**: un solo foglio di lavoro chiamato "Table".
- **Più tabelle**: fogli di lavoro chiamati "Table 1 (Page 3)", "Table 2 (Page 5)", ecc. I nomi dei fogli vengono troncati a 31 caratteri (il limite di Excel).
## Casi d'uso
- Convertire report finanziari in PDF in fogli di calcolo modificabili per ulteriori analisi.
- Estrarre tabelle di inventario o ordini dai PDF dei fornitori.
- Portare in Excel dati strutturati di moduli o cataloghi PDF per ordinarli e filtrarli.
- Archiviare dati tabulari di PDF in un formato con cui possono lavorare anche i colleghi non tecnici.
## Suggerimenti
- Se lo strumento segnala "Nessuna tabella trovata", il PDF probabilmente usa un layout di testo libero invece di tabelle strutturate. Prova [PDF in Testo](./pdf-to-text) per ottenere invece il contenuto grezzo.
- Per un formato piatto più semplice, usa [PDF in CSV](./pdf-to-csv). Per scaricare ogni tabella in più formati, usa [Estrai tabelle PDF](./extract-tables).
- Controlla i nomi dei fogli per capire da quale pagina proviene ogni tabella.
## Strumenti correlati
- [PDF in CSV](./pdf-to-csv)
- [Estrai tabelle PDF](./extract-tables)
- [PDF in Testo](./pdf-to-text)
docs/it/tools/pdf-to-greyscale.md
+42
View File
@@ -0,0 +1,42 @@
---
title: PDF in scala di grigi
description: Converti un PDF a colori in una versione in scala di grigi (bianco e nero). Produce un nuovo PDF con tutti i colori rimossi da ogni pagina.
---
# PDF in scala di grigi
Converte un PDF a colori in una versione in scala di grigi. Ogni pagina viene renderizzata, desaturata e reincorporata come immagine JPEG in un nuovo PDF. L'output mantiene le dimensioni originali delle pagine.
## Come funziona
1. Carica un PDF cliccando sull'area di rilascio o trascinandovi sopra un file.
2. Clicca su **Converti** per elaborare il file.
3. Viene scaricato un nuovo `greyscale.pdf` con tutte le pagine convertite in bianco e nero.
Dietro le quinte, ogni pagina viene renderizzata a scala 2x, i dati dei pixel passano attraverso un filtro in scala di grigi, poi vengono ricodificati come JPEG al 90% di qualità e inseriti in un nuovo documento PDF.
## Opzioni
Questo strumento non ha opzioni configurabili. La conversione in scala di grigi usa una formula di luminanza standard e la qualità JPEG è fissata al 90%.
## Formato di output
- Un unico file `greyscale.pdf` contenente tutte le pagine come immagini JPEG in scala di grigi.
## Casi d'uso
- Preparare documenti per la stampa in bianco e nero e risparmiare sui costi dell'inchiostro a colori.
- Rispettare i requisiti di invio di pratiche legali o governative che richiedono la scala di grigi.
- Ridurre le dimensioni dei PDF molto colorati (le immagini JPEG in scala di grigi sono più piccole di quelle a colori).
- Creare uno stile visivo coerente in documenti con pagine miste a colori e in bianco e nero.
## Suggerimenti
- Poiché ogni pagina viene rasterizzata e reincorporata come JPEG, l'output è basato su immagini. Il testo del PDF originale non sarà più selezionabile né ricercabile. Se in seguito ti serve testo ricercabile, passa l'output nello strumento OCR.
- Per un controllo maggiore sulle regolazioni del colore (luminosità, contrasto, saturazione), guarda lo strumento Regola colori o il nodo Scala di grigi nel [Costruttore di workflow PDF](./pdf-workflow).
## Strumenti correlati
- [PDF in JPG](./pdf-to-jpg)
- [PDF in PNG](./pdf-to-png)
- [Costruttore di workflow PDF](./pdf-workflow)
docs/it/tools/pdf-to-jpg.md
+46
View File
@@ -0,0 +1,46 @@
---
title: PDF in JPG
description: Converti le pagine PDF in immagini JPG con qualità regolabile. I PDF di una pagina vengono scaricati direttamente, quelli multipagina come ZIP.
---
# PDF in JPG
Converte ogni pagina di un PDF in un'immagine JPG. I documenti di una sola pagina vengono scaricati come singolo file `.jpg`. I PDF multipagina producono un archivio ZIP con un JPG per pagina.
## Come funziona
1. Carica un PDF cliccando sull'area di rilascio o trascinandovi sopra un file. Lo strumento mostra il nome del file, la dimensione e il numero di pagine.
2. Regola il cursore **Qualità** per controllare la compressione JPG.
3. Clicca su **Converti** per avviare l'elaborazione.
4. Il risultato viene scaricato automaticamente: un singolo JPG per i PDF di una pagina, oppure un file ZIP per i documenti multipagina.
## Opzioni
- **Qualità**: un cursore da 0% a 100% (predefinito 90%). Valori più alti producono immagini più nitide con file più grandi. Valori più bassi comprimono in modo più aggressivo.
Le pagine vengono renderizzate internamente a scala 2x, quindi la risoluzione di output è il doppio delle dimensioni della pagina PDF. Una pagina standard in formato Letter produce un'immagine di circa 1.224 x 1.584 pixel.
## Formato di output
- **Pagina singola**: `filename.jpg`
- **Più pagine**: `filename_jpgs.zip` contenente `page_1.jpg`, `page_2.jpg`, ecc.
## Casi d'uso
- Generare miniature di anteprima per un sistema di gestione documentale.
- Condividere una pagina di un report in una chat o in un'email che non supporta i PDF.
- Creare risorse grafiche da diagrammi o illustrazioni in PDF.
- Archiviare documenti scansionati come singole immagini.
## Suggerimenti
- Per un output senza perdita, usa invece [PDF in PNG](./pdf-to-png).
- Un valore di qualità tra 80 e 90% offre un buon equilibrio tra dimensione del file e fedeltà visiva.
- Se ti serve un formato specifico per ogni pagina, valuta il [Costruttore di workflow PDF](./pdf-workflow), che ha un nodo di output PDF in immagini.
## Strumenti correlati
- [PDF in PNG](./pdf-to-png)
- [PDF in WebP](./pdf-to-webp)
- [PDF in BMP](./pdf-to-bmp)
- [PDF in TIFF](./pdf-to-tiff)
docs/it/tools/pdf-to-json.md
+45
View File
@@ -0,0 +1,45 @@
---
title: PDF in JSON
description: Converti i file PDF in formato JSON strutturato con CPDF. Esporta la struttura interna del PDF come dati JSON leggibili da macchina.
---
# PDF in JSON
Converte uno o più file PDF in formato JSON. Lo strumento usa CPDF (Coherent PDF) per serializzare la struttura interna di ogni PDF in una rappresentazione JSON leggibile da macchina. L'output viene sempre consegnato come archivio ZIP.
## Come funziona
1. Seleziona uno o più file PDF con il selettore di file.
2. Clicca su **Converti** per avviare l'elaborazione. La conversione gira in un web worker in background.
3. Viene scaricato un archivio ZIP contenente un file JSON per ogni PDF in ingresso.
La barra di stato mostra l'avanzamento delle fasi di conversione e di creazione dello ZIP.
## Opzioni
Questo strumento non ha opzioni configurabili. Ogni PDF viene convertito nella sua rappresentazione JSON completa.
## Formato di output
- Un file `pdfs-to-json.zip` contenente `filename.json` per ogni PDF in ingresso.
L'output JSON rappresenta la struttura interna degli oggetti del PDF, inclusi alberi delle pagine, riferimenti ai font, metadati e flussi di contenuto.
## Casi d'uso
- Ispezionare la struttura interna di un PDF per il debug o la convalida.
- Estrarre in modo programmatico metadati strutturati e proprietà delle pagine.
- Passare i dati sulla struttura del PDF a pipeline di elaborazione personalizzate.
- Verificare la conformità dei documenti PDF analizzando i loro alberi di oggetti.
## Suggerimenti
- Questo strumento produce la struttura grezza degli oggetti del PDF, non il testo estratto. Se ti serve il testo delle pagine in formato JSON, usa invece [Prepara PDF per IA](./prepare-pdf-for-ai).
- Per l'estrazione del solo testo, [PDF in Testo](./pdf-to-text) è più diretto.
- I PDF grandi con strutture complesse producono file JSON molto grandi.
## Strumenti correlati
- [PDF in Testo](./pdf-to-text)
- [Prepara PDF per IA](./prepare-pdf-for-ai)
- [Estrai tabelle PDF](./extract-tables)
docs/it/tools/pdf-to-markdown.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF in Markdown
description: Converti i documenti PDF in formato Markdown con estrazione opzionale delle immagini. Supporta la conversione in blocco di più file.
---
# PDF in Markdown
Converte i file PDF in formato Markdown (`.md`), mantenendo titoli, paragrafi, elenchi e formattazione di base. Può estrarre e includere le immagini incorporate. Supporta la conversione di singoli file e in blocco. Usa PyMuPDF.
## Come funziona
1. Carica uno o più PDF cliccando sull'area di rilascio o trascinandovi sopra i file.
2. Se vuoi, attiva **Includi immagini** per incorporare le immagini estratte nell'output Markdown.
3. Clicca su **Converti** per avviare l'elaborazione.
4. Un singolo file viene scaricato come `filename.md`. Più file producono un `markdown-files.zip`.
## Opzioni
- **Includi immagini**: se selezionata, le immagini incorporate nel PDF vengono estratte e referenziate nell'output Markdown. Se deselezionata, viene convertito solo il contenuto testuale.
## Formato di output
- **File singolo**: `filename.md`
- **Più file**: `markdown-files.zip` contenente un `.md` per ogni PDF in ingresso.
## Casi d'uso
- Convertire la documentazione PDF in Markdown per un generatore di siti statici come VitePress, Hugo o Jekyll.
- Trasformare articoli di ricerca in PDF in Markdown modificabile per app di appunti come Obsidian.
- Migrare vecchie basi di conoscenza in PDF in un formato di testo adatto a Git.
- Estrarre contenuti strutturati da ebook in PDF per riformattarli.
## Suggerimenti
- L'opzione Includi immagini è utile quando il PDF contiene diagrammi o figure essenziali per il contenuto. Disattivala per i documenti ricchi di testo, per mantenere l'output pulito.
- I layout complessi con barre laterali, note a piè di pagina o testo su più colonne possono produrre un Markdown imperfetto. Controlla e correggi l'output se necessario.
- Per il testo grezzo senza alcuna formattazione, usa invece [PDF in Testo](./pdf-to-text).
## Strumenti correlati
- [PDF in Testo](./pdf-to-text)
- [PDF in Word](./pdf-to-word)
- [Prepara PDF per IA](./prepare-pdf-for-ai)
docs/it/tools/pdf-to-pdfa.md
+50
View File
@@ -0,0 +1,50 @@
---
title: PDF in PDF/A
description: Converti i PDF standard in formato PDF/A per l'archiviazione a lungo termine. Supporta i livelli di conformità PDF/A-1b, PDF/A-2b e PDF/A-3b.
---
# PDF in PDF/A
PDF/A è un sottoinsieme del PDF standardizzato ISO, pensato per la conservazione digitale a lungo termine. Questo strumento converte i tuoi PDF standard in documenti conformi a PDF/A usando Ghostscript direttamente nel tuo browser.
## Come funziona
1. Carica uno o più file PDF.
2. Seleziona una **Versione PDF/A** dal menu a tendina.
3. Se vuoi, attiva **Appiattisci PDF prima** per i file complessi che falliscono con la conversione normale.
4. Clicca su **Converti in PDF/A**. Più file producono un archivio ZIP.
## Versioni PDF/A
| Versione | Restrizioni | Ideale per |
| ------------ | --------------------------------------------------- | ----------------------------------------------------------- |
| **PDF/A-1b** | La più rigida. Nessuna trasparenza, nessun livello. | Massima compatibilità con i vecchi sistemi di archiviazione |
| **PDF/A-2b** | Consente trasparenza e JPEG2000. | Archiviazione generica (consigliata) |
| **PDF/A-3b** | Consente allegati incorporati di qualsiasi formato. | Archiviare documenti con i relativi file di dati di origine |
PDF/A-2b è selezionata per impostazione predefinita e soddisfa la grande maggioranza delle esigenze di archiviazione.
## Opzione di appiattimento preliminare
Alcuni PDF contengono elementi che impediscono una conversione pulita in PDF/A: codifiche di font insolite, complesse pile di trasparenze o strutture interne danneggiate. Attivando **Appiattisci PDF prima**, il PDF viene rasterizzato a 300 DPI prima della conversione: questo garantisce la conformità al prezzo di rendere il testo non selezionabile. Usala come soluzione di riserva quando la conversione standard produce errori.
L'appiattimento preliminare richiede il motore PyMuPDF WASM.
## Casi d'uso
- Rispettare i requisiti di archiviazione governativi o legali (molte giurisdizioni impongono PDF/A per gli atti giudiziari)
- Inviare documenti a archivi istituzionali o biblioteche digitali
- Conservare documenti aziendali il cui software originale potrebbe non esistere più tra dieci anni
- Preparare fatture per gli standard di fatturazione elettronica che richiedono PDF/A-3b con allegati XML
## Suggerimenti
- Prova prima la conversione senza appiattimento preliminare. Attivalo solo se ottieni un errore.
- PDF/A incorpora tutti i font, quindi i file di output sono spesso più grandi degli originali.
- Convalida l'output con un validatore PDF/A dedicato se il tuo flusso di lavoro richiede una conformità rigorosa.
## Strumenti correlati
- [Comprimi PDF](./compress-pdf): riduci le dimensioni del file dopo la conversione
- [Appiattisci PDF](./flatten-pdf): appiattisci i moduli prima di convertire in PDF/A
- [Rimuovi metadati](./remove-metadata): elimina i metadati prima di archiviare
docs/it/tools/pdf-to-png.md
+42
View File
@@ -0,0 +1,42 @@
---
title: PDF in PNG
description: Converti le pagine PDF in immagini PNG senza perdita con scala regolabile. Ideale per schermate di alta qualità e sfondi trasparenti.
---
# PDF in PNG
Converte ogni pagina di un PDF in un'immagine PNG. PNG usa una compressione senza perdita, quindi l'output conserva ogni dettaglio della pagina originale. I PDF di una pagina vengono scaricati come file `.png`; i PDF multipagina producono uno ZIP.
## Come funziona
1. Carica un PDF cliccando sull'area di rilascio o trascinandovi sopra un file.
2. Imposta il cursore **Scala** per controllare la risoluzione di output.
3. Clicca su **Converti** per avviare l'elaborazione.
4. Un singolo PNG o un archivio ZIP viene scaricato automaticamente.
## Opzioni
- **Scala**: da 1.0x a 3.0x (predefinito 2.0x). A 2.0x, una pagina standard in formato Letter viene renderizzata a circa 1.224 x 1.584 pixel. Valori di scala più alti producono immagini più grandi e nitide, a scapito di dimensione del file e tempo di elaborazione.
## Formato di output
- **Pagina singola**: `filename.png`
- **Più pagine**: `filename_pngs.zip` contenente `page_1.png`, `page_2.png`, ecc.
## Casi d'uso
- Catturare schermate ad alta fedeltà delle pagine PDF per le presentazioni.
- Estrarre grafici o diagrammi che richiedono bordi nitidi e nessun artefatto di compressione.
- Preparare risorse per il web design a partire da mockup in PDF.
- Creare immagini di pagina senza perdita per la pre-elaborazione OCR.
## Suggerimenti
- I file PNG sono molto più grandi dei JPG. Se la dimensione del file conta più della qualità perfetta, usa [PDF in JPG](./pdf-to-jpg) o [PDF in WebP](./pdf-to-webp).
- A scala 1.0x l'output corrisponde alla risoluzione nativa del PDF. Porta a 3.0x per esportazioni di qualità da stampa.
## Strumenti correlati
- [PDF in JPG](./pdf-to-jpg)
- [PDF in WebP](./pdf-to-webp)
- [PDF in SVG](./pdf-to-svg)
docs/it/tools/pdf-to-svg.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF in SVG
description: Converti le pagine PDF in grafica vettoriale SVG scalabile. Mantiene testo e forme come tracciati vettoriali per una scalabilità infinita.
---
# PDF in SVG
Converte ogni pagina di un PDF in un file SVG (Scalable Vector Graphics). A differenza dei formati raster, SVG conserva tracciati vettoriali, testo e forme, quindi l'output si adatta a qualsiasi dimensione senza pixelazione. Usa PyMuPDF.
## Come funziona
1. Carica uno o più PDF cliccando sull'area di rilascio o trascinandovi sopra i file. Puoi aggiungere più file e gestirli singolarmente.
2. Clicca su **Converti** per elaborare tutti i file caricati.
3. Le conversioni di un solo file con una sola pagina vengono scaricate come `.svg` singolo. Tutto il resto viene scaricato come archivio ZIP.
## Opzioni
Questo strumento non ha opzioni configurabili. Ogni pagina viene convertita in SVG con l'esportazione vettoriale nativa di PyMuPDF.
## Formato di output
- **Un file, una pagina**: `filename.svg`
- **Un file, più pagine**: `filename_svg.zip` contenente `page_1.svg`, `page_2.svg`, ecc.
- **Più file**: `pdf_to_svg.zip` con i file organizzati per nome del documento di origine.
## Casi d'uso
- Estrarre diagrammi vettoriali, grafici o illustrazioni da report PDF da usare in pagine web.
- Modificare il contenuto delle pagine PDF in un editor vettoriale come Inkscape o Illustrator.
- Incorporare anteprime di pagina scalabili in applicazioni web responsive.
- Estrarre loghi o grafica da brochure PDF mantenendo i bordi nitidi.
## Suggerimenti
- SVG funziona al meglio con i PDF che contengono contenuto vettoriale. I documenti scansionati o i PDF ricchi di immagini producono file SVG grandi con dati raster incorporati.
- Per un output raster di PDF ricchi di immagini, usa invece [PDF in PNG](./pdf-to-png) o [PDF in JPG](./pdf-to-jpg).
- Questo strumento supporta la conversione in blocco: carica più PDF insieme per convertirli tutti in una sola esecuzione.
## Strumenti correlati
- [PDF in PNG](./pdf-to-png)
- [PDF in JPG](./pdf-to-jpg)
- [PDF in Markdown](./pdf-to-markdown)
docs/it/tools/pdf-to-text.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF in Testo
description: Estrai il testo semplice dai file PDF. Supporta l'estrazione in blocco di più PDF con output in file TXT.
---
# PDF in Testo
Estrae tutto il contenuto testuale dai file PDF e lo salva come semplici file `.txt`. Supporta l'elaborazione in blocco: carica più PDF e ottieni il testo di ciascuno in una sola operazione. Usa PyMuPDF.
## Come funziona
1. Carica uno o più PDF cliccando sull'area di rilascio o trascinandovi sopra i file. Gestisci l'elenco dei file con i pulsanti Aggiungi altri e Cancella.
2. Clicca su **Estrai** per avviare l'elaborazione.
3. Un singolo file viene scaricato come `filename.txt`. Più file producono un archivio `pdf-to-text.zip`.
## Opzioni
Questo strumento non ha opzioni configurabili. Tutto il testo viene estratto da ogni pagina nell'ordine di lettura.
## Formato di output
- **File singolo**: `filename.txt`
- **Più file**: `pdf-to-text.zip` contenente un `.txt` per ogni PDF in ingresso.
## Casi d'uso
- Estrarre il testo principale dai report PDF per l'indicizzazione della ricerca full-text.
- Convertire ebook o articoli PDF in testo semplice da leggere su dispositivi e-ink.
- Ricavare il testo da contratti o documenti legali per l'analisi delle parole chiave.
- Eliminare la formattazione dai PDF per ottenere testo pulito per script di elaborazione dati.
- Preparare un corpus di testo da archivi PDF per l'elaborazione del linguaggio naturale.
## Suggerimenti
- I PDF scansionati (solo immagine) producono file di testo vuoti perché non c'è alcun livello di testo da estrarre. Passa prima i documenti scansionati attraverso l'OCR.
- L'output mantiene l'ordine di lettura interpretato da PyMuPDF, che in genere procede da sinistra a destra e dall'alto in basso. I layout a più colonne possono produrre testo intercalato.
- Per un output strutturato con titoli e formattazione, prova [PDF in Markdown](./pdf-to-markdown). Per JSON strutturato pronto per l'IA, usa [Prepara PDF per IA](./prepare-pdf-for-ai).
## Strumenti correlati
- [PDF in Markdown](./pdf-to-markdown)
- [Prepara PDF per IA](./prepare-pdf-for-ai)
- [PDF in Word](./pdf-to-word)
docs/it/tools/pdf-to-tiff.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF in TIFF
description: Converti le pagine PDF in immagini TIFF, comunemente usate nei flussi di stampa, fax e archiviazione. Ripiega su PNG se la codifica fallisce.
---
# PDF in TIFF
Converte ogni pagina di un PDF in un'immagine TIFF. TIFF è il formato standard per la produzione di stampa, i sistemi fax e l'archiviazione documentale. Lo strumento usa la compressione PackBits per la codifica TIFF e ripiega su PNG se una pagina non riesce a essere codificata.
## Come funziona
1. Carica un PDF cliccando sull'area di rilascio o trascinandovi sopra un file.
2. Clicca su **Converti** per elaborare il file.
3. Un singolo file TIFF o un archivio ZIP viene scaricato automaticamente.
## Opzioni
Questo strumento non ha opzioni configurabili. Le pagine vengono renderizzate a una scala fissa di 2x.
## Formato di output
- **Pagina singola**: `filename.tiff`
- **Più pagine**: `filename_tiffs.zip` contenente `page_1.tiff`, `page_2.tiff`, ecc.
Se la codifica TIFF fallisce per una pagina specifica (per problemi di compressione), quella pagina viene salvata come file `.png`. In tal caso lo ZIP conterrà un mix di file TIFF e PNG.
## Casi d'uso
- Inviare documenti a enti governativi o sistemi legali che richiedono il formato TIFF.
- Preparare pagine per la trasmissione fax tramite servizi di fax digitali.
- Archiviare documenti scansionati in un formato senza perdita ampiamente supportato.
- Passare pagine a sistemi aziendali di gestione documentale.
## Suggerimenti
- I file TIFF sono grandi. Se ti serve la qualità senza perdita solo per uso web o a schermo, [PDF in PNG](./pdf-to-png) è una scelta migliore.
- Controlla il contenuto dello ZIP se alcune pagine hanno richiesto il ripiego su PNG: potresti volerle convertire separatamente.
## Strumenti correlati
- [PDF in PNG](./pdf-to-png)
- [PDF in BMP](./pdf-to-bmp)
- [PDF in JPG](./pdf-to-jpg)
docs/it/tools/pdf-to-webp.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF in WebP
description: Converti le pagine PDF in immagini WebP con qualità regolabile. File più piccoli del JPG a parità di qualità visiva.
---
# PDF in WebP
Converte ogni pagina di un PDF in un'immagine WebP. WebP produce in genere file più piccoli del 25-35% rispetto al JPG a parità di qualità percepita, il che lo rende una scelta valida per l'uso sul web.
## Come funziona
1. Carica un PDF cliccando sull'area di rilascio o trascinandovi sopra un file.
2. Regola il cursore **Qualità**.
3. Clicca su **Converti** per elaborare il file.
4. Un singolo file `.webp` o un archivio ZIP viene scaricato automaticamente.
## Opzioni
- **Qualità**: un cursore da 0% a 100% (predefinito 85%). Controlla il livello di compressione con perdita. Valori più alti conservano più dettagli.
Le pagine vengono renderizzate internamente a scala 2x, producendo immagini di circa il doppio delle dimensioni native del PDF.
## Formato di output
- **Pagina singola**: `filename.webp`
- **Più pagine**: `filename_webps.zip` contenente `page_1.webp`, `page_2.webp`, ecc.
## Casi d'uso
- Preparare anteprime di pagina per siti web in cui la banda conta.
- Generare versioni di immagine leggere di volantini o brochure per i social media.
- Convertire in blocco documenti multipagina in un insieme di immagini ottimizzate per il web.
## Suggerimenti
- WebP è supportato da tutti i browser moderni. Per la compatibilità con i sistemi più vecchi, ripiega su [PDF in JPG](./pdf-to-jpg).
- Una qualità dell'80-85% di solito è indistinguibile dall'originale a schermo, mantenendo piccole le dimensioni dei file.
## Strumenti correlati
- [PDF in JPG](./pdf-to-jpg)
- [PDF in PNG](./pdf-to-png)
- [PDF in BMP](./pdf-to-bmp)
docs/it/tools/pdf-to-word.md
+42
View File
@@ -0,0 +1,42 @@
---
title: PDF in Word
description: Converti i file PDF in documenti Word (DOCX) modificabili. Supporta la conversione in blocco di più PDF contemporaneamente.
---
# PDF in Word
Converte i file PDF in documenti Word (`.docx`) modificabili. Lo strumento usa PyMuPDF per ricostruire il contenuto del documento, mantenendo testo, formattazione di base e layout. Supporta la conversione di singoli file e in blocco.
## Come funziona
1. Carica uno o più PDF cliccando sull'area di rilascio o trascinandovi sopra i file. Puoi aggiungere altri file o rimuovere singoli file dall'elenco.
2. Clicca su **Converti** per avviare l'elaborazione.
3. Un singolo file viene scaricato come `filename.docx`. Più file vengono raccolti in `converted-documents.zip`.
## Opzioni
Questo strumento non ha opzioni configurabili. Ogni PDF viene convertito in DOCX con il motore di conversione integrato di PyMuPDF.
## Formato di output
- **File singolo**: `filename.docx`
- **Più file**: `converted-documents.zip` contenente un `.docx` per ogni PDF in ingresso.
## Casi d'uso
- Modificare il testo di un PDF ricevuto che devi correggere.
- Convertire report PDF archiviati in un formato che i colleghi possono modificare in Microsoft Word o Google Docs.
- Portare in Word il contenuto di contratti o proposte in PDF per le revisioni.
- Migrare vecchia documentazione PDF in un formato modificabile.
## Suggerimenti
- I layout complessi con testo su più colonne, moduli incorporati o molta grafica potrebbero non essere convertiti perfettamente. Controlla l'output e correggi la formattazione nel tuo elaboratore di testi.
- I PDF scansionati (solo immagine) producono file DOCX vuoti o quasi. Passali prima attraverso l'OCR per aggiungere un livello di testo.
- La modalità in blocco è efficiente per convertire intere cartelle di PDF: caricali tutti insieme.
## Strumenti correlati
- [PDF in Testo](./pdf-to-text)
- [PDF in Markdown](./pdf-to-markdown)
- [Costruttore di workflow PDF](./pdf-workflow)
docs/it/tools/pdf-to-zip.md
+41
View File
@@ -0,0 +1,41 @@
---
title: PDF in ZIP
description: Raccogli più file PDF in un unico archivio ZIP per condividerli e archiviarli facilmente.
---
# PDF in ZIP
Raccogli più file PDF in un unico archivio ZIP. È un semplice strumento di impacchettamento: nessuna conversione, compressione o modifica dei PDF stessi.
## Come funziona
1. Carica più file PDF usando l'area di rilascio.
2. Controlla l'elenco dei file. Rimuovi quelli che non vuoi includere.
3. Clicca sul pulsante di elaborazione.
4. Un archivio ZIP contenente tutti i PDF caricati viene scaricato subito.
## Funzionalità
- Accetta qualsiasi numero di file PDF
- Rimozione dei singoli file prima di creare l'archivio
- Mantiene i nomi originali dei file all'interno dello ZIP
- Nessuna modifica al contenuto dei PDF: i file vengono impacchettati così come sono
- Mostra nome e dimensione di ogni PDF caricato
## Casi d'uso
- Raccogliere un insieme di fatture o ricevute da allegare a un'email
- Impacchettare i deliverable di un progetto (più report PDF) per la consegna
- Creare un unico download per una raccolta di moduli o modelli
- Archiviare un gruppo di documenti in un unico file compresso
## Suggerimenti
- Il file ZIP usa i nomi originali dei PDF. Se hai file con lo stesso nome, rinominali prima del caricamento per evitare conflitti.
- Questo strumento non comprime i PDF stessi. Per ridurre le dimensioni dei file, passali prima da Comprimi PDF, poi impacchettali con questo strumento.
## Strumenti correlati
- [Unisci PDF](./merge-pdf)
- [Dividi PDF](./split-pdf)
- [Comprimi PDF](./compress-pdf)
docs/it/tools/pdf-workflow.md
+95
View File
@@ -0,0 +1,95 @@
---
title: Costruttore di workflow PDF
description: Crea visivamente pipeline di elaborazione PDF personalizzate collegando nodi su una tela. Concatena operazioni come unione, compressione, filigrana ed esportazione.
---
# Costruttore di workflow PDF
Il Costruttore di workflow ti permette di concatenare più operazioni PDF in un'unica pipeline automatizzata. Invece di eseguire gli strumenti uno alla volta, colleghi un grafo visivo di nodi (input, elaborazione, output) ed esegui tutto con un clic. I tuoi file non lasciano mai il browser.
## Come funziona
L'interfaccia è divisa in tre pannelli: una **casella dei nodi** a sinistra, la **tela** al centro e un **pannello delle impostazioni** a destra che compare quando selezioni un nodo.
1. **Aggiungi nodi** cliccandoli nella barra laterale sinistra, oppure trascinandoli direttamente sulla tela. Usa la barra di ricerca in cima alla casella dei nodi per filtrare per nome.
2. **Collega i nodi** trascinando da un socket di output (in basso in un nodo) a un socket di input (in alto in un altro nodo). Le connessioni scorrono dall'alto verso il basso.
3. **Configura le impostazioni** cliccando un nodo per aprire il suo pannello delle impostazioni a destra. Ogni tipo di nodo ha le proprie opzioni (intervalli di pagine, cursori di qualità, password, ecc.).
4. **Esegui il workflow** cliccando sul pulsante **Esegui** nella barra degli strumenti. Il motore esegue i nodi in ordine topologico, elaborandoli uno dopo l'altro. Una barra di stato in basso mostra l'avanzamento.
5. **Scarica i risultati**: il nodo Download finale salva il PDF risultante (o uno ZIP se vengono prodotti più file).
## Categorie di nodi
I nodi sono organizzati in sei categorie, ciascuna con un colore sulla tela:
- **Input** (blu): Input PDF, Immagine di input, Word/Excel/PowerPoint in PDF e oltre 15 altri convertitori di formato che portano i file nella pipeline.
- **Modifica e annotazione** (indaco): Ritaglia, Scala di grigi, Inverti colori, Filigrana, Numeri di pagina, Intestazione e piè di pagina, Effetto scanner, Regola colori, Colore di sfondo, Rimuovi pagine vuote, Rimuovi annotazioni.
- **Organizza e gestisci** (viola): Unisci, Dividi, Estrai pagine, Ruota, Elimina pagine, Inverti, Aggiungi pagina vuota, Dividi pagine, N-Up, Correggi dimensione pagina, Combina in una sola pagina, Opuscolo, Posterizza, Modifica metadati, Indice, OCR.
- **Ottimizza e ripara** (ambra): Comprimi, Rasterizza, Linearizza, Raddrizza, PDF in PDF/A, Font in contorni, Ripara.
- **Proteggi PDF** (rosa): Cripta, Decripta, Sanifica, Appiattisci, Firma digitale, Oscura.
- **Output** (verde acqua): Download (rileva automaticamente PDF singolo o ZIP), PDF in immagini, PDF in testo, PDF in DOCX, PDF in XLSX, PDF in CSV, PDF in SVG, PDF in Markdown, Estrai immagini.
## Salvare e caricare i workflow
La barra degli strumenti offre quattro opzioni di persistenza:
- **Salva**: memorizza il workflow corrente come modello con nome nella memoria locale del browser. Puoi salvare più modelli.
- **Carica**: apre una finestra con l'elenco di tutti i modelli salvati. Clicca su Carica per ripristinarne uno, oppure elimina i modelli che non ti servono più.
- **Esporta**: scarica il workflow come file `.json` per condividerlo o farne un backup.
- **Importa**: carica un file di workflow `.json` dal disco, ripristinando tutti i nodi, le posizioni e le connessioni.
I modelli persistono tra le sessioni nella memoria locale. I file JSON esportati sono portabili tra browser e computer.
## Modello di esecuzione
Il motore costruisce un grafo di dipendenze dalle tue connessioni ed esegue i nodi in ordine topologico. Se un nodo fallisce, l'esecuzione si interrompe e il nodo in errore viene segnato in rosso. Alcune regole da ricordare:
- Ogni workflow richiede almeno un nodo **Input** e un nodo **Output**.
- Il motore rileva le dipendenze circolari e blocca l'esecuzione con un errore.
- Il nodo **Cripta** deve essere l'ultimo passo di elaborazione prima del nodo di output. Collocarlo prima genera un avviso di convalida, perché i nodi a valle non possono operare su dati cifrati.
- I PDF protetti da password chiedono una password durante l'esecuzione.
- Sono supportati input con più PDF: il nodo Unisci può combinarli, oppure i nodi di elaborazione in blocco elaboreranno ogni PDF singolarmente.
## Tipi di socket
Le connessioni usano socket tipizzati per evitare collegamenti non validi:
- **PDF** (indaco): un singolo documento PDF.
- **MultiPDF** (ambra): più documenti PDF raggruppati insieme.
- **Image** (verde): un blob di immagine.
## Opzioni
Ogni nodo ha una propria configurazione accessibile dal pannello delle impostazioni a destra. Gli schemi comuni includono:
- **Intervalli di pagine** nei nodi Dividi, Estrai pagine, Elimina pagine
- **Cursori di qualità** nei nodi di output per la conversione in immagini
- **Campi password** nei nodi Cripta e Decripta
- **Campi di testo** per Filigrana, Intestazione e piè di pagina, Modifica metadati
- **Angoli di rotazione** nel nodo Ruota
- **Livello di compressione** nel nodo Comprimi
- **Selezione della lingua OCR** nel nodo OCR
## Casi d'uso
- **Pipeline di elaborazione fatture**: Input PDF -> OCR -> Estrai tabelle -> Download come CSV.
- **Standardizzazione dei report**: Word in PDF -> Correggi dimensione pagina -> Aggiungi numeri di pagina -> Filigrana -> Comprimi -> Download.
- **Preparazione all'archiviazione**: Input PDF -> Ripara -> Appiattisci -> Sanifica -> PDF in PDF/A -> Download.
- **Estrazione di immagini in blocco**: Input PDF (più file) -> Estrai immagini -> Download ZIP.
- **Opuscoli pronti per la stampa**: Input PDF -> Opuscolo -> Ritaglia -> Comprimi -> Download.
- **Distribuzione sicura**: Input PDF -> Oscura -> Rimuovi annotazioni -> Cripta -> Download.
## Suggerimenti
- Usa **Canc** o **Backspace** per rimuovere dalla tela il nodo selezionato.
- Clicca sul pulsante **X** nella barra di stato di un nodo per eliminarlo direttamente.
- Sposta la tela cliccando e trascinando in uno spazio vuoto. Il cursore diventa una mano mentre trascini.
- Su dispositivi mobili, usa il pulsante **+** nella barra degli strumenti per mostrare o nascondere la casella dei nodi.
- Se il tuo workflow produce più file di output, il nodo Download li raccoglie automaticamente in uno ZIP.
- Inizia in modo semplice: crea e prova una pipeline di due nodi prima di aggiungere complessità.
## Strumenti correlati
- [PDF in Testo](./pdf-to-text)
- [PDF in Excel](./pdf-to-excel)
- [Estrai immagini](./extract-images)
- [PDF in Markdown](./pdf-to-markdown)
docs/it/tools/png-to-pdf.md
+49
View File
@@ -0,0 +1,49 @@
---
title: PNG in PDF
description: Converti una o più immagini PNG in un documento PDF con qualità regolabile, interamente nel tuo browser.
---
# PNG in PDF
Converti le immagini PNG in PDF mantenendo la loro piena risoluzione. Ogni PNG diventa una pagina a sé, delle stesse dimensioni dell'immagine originale. La trasparenza viene gestita automaticamente.
## Formati supportati
| Formato | Estensioni |
| :------ | :--------- |
| PNG | `.png` |
## Come funziona
1. Clicca sull'area di caricamento o trascina i file PNG. Puoi selezionarne più di uno alla volta.
2. Gestisci l'elenco dei file: rimuovi quelli indesiderati o aggiungine altri.
3. Scegli un livello di **Qualità PDF** dal menu a tendina.
4. Clicca su **Converti in PDF**. L'output viene scaricato come `from_jpgs.pdf`.
Lo strumento usa pdf-lib per incorporare direttamente ogni immagine. Se un PNG non può essere incorporato in modo nativo (ad es. per un profilo colore insolito), ripiega sul ridisegno tramite canvas come JPEG.
## Opzioni
**Qualità PDF** controlla la compressione applicata prima dell'incorporamento:
- **Alta qualità**: compressione minima, dimensione del file maggiore.
- **Media qualità** (predefinita): buon equilibrio tra dimensione e nitidezza.
- **Bassa qualità**: compressione massima, output più piccolo.
## Casi d'uso
- Convertire schermate in un PDF multipagina per segnalazioni di bug o documentazione
- Impacchettare le esportazioni di design dell'interfaccia in un unico file da rivedere
- Trasformare le esportazioni di diagrammi (draw.io, Excalidraw) in un PDF condivisibile
- Assemblare un insieme di immagini di grafici in un report
## Suggerimenti
- I file PNG con trasparenza ottengono uno sfondo bianco nel PDF. Se ti serve uno sfondo diverso, modifica prima le immagini.
- Per schermate e diagrammi con bordi netti e testo, l'alta qualità evita gli artefatti di compressione JPEG. La qualità media o bassa può convertire internamente in JPEG.
## Strumenti correlati
- [Immagini in PDF](./image-to-pdf)
- [JPG in PDF](./jpg-to-pdf)
- [SVG in PDF](./svg-to-pdf)
docs/it/tools/posterize-pdf.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Posterizza PDF
description: Dividi le pagine di un PDF in una griglia di pagine più piccole per la stampa in grande formato su più fogli.
---
# Posterizza PDF
Dividi ogni pagina di un PDF in una griglia di sottopagine più piccole. È lo strumento giusto per stampare una singola pagina su più fogli di carta, da affiancare poi per creare un grande poster o striscione.
## Come funziona
1. Carica un file PDF.
2. Imposta il numero di **righe** e **colonne** per definire la griglia (ad es. 2 righe x 2 colonne divide ogni pagina in 4 sottopagine).
3. Se vuoi, specifica un intervallo di pagine per limitare le pagine da posterizzare.
4. L'anteprima mostra una griglia sovrapposta alla pagina corrente, così puoi vedere dove avverranno i tagli.
5. Scorri le pagine per controllare la griglia anche sulle altre.
6. Fai clic sul pulsante di elaborazione. Ogni cella della griglia diventa una pagina a sé nel PDF di output.
## Funzionalità
- Numero di righe e colonne configurabile per griglie di qualsiasi dimensione
- Anteprima in tempo reale con griglia sovrapposta che mostra esattamente dove verranno divise le pagine
- Filtro per intervallo di pagine per posterizzare solo alcune pagine
- Navigazione pagina per pagina nell'anteprima
- Istantanee delle pagine in cache per scorrere l'anteprima più velocemente
- Linee rosse tratteggiate che indicano chiaramente i bordi di taglio
## Opzioni
| Opzione | Descrizione |
| ------------------------ | ------------------------------------------------ |
| **Righe** | Numero di divisioni orizzontali (predefinito: 1) |
| **Colonne** | Numero di divisioni verticali (predefinito: 1) |
| **Intervallo di pagine** | Pagine da posterizzare (vuoto = tutte le pagine) |
## Casi d'uso
- Stampare un PDF in formato poster su normali fogli A4 o Letter da montare a parete
- Creare grandi striscioni a partire da un progetto di una sola pagina
- Dividere in riquadri stampabili disegni tecnici di grandi dimensioni
- Realizzare stampe in grande formato senza una stampante per grandi formati
## Suggerimenti
- Una griglia 2x2 trasforma una pagina in 4 pagine. Una griglia 3x3 la trasforma in 9. Scegli la griglia in base alle dimensioni finali che vuoi ottenere.
- L'anteprima con la griglia ti aiuta a verificare che i contenuti importanti non cadano su una linea di taglio. Se serve, modifica righe e colonne.
- Per l'operazione inversa (disporre più pagine su un solo foglio), usa [N-Up PDF](./n-up-pdf).
## Strumenti correlati
- [N-Up PDF](./n-up-pdf)
- [Dividi Pagine](./divide-pages)
- [Dividi PDF](./split-pdf)
docs/it/tools/powerpoint-to-pdf.md
+55
View File
@@ -0,0 +1,55 @@
---
title: PowerPoint in PDF
description: Converti presentazioni PowerPoint (PPT, PPTX) e file ODP in PDF mantenendo la formattazione delle diapositive.
---
# PowerPoint in PDF
Converti file di presentazione in PDF. Ogni diapositiva diventa una pagina del documento di output, con testo, immagini, forme e transizioni elaborati da un motore LibreOffice che gira nel browser. Supporta i formati PowerPoint moderni e legacy, oltre al formato OpenDocument Presentation.
## Formati supportati
| Formato | Estensioni |
| :------------------------ | :--------- |
| PowerPoint (moderno) | `.pptx` |
| PowerPoint (legacy) | `.ppt` |
| OpenDocument Presentation | `.odp` |
## Come funziona
1. Fai clic sull'area di caricamento o trascina i file delle presentazioni.
2. Controlla l'elenco dei file. Aggiungine altri o rimuovi quelli che non servono.
3. Fai clic su **Converti in PDF**. Il motore LibreOffice si carica al primo utilizzo, poi converte ogni file.
4. Un singolo file viene scaricato direttamente come PDF. Più file vengono raccolti in `powerpoint-converted.zip`.
## Opzioni
Questo strumento non ha impostazioni aggiuntive. Le diapositive vengono elaborate nelle loro dimensioni originali.
## Output
| Numero di file | Output |
| :------------- | :--------------------------------------------------------------------- |
| 1 file | Download di un singolo PDF (nome file originale con estensione `.pdf`) |
| 2+ file | Archivio ZIP (`powerpoint-converted.zip`) con un PDF per file |
## Casi d'uso
- Convertire una presentazione in PDF prima di condividerla con un pubblico che potrebbe non avere PowerPoint
- Creare una versione stampabile di una presentazione come dispensa per una conferenza o un workshop
- Archiviare le presentazioni in un formato che appare identico su ogni dispositivo
- Convertire in blocco una raccolta di presentazioni ODP di LibreOffice Impress in PDF
- Produrre una versione PDF di una presentazione commerciale da allegare a un'email
## Suggerimenti
- Animazioni e transizioni delle diapositive non sono rappresentate nel PDF. Ogni diapositiva viene acquisita come pagina statica.
- I video incorporati non compaiono nell'output. Se serve, sostituiscili con uno screenshot o un'immagine segnaposto.
- Le note del relatore non sono incluse nell'esportazione PDF predefinita. Se ti servono, esporta prima dalla vista "Stampa note" di PowerPoint.
- Il motore LibreOffice resta in cache dopo il primo caricamento, quindi convertire una seconda presentazione nella stessa sessione è molto più veloce.
## Strumenti correlati
- [Word in PDF](./word-to-pdf)
- [Excel in PDF](./excel-to-pdf)
- [Immagini in PDF](./image-to-pdf)
docs/it/tools/prepare-pdf-for-ai.md
+47
View File
@@ -0,0 +1,47 @@
---
title: Prepara PDF per IA
description: Estrai il contenuto dei PDF in JSON strutturato, ottimizzato per LLM e pipeline di IA come LlamaIndex. Supporta l'elaborazione in batch.
---
# Prepara PDF per IA
Estrae il contenuto dei file PDF e lo struttura in JSON ottimizzato per l'importazione in modelli linguistici di grandi dimensioni (LLM) e framework di IA come LlamaIndex. Il contenuto di ogni pagina viene estratto e organizzato in un formato strutturato, pronto per pipeline RAG, chatbot o sistemi di ricerca semantica.
## Come funziona
1. Carica uno o più PDF facendo clic sull'area di rilascio o trascinandovi i file.
2. Fai clic su **Estrai** per avviare l'elaborazione.
3. Un singolo file viene scaricato come `filename_llm.json`. Più file producono un archivio `pdf-for-ai.zip`.
Lo strumento usa l'integrazione LlamaIndex di PyMuPDF per estrarre il contenuto a livello di pagina insieme ai metadati, producendo un output che può essere caricato direttamente nei framework di IA.
## Opzioni
Questo strumento non ha opzioni configurabili. Tutte le pagine vengono estratte con testo completo e metadati.
## Formato di output
- **File singolo**: `filename_llm.json`
- **File multipli**: `pdf-for-ai.zip` con un `_llm.json` per ogni PDF di input.
L'output JSON segue lo schema dei documenti di LlamaIndex, con il testo di ogni pagina e i campi dei metadati.
## Casi d'uso
- Preparare documenti PDF per pipeline di retrieval-augmented generation (RAG).
- Creare una base di conoscenza consultabile da archivi PDF per un chatbot di IA.
- Fornire report PDF a flussi di analisi basati su LLM.
- Pre-elaborare articoli scientifici per sistemi di ricerca semantica e di domande e risposte.
- Creare dati di addestramento strutturati da raccolte di documenti PDF.
## Suggerimenti
- Per l'estrazione di solo testo, senza formattazione specifica per l'IA, usa [PDF in Testo](./pdf-to-text).
- Per un output Markdown che conservi titoli e struttura, usa [PDF in Markdown](./pdf-to-markdown).
- I PDF scansionati producono un output vuoto o minimo. Passali prima dall'OCR per aggiungere un livello di testo prima dell'estrazione.
## Strumenti correlati
- [PDF in Testo](./pdf-to-text)
- [PDF in Markdown](./pdf-to-markdown)
- [PDF in JSON](./pdf-to-json)
docs/it/tools/protect-pdf.md
+64
View File
@@ -0,0 +1,64 @@
---
title: Proteggi PDF
description: Proteggi i file PDF con una password usando la crittografia AES a 256 bit. Imposta password utente e proprietario con restrizioni d'uso configurabili.
---
# Proteggi PDF
Blocca il tuo PDF con una password, così solo le persone autorizzate potranno aprirlo. BentoPDF usa la crittografia AES a 256 bit, lo stesso standard usato da banche e agenzie governative, applicata interamente nel tuo browser tramite QPDF.
## Come funziona
1. Carica un file PDF.
2. Inserisci una **Password utente** (obbligatoria). È la password che serve per aprire il file.
3. Se vuoi, inserisci una **Password proprietario**. Se impostata, il PDF ottiene restrizioni d'uso che impediscono di stampare, modificare, copiare e annotare.
4. Fai clic su **Cripta PDF**.
5. Scarica il file criptato.
## Tipi di password
### Password utente (obbligatoria)
La password utente è quella che i destinatari digitano per aprire il PDF. Senza di essa il documento è completamente inaccessibile. Ogni PDF criptato deve averne una.
### Password proprietario (facoltativa)
La password proprietario controlla cosa può fare un utente autorizzato dopo aver aperto il file. Quando imposti una password proprietario distinta, BentoPDF applica automaticamente il set di restrizioni più severo:
- Modifica disabilitata
- Estrazione/copia disabilitata
- Stampa disabilitata
- Annotazione disabilitata
- Compilazione dei moduli disabilitata
- Assemblaggio del documento disabilitato
Se lasci vuota la password proprietario, il PDF viene criptato (per aprirlo serve comunque la password utente) ma, una volta aperto, non ha restrizioni d'uso.
## Dettagli sulla crittografia
- **Algoritmo**: AES-256 (Advanced Encryption Standard a 256 bit)
- **Lunghezza della chiave**: 256 bit
- **Standard**: crittografia PDF 2.0 (implementazione QPDF)
Con la tecnologia attuale, AES-256 non è violabile con un attacco a forza bruta. La sicurezza del tuo PDF criptato dipende interamente dalla robustezza della password.
## Casi d'uso
- Proteggere report finanziari riservati prima di inviarli per email
- Mettere al sicuro documenti legali condivisi con la controparte
- Aggiungere una password a cartelle cliniche o a dati personali identificabili
- Distribuire contenuti a pagamento (e-book, report) con controllo degli accessi
- Rispettare le policy di protezione dei dati che richiedono la crittografia dei dati archiviati
## Suggerimenti
- Usa una password forte e univoca. Una passphrase di almeno 12 caratteri con maiuscole, minuscole, numeri e simboli è l'ideale.
- Condividi la password attraverso un canale separato (telefono, messaggio di testo), mai nella stessa email del PDF.
- Se ti serve solo limitare alcune azioni (niente stampa, niente copia) senza richiedere una password per aprire il file, usa invece lo strumento Modifica permessi.
## Strumenti correlati
- [Decrittografa PDF](./unlock-pdf): rimuovi la crittografia quando conosci la password
- [Modifica permessi](./change-permissions): modifica restrizioni d'uso specifiche
- [Rimuovi Restrizioni](./remove-restrictions): elimina ogni protezione da un PDF
- [Sanitizza PDF](./sanitize-pdf): rimuovi i contenuti nascosti prima di criptare
docs/it/tools/psd-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: PSD in PDF
description: Converti i file Photoshop (PSD) in PDF nel tuo browser. Gratis, privato, senza bisogno di software Adobe.
---
# PSD in PDF
Converti i file Adobe Photoshop PSD in documenti PDF. PSD è il formato nativo di Photoshop e aprirlo di solito richiede costosi software Adobe. Questo strumento elabora l'immagine composita appiattita del tuo file PSD come pagina PDF a piena risoluzione.
## Formati supportati
| Formato | Estensione | Note |
| :-------------- | :--------- | :-------------------------------------- |
| Adobe Photoshop | `.psd` | Elabora l'immagine composita appiattita |
## Come funziona
1. Fai clic sull'area di caricamento o trascina i tuoi file PSD. Sono supportati più file.
2. Controlla l'elenco dei file. Rimuovi quelli che non vuoi con l'icona del cestino oppure usa **Aggiungi altri file** per includerne altri.
3. Fai clic su **Converti in PDF**. Il motore PyMuPDF legge il file PSD e incorpora l'immagine composita in una pagina PDF alla risoluzione originale.
4. Un singolo PSD produce un PDF. Se carichi più file PSD, vengono uniti in un unico PDF multipagina chiamato `psd_to_pdf.pdf`, in cui ogni PSD diventa una pagina.
## Opzioni
Non servono impostazioni. Il convertitore usa i dati immagine appiattiti del file PSD.
## Casi d'uso
- Visualizzare in anteprima i progetti Photoshop senza aprire Photoshop
- Inviare bozze di design a clienti che non hanno Adobe Creative Suite
- Stampare illustrazioni ad alta risoluzione da file PSD
- Creare un portfolio PDF da più file di design PSD: ognuno diventa una pagina di un unico documento
## Suggerimenti
- La conversione elabora la vista composita (appiattita) del PSD. I singoli livelli, i livelli di regolazione e gli effetti di livello non vengono conservati come elementi separati nel PDF.
- Più file PSD vengono uniti in un unico PDF multipagina anziché in PDF separati. È utile per creare portfolio o lookbook.
- I file PSD ad altissima risoluzione (file di stampa a 300+ DPI) producono PDF di grandi dimensioni. Lo strumento mantiene la risoluzione completa.
## Strumenti correlati
- [Immagini in PDF](./image-to-pdf)
- [PNG in PDF](./png-to-pdf)
- [VSD in 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