### Generate EPUB using Main Entry Point

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/README.md

Use the main `epub` function for straightforward EPUB generation. It accepts options and chapter data to produce an EPUB buffer. This is the simplest way to get started.

```typescript
import epub from 'epub-gen-memory';

const buffer = await epub(options, chapters);
```

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

### Install epub-gen-memory

Source: https://github.com/cpiber/epub-gen-memory/blob/master/README.md

Install the library using npm and add it as a project dependency.

```shell
npm install epub-gen-memory --save
```

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

### Simple Chapter Example

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/02-types.md

A basic example of a chapter object with a title and content. This demonstrates the minimum required fields.

```typescript
const chapter: Chapter = {
  title: 'Introduction',
  content: '<p>Welcome to the book.</p>'
};
```

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

### Full Options Configuration

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/02-types.md

Example demonstrating how to set all available options for comprehensive EPUB customization. Includes metadata, styling, and advanced generation settings.

```typescript
const options: Options = {
  title: 'Alice in Wonderland',
  author: ['Lewis Carroll'],
  publisher: 'Macmillan & Co.',
  description: 'A classic children\'s novel',
  cover: 'http://example.com/cover.jpg',
  tocTitle: 'Contents',
  tocInTOC: true,
  numberChaptersInTOC: true,
  prependChapterTitles: true,
  date: '2023-01-01',
  lang: 'en',
  version: 3,
  fetchTimeout: 30000,
  retryTimes: 5,
  batchSize: 50,
  ignoreFailedDownloads: false,
  verbose: true,
  fonts: [
    { filename: 'Merriweather.ttf', url: 'http://...' }
  ]
};
```

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

### Example Usage of LogFn

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/02-types.md

Demonstrates how to implement a custom logging function for the verbose option, including timestamps and message type handling.

```typescript
const options: Options = {
  title: 'My Book',
  verbose: (type, ...args) => {
    const timestamp = new Date().toISOString();
    if (type === 'warn') {
      console.error(`[${timestamp}] WARN:`, ...args);
    } else {
      console.log(`[${timestamp}] LOG:`, ...args);
    }
  }
};
```

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

### HTML Code Sample Example

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/05-html-content-guide.md

Display code samples using the code tag for inline code and pre tags for blocks. Styling can enhance readability.

```html
<p>To define a function, use the <code>def</code> keyword:</p>
<pre style="background-color: #f5f5f5; padding: 1em; overflow-x: auto;">
def hello():
    print("Hello, World!")
</pre>
```

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

### Chapter Organization with Metadata

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/README.md

Provides an example of how to structure chapters for an EPUB, including options for placing chapters before the table of contents (TOC) or excluding them from the TOC.

```typescript
const chapters = [
  { title: 'Preface', content: '...', beforeToc: true },   // Before TOC
  { title: 'Chapter 1', content: '...' },                   // Normal
  { title: 'Appendix', content: '...', excludeFromToc: true } // No TOC entry
];
```

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

### Generate EPUB with Options Object

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

This example demonstrates generating an EPUB with detailed options, including title, author, publisher, cover image URL, EPUB version, and verbose logging. Ensure all provided options are correctly formatted.

```typescript
import epub from 'epub-gen-memory';

const options = {
  title: 'Alice in Wonderland',
  author: 'Lewis Carroll',
  publisher: 'Macmillan & Co.',
  cover: 'http://example.com/cover.jpg',
  version: 3,
  verbose: true
};

const content = [
  {
    title: 'Down the Rabbit Hole',
    content: '<p>Alice was beginning to get very tired...</p>'
  }
];

const epubBuffer = await epub(options, content);
```

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

### Font Example

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/02-types.md

Shows how to configure font options for an EPUB, including specifying filenames and URLs for multiple fonts, and providing custom CSS. This configuration is passed to the epub() function via the Options object.

```typescript
const options: Options = {
  title: 'Styled Book',
  fonts: [
    {
      filename: 'Merriweather.ttf',
      url: 'https://fonts.example.com/Merriweather.ttf'
    },
    {
      filename: 'Courier.ttf',
      url: 'https://fonts.example.com/Courier.ttf'
    }
  ],
  css: "
    @font-face {
      font-family: 'Merriweather';
      src: url(./fonts/Merriweather.ttf);
    }
    body { font-family: 'Merriweather', serif; }
  "
};
```

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

### Minimal Options Configuration

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/02-types.md

Example of providing only the required `title` field for EPUB generation. Other fields will use their default values.

```typescript
const options: Options = {
  title: 'My Book'
};
```

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

### Get Default EPUB Options

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/03-configuration.md

Retrieve the default configuration options for EPUB 3 or EPUB 2. These defaults can be used as a base for custom configurations.

```typescript
import { optionsDefaults } from 'epub-gen-memory';

const defaults = optionsDefaults(3);  // EPUB 3 defaults
const defaults2 = optionsDefaults(2); // EPUB 2 defaults
```

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

