SuperAPI AI Directory

deck-web-converter

General & other

View repository

Updated 10-16 08:46

About this skill

Deck Web Converter

Convert pitch deck files (.pptx or .pdf) into a beautiful, responsive single-file HTML presentation.

When to Use

Use this skill when:

  • The user already has .pptx or .pdf files and needs to convert them into a shareable webpage
  • The user needs to share roadshow materials via email, WeChat, QR code, or browser
  • The user needs to view the PPT on a phone
  • The user needs an online presentation rather than a file attachment

Do NOT use this skill if:

  • The user needs to create a BP from scratch → use pitch-deck-creator instead
  • The user needs to edit the source PPT content → edit first, then convert
  • The input file is missing or unreadable → ask for the correct file path

Typical triggers:

  • "Convert PPT to webpage" "BP online presentation" "Generate HTML version of PPT"
  • "pitch deck to link" "PPT to view on a phone" "web version roadshow materials"
  • "convert pitch to web", "PPT to HTML", "share presentation online"

Workflow

This workflow follows a six-step progression method, with 6 steps in total:

  1. Probe (Probe): Before starting, fully read all inputs and confirm the goals and constraints.
  2. Constrain (Constrain): Verify input completeness, set boundaries and non-degradable delivery standards, and switch channels when blocked.
  3. Evidence (Evidence): Every number must come from the input, a specific source, or reproducible calculation, and supporting data must be collected.
  4. Execute (Execute): Call scripts/APIs/generate content, giving impact and conclusions first, then actions and necessary evidence.
  5. Verify (Verify): Verify with actions that "may fail"—read back the output in a way different from the generation path.
  6. Deliver (Deliver): Return the results and clean up temporary files.

Step 1: Probe (Probe)

Confirm the input file path. Supported formats:

  • .pptx — PowerPoint file
  • .pdf — PDF file

If the user does not provide a file path, ask proactively.

Step 2: Constrain (Constrain)

Set output boundaries:

  • The output must bea single self-contained HTML file, with zero external dependencies
  • The output HTML must be saved to the same directory as the input file, using the same base name + _presentation.html
  • Retain all textual content from the source file, without summarizing or omitting
  • Chinese characters must render correctly
  • When blocked, switch channels (e.g., generate a script and guide the user to install it when dependencies are missing), without degrading the deliverable

Step 3: Evidence (Evidence)

Extract all content from the source file as evidence:

  • .pptx file: Use python-pptx to extract all slide content—text, shapes, tables, images (base64-encoded), layout information, and colors
  • .pdf file: Use pymupdf (fitz) to extract the text, images (base64), and page structure of each page
  • The content of each slide comes from source file extraction, with no fabrication

Step 4: Execute (Execute)

Generate and run a Python script to extract content and generate the complete HTML. Give impact and conclusions first, then actions and necessary evidence.

HTML output specifications

Architecture:

  • Single .html file, fully self-contained (CSS + JS inline, images as base64 data URI)
  • No CDN links, no external fonts, no external JS—100% offline usable
  • Use system fonts:-apple-system, BlinkMacSystemFont, "Segoe UI", "Microsoft YaHei", sans-serif

Presentation mode: The HTML should serve as a slide-based presentation, with:

  • Slide navigation: arrow keys (← →), click, or swipe to switch
  • Slide indicator: dots at the bottom show the current position
  • Progress bar: a thin bar at the top shows presentation progress
  • Fullscreen toggle: button to enter/exit fullscreen (F key shortcut)
  • Slide count: "3 / 10" indicator
  • Smooth transitions: CSS transitions between slides (slide or fade in)
  • Responsive: supports desktop, tablet, and mobile

Visual design:

