### Install remove-markdown

Source: https://github.com/zuchka/remove-markdown/blob/main/README.md

Install the remove-markdown package using npm. This is the first step before using the module in your Node.js project.

```bash
npm install remove-markdown
```

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

### TypeScript Usage Example

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/module-exports.md

Demonstrates how to import and use the `remove-markdown` module within a TypeScript project, including passing an options object to customize its behavior.

```typescript
import removeMd from 'remove-markdown';

const markdown: string = '# Heading\n\n**bold**';
const plainText: string = removeMd(markdown, {
  stripListLeaders: true,
  gfm: true
});
```

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

### Complex Multi-Option Example

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/api-reference.md

Demonstrates combining multiple options for advanced markdown stripping, including preserving list content, using alt text for images, and replacing links with URLs.

```javascript
const markdown = `## Header

- **Bold item** with [link](http://example.com)
- Regular item
- Item with 

> A blockquote

![Image](url)
`;

const result = removeMd(markdown, {
  stripListLeaders: true,
  gfm: true,
  useImgAltText: true,
  replaceLinksWithURL: true
});
// Removes markdown, keeps list content, preserves alt text, shows URLs instead of link text
```

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

### Comment Examples in JavaScript

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Illustrates the minimal commenting style used, primarily for explaining specific regex rule purposes. Most rules rely on self-documenting regex patterns.

```javascript
// Remove horizontal rules (stripListHeaders conflict with this rule, ...)
// Header (for GFM)
// Fenced codeblocks (with backticks)
// Strikethrough
// // Remove newlines in a paragraph  (commented out)
```

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

### Markdown Removal with Options

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/README.md

Configure the markdown removal process by passing an options object. This example shows how to enable stripping list leaders, GitHub Flavored Markdown, using image alt text, and replacing links with URLs.

```javascript
const result = removeMd(markdown, {
  stripListLeaders: true,
  gfm: true,
  useImgAltText: true,
  replaceLinksWithURL: true
});
```

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

### Basic Usage of remove-markdown

Source: https://github.com/zuchka/remove-markdown/blob/main/README.md

Import and use the removeMd function to strip Markdown from a string. This example shows how to convert a Markdown string containing a heading, paragraph, and link into plain text.

```javascript
const removeMd = require('remove-markdown');
const markdown = '# This is a heading\n\nThis is a paragraph with [a link](http://www.disney.com/) in it.';
const plainText = removeMd(markdown); // plainText is now 'This is a heading\n\nThis is a paragraph with a link in it.'
```

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

### Advanced Usage with Options

Source: https://github.com/zuchka/remove-markdown/blob/main/README.md

Utilize the removeMd function with an options object to customize Markdown stripping behavior. This example demonstrates various options like stripping list leaders, replacing links with URLs, and skipping specific HTML tags.

```javascript
const plainText = removeMd(markdown, {
  stripListLeaders: true ,     // strip list leaders (default: true)
  listUnicodeChar: '',         // char to insert instead of stripped list leaders (default: '')
  gfm: true,                   // support GitHub-Flavored Markdown (default: true)
  useImgAltText: true,         // replace images with alt-text, if present (default: true)
  abbr: true,                  // remove abbreviations, if present (default: false)
  replaceLinksWithURL: true,   // remove inline links, if present (default: false)
  separateLinksAndTexts: ': ', // replace inline links with text, separator and link, if present (default: null)
  htmlTagsToSkip: ['a', 'b'],  // HTML tags to skip, if present (default: [])
  throwError: false,           // throw errors instead of catching and logging (default: false)
});
```

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

### Triggering Regex Error with Invalid htmlTagsToSkip

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/errors.md

This example demonstrates how passing invalid regex special characters within the `htmlTagsToSkip` array could theoretically lead to a regex SyntaxError.

```javascript
// This COULD cause a regex error (in theory):
removeMd(markdown, {
  htmlTagsToSkip: ['[invalid]']  // [ and ] are regex metacharacters
});

```

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

### Sanitize HTML Tag Names for Safe Skipping

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/errors.md

When using the `htmlTagsToSkip` option with user-provided input, sanitize tag names to prevent potential security issues. This example filters out invalid characters from tag names.

```javascript
function sanitizeTagName(tag) {
  // Only allow alphanumeric characters and hyphens (valid HTML tag names)
  return tag.replace(/[^a-zA-Z0-9\-]/g, '');
}

const userTags = ['span', 'b<script>', 'i'];
const safeTags = userTags.map(sanitizeTagName).filter(Boolean);

removeMd(markdown, { htmlTagsToSkip: safeTags });
```

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

### Strip List Leaders

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

Removes unordered list markers (*, -, +) or ordered list markers (1., 2., etc.) from the start of a line, preserving indentation. If `listUnicodeChar` is provided, it replaces the marker; otherwise, it's removed along with the following space.

```javascript
if (options.listUnicodeChar)
  output = output.replace(/^([		]*)(["*"]|
+\.)\s+/gm, options.listUnicodeChar + ' $1');
else
  output = output.replace(/^([		]*)(["*"]|
+\.)\s+/gm, '$1');
```

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

### Multiline Mode Regex for Line Processing

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Uses `gm` flags for global and multiline matching. `^` matches line start and `$` matches line end, enabling independent line processing within a single operation.

```javascript
.replace(/^ {0,3}..../gm, '')      // ^ matches line start, not string start
```

```javascript
.replace(/^...$/gm, '')            // $ matches line end, not string end
```

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

### Preserve Specific HTML Tags

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/api-reference.md

Use `htmlTagsToSkip` to specify an array of HTML tag names that should not have their content removed. For example, to preserve bold tags.

```javascript
const html = '<p>Text with <b>bold</b> and <i>italic</i></p>';
const result = removeMd(html, { htmlTagsToSkip: ['b'] });
// Result: 'Text with <b>bold</b> and italic'
```

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

### Generate Article List Previews

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Use this to create concise text previews of markdown content for article listings. It removes all markdown formatting and truncates the text.

```javascript
const removeMd = require('remove-markdown');

const posts = [
  { title: 'Post 1', content: '# Welcome\n\nThis is a **great** post with [links](url).' },
  { title: 'Post 2', content: '## Another post\n\nMore content here.' }
];

const postsWithPreview = posts.map(post => ({
  ...post,
  preview: removeMd(post.content).substring(0, 150) + '...'
}));

// Result:
// { title: 'Post 1', preview: 'Welcome\n\nThis is a great post with links...' }
```

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

### Run Tests with npm test

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/README.md

Execute the comprehensive test suite for the remove-markdown package. This command verifies basic markdown removal, complex scenarios, GFM features, HTML tag handling, list and link processing, edge cases, and performance.

```bash
npm test
```

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

### Preserve Content in Fenced Code Blocks

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

Fenced code blocks are processed early, preserving their content from subsequent markdown removal rules. This example shows how asterisks within a fenced code block are retained.

```markdown
Input:  "```\n*not bold*\n```"
Output: "*not bold*"  (asterisks preserved because code block extracted first)
```

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

### Strict Error Mode with Try-Catch Pattern

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/errors.md

Shows how to use a try-catch block when `throwError` is set to true to immediately catch and handle any exceptions that occur during markdown processing.

```javascript
const removeMd = require('remove-markdown');

try {
  const result = removeMd(markdown, { throwError: true });
  // Process result
} catch (error) {
  console.error('Failed to remove markdown:', error.message);
  // Handle error: log, notify user, use fallback, etc.
}

```

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

### Output Variable Initialization

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Initializes the output variable with the input markdown or an empty string if the input is null or undefined. This ensures type safety throughout the transformation process.

```javascript
var output = md || '';
output = output.replace(/.../, '');  // Rule 1
output = output.replace(/.../, '');  // Rule 2
// ... chains continue
return output;
```

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

### Display Excerpts with URLs

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/configuration.md

Configure the function to replace link text with their corresponding URLs, useful for generating text previews while retaining link destinations. Ensure 'remove-markdown' is required.

```javascript
const result = removeMd(markdown, {
  stripListLeaders: true,
  gfm: true,
  useImgAltText: true,
  replaceLinksWithURL: true,
  htmlTagsToSkip: []
});
```

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

### Process Image Syntax

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

Removes image syntax, optionally keeping alt text based on the `useImgAltText` option.

```javascript
.replace(/!\\\[(.*?)\\\\][\\[\\(].*?[\\][\\)]/g, options.useImgAltText ? '$1' : '')
```

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

### HTML Tag Filtering vs. Markdown

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

The `htmlTagsToSkip` option specifically targets HTML tags and does not affect markdown formatting within those tags. This example demonstrates that bold markdown inside a skipped HTML tag is still removed.

```markdown
Input:  "<b>**bold**</b>"
With htmlTagsToSkip: ['b']
Output: "<b>bold</b>"  (HTML <b> preserved, markdown ** removed)
```

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

### Generate SEO Meta Descriptions

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Create SEO-friendly meta descriptions from markdown content. This function removes markdown, normalizes whitespace, truncates to a specified length, and adds an ellipsis if truncated.

```javascript
const removeMd = require('remove-markdown');

function generateMetaDescription(markdown, maxLength = 160) {
  const text = removeMd(markdown, {
    gfm: true,
    useImgAltText: true,
    stripListLeaders: true
  });

  // Remove extra whitespace and truncate
  return text
    .replace(/\s+/g, ' ')
    .trim()
    .substring(0, maxLength)
    .replace(/\s+$/, '') // Trim trailing space before adding ellipsis
    .concat(text.length > maxLength ? '...' : '');
}

const metaDescription = generateMetaDescription(articleContent);
```

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

### String Mutation Chain

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Illustrates the sequential replacement operations performed on a string. Each replace operation scans the entire string, potentially leading to O(N×M) complexity where N is string length and M is the number of rules.

```javascript
var output = md || '';
output = output.replace(...);
output = output.replace(...);
output = output.replace(...);
```

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

### Prepare Content for Search Engine Indexing

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

This function cleans markdown content and extracts keywords for indexing in search engines like Elasticsearch. It uses specific options for stripping list leaders, enabling GitHub Flavored Markdown, and optionally using image alt text.

```javascript
const removeMd = require('remove-markdown');

function indexContent(doc) {
  const plainText = removeMd(doc.markdown, {
    stripListLeaders: true,
    gfm: true,
    useImgAltText: false
  });

  return {
    id: doc.id,
    title: doc.title,
    body: plainText,
    keywords: extractKeywords(plainText)
  };
}
```

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

### Error Handling with remove-markdown

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/README.md

Demonstrates default safe error handling and strict mode error propagation using a try-catch block.

```javascript
// Safe processing (default)
const result = removeMd(markdown);

// Strict processing
try {
  const result = removeMd(markdown, { throwError: true });
} catch (error) {
  console.error('Processing failed:', error);
}
```

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

### Memoization for Repeated Content Processing in JavaScript

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Implement this pattern to cache results when processing the same markdown content multiple times, improving performance by avoiding redundant computations.

```javascript
const removeMd = require('remove-markdown');

const cache = new Map();

function processWithCache(markdown, options = {}) {
  const key = JSON.stringify({ markdown, options });

  if (cache.has(key)) {
    return cache.get(key);
  }

  const result = removeMd(markdown, options);
  cache.set(key, result);
  return result;
}

// Use memoized version
const text1 = processWithCache(largeMarkdown);  // Computes
const text2 = processWithCache(largeMarkdown);  // Returns cached
```

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

### Use Image Alt Text

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/api-reference.md

Set `useImgAltText` to `true` to extract and use the alternative text from image markdown. If `false`, image markdown is removed entirely.

```javascript
const markdown = '![Alt description](http://example.com/image.png)';
const result = removeMd(markdown, { useImgAltText: true });
// Result: 'Alt description'

const result2 = removeMd(markdown, { useImgAltText: false });
// Result2: ''
```

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

### Normalize Options in JavaScript

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/README.md

Handles missing or falsy option values by setting defaults. Ensure options are explicitly checked for existence before assignment.

```javascript
options = options || {};
options.stripListLeaders = options.hasOwnProperty('stripListLeaders') 
  ? options.stripListLeaders 
  : true;
// ... repeated for all options
```

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

### Package.json Files Field

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/module-exports.md

Specifies the files included in the npm package. Only these listed files are published to npm.

```json
"files": [
  "index.js",
  "index.d.ts",
  "README.md",
  "LICENSE"
]
```

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

### Dynamic Regex Compilation

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Shows a regular expression constructed dynamically using the RegExp constructor. This regex is compiled each time the function is called with the relevant option, which might be a performance bottleneck in high-frequency use cases.

```javascript
new RegExp(`<(?![\/]?(${joinedHtmlTagsToSkip})(?=>|\s[^>]*>))[^>]*>`, 'g')
```

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

### Silent Failure with Logging in JavaScript

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Use this pattern for production systems where silent failure is acceptable. It logs a warning if processing fails without throwing an error.

```javascript
const removeMd = require('remove-markdown');

function processContent(markdown, logger) {
  const plainText = removeMd(markdown);  // throwError: false by default

  // Additional logging
  if (markdown !== plainText && plainText === markdown) {
    logger.warn('Markdown processing failed silently, input unchanged');
  }

  return plainText;
}
```

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

### Default Configuration Options

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/configuration.md

These are the default settings used by the removeMd() function when no options are explicitly provided. They represent a balanced approach to markdown removal.

```javascript
const defaults = {
  stripListLeaders: true,
  listUnicodeChar: false,           // falsy value becomes empty string ''
  gfm: true,
  useImgAltText: true,
  abbr: false,
  replaceLinksWithURL: false,
  separateLinksAndTexts: null,
  htmlTagsToSkip: [],
  throwError: false
};
```

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

### Batch Process Markdown Documents

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Asynchronously processes an array of markdown documents, applying specified options to each. Returns an array of objects containing the original markdown, processed plain text, and document ID.

```javascript
const removeMd = require('remove-markdown');

async function batchProcessMarkdown(documents, options = {}) {
  return documents.map(doc => ({
    id: doc.id,
    plainText: removeMd(doc.markdown, options),
    original: doc.markdown
  }));
}

const results = await batchProcessMarkdown(blogPosts, {
  stripListLeaders: true,
  gfm: true
});
```

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

### Minimal Markdown Removal

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/configuration.md

Use this configuration for the most conservative removal, stripping only essential formatting while preserving most markdown elements. Ensure 'remove-markdown' is required.

```javascript
const removeMd = require('remove-markdown');

// Only remove the most important formatting
const result = removeMd(markdown, {
  stripListLeaders: true,
  gfm: false,
  useImgAltText: false,
  replaceLinksWithURL: false
});
```

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

### Sequential Rule Application in JavaScript

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/README.md

Applies a series of rules sequentially to a mutable string. This pattern is used for transforming markdown to plain text.

```javascript
var output = md || '';
output = output.replace(/rule1/, '');
output = output.replace(/rule2/, '');
// ...continues through rule 17
return output;
```

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

### Sequential String Replacements Algorithm

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Applies regex replacements in sequence to a mutable output variable. This approach is simple and predictable but cannot be parallelized.

```javascript
var output = md || '';
// ... rules 1–17 applied via .replace() chaining
return output;
```

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

### Prevent ReDoS with ATX Headers

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

This test case ensures that the ATX header regular expression does not trigger ReDoS vulnerabilities. It verifies that processing a long ATX header completes within an acceptable time frame.

```javascript
// From test/remove-markdown.js line 224–232
it('should not trigger ReDoS with atx-headers', function () {
  const start = Date.now();
  const paragraph = '\n## This is a long "'+' '.repeat(200)+'" heading ##\n';
  const expected = /\nThis is a long " {200}" heading\n/;
  expect(removeMd(paragraph)).to.match(expected);
  const duration = Date.now()-start;
  expect(duration).to.be.lt(1000);  // Must complete in < 1 second
});
```

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

### Main Export Function

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/module-exports.md

The remove-markdown module exports a single function directly, which takes markdown text and optional options as input and returns the plain text. This is the primary way to use the library.

```APIDOC
## Main Export Function

### Description
Exports a single function that processes markdown text.

### Function Signature
`removeMd(md: string, options?: object): string`

### Parameters
#### `md` (string) - Required
The markdown string to process.

#### `options` (object) - Optional
Configuration options for markdown processing.
- **stripListLeaders** (boolean) - Optional - Remove list leaders.
- **listUnicodeChar** (string) - Optional - Unicode character to use for list leaders.
- **gfm** (boolean) - Optional - Enable GitHub Flavored Markdown parsing.
- **useImgAltText** (boolean) - Optional - Use image alt text when replacing links.
- **abbr** (boolean) - Optional - Enable abbreviation parsing.
- **replaceLinksWithURL** (boolean) - Optional - Replace links with their URLs.
- **separateLinksAndTexts** (string) - Optional - Separator for link text and URL.
- **htmlTagsToSkip** (string[]) - Optional - Array of HTML tags to skip.
- **throwError** (boolean) - Optional - Throw an error if parsing fails.

### Returns
(string) - The processed plain text string.
```

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

### Import remove-markdown with ECMAScript Modules

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/README.md

Use this import statement for projects utilizing ECMAScript Modules.

```javascript
import removeMd from 'remove-markdown';
```

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

### Alternative Syntax for Delimiter Matching

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Matches multiple possible delimiters using character sets like `[\(\[` and `[\)\]`. This allows a single pattern to handle both bracketed `[text][ref]` and parenthesized `[text](url)` markdown link styles.

```regex
\[([\s\S]*?)\]\s*[\(\[](.*?)[\)\]]
```

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

### Prepare Markdown for Search Indexing

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Clean markdown content for full-text search indexing by removing all formatting noise. This function also converts text to lowercase, splits it into words, and filters out short words.

```javascript
const removeMd = require('remove-markdown');

function prepareForSearch(markdown) {
  // Aggressive cleanup: remove all formatting noise
  const plainText = removeMd(markdown, {
    stripListLeaders: true,
    gfm: true,
    useImgAltText: false,
    htmlTagsToSkip: []
  });

  // Index the plain text
  return plainText
    .toLowerCase()
    .split(/\s+/)
    .filter(word => word.length > 2);  // Remove short words
}

const keywords = prepareForSearch(userMarkdown);
```

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

### Error Handling Strategy

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Wraps regex operations in a try-catch block, returning the original input on error unless `throwError` is enabled.

```javascript
try {
  // All regex processing
} catch(e) {
  if (options.throwError) throw e;
  console.error("remove-markdown encountered error: %s", e);
  return md;
}
```

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

### Safe Markdown Processing with Fallback

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Processes markdown input safely, handling potential errors and providing a fallback empty string. It also normalizes whitespace and truncates the output to a specified maximum length.

```javascript
const removeMd = require('remove-markdown');

function safeFlatten(markdown, maxLength = 1000) {
  try {
    let text = removeMd(markdown, { throwError: false });
    text = text.replace(/\s+/g, ' ').trim();
    return text.substring(0, maxLength);
  } catch (error) {
    console.error('Error processing markdown:', error);
    return '';
  }
}

const result = safeFlatten(userInput);
```

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

### Replace Links with URLs

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/api-reference.md

To display the URL directly instead of the link text, set `replaceLinksWithURL` to `true`.

```javascript
const markdown = 'Visit [our site](http://example.com) for more.';
const result = removeMd(markdown, { replaceLinksWithURL: true });
// Result: 'Visit http://example.com for more.'
```

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

### Processing with List Bullet Points

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/configuration.md

Maintain visual list structure during markdown conversion by replacing list leaders with a specified Unicode character. Ensure 'remove-markdown' is required.

```javascript
const result = removeMd(markdown, {
  stripListLeaders: true,
  listUnicodeChar: '•',
  gfm: true,
  useImgAltText: true
});
```

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

### Compare Markdown Content Semantically

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Compare two markdown strings for semantic equality by removing all formatting differences. This is useful for detecting if only formatting was changed, not the actual content.

```javascript
const removeMd = require('remove-markdown');

function compareContent(oldMarkdown, newMarkdown) {
  const oldText = removeMd(oldMarkdown).toLowerCase();
  const newText = removeMd(newMarkdown).toLowerCase();
  return oldText === newText;
}

if (compareContent(originalContent, editedContent)) {
  console.log('Only formatting was changed, no content diff');
}
```

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

### Console Error Output Format

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/errors.md

Shows the format of the console error message when an error occurs and `throwError` is set to false. The message is logged using `console.error`.

```text
remove-markdown encountered error: [error message]

```

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

### Process Link Syntax

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

Removes link syntax, optionally replacing with the URL or keeping the link text based on `replaceLinksWithURL`.

```javascript
.replace(/\\[([\s\S]*?)\\]\s*[\\(\[](.*?)[\\)\]]/g, options.replaceLinksWithURL ? '$2' : '$1')
```

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

### Option Normalization Logic

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Normalizes options to explicit boolean or string values using `hasOwnProperty`. This distinguishes between 'not provided' and 'explicitly set to falsy'.

```javascript
options = options || {};
options.listUnicodeChar = options.hasOwnProperty('listUnicodeChar') ? options.listUnicodeChar : false;
options.stripListLeaders = options.hasOwnProperty('stripListLeaders') ? options.stripListLeaders : true;
// ... etc for all 9 options
```

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

### Error Handling Behavior

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/api-reference.md

Configures error handling during markdown processing. If `throwError` is true, errors are thrown. Otherwise, errors are logged to the console, and the original string is returned.

```javascript
// Default: throwError is false
```

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

### ESM Default Import Usage

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/module-exports.md

Use the `import` syntax for default imports in Node.js ESM environments. Similar to CommonJS, direct invocation is used, and destructuring is not supported.

```javascript
import removeMd from 'remove-markdown';

const plainText = removeMd(markdown);
```

```javascript
// This will NOT work
import { removeMd } from 'remove-markdown';  // ERROR
```

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

### Aggressive Markdown Removal

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/configuration.md

This configuration provides the most comprehensive removal, stripping nearly all markdown formatting and enabling all GitHub-Flavored Markdown features. It also sets a separator for links.

```javascript
const result = removeMd(markdown, {
  stripListLeaders: true,
  listUnicodeChar: '•',
  gfm: true,
  useImgAltText: true,
  abbr: true,
  replaceLinksWithURL: false,
  separateLinksAndTexts: ' → ',
  htmlTagsToSkip: [],
  throwError: false
});
```

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

### Robust Markdown Processing with Validation and Retry in JavaScript

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

This pattern validates input and uses a fallback strategy for potentially problematic markdown. It first attempts standard processing and then a more conservative approach if the output is too similar to the input.

```javascript
const removeMd = require('remove-markdown');

function robustProcess(markdown) {
  // Validate input
  if (!markdown || typeof markdown !== 'string') {
    return '';
  }

  // Try standard processing
  let result = removeMd(markdown, { throwError: false });

  // If output is suspiciously similar to input, try conservative approach
  if (result.length > markdown.length * 0.9) {
    result = removeMd(markdown, {
      stripListLeaders: false,
      gfm: false,
      throwError: false
    });
  }

  return result;
}
```

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

### Basic Markdown Removal

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/api-reference.md

Use this for straightforward removal of markdown syntax from a string. It handles common markdown elements like headings, paragraphs, bold, and links.

```javascript
const removeMd = require('remove-markdown');
const markdown = '# Heading

Paragraph with **bold** and [link](http://example.com).';
const result = removeMd(markdown);
// Result: 'Heading

Paragraph with bold and link.'
```

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

### Remove ATX Headers

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

Removes ATX-style headers (e.g., '# Heading', '## Subheading') with or without closing hashes. It preserves the leading newline and the header content.

```regex
.replace(/^(\n)?\s{0,}#{1,6}\s*( (.+))? +#+$|^(\n)?\s{0,}#{1,6}\s*( (.+))?$/gm, '$1$3$4$6')
```

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

### Error Handling in JavaScript

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/README.md

Wraps regex operations in a try-catch block for robust error management. Optionally throws errors or logs them to the console.

```javascript
try {
  // All 17 regex rules applied here
} catch(e) {
  if (options.throwError) throw e;
  console.error("remove-markdown encountered error: %s", e);
  return md;  // Return original on error
}
```

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

### Define RemoveMarkdownOptions Interface

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/types.md

This interface defines the available options for customizing the markdown removal process. All properties are optional.

```typescript
interface RemoveMarkdownOptions {
  stripListLeaders?: boolean;
  listUnicodeChar?: string;
  gfm?: boolean;
  useImgAltText?: boolean;
  abbr?: boolean;
  replaceLinksWithURL?: boolean;
  separateLinksAndTexts?: string;
  htmlTagsToSkip?: string[];
  throwError?: boolean;
}
```

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

### Archive Markdown as Text

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Reads markdown files from a source directory, converts them to plain text using remove-markdown, and writes the plain text to an archive directory. Ensures markdown files are backed up as clean text.

```javascript
const fs = require('fs');
const path = require('path');
const removeMd = require('remove-markdown');

function archiveMarkdownAsText(sourceDir, archiveDir) {
  const files = fs.readdirSync(sourceDir).filter(f => f.endsWith('.md'));

  files.forEach(file => {
    const markdown = fs.readFileSync(path.join(sourceDir, file), 'utf8');
    const plainText = removeMd(markdown, {
      stripListLeaders: true,
      gfm: true,
      useImgAltText: true
    });

    const archivePath = path.join(archiveDir, file.replace('.md', '.txt'));
    fs.writeFileSync(archivePath, plainText, 'utf8');
  });
}

archiveMarkdownAsText('./docs', './archive');
```

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

### Default Error Handling (throwError: false)

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/errors.md

When `throwError` is false, errors during regex processing are caught, logged to the console, and the original markdown input is returned without propagating an exception.

```javascript
}
catch(e) {
  if (options.throwError) throw e;
  console.error("remove-markdown encountered error: %s", e);
  return md;
}
```

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

### Process Markdown for Chat

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Removes markdown formatting and normalizes whitespace to create clean text suitable for chat applications. Image alt text is not included, and excessive newlines are reduced.

```javascript
const removeMd = require('remove-markdown');

function processMarkdownForChat(markdown) {
  // Remove all formatting to create clean chat text
  let text = removeMd(markdown, {
    stripListLeaders: true,
    gfm: true,
    useImgAltText: false          // Don't need image alt text
  });

  // Additional processing: normalize whitespace
  text = text
    .replace(/\n{3,}/g, '\n\n')   // Max 2 newlines
    .replace(/\t/g, '  ')          // Convert tabs to spaces
    .trim();

  return text;
}
```

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

### Default Silent Error Handling Pattern

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/errors.md

Illustrates the default behavior where errors are logged to the console, and the original input string is returned if an error occurs during markdown removal.

```javascript
const removeMd = require('remove-markdown');

// Default behavior: errors are logged, original string returned
const result = removeMd(userInput);
// If error occurs, console logs it and result === userInput

```

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

### Clean Markdown Before Database Storage

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

This function cleans markdown content to plain text before saving it to a database. It calculates the word count based on the resulting plain text. Options include stripping list leaders, enabling GFM, and using image alt text.

```javascript
const removeMd = require('remove-markdown');

async function saveArticle(article) {
  const plainText = removeMd(article.markdown, {
    stripListLeaders: true,
    gfm: true,
    useImgAltText: true
  });

  return db.insert({
    title: article.title,
    markdown: article.markdown,
    plainText: plainText,
    wordCount: plainText.split(/\s+/).length
  });
}
```

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

### Clean API Response Markdown

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Prepare markdown descriptions from a content API for use in JSON responses. This cleans the markdown, removes HTML tags, but does not replace links with URLs.

```javascript
const removeMd = require('remove-markdown');

function cleanApiResponse(markdownContent) {
  return removeMd(markdownContent, {
    stripListLeaders: true,
    gfm: true,
    useImgAltText: true,
    replaceLinksWithURL: false,
    htmlTagsToSkip: []
  });
}

app.get('/api/posts/:id', (req, res) => {
  const post = db.getPost(req.params.id);
  res.json({
    id: post.id,
    title: post.title,
    description: cleanApiResponse(post.content)
  });
});
```

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

### TypeScript Declaration File

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/module-exports.md

This is the TypeScript declaration file (`index.d.ts`) that defines the function signature and options for the `remove-markdown` module. It specifies the expected types for input markdown and options.

```typescript
declare function removeMd(md: string, options?: {
  stripListLeaders?: boolean;
  listUnicodeChar?: string;
  gfm?: boolean;
  useImgAltText?: boolean;
  abbr?: boolean;
  replaceLinksWithURLs?: boolean;
  separateLinksAndTexts?: string;
  htmlTagsToSkip?: string[];
  throwError?: boolean;
}): string;

export = removeMd;
```

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

### Error Handling with `throwError` Option

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/api-reference.md

Control error handling behavior. By default (`throwError: false`), errors are logged to the console and the original input is returned. Set `throwError: true` to have errors thrown.

```javascript
const removeMd = require('remove-markdown');

// With throwError: false (default)
const result = removeMd(invalidInput, { throwError: false });
// Logs error to console, returns original input

// With throwError: true
try {
  const result = removeMd(invalidInput, { throwError: true });
} catch (error) {
  console.error('Markdown parsing failed:', error.message);
}
```

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

### Validating Input Before Markdown Processing

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/errors.md

Demonstrates a pattern for validating input types before passing them to `removeMd` to prevent potential errors, such as TypeErrors for non-string inputs.

```javascript
function processMarkdown(input, options) {
  // Validate input
  if (typeof input !== 'string') {
    throw new TypeError('Input must be a string');
  }

  // Safe processing
  return removeMd(input, options);
}

```

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

### Import remove-markdown with CommonJS

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/README.md

Use this import statement when working with CommonJS module systems.

```javascript
const removeMd = require('remove-markdown');
```

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

### Replace List Leaders with Unicode

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/api-reference.md

Replace default list markers with a specified Unicode character by using the `listUnicodeChar` option.

```javascript
const markdown = '- First
- Second
- Third';
const result = removeMd(markdown, { listUnicodeChar: '•' });
// Result: '• First
• Second
• Third'
```

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

### Dynamic HTML Tag Skip Regex Construction

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Constructs a regular expression to match HTML tags, with an option to skip specific tags provided in an array. The default regex matches all HTML tags, while the custom regex uses a negative lookahead to exclude specified tags.

```javascript
let htmlReplaceRegex = /<[^>]*>/g
if (options.htmlTagsToSkip && options.htmlTagsToSkip.length > 0) {
  const joinedHtmlTagsToSkip = options.htmlTagsToSkip.join('|')
  htmlReplaceRegex = new RegExp(
    `<(?!/(${joinedHtmlTagsToSkip})(?=>|\s[^>]*>))[^>]*>`,
    'g',
  )
}
```

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

### Main CommonJS Export

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/module-exports.md

The module exports a single function directly. This is the primary way to use the module in CommonJS environments.

```javascript
module.exports = function(md, options) { ... }
```

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

### Processing Large Batches of Documents in JavaScript

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Optimize for processing many documents efficiently by pre-computing options to avoid object recreation within the map function.

```javascript
const removeMd = require('remove-markdown');

function processLargeBatch(documents) {
  // Pre-compute options to avoid object recreation
  const options = {
    stripListLeaders: true,
    gfm: true,
    useImgAltText: true
  };

  return documents.map(doc => ({
    ...doc,
    plainText: removeMd(doc.markdown, options)
  }));
}
```

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

### CommonJS Require Usage

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/module-exports.md

Import the module using `require` in CommonJS and invoke the exported function directly. Ensure you are not attempting to destructure, as the module exports a function, not an object.

```javascript
const removeMd = require('remove-markdown');

// Direct invocation
const plainText = removeMd(markdown);
```

```javascript
// This will NOT work (module exports a function, not an object)
const { removeMd } = require('remove-markdown');  // ERROR
```

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

### Preserve Semantic HTML

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/configuration.md

This configuration focuses on converting markdown to plain text while preserving specific semantic HTML tags for accessibility. Specify the tags to keep in the 'htmlTagsToSkip' array.

```javascript
const result = removeMd(html, {
  stripListLeaders: true,
  gfm: true,
  htmlTagsToSkip: ['em', 'strong', 'code', 'mark', 'small']
});
```

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

### Process Markdown with Conditional Options

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Applies markdown removal options dynamically based on a specified use case, such as 'email', 'search', or 'display'. This allows for tailored text processing.

```javascript
const removeMd = require('remove-markdown');

function processMarkdown(markdown, useCase) {
  const options = {
    stripListLeaders: true,
    gfm: true,
    useImgAltText: true,
    // Use case determines other options
    ...(useCase === 'email' && { replaceLinksWithURL: true }),
    ...(useCase === 'search' && { htmlTagsToSkip: [] }),
    ...(useCase === 'display' && { separateLinksAndTexts: ' → ' })
  };

  return removeMd(markdown, options);
}

const emailText = processMarkdown(content, 'email');
const searchText = processMarkdown(content, 'search');
const displayText = processMarkdown(content, 'display');
```

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

### Separate Link Text and URL

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

Replaces markdown links with text, a separator, and URL. Applied when 'separateLinksAndTexts' option is a non-null string. Works with nested brackets in the link text.

```javascript
output = output.replace(/<[^>]*>/g, '$1' + options.separateLinksAndTexts + '$2');
```

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

### TypeScript Usage

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/module-exports.md

Import and use removeMd in a TypeScript project, including type annotations for the result.

```typescript
import removeMd from 'remove-markdown';
const result: string = removeMd(markdown);
```

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

### Timeout Protection for Server-Side Markdown Processing

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/errors.md

Implement a timeout mechanism for processing untrusted markdown on a server to prevent indefinite hangs. This uses `Promise.race` to either resolve the markdown processing or reject with a timeout error.

```javascript
const removeMd = require('remove-markdown');

async function processWithTimeout(markdown, timeoutMs = 5000) {
  return Promise.race([
    Promise.resolve(removeMd(markdown, { throwError: true })),
    new Promise((_, reject) =>
      setTimeout(() => reject(new Error('Markdown processing timeout')), timeoutMs)
    )
  ]);
}
```

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

### Custom Link Text and URL Separator

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/api-reference.md

Customize the separator between link text and its URL when `replaceLinksWithURL` is used by providing a string to `separateLinksAndTexts`.

```javascript
const markdown = 'Check [this article](http://example.com) out.';
const result = removeMd(markdown, { separateLinksAndTexts: ' — ' });
// Result: 'Check this article — http://example.com out.'
```

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

### Clean Markdown for Email Bodies

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Format markdown content into plain text suitable for email bodies. This option preserves list structure using bullet points and replaces links with their URLs.

```javascript
const removeMd = require('remove-markdown');

function createEmailBody(markdown) {
  return removeMd(markdown, {
    stripListLeaders: true,
    listUnicodeChar: '•',
    gfm: true,
    useImgAltText: true,
    replaceLinksWithURL: true    // Show URLs in email
  });
}

const emailBody = createEmailBody(gitHubMarkdown);
```

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

### Remove Footnote Markers and Definitions

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

Removes footnote reference markers like '[^1]' and reference-style link/footnote definitions like '[label]: url'.

```regex
.replace(/\ Kar\^.+?\](\: .*?$) ?/g, '')
```

```regex
.replace(/\s{0,2}\[.*?\ ]: .*?$/g, '')
```

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

### CommonJS Usage

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/module-exports.md

Import the removeMd function using require for Node.js, webpack, and similar environments.

```javascript
const removeMd = require('remove-markdown');
const result = removeMd(markdown);
```

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

### Remove Setext Headers

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

Removes lines consisting solely of two or more equals or hyphens, which are used for Setext-style headers.

```regex
.replace(/^[=\-]{2,}\s*$/g, '')
```

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

### Safely Remove Markdown with Input Validation

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/errors.md

Validate input to ensure it is a non-empty string before processing. This prevents unexpected errors with invalid input types.

```javascript
function removeMarkdownSafely(markdown) {
  if (!markdown || typeof markdown !== 'string') {
    return '';  // or return markdown
  }
  return removeMd(markdown);
}
```

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

### Basic Markdown Removal

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/README.md

Use this snippet to remove markdown from a string. It requires importing the 'remove-markdown' module.

```javascript
const removeMd = require('remove-markdown');

const markdown = '# Heading\n\nParagraph with **bold** and [link](http://example.com).';
const plainText = removeMd(markdown);
// Result: 'Heading\n\nParagraph with bold and link.'
```

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

### Non-Greedy Quantifiers in Regex

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/implementation-details.md

Employs non-greedy quantifiers (`*?`, `+?`) to match the shortest possible substring. This prevents over-matching when multiple delimiters appear on a single line, ensuring correct parsing of markdown links.

```javascript
.replace(/[\[\]\(([^\)]+)\)\]/g, ...)
```

```javascript
.replace(/\!\[(.*?)(\].*)/...)
```

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

### Remove Inline Code Markers

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/markdown-processing-rules.md

Removes single-backtick inline code markers, preserving the content within.

```javascript
.replace(/`(.+?)`/g, '$1')
```

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

### Export Markdown to Plain Text

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Convert entire markdown documents to plain text for archival or text-only export formats. This function reads a markdown file and writes its plain text version to another file.

```javascript
const fs = require('fs');
const removeMd = require('remove-markdown');

function exportToPlainText(mdFile, txtFile) {
  const markdown = fs.readFileSync(mdFile, 'utf8');
  const plainText = removeMd(markdown, {
    stripListLeaders: true,
    gfm: true,
    useImgAltText: true
  });
  fs.writeFileSync(txtFile, plainText, 'utf8');
}

exportToPlainText('document.md', 'document.txt');
```

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

### Strict Error Mode in JavaScript

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Employ this for development or critical systems that require immediate feedback on processing errors. It throws an error if markdown conversion fails.

```javascript
const removeMd = require('remove-markdown');

function strictProcess(markdown) {
  try {
    return removeMd(markdown, { throwError: true });
  } catch (error) {
    console.error('Markdown processing failed:', error.message);
    throw error;  // Re-throw for caller to handle
  }
}
```

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

### Extract Links from Markdown

Source: https://github.com/zuchka/remove-markdown/blob/main/_autodocs/usage-patterns.md

Extracts all URLs from markdown content by first removing most formatting and then using a regular expression to find link patterns. This is useful for collecting all hyperlinks present in a document.

```javascript
const removeMd = require('remove-markdown');

function extractLinks(markdown) {
  // First pass: remove everything except link structure
  const withLinks = removeMd(markdown, {
    stripListLeaders: true,
    gfm: true,
    useImgAltText: false,
    replaceLinksWithURL: true,
    htmlTagsToSkip: []
  });

  // Extract URLs
  const urls = withLinks.match(/https?:\[^\s]+/g) || [];
  return urls;
}

const links = extractLinks(markdown);
```