### Configure Fetch Timeout for Large Resources

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

This example shows how to set a `fetchTimeout` option, which can be exceeded if a resource is very large or the server is slow. Increase the timeout or use `ignoreFailedDownloads` to prevent errors.

```typescript
const options = {
  title: 'My Book',
  fetchTimeout: 5000,  // 5 seconds (short!)
  cover: 'http://example.com/large-cover.jpg'  // 10MB file
};
await epub(options, chapters);  // May timeout
```

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

### optionsDefaults()

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Returns default options for EPUB generation. This function can be used to get a base set of options that can then be customized.

```APIDOC
## optionsDefaults()

### Description
Returns default options for EPUB generation.

### Signature
```typescript
optionsDefaults(version?: number): Omit<Options, 'title'>
```

### Parameters
#### Path Parameters
- **version** (number) - Optional - EPUB version (2 or 3). Defaults to 3.

### Return Type
`Omit<Options, 'title'>` — Default options object without the required `title` field.

### Default Values
```json
{
  "author": ["anonymous"],
  "publisher": "anonymous",
  "description": "",
  "tocTitle": "Table of Contents",
  "tocInTOC": true,
  "numberChaptersInTOC": true,
  "prependChapterTitles": true,
  "date": "(today's date in ISO format)",
  "lang": "en",
  "css": "(default styles)",
  "version": 3,
  "fetchTimeout": 20000,
  "retryTimes": 3,
  "batchSize": 100,
  "ignoreFailedDownloads": false,
  "verbose": false
}
```

### Example
```typescript
import { optionsDefaults } from 'epub-gen-memory';

const defaults = optionsDefaults(2);  // EPUB 2 defaults
const customOptions = {
  ...defaults,
  title: 'My Book',
  author: 'Jane Doe'
};
```
```

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

### Generate EPUB with Title and Content

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Use this basic example to generate an EPUB file from a title string and an array of chapter content. It returns a Promise resolving to a Buffer or Blob. For Node.js, you can then use `fs/promises.writeFile` to save the buffer to a file.

```typescript
import epub from 'epub-gen-memory';

const content = [
  {
    title: 'Chapter 1',
    content: '<p>Chapter content here</p>'
  }
];

const buffer = await epub('My Book', content);
// Save to file (Node.js)
import { writeFile } from 'fs/promises';
await writeFile('book.epub', buffer);
```

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

### Content Example

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/02-types.md

Illustrates how to define book content using the Content type, including chapters with titles and HTML content. This structure is passed to the epub() function.

```typescript
const content: Content = [
  {
    title: 'Preface',
    content: '<p>Preface text</p>',
    beforeToc: true
  },
  {
    title: 'Chapter 1',
    content: '<p>Chapter 1 content</p>'
  },
  {
    title: 'Chapter 2',
    content: '<p>Chapter 2 content</p>'
  }
];

const buffer = await epub('My Book', content);
```

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

### Get EPUB Options Defaults

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Use `optionsDefaults` to retrieve default configuration options for EPUB generation. You can specify the EPUB version (2 or 3) to get version-specific defaults. The returned object omits the `title` field, which must be provided separately.

```typescript
import { optionsDefaults } from 'epub-gen-memory';

const defaults = optionsDefaults(2);  // EPUB 2 defaults
const customOptions = {
  ...defaults,
  title: 'My Book',
  author: 'Jane Doe'
};
```

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

### optionsDefaults([version])

Source: https://github.com/cpiber/epub-gen-memory/blob/master/README.md

Retrieves the default options for EPUB generation. An optional version number can be provided to get defaults specific to EPUB 2 or 3.

```APIDOC
## optionsDefaults([version])

### Description
Returns the default configuration options for EPUB generation.

### Parameters
- **version** (`number`, optional, default `3`): The EPUB version (2 or 3) for which to retrieve defaults.

### Returns
- `Options`: An object containing the default options.
```

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

### Manage Retry Exhaustion for Unreliable Resources

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

This example configures `retryTimes` for fetching resources. If all retries fail due to network issues or server unavailability, an error will be thrown. Adjust `retryTimes` or `ignoreFailedDownloads`.

```typescript
const options = {
  title: 'My Book',
  retryTimes: 3,  // Try 3 times total
  cover: 'http://example.com/unreachable.jpg'  // Network error
};
await epub(options, chapters);
// Logs "Failed to fetch `http://...` 1 time. Retrying..."
// Logs "Failed to fetch `http://...` 2 times. Retrying..."
// Throws on 3rd attempt
```

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

### Handle HTTP Error Responses During Download

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

This example demonstrates setting options that may lead to an HTTP error response if the provided URLs are invalid or inaccessible. Verify URLs and consider `ignoreFailedDownloads`.

```typescript
const options = {
  title: 'My Book',
  cover: 'http://example.com/missing-cover.jpg'  // 404
};
const chapters = [
  {
    title: 'Ch1',
    content: '<img src="http://example.com/bad-image.png" />'  // 404
  }
];
await epub(options, chapters);  // Throws during image download
```

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

### Chapter with Author and URL

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/02-types.md

An example of a chapter object including optional fields like `author` and `url`. The `beforeToc` field is used to place this chapter before the table of contents.

```typescript
const chapter: Chapter = {
  title: 'About the Author',
  author: 'John Smith',
  content: '<p>John is an author...</p>',
  url: 'https://johnsmith.com',
  beforeToc: true  // Put before table of contents
};
```

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

### Inline CSS Styling for HTML Elements

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/05-html-content-guide.md

Provides examples of applying CSS styles directly to HTML elements using the `style` attribute for properties like font-weight, color, text-decoration, text-align, and margin.

```html
<p style="font-weight: bold; color: #333;">Bold text</p>

