### Install docx2pdf-converter using npm or yarn

Source: https://github.com/bansnetsajak007/docx2pdf-converter/blob/master/README.md

Instructions for installing the 'docx2pdf-converter' package using either npm or yarn. This package is a prerequisite for using its conversion and image extraction functionalities.

```bash
npm i docx2pdf-converter
```

```bash
yarn add docx2pdf-converter
```

--------------------------------

### Linux-Specific DOCX to PDF Conversion with unoconv

Source: https://context7.com/bansnetsajak007/docx2pdf-converter/llms.txt

Performs DOCX to PDF conversion on Linux using unoconv (LibreOffice-based conversion). Includes dependency verification to ensure unoconv is installed, proper error handling with installation instructions, and platform-specific execution checks. Note that fonts and layout may differ from the original Word document.

```javascript
const { linux } = require('docx2pdf-converter');
const path = require('path');
const { exec } = require('child_process');
const { promisify } = require('util');

const execAsync = promisify(exec);

async function linuxConversion() {
  // First check if unoconv is installed
  try {
    await execAsync('which unoconv');
  } catch (error) {
    console.error('unoconv is not installed. Install it using:');
    console.error('  Ubuntu/Debian: sudo apt-get install unoconv');
    console.error('  Fedora/RHEL: sudo dnf install unoconv');
    return;
  }

  const inputPath = path.join(__dirname, './documents/manual.docx');
  const outputPath = path.join(__dirname, './output/manual.pdf');

  try {
    const result = await linux(inputPath, outputPath, false);
    console.log('Linux conversion result:', result);
    console.log('PDF created successfully using unoconv');
    console.log('Note: Fonts and layout may differ from original Word document');
  } catch (error) {
    console.error('Linux conversion error:', error.message);
    if (error.message.includes('unoconv')) {
      console.error('Make sure LibreOffice and unoconv are properly installed');
    }
  }
}

// Only run on Linux platform
if (process.platform === 'linux') {
  linuxConversion();
} else {
  console.log('This example only runs on Linux');
}
```

--------------------------------

### Convert DOCX to PDF on Windows (JavaScript)

Source: https://context7.com/bansnetsajak007/docx2pdf-converter/llms.txt

Performs DOCX to PDF conversion on Windows using the 'docx2pdf-converter' library's Windows-specific module. It leverages PowerShell and Microsoft Word COM objects. Requires Microsoft Word to be installed. Inputs are source DOCX path, output PDF path, and a boolean to keep Word active. Outputs are the conversion result or an error message. This code is intended to run exclusively on Windows.

```javascript
const { windows } = require('docx2pdf-converter');
const path = require('path');

async function windowsConversion() {
  const inputPath = path.join(__dirname, './documents/contract.docx');
  const outputPath = path.join(__dirname, './output/contract.pdf');
  const keepActive = false; // Set to true to keep Word application running

  try {
    const result = await windows(inputPath, outputPath, keepActive);
    console.log('Windows conversion result:', result);
    console.log('PDF created successfully using Microsoft Word');
  } catch (error) {
    console.error('Windows conversion error:', error.message);
    // Handle errors such as Word not being installed
    if (error.message.includes('Word.Application')) {
      console.error('Microsoft Word must be installed for Windows conversion');
    }
  }
}

// Only run on Windows platform
if (process.platform === 'win32') {
  windowsConversion();
} else {
  console.log('This example only runs on Windows');
}
```

--------------------------------

### Convert a Single DOCX File to PDF using JavaScript

Source: https://github.com/bansnetsajak007/docx2pdf-converter/blob/master/README.md

Demonstrates how to convert a single DOCX file to a PDF file using the 'convert' function from the 'docx2pdf-converter' package. It takes the input DOCX file path and the desired output PDF file path as arguments and returns a promise.

```javascript
const DOCX2PDFConverter = require('docx2pdf-converter');
const path = require('path');

const inputPath = path.join(__dirname, "./report.docx");
DOCX2PDFConverter.convert(inputPath, path.join(__dirname, "output.pdf"))
  .then((res) => {
    console.log(res);
  })
  .catch(error=> {
    console.error(error)
  });
```

--------------------------------

