mdka 2.0.3

HTML to Markdown converter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

# Usage — Node.js

## Installation

```bash
npm install mdka
```

## Basic Conversion

```js
const { htmlToMarkdown } = require('mdka')

const html = `
  <h1>Hello</h1>
  <p>mdka converts <strong>HTML</strong> to <em>Markdown</em>.</p>
`
const md = htmlToMarkdown(html)
console.log(md)
// # Hello
//
// mdka converts **HTML** to *Markdown*.
```

## Async Conversion

`htmlToMarkdownAsync` offloads work to a Rust thread pool, keeping the
Node.js event loop free:

```js
const { htmlToMarkdownAsync } = require('mdka')

const md = await htmlToMarkdownAsync(html)

// Concurrent conversion of many pages
const results = await Promise.all(pages.map(p => htmlToMarkdownAsync(p.html)))
```

## Conversion with Options

```js
const { htmlToMarkdownWith, htmlToMarkdownWithAsync } = require('mdka')

// Strip nav/header/footer — useful for content extraction
const md = htmlToMarkdownWith(html, {
  mode: 'minimal',
  dropInteractiveShell: true,
})

// Async version
const md = await htmlToMarkdownWithAsync(html, { mode: 'semantic' })
```

Available mode strings: `"balanced"` (default), `"strict"`, `"minimal"`,
`"semantic"`, `"preserve"`.

## Single File Conversion

```js
const { htmlFileToMarkdown, htmlFileToMarkdownWith } = require('mdka')

// Output to same directory: page.html → page.md
const result = await htmlFileToMarkdown('page.html')
console.log(`${result.src} → ${result.dest}`)

// Output to specific directory
const result = await htmlFileToMarkdown('page.html', 'out/')

// With options
const result = await htmlFileToMarkdownWith('page.html', 'out/', {
  mode: 'minimal',
  dropInteractiveShell: true,
})
```

## Bulk Parallel Conversion

```js
const { htmlFilesToMarkdown, htmlFilesToMarkdownWith } = require('mdka')
const path = require('path')

const files = ['a.html', 'b.html', 'c.html']
const results = await htmlFilesToMarkdown(files, 'out/')

for (const r of results) {
  if (r.error) console.error(`${r.src}: ${r.error}`)
  else         console.log(`${r.src} → ${r.dest}`)
}

// With options
const results = await htmlFilesToMarkdownWith(files, 'out/', {
  mode: 'semantic',
  preserveAriaAttrs: true,
})
```

## TypeScript

Type definitions are bundled. No `@types/` package is needed:

```ts
import {
  htmlToMarkdown,
  htmlToMarkdownWith,
  htmlToMarkdownAsync,
  htmlFileToMarkdown,
  htmlFilesToMarkdown,
  ConversionOptions,
  ConvertResult,
} from 'mdka'

const opts: ConversionOptions = {
  mode: 'minimal',
  dropInteractiveShell: true,
}
const md: string = htmlToMarkdownWith(html, opts)
```