<span style="text-decoration: underline;">Underlined</span>

<div style="text-align: center; margin-top: 1em;">Centered</div>
```

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

### Handle Out-of-Order beforeToc Flag

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

This example illustrates the warning emitted when chapters with `beforeToc=true` appear after chapters with `beforeToc=false`. The EPUB is generated, but the table of contents order may be affected.

```typescript
const chapters = [
  { title: 'Ch1', content: '<p>Ch1</p>', beforeToc: false },
  { title: 'Preface', content: '<p>Preface</p>', beforeToc: true }  // Should be first!
];
await epub('My Book', chapters, true);
// Logs: "Warning (content[1]): Got `beforeToc=true` after at least one `beforeToc=false`. ..."
```

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

### Handle File Read Errors for Local Resources (Node.js)

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

This example illustrates a scenario where a local file specified with a `file://` URL cannot be read, typically due to incorrect paths or permissions. Ensure the path is correct and accessible.

```typescript
const options = {
  title: 'My Book',
  // Node.js only
  cover: 'file:///absolute/path/to/missing-cover.jpg'
};
await epub(options, chapters);  // Throws
```

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

### Instantiate EPub Class

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Use this constructor to create an EPub instance for manual control over the EPUB generation process. Provide configuration options and an array of chapters.

```typescript
import { EPub } from 'epub-gen-memory';

const options = {
  title: 'My Book',
  author: 'John Doe'
};

const chapters = [
  { title: 'Introduction', content: '<p>Welcome</p>' }
];

const epub = new EPub(options, chapters);
const buffer = await epub.genEpub();
```

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

### Original HTML Image Tag

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/05-html-content-guide.md

Example of an original HTML image tag before processing.

```html
<p>
  <img src="http://example.com/photos/portrait.jpg" alt="Portrait" />
</p>
```

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

### HTML Blockquote Example

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/05-html-content-guide.md

Use blockquotes to represent quoted text. Styling can be applied for alignment and spacing.

```html
<blockquote>
  <p>"The only way to do great work is to love what you do."</p>
  <p style="text-align: right; margin-top: 1em;">— Steve Jobs</p>
</blockquote>
```

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

### Processed HTML Image Tag in EPUB

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/05-html-content-guide.md

Example of an HTML image tag after processing and embedding within an EPUB.

```html
<p>
  <img src="images/f47ac10b-58cc-4372-a567-0e02b2c3d479.jpg" alt="Portrait" />
</p>
```

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

### EPub Constructor

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Creates a new EPub instance for manual control over the EPUB generation process. It requires configuration options and an array of chapters.

```APIDOC
## Constructor EPub

### Description
Creates a new EPub instance for manual control over the EPUB generation process.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **options** (Options) - Required - Configuration object (see [Options Type](#options))
- **content** (Content) - Required - Array of chapters

### Request Example
```typescript
import { EPub } from 'epub-gen-memory';

const options = {
  title: 'My Book',
  author: 'John Doe'
};

const chapters = [
  { title: 'Introduction', content: '<p>Welcome</p>' }
];

const epub = new EPub(options, chapters);
const buffer = await epub.genEpub();
```

### Response
None

### Response Example
None
```

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

### EPUB Generation Data Flow

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/06-module-architecture.md

Illustrates the step-by-step process of generating an EPUB file, from initial options and chapters to final file creation and zipping. It highlights key internal functions and data transformations.

```mermaid
graph TD
epub(options, chapters)
  ↓
validateIsOptionsOrTitle() + validateIsChapters()
  ↓
new EPub(options, content)
  ↓ (constructor)
  validateAndNormalizeOptions()  → NormOptions
  validateAndNormalizeChapters() → NormChapter[]
  (images, fonts extracted from content)
  ↓
await epub.render()
  ↓ (for each chapter)
  normalizeHTML()
    → fixHTML() (parse + validate)
    → register images for download
    → return sanitized HTML
  ↓
await downloadAllFonts()
  → batch by batchSize
  → retryFetch() each
  → write to zip: OEBPS/fonts/
  ↓
await downloadAllImages()
  → batch by batchSize
  → retryFetch() each
  → write to zip: OEBPS/images/{uuid}.{ext}
  ↓
await makeCover()
  → retryFetch() cover image
  → write to zip: OEBPS/cover.{ext}
  ↓
await generateTemplateFiles()
  → render chapter files via EJS
  → render content.opf (manifest)
  → render toc.ncx (EPUB 2 nav)
  → render toc.xhtml (EPUB 3 nav)
  → write style.css
  → write META-INF/container.xml
  ↓
await genEpub()
  → (calls render())
  → zip.generateAsync()
  → return Buffer | Blob
```

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