### Complete DOCX to PDF Workflow with Image Extraction and Validation

Source: https://context7.com/bansnetsajak007/docx2pdf-converter/llms.txt

End-to-end workflow demonstrating the complete docx2pdf-converter functionality including path validation, directory creation, image extraction, DOCX to PDF conversion, and file verification. Implements comprehensive error handling and provides detailed step-by-step logging of the conversion process with final success/failure reporting.

```javascript
const DOCX2PDFConverter = require('docx2pdf-converter');
const { convert, extractImages, resolvePaths } = DOCX2PDFConverter;
const fs = require('fs').promises;
const path = require('path');

async function completeWorkflow() {
  const config = {
    inputFile: path.join(__dirname, './source/annual-report.docx'),
    outputDir: path.join(__dirname, './processed'),
    imageDir: path.join(__dirname, './processed/images')
  };

  try {
    // Step 1: Validate and resolve paths
    console.log('Step 1: Validating paths...');
    const pathInfo = await resolvePaths(config.inputFile, config.outputDir);
    console.log('Resolved paths:', pathInfo);

    // Step 2: Create output directories
    console.log('\nStep 2: Creating output directories...');
    await fs.mkdir(config.outputDir, { recursive: true });
    await fs.mkdir(config.imageDir, { recursive: true });

    // Step 3: Extract images from DOCX
    console.log('\nStep 3: Extracting images...');
    const extractionResult = await extractImages(config.inputFile, config.imageDir);
    if (extractionResult) {
      const images = await fs.readdir(config.imageDir);
      console.log(`Extracted ${images.length} images`);
    }

    // Step 4: Convert DOCX to PDF
    console.log('\nStep 4: Converting DOCX to PDF...');
    const conversionResult = await convert(config.inputFile, pathInfo.output);
    console.log('Conversion result:', conversionResult);

    // Step 5: Verify output file exists
    console.log('\nStep 5: Verifying output...');
    const stats = await fs.stat(pathInfo.output);
    console.log(`PDF created successfully: ${(stats.size / 1024).toFixed(2)} KB`);

    return {
      success: true,
      pdfPath: pathInfo.output,
      imageCount: (await fs.readdir(config.imageDir)).length,
      fileSize: stats.size
    };

  } catch (error) {
    console.error('\nWorkflow failed:', error.message);
    return {
      success: false,
      error: error.message
    };
  }
}

// Execute the complete workflow
completeWorkflow()
  .then((result) => {
    if (result.success) {
      console.log('\n✓ Complete workflow finished successfully');
      console.log(`  PDF: ${result.pdfPath}`);
      console.log(`  Images: ${result.imageCount}`);
      console.log(`  Size: ${(result.fileSize / 1024).toFixed(2)} KB`);
    } else {
      console.log('\n✗ Workflow failed');
      process.exit(1);
    }
  })
  .catch(console.error);
```

--------------------------------

### Batch Convert DOCX Files in a Directory to PDF using JavaScript

Source: https://github.com/bansnetsajak007/docx2pdf-converter/blob/master/README.md

Provides a JavaScript function to convert all DOCX files within a specified input directory to PDF format, saving them in an output directory. It utilizes the 'convert' and 'resolvePaths' functions from the 'docx2pdf-converter' package and handles asynchronous operations.

```javascript
const fs = require('fs');
const path = require('path');
const { convert, resolvePaths } = require('docx2pdf-converter');

async function convertDirectory(inputDir, outputDir) {
  const files = fs.readdirSync(inputDir);

  for(const file of files) {
    if (file.endsWith('.docx')) {
      const inputPath = path.join(inputDir, file);
      const { output } = resolvePaths(inputPath, outputDir);
      try {
        const result = await convert(inputPath, output);
        console.log(`Converted: ${file}`, result);
      } catch(err) {
        console.error(err);
      }
    }
  }
}

/*
Assume both directories (input and output) are in the same folder.
If not, you can provide absolute paths to the folders.
*/
const inputDirectory = path.join(__dirname, './inputdir');
const outputDirectory = path.join(__dirname, './outputdir');

convertDirectory(inputDirectory, outputDirectory)
  .then(() => {
    console.log("convert success !");
  })
  .catch(console.error);
```