Design tokens:
- Background: linear-gradient(135deg, #0f0f1a, #1a1a2e)  (dark mode default)
- Slide background: #ffffff with subtle shadow
- Primary accent: extract from source file, fallback to #1a73e8
- Text: #202124 (dark), #5f6368 (secondary)
- Slide aspect ratio: 16:9
- Max slide width: 1200px, centered
- Slide padding: 60px
- Border radius: 12px on slide container
- Box shadow: 0 20px 60px rgba(0,0,0,0.3)

HTML template structure:

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{Project Name} — Business Plan</title>
    <style>
        /* Reset + Base styles */
        /* Slide container styles */
        /* Navigation styles */
        /* Responsive breakpoints */
        /* Print styles */
        /* Animation keyframes */
    </style>
</head>
<body>
    <!-- Progress bar -->
    <div class="progress-bar"><div class="progress-fill"></div></div>

    <!-- Slides container -->
    <div class="slides-container">
        <div class="slide active" data-index="0">
            <!-- Slide content reconstructed from source -->
        </div>
        <!-- ... more slides ... -->
    </div>

    <!-- Navigation -->
    <div class="nav-dots">
        <span class="dot active"></span>
        <!-- ... -->
    </div>
    <div class="slide-counter">1 / 10</div>
    <button class="fullscreen-btn" title="Fullscreen (F)">⛶</button>
    <button class="nav-arrow prev" title="Previous (←)">‹</button>
    <button class="nav-arrow next" title="Next (→)">›</button>

    <script>
        // Slide navigation logic
        // Keyboard shortcuts (←, →, F, Escape)
        // Touch/swipe support
        // Fullscreen API
        // Progress bar update
    </script>
</body>
</html>

Content mapping rules:

Source Element HTML Rendering
Slide title <h1> or <h2> with accent underline
Subtitle <p class="subtitle">
Body text <p> with proper spacing
Bullet points <ul> with styled list items
Tables <table> with striped rows and hover effects
Images <img> with base64 src, responsive sizing
Charts/shapes Describe as styled <div> blocks or reconstruct with CSS
Stat numbers Large <span class="stat"> with label below
Cards <div class="card"> with shadow and border
Timeline Horizontal flex layout with dots and lines
Comparison table Feature matrix with ✓/✗ icons

Slide type-specific styles:

  1. Cover: full-bleed dark background, large title, gradient overlay
  2. Pain points: colorful cards in a grid
  3. Solution: feature cards with icons
  4. Business model: revenue breakdown with visual bars
  5. Product demo: centered image/model diagram + annotations
  6. Competitive analysis: styled comparison table
  7. Traction: metrics row + timeline visualization
  8. Roadmap: phase cards connected by arrows
  9. Team: a row of avatar cards
  10. Financing: key statistics + use of funds bar chart

Python script requirements

The script must:

  1. Accept the input file path as a variable or argument
  2. Detect the file type (.pptx or .pdf) and use the appropriate extraction method
  3. Extract all text content and preserve hierarchy (title vs body)
  4. Extract images and convert them to base64 data URIs
  5. For .pptx: extract shape positions, colors, and font sizes to guide layout
  6. For .pdf: extract text blocks with position data and embedded images
  7. Generate complete HTML with inline CSS and JS
  8. Correctly handle Chinese and English text
  9. Save the output file and print the path
  10. Dependencies:python-pptx、pymupdf (fitz)、base64、os

Script template

#!/usr/bin/env python3
"""Deck to HTML Converter by Unique Club"""

import os
import sys
import base64

def extract_from_pptx(filepath):
    """Extract slide content from a .pptx file."""
    from pptx import Presentation
    from pptx.util import Inches, Pt, Emu
    # ... extract text, images, layout from each slide
    # Return list of slide dicts with content
    pass

def extract_from_pdf(filepath):
    """Extract page content from a .pdf file."""
    import fitz  # pymupdf
    # ... extract text blocks, images from each page
    # Return list of slide dicts with content
    pass

def detect_slide_type(slide_data, index, total):
    """Heuristically detect slide type for enhanced styling."""
    # Cover (first slide), Fundraising (last slide), etc.
    pass

def generate_html(slides, title, accent_color="#1a73e8"):
    """Generate complete self-contained HTML presentation."""
    # Build CSS, HTML slides, JS navigation
    pass

def main():
    input_file = INPUT_FILE  # Set by the skill
    ext = os.path.splitext(input_file)[1].lower()

    if ext == ".pptx":
        slides = extract_from_pptx(input_file)
    elif ext == ".pdf":
        slides = extract_from_pdf(input_file)
    else:
        print(f"Unsupported format: {ext}")
        sys.exit(1)

    title = os.path.splitext(os.path.basename(input_file))[0]
    html = generate_html(slides, title)

    output_file = os.path.splitext(input_file)[0] + "_presentation.html"
    with open(output_file, "w", encoding="utf-8") as f:
        f.write(html)
    print(f"HTML presentation generated: {output_file}")

if __name__ == "__main__":
    main()

Step 5: Verify

Read back the output in a different way from the generation path:

  • Open the HTML in a browser and confirm all slides render correctly
  • Test keyboard navigation (← →), fullscreen (F), and swipe operations
  • Confirm that all text content matches the source file with no omissions
  • Verify that Chinese characters render correctly
  • Check that the responsive layout works properly on mobile
  • Confirm the file size is reasonable (<10MB, unless the source file has many large images)
  • Test print functionality (including @media print styles)

Step 6: Deliver

Return results, clean up temporary files:

  1. Inform the user of the output file path
  2. Explain that it can be opened directly in the browser
  3. Mention keyboard shortcuts: ← → to navigate, F for fullscreen
  4. Provide the file path for easy copying and sharing
  5. If the user requests, a QR code can be generated for mobile access

Output

Output constraints

  • Single HTML file, fully self-contained, zero external dependencies
  • File size should be reasonable (<10MB, unless the source file has many large images)
  • Must work properly in Chrome, Safari, Firefox, Edge
  • Must be printable (including @media print styles)
  • Retain all text content from the source file — do not summarize or omit
  • Chinese characters must render correctly

Output file naming

Save the output HTML to the same directory as the input file, using the same base name + _presentation.html。

Guardrails

Anti-patterns

  • NEVER output non-self-contained HTML — external CDN links are prohibited
  • Do NOT omit slides or summary content — retain all text from the source file
  • Do NOT fail to warn the user that the HTML may be very large when the source file contains large images (>2MB each)
  • NEVER save the HTML to a directory different from the input file or use a different base name
  • Do NOT give up when dependencies are missing — generate a script and guide the user to install the required dependencies

Constraints

  • The output must be a single .html file
  • Supports .pptx and .pdf two input formats
  • Depends on python-pptx and pymupdf, guide installation if missing
  • Images are inlined as base64 data URIs
  • Use system fonts, do not rely on external fonts
  • 16:9 slide aspect ratio, max width 1200px centered

Related Skills

  • pitch-deck-creator — Create a professional pitch deck from scratch, then convert it to HTML to complete the full workflow from creation to sharing
  • business-plan-ppt — Create an 18-page Chinese-style business plan PPT, then use this skill to convert it into a webpage for sharing
  • fundraising-bp-planner — First outline the fundraising BP before creating and converting the deck

About UniqueClub

This skill is part of the UniqueClub founder toolkit. 🌐 https://uniqueclub.ai 📂 https://github.com/wulaosiji/founder-skills