### Import epub-gen-memory using the browserify bundle

Source: https://github.com/cpiber/epub-gen-memory/blob/master/README.md

Import the UMD bundle for browser usage. The bundle also provides a Promise<Blob> return type.

```javascript
import epub from 'epub-gen-memory/bundle';
```

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

### HTML Poetry/Verse Example

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/05-html-content-guide.md

Use preformatted text tags for poetry to preserve whitespace and line breaks. Styling can be applied for font and wrapping.

```html
<pre style="font-family: Georgia, serif; white-space: pre-wrap;">
Once upon a midnight dreary,
  while I pondered, weak and weary,
Over many a quaint and curious
  volume of forgotten lore—
</pre>
```

```html
<p>Once upon a midnight dreary,<br />
&nbsp;&nbsp;while I pondered, weak and weary,<br />
Over many a quaint and curious<br />
&nbsp;&nbsp;volume of forgotten lore—</p>
```

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

### Sequential Batch Processing

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/06-module-architecture.md

Processes batches of images sequentially to manage memory usage. Waits for one batch to complete before starting the next.

```typescript
// Batches are processed sequentially to manage memory
for (let i = 0; i < images.length; i += batchSize) {
  // Wait for batch to complete before next batch
  const results = await Promise.all(batch);
  results.forEach(image => zip.file(...));
}
```

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

### HTML Drop Cap Example

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/05-html-content-guide.md

Create a drop cap effect by styling the first letter of a paragraph with a larger font size and float property.

```html
<p>
  <span style="font-size: 2em; font-weight: bold; float: left; line-height: 0.8em;">T</span>
  he story begins...
</p>
```

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

### HTML Footnote/Side Note Example

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/05-html-content-guide.md

Implement footnotes or side notes using spans for superscripts and styled paragraphs or aside elements for the note content.

```html
<p>
  This is main text<span style="font-size: 0.8em; vertical-align: super;">[1]</span>.
</p>
<p style="margin-left: 2em; font-size: 0.9em;">
  [1] This is a footnote.
</p>
```

```html
<p>Main paragraph.</p>
<aside style="border-left: 2px solid gray; padding-left: 1em; margin: 1em 0;">
  <p><strong>Note:</strong> Additional information here.</p>
</aside>
```

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

### Browser Bundle Creation

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/06-module-architecture.md

Creates a UMD bundle for browsers using browserify, excluding specific entry points, and then minifies it with terser. This process includes mangling and compression for optimization.

```bash
browserify -e ./dist/lib/SharedArrayBufferStub.js -e ./dist/lib/index.js
```

```bash
terser --mangle --compress
```

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

### Generate EPUB using EPub Class

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/README.md

Instantiate the `EPub` class for more control over the EPUB generation process. This approach allows for creating an EPUB object with specific options and chapters, then calling `genEpub` to create the buffer. Requires importing `EPub`, `optionsDefaults`, and `chapterDefaults`.

```typescript
import { EPub, optionsDefaults, chapterDefaults } from 'epub-gen-memory';

const epub = new EPub(options, chapters);
const buffer = await epub.genEpub();
```

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

### EPub.prototype.genEpub()

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Completes the EPUB generation pipeline by calling `render()` internally and then generating the final ZIP archive.

```APIDOC
## EPub.prototype.genEpub()

### Description
Complete EPUB generation pipeline. Calls `render()` internally, then generates the final ZIP archive.

### Method
`async genEpub(): Promise<Buffer | Blob>`

### Endpoint
None

### Parameters
None

### Request Example
```typescript
const epub = new EPub(options, content);
const buffer = await epub.genEpub();
```

### Response
#### Success Response (200)
- **Node.js:** `Promise<Buffer>` — Binary buffer
- **Browser:** `Promise<Blob>` — Blob object

### Response Example
None
```

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

### Basic Usage of epub-gen-memory

Source: https://github.com/cpiber/epub-gen-memory/blob/master/README.md

Import the library and call the epub function with options to generate an ebook. Handles success and error logging.

```javascript
import epub from 'epub-gen-memory';

epub(options).then(
    content => console.log("Ebook Generated Successfully!"),
    err => console.error("Failed to generate Ebook because of ", err)
);
```

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

### Common Verbose Logging Patterns

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/03-configuration.md

Illustrates different ways to implement custom verbose logging, including logging only warnings, logging with levels, and redirecting to a logger library.