--------------------------------

### Batch Convert DOCX Files in a Directory to PDF using Node.js

Source: https://context7.com/bansnetsajak007/docx2pdf-converter/llms.txt

Processes all DOCX files within a specified input directory and converts them to PDF format, saving them to an output directory. This function ensures the output directory exists, iterates through DOCX files, and uses the `convert` function for each file. It provides asynchronous operation with error handling for individual file conversions and reports a summary of successful and failed conversions.

```javascript
const fs = require('fs');
const path = require('path');
const { convert, resolvePaths } = require('docx2pdf-converter');

async function convertDirectory(inputDir, outputDir) {
  // Ensure output directory exists
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  const files = fs.readdirSync(inputDir);
  const results = [];

  for (const file of files) {
    if (file.endsWith('.docx')) {
      const inputPath = path.join(inputDir, file);
      const outputPath = path.join(outputDir, file.replace('.docx', '.pdf'));

      try {
        const result = await convert(inputPath, outputPath);
        results.push({ file, status: 'success', result });
        console.log(`✓ Converted: ${file}`);
      } catch (error) {
        results.push({ file, status: 'failed', error: error.message });
        console.error(`✗ Failed: ${file} - ${error.message}`);
      }
    }
  }

  return results;
}

// Execute batch conversion
const inputDirectory = path.join(__dirname, './documents');
const outputDirectory = path.join(__dirname, './pdf-output');

convertDirectory(inputDirectory, outputDirectory)
  .then((results) => {
    const successful = results.filter(r => r.status === 'success').length;
    const failed = results.filter(r => r.status === 'failed').length;
    console.log(`\nConversion complete: ${successful} succeeded, ${failed} failed`);
  })
  .catch(console.error);
```

--------------------------------

### Resolve Paths for DOCX to PDF Conversion (JavaScript)

Source: https://context7.com/bansnetsajak007/docx2pdf-converter/llms.txt

Utility function to validate and resolve input and output paths for DOCX to PDF conversion. It handles single files and directories, supporting batch processing. Dependencies include the 'docx2pdf-converter' and 'path' modules. Inputs are the source file/directory and an optional output path/directory. Outputs are objects detailing resolved input, output, and batch status. Limitations may arise with complex path structures or unsupported file types.

```javascript
const { resolvePaths } = require('docx2pdf-converter');
const path = require('path');

async function demonstratePathResolution() {
  // Example 1: Single file with output directory
  const result1 = await resolvePaths(
    path.join(__dirname, './input/document.docx'),
    path.join(__dirname, './output')
  );
  console.log('Single file to directory:', result1);
  // Output: { input: '/absolute/path/to/input/document.docx',
  //          output: '/absolute/path/to/output/document.pdf',
  //          batch: false }

  // Example 2: Single file with explicit output path
  const result2 = await resolvePaths(
    path.join(__dirname, './input/report.docx'),
    path.join(__dirname, './output/final-report.pdf')
  );
  console.log('Single file with specific output:', result2);
  // Output: { input: '/absolute/path/to/input/report.docx',
  //          output: '/absolute/path/to/output/final-report.pdf',
  //          batch: false }

  // Example 3: Directory (batch processing)
  const result3 = await resolvePaths(
    path.join(__dirname, './input'),
    path.join(__dirname, './output')
  );
  console.log('Directory batch processing:', result3);
  // Output: { input: '/absolute/path/to/input',
  //          output: '/absolute/path/to/output',
  //          batch: true }

  // Example 4: Single file without output (uses same directory)
  const result4 = await resolvePaths(
    path.join(__dirname, './documents/invoice.docx')
  );
  console.log('Single file, default output:', result4);
  // Output: { input: '/absolute/path/to/documents/invoice.docx',
  //          output: '/absolute/path/to/documents/invoice.pdf',
  //          batch: false }
}

demonstratePathResolution().catch(console.error);
```

--------------------------------

### Convert Single DOCX to PDF using Node.js

Source: https://context7.com/bansnetsajak007/docx2pdf-converter/llms.txt

Converts a single DOCX file to PDF format. The function automatically detects the operating system and uses the appropriate conversion method. It accepts input and output file paths and an optional boolean flag 'keepActive' for Windows to keep Microsoft Word open after conversion. The API is promise-based, returning a promise that resolves on success or rejects on failure.