```typescript
// Only log warnings
verbose: (type, ...args) => {
  if (type === 'warn') console.warn(...args);
}
```

```typescript
// Log with levels
verbose: (type, ...args) => {
  console.log(`[${type.toUpperCase()}]`, ...args);
}
```

```typescript
// Redirect to logger library
verbose: (type, ...args) => {
  if (type === 'warn') logger.warn(...args);
  else logger.info(...args);
}
```

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

### Options with Custom Logging Function

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/02-types.md

Example of configuring the `verbose` option with a custom logging function to handle different log types, such as redirecting warnings to `console.error`.

```typescript
const options: Options = {
  title: 'My Book',
  verbose: (type, ...args) => {
    if (type === 'warn') console.error(...args);
    else console.log(...args);
  }
};
```

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

### Error Handling with Try-Catch

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/README.md

Demonstrates how to handle potential errors during EPUB generation using a try-catch block. It shows how to differentiate between download failures and validation errors based on the error message.

```typescript
try {
  const buffer = await epub(options, chapters);
  // Handle success
} catch (error) {
  if (error.message.includes('Got error')) {
    // Resource download failed
  } else if (error.message.includes('attribute')) {
    // Validation error
  }
  // Handle error
}
```

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

### Invalid Chapter Object Examples

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

Shows invalid chapter objects that cause TypeErrors. Ensure chapters have a 'content' field and filenames do not contain path separators.

```typescript
// Invalid: missing content
const chapter = {
  title: 'Chapter 1'
  // content missing!
};
await epub('My Book', [chapter]);  // Throws
```

```typescript
// Invalid: filename with path
const chapter = {
  title: 'Chapter 1',
  content: '<p>Text</p>',
  filename: 'chapters/ch1.xhtml'  // Slashes not allowed
};
await epub('My Book', [chapter]);  // Throws
```

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

### epub() function

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/MANIFEST.txt

The main entry point for generating EPUB files. This function orchestrates the entire process, taking options and content to produce a valid EPUB.

```APIDOC
## epub()

### Description
Generates an EPUB file from provided options and content.

### Method
```
function epub(options, content)
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **options** (Options) - Required - Configuration object for EPUB generation.
- **content** (Chapter[]) - Required - An array of chapter objects defining the EPUB content.

### Request Example
```json
{
  "options": {
    "version": 3,
    "title": "My EPUB",
    "author": "Me"
  },
  "content": [
    {
      "title": "Introduction",
      "html": "<p>This is the introduction.</p>"
    }
  ]
}
```

### Response
#### Success Response (200)
- **epubFilePath** (string) - The path to the generated EPUB file.

#### Response Example
```json
{
  "epubFilePath": "/path/to/my-epub.epub"
}
```
```

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

### Manual EPUB Control with EPub Class

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/07-quick-start-examples.md

Use the EPub class for manual control over the EPUB generation process, including explicit rendering and saving steps.

```typescript
import { EPub } from 'epub-gen-memory';

const options = {
  title: 'Manual EPUB',
  verbose: true
};

const chapters = [
  { title: 'Ch1', content: '<p>Text</p>' }
];

// Create instance
const epubInstance = new EPub(options, chapters);

// Manually control rendering
console.log('Starting render...');
await epubInstance.render();
console.log('Render complete, fonts and images downloaded');

// Generate final EPUB
const buffer = await epubInstance.genEpub();
console.log('EPUB generation complete');

// Save
import { writeFile } from 'fs/promises';
await writeFile('manual.epub', buffer);
```

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

### Get Chapter Defaults

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Use `chapterDefaults` to obtain default values for a chapter object. Provide the zero-based index of the chapter to generate default `title` and `id` properties.

```typescript
import { chapterDefaults } from 'epub-gen-memory';

const ch = chapterDefaults(0);
// { title: 'Chapter 1', id: 'item_0', url: '', excludeFromToc: false, beforeToc: false }
```

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

### Set EPUB Version to 3 (Recommended)

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/03-configuration.md

Use the modern EPUB 3 standard for new projects. It supports XHTML 5, toc.xhtml navigation, and offers better media and font support.

```typescript
const options = {
  title: 'My Book',
  version: 3  // default
};
```

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

### Logging Progress with Verbose Option

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/README.md

Shows how to enable detailed logging during the EPUB generation process by providing a verbose callback function in the options. This function will be called with log type and arguments.

```typescript
const options = {
  title: 'My Book',
  verbose: (type, ...args) => {
    console.log(`[${type}]`, ...args);
  }
};
```

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

### Core Classes

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/README.md

Instantiate the EPub class with options and chapters to generate an EPUB. The genEpub method returns a Promise resolving to the EPUB data.

```typescript
import { EPub, optionsDefaults, chapterDefaults } from 'epub-gen-memory';

const epubInstance = new EPub(options, chapters);
const buffer = await epubInstance.genEpub();
```

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

### Remove Image Tag with Missing Source

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

This example demonstrates the removal of an image tag that lacks a 'src' attribute. The tag is silently removed, and the EPUB generation proceeds without the incomplete image element.

```typescript
const chapters = [
  {
    title: 'Ch1',
    content: '<p>Text <img alt="broken" /> more text</p>'
  }
];
await epub('My Book', chapters);
// Results in: <p>Text  more text</p>
```

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

### Import epub-gen-memory for environments without SharedArrayBuffer

Source: https://github.com/cpiber/epub-gen-memory/blob/master/README.md

Use this import if SharedArrayBuffer is not available in your environment. It includes a non-functional stub.

```javascript
import epub from 'epub-gen-memory/sabstub';
```

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

### Invalid Font Object Example

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

Illustrates an invalid font object within the options, leading to a TypeError. Each font object must include both 'url' and 'filename' as strings, with 'filename' free of path separators.

```typescript
const options = {
  title: 'My Book',
  fonts: [
    {
      // url missing!
      filename: 'MyFont.ttf'
    }
  ]
};
await epub(options, chapters);  // Throws
```

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

### EPub.prototype.render()

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Generates all template files, downloads fonts and images, and prepares the cover. This method is called automatically by `genEpub()` but can be invoked separately for manual control.

```APIDOC
## EPub.prototype.render()

### Description
Generates all template files, downloads fonts and images, and prepares the cover. This is called automatically by `genEpub()`, but can be called separately for manual control.

### Method
`async render(): Promise<EPub>`

### Endpoint
None

### Parameters
None

### Request Example
```typescript
const epub = new EPub(options, content);
await epub.render();
// At this point, all resources have been downloaded
```

### Response
#### Success Response (200)
Returns `Promise<EPub>` (self) for chaining.

### Response Example
None
```

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

### Invalid Options Object Examples

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

Demonstrates invalid options objects that trigger TypeErrors due to missing fields, incorrect types, or invalid values. Ensure all required fields are present and correctly formatted.

```typescript
// Invalid: missing title
const options = {
  author: 'John Doe'
};
await epub(options, chapters);  // Throws
```

```typescript
// Invalid: wrong version
const options = {
  title: 'My Book',
  version: 4  // Only 2 or 3 allowed
};
await epub(options, chapters);  // Throws
```

```typescript
// Invalid: negative timeout
const options = {
  title: 'My Book',
  fetchTimeout: -1000  // Must be positive
};
await epub(options, chapters);  // Throws
```

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

### Handle Disallowed HTML Tag in EPUB 2

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

This example shows how an HTML tag not permitted in EPUB 2 (like 'aside') is replaced with a 'div' element, preserving its content and attributes. The process continues after the tag replacement.

```typescript
const chapters = [
  {
    title: 'Ch1',
    content: '<p>Text</p><aside>Note</aside>'  // aside not in XHTML 1.1
  }
];
const options = { title: 'My Book', version: 2 };
await epub(options, chapters, true);
// Logs: "Warning (content[0]): tag aside isn't allowed in EPUB 2/XHTML 1.1 DTD."
// Results in: <div>Note</div>
```

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

### Generate EPUB with Varargs for Verbose and Version

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

This snippet shows how to use variadic arguments to control verbose logging and specify the EPUB version. The order of boolean (verbose) and number (version) arguments matters.

```typescript
// Set verbose logging and EPUB version 2
const buffer = await epub('My Book', chapters, true, 2);

// Set EPUB version 3 with no logging
const buffer = await epub('My Book', chapters, 3, false);
```

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

### Set EPUB Description

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/03-configuration.md

Provide a synopsis or description for the EPUB.

```typescript
const options = {
  title: 'My Book',
  description: 'A thrilling adventure through wonderland and beyond. Perfect for readers of all ages.'
};
```

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

### EPub.prototype.generateAsync()

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Provides low-level access for advanced control over ZIP generation, delegating to JSZip's `generateAsync()` method. This is called internally by `genEpub()` but is exposed for custom workflows.

```APIDOC
## EPub.prototype.generateAsync()

### Description
Low-level method for advanced control over ZIP generation. Delegates to JSZip's `generateAsync()` method. This is called internally by `genEpub()` but is exposed for custom workflows.

### Method
`generateAsync<T extends NonNullable<JSZipGeneratorOptions['type']>>(
  options: JSZipGeneratorOptions<T>
): ReturnType<typeof generateAsync<T>>`