```javascript
const DOCX2PDFConverter = require('docx2pdf-converter');
const path = require('path');

// Basic conversion
const inputPath = path.join(__dirname, './reports/quarterly-report.docx');
const outputPath = path.join(__dirname, './output/quarterly-report.pdf');

DOCX2PDFConverter.convert(inputPath, outputPath)
  .then((result) => {
    console.log('Conversion successful:', result);
  })
  .catch((error) => {
    console.error('Conversion failed:', error.message);
    process.exit(1);
  });

// With keepActive flag (Windows only - keeps Word application open)
DOCX2PDFConverter.convert(inputPath, outputPath, true)
  .then((result) => {
    console.log('Conversion completed with Word kept active');
  })
  .catch(console.error);
```

--------------------------------

### Convert DOCX to PDF on macOS (JavaScript)

Source: https://context7.com/bansnetsajak007/docx2pdf-converter/llms.txt

Performs DOCX to PDF conversion on macOS using the 'docx2pdf-converter' library's macOS-specific module. It utilizes the 'textutil' command-line utility. Inputs are the source DOCX path and the output PDF path. Outputs are the conversion result or an error message. This code is intended to run exclusively on macOS.

```javascript
const { macos } = require('docx2pdf-converter');
const path = require('path');

async function macosConversion() {
  const inputPath = path.join(__dirname, './documents/proposal.docx');
  const outputPath = path.join(__dirname, './output/proposal.pdf');

  try {
    const result = await macos(inputPath, outputPath, false);
    console.log('macOS conversion result:', result);
    console.log('PDF created successfully using textutil');
  } catch (error) {
    console.error('macOS conversion error:', error.message);
  }
}

// Only run on macOS platform
if (process.platform === 'darwin') {
  macosConversion();
} else {
  console.log('This example only runs on macOS');
}
```

--------------------------------

### Extract Images from DOCX File using JavaScript

Source: https://github.com/bansnetsajak007/docx2pdf-converter/blob/master/README.md

Shows how to extract all embedded images from a DOCX file and save them to a designated directory using the 'extractImages' function. It includes creating the output directory if it doesn't exist and handles the extraction process asynchronously.

```javascript
const { extractImages } = require('docx2pdf-converter');
const path = require('path');
const fs = require('fs');

const inputPath = path.join(__dirname, './report.docx');  // Path to your DOCX file
const outputDir = path.join(__dirname, './extracted-images');  // Directory where images will be saved

if(!fs.existsSync(outputDir)) {
  fs.mkdirSync(outputDir);
}

extractImages(inputPath, outputDir)
  .then((result) => {
    console.log("convert success !", result);
  })
  .catch(console.error);
```

--------------------------------

### Extract Images from DOCX File using Node.js

Source: https://context7.com/bansnetsajak007/docx2pdf-converter/llms.txt

Extracts all embedded images from a specified DOCX file and saves them as individual image files into a designated output directory. The function creates the output directory if it does not exist. It returns a promise that resolves with the result of the extraction or rejects if an error occurs. The function logs the number and details of extracted images upon successful completion.

```javascript
const { extractImages } = require('docx2pdf-converter');
const path = require('path');
const fs = require('fs');

async function extractAndOrganizeImages() {
  const inputPath = path.join(__dirname, './documents/presentation.docx');
  const outputDir = path.join(__dirname, './extracted-images');

  // Create output directory if it doesn't exist
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  try {
    const result = await extractImages(inputPath, outputDir);

    if (result) {
      // List all extracted images
      const extractedFiles = fs.readdirSync(outputDir);
      console.log(`\nExtracted ${extractedFiles.length} images:`);
      extractedFiles.forEach(file => {
        const stats = fs.statSync(path.join(outputDir, file));
        console.log(`  - ${file} (${(stats.size / 1024).toFixed(2)} KB)`);
      });
    }

    return result;
  } catch (error) {
    console.error('Image extraction failed:', error.message);
    throw error;
  }
}

extractAndOrganizeImages()
  .then(() => console.log('\nImage extraction completed successfully'))
  .catch(console.error);
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.