### Endpoint
None

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **options** (JSZipGeneratorOptions<T>) - Required - JSZip generator options (see [JSZip documentation](https://stuk.github.io/jszip/documentation/api_jszip/generate_async.html))

### Request Example
```typescript
const epub = new EPub(options, content);
await epub.render();
const buffer = await epub.generateAsync({
  type: 'nodebuffer',
  mimeType: 'application/epub+zip',
  compression: 'DEFLATE'
});
```

### Response
#### Success Response (200)
Determined by the `type` option in JSZipGeneratorOptions. Common return types: `Promise<Buffer>`, `Promise<Blob>`, `Promise<string>`.

### Response Example
None
```

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

### epub(optionsOrTitle, content, [version | verbose])

Source: https://github.com/cpiber/epub-gen-memory/blob/master/README.md

The main function to generate an EPUB. It accepts options or a title, chapter content, and optional version or verbose flag. It returns a Promise that resolves to a Buffer (Node.js) or Blob (Browser).

```APIDOC
## epub(optionsOrTitle, content, [version | verbose])

### Description
Generates an EPUB file from the provided options and content.

### Parameters
- **optionsOrTitle** (`Options | string`): Either an Options object or a string representing the book's title.
- **content** (`Chapter[]`): An array of Chapter objects defining the book's content.
- **varargs** (`version: 3 | 2` or `verbose: boolean`): Optional arguments for EPUB version (2 or 3) or to enable verbose logging.

### Returns
- `Promise<Buffer>`: In Node.js environment.
- `Promise<Blob>`: In Browser environment.
```

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

### Options Type Definition

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/02-types.md

Defines the structure for all configuration options when generating an EPUB. Includes fields for metadata, table of contents, styling, and generation behavior.

```typescript
type Options = {
  title: string,
  author?: string | string[],
  publisher?: string,
  description?: string,
  cover?: string | File,
  tocTitle?: string,
  tocInTOC?: boolean,
  numberChaptersInTOC?: boolean,
  prependChapterTitles?: boolean,
  date?: string,
  lang?: string,
  css?: string,
  chapterXHTML?: string,
  contentOPF?: string,
  tocNCX?: string,
  tocXHTML?: string,
  fonts?: Font[],
  version?: number,
  fetchTimeout?: number,
  retryTimes?: number,
  batchSize?: number,
  ignoreFailedDownloads?: boolean,
  verbose?: boolean | LogFn,
};
```

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

### Catch and Continue on Download Failure

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/04-errors.md

This pattern demonstrates how to catch errors during the EPUB generation process and conditionally log them based on the error message. It allows for specific handling of download-related issues.

```typescript
try {
  const buffer = await epub(options, chapters);
  await fs.writeFile('book.epub', buffer);
} catch (error) {
  if (error.message.includes('Got error')) {
    console.error('Failed to download resource:', error.message);
  } else {
    console.error('Unknown error:', error);
  }
}
```

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

### Generate EPUB Archive

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Use `genEpub()` to complete the EPUB generation pipeline. This method internally calls `render()` and then creates the final ZIP archive. The return type differs between Node.js (Buffer) and browser (Blob) environments.

```typescript
const epub = new EPub(options, content);
const buffer = await epub.genEpub();
```

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

### Generate EPUB from HTML Files

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/07-quick-start-examples.md

Creates an EPUB by reading content from multiple HTML files. Allows setting EPUB metadata like title, author, publisher, and version.

```typescript
import epub from 'epub-gen-memory';
import { readFile } from 'fs/promises';
import { writeFile } from 'fs/promises';

// Read chapter files
const [ch1, ch2, ch3] = await Promise.all([
  readFile('./chapters/01-intro.html', 'utf-8'),
  readFile('./chapters/02-story.html', 'utf-8'),
  readFile('./chapters/03-ending.html', 'utf-8')
]);

const buffer = await epub(
  {
    title: 'The Great Adventure',
    author: 'John Smith',
    publisher: 'Adventure Press',
    version: 3
  },
  [
    { title: 'Introduction', content: ch1, beforeToc: true },
    { title: 'The Story Begins', content: ch2 },
    { title: 'The End', content: ch3 }
  ]
);

await writeFile('adventure.epub', buffer);
```

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

### Render EPUB Resources

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

Call `render()` to generate template files, download fonts and images, and prepare the cover. This method is automatically invoked by `genEpub()` but can be used independently for manual control.

```typescript
const epub = new EPub(options, content);
await epub.render();
// At this point, all resources have been downloaded
```

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

### Import EPUB Generator Modules

Source: https://github.com/cpiber/epub-gen-memory/blob/master/README.md

Import the necessary modules from the 'epub-gen-memory' library. This includes the main epub generator function, the EPub class, and default configurations for options and chapters.

```typescript
import epub, { EPub, optionsDefaults, chapterDefaults } from 'epub-gen-memory';
import type { Options, Content, Chapter, Font } from 'epub-gen-memory';
```

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

### Utility Functions

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/MANIFEST.txt

Helper functions for setting default options and chapter structures, ensuring consistency and simplifying configuration.

```APIDOC
## Utility Functions

### `optionsDefaults(options)`
Merges user-provided options with default settings.

- **options** (Options) - User-defined options.
- Returns (Options) - Merged options with defaults applied.

### `chapterDefaults(chapter)`
Applies default values to chapter properties if not provided.

- **chapter** (Chapter) - User-defined chapter object.
- Returns (Chapter) - Chapter object with defaults applied.

### `validateAndNormalizeOptions(options)`
Validates and normalizes the provided options object.

- **options** (Options) - The options object to validate.
- Returns (NormOptions) - The validated and normalized options.

### `normalizeHTML(html)`
Normalizes HTML content according to EPUB standards.

- **html** (string) - The HTML string to normalize.
- Returns (string) - The normalized HTML string.

### `fixHTML(html)`
Applies fixes to HTML content to ensure compatibility.

- **html** (string) - The HTML string to fix.
- Returns (string) - The fixed HTML string.

### `uuid()`
Generates a universally unique identifier.

- Returns (string) - A unique UUID string.

### `retryFetch(url, options)`
Fetches a URL with retry logic.

- **url** (string) - The URL to fetch.
- **options** (object) - Fetch options, including retry configuration.
- Returns (Promise<Response>) - A promise that resolves with the fetch response.
```

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

### Custom Chapter Styling with CSS

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/05-html-content-guide.md

Demonstrates custom styling for chapter content using inline CSS, including properties for margins, text alignment, font size, and bold text.

```html
<p style="margin-top: 2em; text-align: center; font-size: 1.2em;">
  <strong>End of Chapter 1</strong>
</p>
```

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

### Custom Styling with CSS Option

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/README.md

Illustrates how to apply custom CSS styling to the generated EPUB by providing a CSS string in the options. This allows for fine-grained control over the appearance of the book.

```typescript
const options = {
  title: 'My Book',
  css: `body { font-family: Georgia, serif; }`
};
```

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

### Generate EPUB with Uploaded Cover Image

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/07-quick-start-examples.md

Generates an EPUB using an image file uploaded by the user as the cover. The generated EPUB is then saved to the user's device.

```html
<!DOCTYPE html>
<html>
<head>
  <script src="https://unpkg.com/epub-gen-memory/bundle"></script>
</head>
<body>
  <input type="file" id="cover" accept="image/*" />
  <button onclick="generateFromUpload()">Create EPUB</button>
  
  <script>
    async function generateFromUpload() {
      const coverInput = document.getElementById('cover');
      const coverFile = coverInput.files[0];
      
      if (!coverFile) {
        alert('Please select a cover image');
        return;
      }
      
      const blob = await epubGen(
        {
          title: 'My EPUB',
          cover: coverFile  // Use uploaded file directly
        },
        [
          {
            title: 'Chapter 1',
            content: '<p>Content with uploaded cover image</p>'
          }
        ]
      );
      
      // Save to user's device
      const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = 'output.epub';
      a.click();
    }
  </script>
</body>
</html>
```

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

### Advanced ZIP Generation with generateAsync

Source: https://github.com/cpiber/epub-gen-memory/blob/master/_autodocs/01-api-reference.md

For advanced control over ZIP generation, use `generateAsync()`, which delegates to JSZip's `generateAsync()` method. This is useful for custom workflows and allows specifying options like type, mimeType, and compression.

```typescript
const epub = new EPub(options, content);
await epub.render();
const buffer = await epub.generateAsync({
  type: 'nodebuffer',
  mimeType: 'application/epub+zip',
  compression: 'DEFLATE'
});
```

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

### Options Schema

Source: https://github.com/cpiber/epub-gen-memory/blob/master/README.md

Defines the available configuration options for EPUB generation, including title, author, cover, TOC settings, and more.

```APIDOC
## Options

### Properties
- **title** (`string`): Title of the book.
- **author** (`string | string[]`, optional, default `['anonymous']`): Name of the author(s).
- **publisher** (`string`, optional, default `anonymous`): Publisher name.
- **description** (`string`, optional): Book description.
- **cover** (`string | File`, optional): URL or File object for the book cover image.
- **tocTitle** (`string`, optional, default `Table of Contents`): Title for the Table of Contents.
- **tocInTOC** (`boolean`, optional, default `true`): Whether to include the TOC entry in the reader's TOC (EPUB2 only).
- **numberChaptersInTOC** (`boolean`, optional, default `true`): Automatically number TOC entries.
- **prependChapterTitles** (`boolean`, optional, default `true`): Prepend chapter titles before content.
- **date** (`string`, optional, default today): Publication date.
- **lang** (`string`, optional, default `en`): Language code of the book.
- **css** (`string`, optional): Custom CSS string to replace default styles.
- **fonts** (`Font[]`, optional): Array of fonts to include in the EPUB.
- **version** (`number`, optional, default `3`): EPUB version (2 or 3).
- **fetchTimeout** (`number`, optional, default `20000`): Timeout for resource fetching in milliseconds.
- **retryTimes** (`number`, optional, default `3`): Number of times to retry fetching resources.
- **batchSize** (`number`, optional, default `100`): Batch size for downloading files.
- **ignoreFailedDownloads** (`boolean`, optional, default `false`): Ignore errors during downloads and write empty files instead.
- **verbose** (`boolean | ((type, ...args) => void)`, optional, default `false`): Enable verbose logging or provide a custom logging function.
```