Mdast Util Gfm

https://github.com/syntax-tree/mdast-util-gfm
Admin
This package provides mdast extensions to parse and serialize GFM (GitHub Flavored Markdown) syntax,...
Tokens:14,979
Snippets:95
Trust Score:9.7
License:MIT
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Usage example

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/index.md

Shows how to parse and serialize GFM markdown using the package's functions. The example parses '~~hi~~' and outputs the same string.

```js
import {fromMarkdown} from 'mdast-util-from-markdown'
import {toMarkdown} from 'mdast-util-to-markdown'
import {gfm} from 'micromark-extension-gfm'
import {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'

const tree = fromMarkdown('~~hi~~', {
  extensions: [gfm()],
  mdastExtensions: [gfmFromMarkdown()]
})

const value = toMarkdown(tree, {extensions: [gfmToMarkdown()]})
console.log(value) // '~~hi~~'
```

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

### Example: using gfmToMarkdown with null options

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/configuration.md

Shows that passing null or undefined for options is equivalent to using all defaults. This is a concise example of using gfmToMarkdown without custom configuration.

```js
const result = toMarkdown(tree, {extensions: [gfmToMarkdown(null)]})
```

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

### Install mdast-util-gfm with npm

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/readme.md

Install with npm in Node.js (version 16+).

```sh
npm install mdast-util-gfm
```

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

### Example: using gfmToMarkdown with options

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/configuration.md

Example of using gfmToMarkdown with custom options to configure footnote and table serialization. The options object includes firstLineBlank, tableCellPadding, tablePipeAlign, and stringLength, with comments explaining each setting.

```js
import {toMarkdown} from 'mdast-util-to-markdown'
import {gfmToMarkdown} from 'mdast-util-gfm'

const result = toMarkdown(tree, {
  extensions: [
    gfmToMarkdown({
      firstLineBlank: true,      // blank line before footnote definition content
      tableCellPadding: false,   // no padding between | and cell content
      tablePipeAlign: false,     // do not pad cells to equal widths
      stringLength: (s) => s.length
    })
  ]
})
```

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

### Markdown example.md

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/readme.md

Example markdown file used in the Use section.

```markdown
# GFM

## Autolink literals

www.example.com, https://example.com, and contact@example.com.

## Footnote

A note[^1]

[^1]: Big note.

## Strikethrough

~one~ or ~~two~~ tildes.

## Table

| a | b  |  c |  d  |
| - | :- | -: | :-: |

## Tasklist

* [ ] to do
* [x] done
```

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

### Using Options with gfmToMarkdown

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/types.md

Example usage of the `Options` type with `gfmToMarkdown`. Shows setting `firstLineBlank`, `tableCellPadding`, `tablePipeAlign`, and a custom `stringLength` that counts code points.

```ts
import {gfmToMarkdown} from 'mdast-util-gfm'
import type {Options} from 'mdast-util-gfm'

const options: Options = {
  firstLineBlank: true,
  tableCellPadding: false,
  tablePipeAlign: false,
  stringLength: (value) => Array.from(value).length // count code points, not UTF-16 units
}

const extension = gfmToMarkdown(options)
```

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

### Using the extension in a remark-style pipeline

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-from-markdown.md

Example of using the extension in a remark-style pipeline. It parses markdown with a footnote and then uses `unist-util-visit` to traverse the resulting tree, logging the identifier of each `footnoteDefinition` node.

```js
import {fromMarkdown} from 'mdast-util-from-markdown'
import {gfmFromMarkdown} from 'mdast-util-gfm'
import {gfm} from 'micromark-extension-gfm'
import {visit} from 'unist-util-visit'

const tree = fromMarkdown('A note[^1]\n\n[^1]: Big note.', {
  extensions: [gfm()],
  mdastExtensions: [gfmFromMarkdown()]
})

// The tree now contains footnoteDefinition / footnoteReference nodes.
visit(tree, 'footnoteDefinition', (node) => {
  console.log(node.identifier) // '1'
})
```

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

### Basic use: parsing GFM markdown to an mdast tree

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-from-markdown.md

Basic usage example: parses GFM markdown into an mdast tree using `fromMarkdown` with both the `gfm()` syntax extension and `gfmFromMarkdown()` as `mdastExtensions`. The `micromark-extension-gfm` `gfm()` syntax extension is mandatory; the mdast extension alone cannot parse GFM.

```js
import {fromMarkdown} from 'mdast-util-from-markdown'
import {gfm} from 'micromark-extension-gfm'
import {gfmFromMarkdown} from 'mdast-util-gfm'

const tree = fromMarkdown(
  '# GFM\n\nwww.example.com, ~~strike~~, [^1], \| a \| b \|, * [x] done\n\n[^1]: note',
  {
    extensions: [gfm()],
    mdastExtensions: [gfmFromMarkdown()]
  }
)

console.log(tree.children[1].children[0])
// {type: 'link', url: 'http://www.example.com', ...}
```

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

### Parse and serialize GFM with example.js

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/readme.md

Module that reads example.md, parses with fromMarkdown, and serializes with toMarkdown using GFM extensions.

```js
import fs from 'node:fs/promises'
import {fromMarkdown} from 'mdast-util-from-markdown'
import {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'
import {toMarkdown} from 'mdast-util-to-markdown'
import {gfm} from 'micromark-extension-gfm'

const value = await fs.readFile('example.md', 'utf8')

const tree = fromMarkdown(value, {
  extensions: [gfm()],
  mdastExtensions: [gfmFromMarkdown()]
})

console.log(tree)

const result = toMarkdown(tree, {extensions: [gfmToMarkdown()]})

console.log(result)
```

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

### package.json exports and files

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/index.md

Declares the single export entry point and the files included in the package.

```json
{
  "exports": "./index.js",
  "files": [
    "index.d.ts",
    "index.js",
    "lib/"
  ]
}
```

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

### Advanced configuration with table and footnote options

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-to-markdown.md

Shows how to pass options to gfmToMarkdown for table alignment and footnote first-line-blank behavior. Includes a full tree with table and footnoteDefinition.

```js
import {toMarkdown} from 'mdast-util-to-markdown'
import {gfmToMarkdown} from 'mdast-util-gfm'

const tree = {
  type: 'root',
  children: [
    {
      type: 'table',
      align: [null, 'left'],
      children: [
        {
          type: 'tableRow',
          children: [
            {type: 'tableCell', children: [{type: 'text', value: 'aaa'}]},
            {type: 'tableCell', children: [{type: 'text', value: 'b'}]}
          ]
        }
      ]
    },
    {
      type: 'footnoteDefinition',
      identifier: 'a',
      children: [{type: 'paragraph', children: [{type: 'text', value: 'note'}]}]
    }
  ]
}

const value = toMarkdown(tree, {
  extensions: [
    gfmToMarkdown({
      // Table options:
      tablePipeAlign: false,
      tableCellPadding: false,
      stringLength: (value) => value.length,
      // Footnote options:
      firstLineBlank: true
    })
  ]
})
console.log(value)
```

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

### Parsed tree output from example.js

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/readme.md

Output of running example.js, showing the parsed tree with positional info removed.

```js
{
  type: 'root',
  children: [
    {type: 'heading', depth: 1, children: [{type: 'text', value: 'GFM'}]},
    {
      type: 'heading',
      depth: 2,
      children: [{type: 'text', value: 'Autolink literals'}]
    },
    {
      type: 'paragraph',
      children: [
        {
          type: 'link',
          title: null,
          url: 'http://www.example.com',
          children: [{type: 'text', value: 'www.example.com'}]
        },
        {type: 'text', value: ', '},
        {
          type: 'link',
          title: null,
          url: 'https://example.com',
          children: [{type: 'text', value: 'https://example.com'}]
        },
        {type: 'text', value: ', and '},
        {
          type: 'link',
          title: null,
          url: 'mailto:contact@example.com',
          children: [{type: 'text', value: 'contact@example.com'}]
        },
        {type: 'text', value: '.'}
      ]
    },
    {type: 'heading', depth: 2, children: [{type: 'text', value: 'Footnote'}]},
    {
      type: 'paragraph',
      children: [
        {type: 'text', value: 'A note'},
        {type: 'footnoteReference', identifier: '1', label: '1'}
      ]
    },
    {
      type: 'footnoteDefinition',
      identifier: '1',
      label: '1',
      children: [
        {type: 'paragraph', children: [{type: 'text', value: 'Big note.'}]}
      ]
    },
    {
      type: 'heading',
      depth: 2,
      children: [{type: 'text', value: 'Strikethrough'}]
    },
    {
      type: 'paragraph',
      children: [
        {
          type: 'delete',
          children: [{type: 'text', value: 'one'}]
        },
        {type: 'text', value: ' or '},
        {
          type: 'delete',
          children: [{type: 'text', value: 'two'}]
        },
        {type: 'text', value: ' tildes.'}
      ]
    },
    {type: 'heading', depth: 2, children: [{type: 'text', value: 'Table'}]},
    {
      type: 'table',
      align: [null, 'left', 'right', 'center'],
      children: [
        {
          type: 'tableRow',
          children: [
            {type: 'tableCell', children: [{type: 'text', value: 'a'}]},
            {type: 'tableCell', children: [{type: 'text', value: 'b'}]},
            {type: 'tableCell', children: [{type: 'text', value: 'c'}]},
            {type: 'tableCell', children: [{type: 'text', value: 'd'}]}
          ]
        }
      ]
    },
    {type: 'heading', depth: 2, children: [{type: 'text', value: 'Tasklist'}]},
    {
      type: 'list',
      ordered: false,
      start: null,
      spread: false,
      children: [
        {
          type: 'listItem',
          spread: false,
          checked: false,
          children: [
            {type: 'paragraph', children: [{type: 'text', value: 'to do'}]}
          ]
        },
        {
          type: 'listItem',
          spread: false,
          checked: true,
          children: [
            {type: 'paragraph', children: [{type: 'text', value: 'done'}]}
          ]
        }
      ]
    }
  ]
}
```

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

### Import mdast-util-gfm in browsers

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/readme.md

Import the package in browsers using esm.sh with the bundle parameter.

```html
<script type="module">
  import {gfmFromMarkdown, gfmToMarkdown} from 'https://esm.sh/mdast-util-gfm@3?bundle'
</script>
```

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

### Peer ecosystem diagram

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/index.md

Illustrates how the package plugs into the micromark and mdast ecosystem.

```text
micromark-extension-gfm ──► mdast-util-from-markdown (extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()])
                                                                                    ▲
mdast-util-to-markdown (extensions: [gfmToMarkdown()])                              │
```

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

### Import mdast-util-gfm in Deno

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/readme.md

Import the package in Deno using esm.sh.

```js
import {gfmFromMarkdown, gfmToMarkdown} from 'https://esm.sh/mdast-util-gfm@3'
```

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

### Options

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/readme.md

Configuration options for gfmToMarkdown.

```APIDOC
## Options

### Description
Configuration (TypeScript type).

### Fields
- `firstLineBlank` (`boolean`, default: `false`) - Optional - Use a blank line for the first line of footnote definitions
- `stringLength` (`((value: string) => number)`, default: `s => s.length`) - Optional - Function to detect the length of table cell content, used when aligning the delimiters between cells
- `tableCellPadding` (`boolean`, default: `true`) - Optional - Whether to add a space of padding between delimiters and cells
- `tablePipeAlign` (`boolean`, default: `true`) - Optional - Whether to align the delimiters
```

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

### gfmFromMarkdown()

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-from-markdown.md

Creates an extension for mdast-util-from-markdown to enable GFM support. It returns an array of five extension objects for autolink literals, footnotes, strikethrough, tables, and tasklists.

```APIDOC
## gfmFromMarkdown()

### Description
Creates an extension for `mdast-util-from-markdown` to enable GFM (autolink literals, footnotes, strikethrough, tables, tasklists).

### Signature
```js
export function gfmFromMarkdown() {
  return [
    gfmAutolinkLiteralFromMarkdown(),
    gfmFootnoteFromMarkdown(),
    gfmStrikethroughFromMarkdown(),
    gfmTableFromMarkdown(),
    gfmTaskListItemFromMarkdown()
  ]
}
```

### Parameters
None. The function accepts no parameters.

### Return Value
- **Type**: `Array<FromMarkdownExtension>`
- **Description**: An array of five extension objects, one per GFM feature, in this order: autolink literals, footnotes, strikethrough, tables, tasklists.

### Usage
Pass the returned array as the `mdastExtensions` option of `mdast-util-from-markdown`.

### Example
```js
import {fromMarkdown} from 'mdast-util-from-markdown'
import {gfm} from 'micromark-extension-gfm'
import {gfmFromMarkdown} from 'mdast-util-gfm'

const tree = fromMarkdown(
  '# GFM\n\nwww.example.com, ~~strike~~, [^1], \| a \| b \|, * [x] done\n\n[^1]: note',
  {
    extensions: [gfm()],
    mdastExtensions: [gfmFromMarkdown()]
  }
)

console.log(tree.children[1].children[0])
// {type: 'link', url: 'http://www.example.com', ...}
```

### Notes
- The `micromark-extension-gfm` `gfm()` syntax extension is mandatory — the mdast extension alone cannot parse GFM.
- The function returns a fresh array on every call, so it can be invoked safely each time a parse is set up.
- Throws: None.
```

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

### gfmToMarkdown(options?)

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-to-markdown.md

Creates an extension for mdast-util-to-markdown to enable GFM support. Accepts optional configuration options and returns a ToMarkdownExtension.

```APIDOC
## gfmToMarkdown(options?)

### Description
Creates an extension for `mdast-util-to-markdown` to enable GFM support while serializing an mdast syntax tree to markdown. The extension enables autolink literals, footnotes, strikethrough, tables, and tasklists.

### Signature
```js
export function gfmToMarkdown(options) {
  return {
    extensions: [
      gfmAutolinkLiteralToMarkdown(),
      gfmFootnoteToMarkdown(options),
      gfmStrikethroughToMarkdown(),
      gfmTableToMarkdown(options),
      gfmTaskListItemToMarkdown()
    ]
  }
}
```

TypeScript signature:
```ts
export function gfmToMarkdown(options?: Options | null | undefined): Options
```

### Parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `options` | `Options \| null \| undefined` | No | `undefined` | Configuration passed through to the footnote and table sub-extensions. Fully described in [Configuration](../configuration.md). |

### Return Value
Returns a `ToMarkdownExtension` (type alias for `import('mdast-util-to-markdown').Options`) that enables GFM support in `mdast-util-to-markdown`.

### Notes
- Passing `null` is equivalent to passing no options.
```

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

### gfmToMarkdown implementation from lib/index.js

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/configuration.md

Shows the implementation of gfmToMarkdown, which returns an object with an extensions array containing the five sub-extension functions. The options parameter is passed to gfmFootnoteToMarkdown and gfmTableToMarkdown, while the other three sub-extensions are called without arguments.

```js
export function gfmToMarkdown(options) {
  return {
    extensions: [
      gfmAutolinkLiteralToMarkdown(),
      gfmFootnoteToMarkdown(options),
      gfmStrikethroughToMarkdown(),
      gfmTableToMarkdown(options),
      gfmTaskListItemToMarkdown()
    ]
  }
}
```

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

### Module graph

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/index.md

Shows the module dependency graph: the package delegates to five per-feature sub-packages.

```text
mdast-util-gfm (index.js)
└── lib/index.js
    ├── mdast-util-gfm-autolink-literal     (gfmAutolinkLiteralFromMarkdown, gfmAutolinkLiteralToMarkdown)
    ├── mdast-util-gfm-footnote             (gfmFootnoteFromMarkdown, gfmFootnoteToMarkdown)
    ├── mdast-util-gfm-strikethrough        (gfmStrikethroughFromMarkdown, gfmStrikethroughToMarkdown)
    ├── mdast-util-gfm-table                (gfmTableFromMarkdown, gfmTableToMarkdown)
    └── mdast-util-gfm-task-list-item       (gfmTaskListItemFromMarkdown, gfmTaskListItemToMarkdown)
```

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

### Basic use - serializing an mdast tree to markdown

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-to-markdown.md

Imports toMarkdown and gfmToMarkdown, creates a simple tree with a delete node, and serializes it to markdown. Outputs '~~struck~~'.

```js
import {toMarkdown} from 'mdast-util-to-markdown'
import {gfmToMarkdown} from 'mdast-util-gfm'

const tree = {
  type: 'root',
  children: [
    {type: 'paragraph', children: [{type: 'delete', children: [{type: 'text', value: 'struck'}]}]}
  ]
}

const value = toMarkdown(tree, {extensions: [gfmToMarkdown()]})
console.log(value) // '~~struck~~'
```

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

### gfmToMarkdown(options?)

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/configuration.md

Documentation for the gfmToMarkdown function and its Options interface.

```APIDOC
## gfmToMarkdown(options?)

### Description
Configures serialization of GFM syntax to markdown. Accepts an optional `Options` object that is passed to the footnote and table sub-extensions.

### Parameters
#### Options (optional)
- **options** (`Options | null | undefined`) - Optional - Configuration for serialization. Passed verbatim to `gfmFootnoteToMarkdown(options)` and `gfmTableToMarkdown(options)`; ignored by the other three sub-extensions.

### Options Fields
- **firstLineBlank** (`boolean`) - Optional - Default: `false` - Use a blank line for the first line of footnote definitions. Routed to `mdast-util-gfm-footnote`.
- **stringLength** (`(value: string) => number`) - Optional - Default: `s => s.length` - Function to detect the length of table cell content, used when aligning the delimiters between cells. Routed to `mdast-util-gfm-table`.
- **tableCellPadding** (`boolean`) - Optional - Default: `true` - Whether to add a space of padding between delimiters and cells. Routed to `mdast-util-gfm-table`.
- **tablePipeAlign** (`boolean`) - Optional - Default: `true` - Whether to align the delimiters. Routed to `mdast-util-gfm-table`.

### Example
```js
import {toMarkdown} from 'mdast-util-to-markdown'
import {gfmToMarkdown} from 'mdast-util-gfm'

const result = toMarkdown(tree, {
  extensions: [
    gfmToMarkdown({
      firstLineBlank: true,      // blank line before footnote definition content
      tableCellPadding: false,   // no padding between | and cell content
      tablePipeAlign: false,     // do not pad cells to equal widths
      stringLength: (s) => s.length
    })
  ]
})
```

Passing `null` or `undefined` for `options` is equivalent to using all defaults:

```js
const result = toMarkdown(tree, {extensions: [gfmToMarkdown(null)]})
```
```

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

### Reading a parsed tree back into GFM (round-trip)

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-to-markdown.md

Demonstrates round-tripping: parse markdown with fromMarkdown, then serialize back with toMarkdown using gfmToMarkdown. Outputs '*   [x] done'.

```js
import {fromMarkdown} from 'mdast-util-from-markdown'
import {toMarkdown} from 'mdast-util-to-markdown'
import {gfm} from 'micromark-extension-gfm'
import {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'

const tree = fromMarkdown('* [x] done', {
  extensions: [gfm()],
  mdastExtensions: [gfmFromMarkdown()]
})

const back = toMarkdown(tree, {extensions: [gfmToMarkdown()]})
console.log(back) // '*   [x] done'
```

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

### gfmFromMarkdown() function implementation

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-from-markdown.md

Exact source of the `gfmFromMarkdown()` function from `lib/index.js` lines 25–41. It returns an array of five extension objects, one per GFM feature, in order: autolink literals, footnotes, strikethrough, tables, tasklists. The function takes no arguments and returns a fresh array on every call.

```js
/**
 * Create an extension for `mdast-util-from-markdown` to enable GFM (autolink
 * literals, footnotes, strikethrough, tables, tasklists).
 *
 * @returns {Array<FromMarkdownExtension>}
 *   Extension for `mdast-util-from-markdown` to enable GFM (autolink literals,
 *   footnotes, strikethrough, tables, tasklists).
 */
export function gfmFromMarkdown() {
  return [
    gfmAutolinkLiteralFromMarkdown(),
    gfmFootnoteFromMarkdown(),
    gfmStrikethroughFromMarkdown(),
    gfmTableFromMarkdown(),
    gfmTaskListItemFromMarkdown()
  ]
}
```

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

### index.js re-export

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/index.md

Re-exports the two public functions from the implementation module.

```js
// Note: types exposed from `index.d.ts`.
export {gfmFromMarkdown, gfmToMarkdown} from './lib/index.js'
```

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

### gfmToMarkdown(options?)

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-to-markdown.md

The gfmToMarkdown function is the main entry point for converting an mdast tree to GFM markdown. It returns an extension object that can be passed to mdast-util-to-markdown.

```APIDOC
## gfmToMarkdown(options?)

### Description
Creates an extension object for `mdast-util-to-markdown` that enables serialization of GFM (GitHub Flavored Markdown) features to markdown. The returned object contains an `extensions` array with five sub-extensions, one per GFM feature.

### Parameters
#### Options (optional)
- **firstLineBlank** (boolean) - Optional - Used by the footnote sub-extension; when `true`, a blank line is inserted before the first footnote definition.
- **stringLength** (function) - Optional - Used by the table sub-extension; a function that returns the length of a string, used for alignment.
- **tableCellPadding** (boolean) - Optional - Used by the table sub-extension; when `true`, table cells are padded with spaces.
- **tablePipeAlign** (boolean) - Optional - Used by the table sub-extension; when `true`, table pipes are aligned.

### Return Value
Returns a `ToMarkdownExtension` object (an `mdast-util-to-markdown.Options`) with a single `extensions` property containing an array of five `ToMarkdownExtension` values.

### Example
```js
import {toMarkdown} from 'mdast-util-to-markdown'
import {gfmToMarkdown} from 'mdast-util-gfm'

const tree = {
  type: 'root',
  children: [
    {type: 'paragraph', children: [{type: 'delete', children: [{type: 'text', value: 'struck'}]}]}
  ]
}

const value = toMarkdown(tree, {extensions: [gfmToMarkdown()]})
console.log(value) // '~~struck~~'
```
```

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

### Options interface definition

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/types.md

Exact definition of the `Options` interface from `index.d.ts` (lines 1–10). It inherits all fields from `mdast-util-gfm-footnote.ToMarkdownOptions` and `mdast-util-gfm-table.Options`.

```ts
import type {ToMarkdownOptions as FootnoteOptions} from 'mdast-util-gfm-footnote'
import type {Options as TableOptions} from 'mdast-util-gfm-table'

/**
 * Configuration for `gfmToMarkdown` from `mdast-util-gfm`.
 *
 * Currently supports options for `mdast-util-gfm-footnote` and
 * `mdast-util-gfm-table`.
 */
export interface Options extends FootnoteOptions, TableOptions {}
```

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

### Runtime shape of gfmToMarkdown extension object

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-to-markdown.md

Shows the structure of the returned extension object with five sub-extensions. Only gfmFootnoteToMarkdown and gfmTableToMarkdown receive options.

```js
{
  extensions: [
    gfmAutolinkLiteralToMarkdown(),  // mdast-util-gfm-autolink-literal
    gfmFootnoteToMarkdown(options),  // mdast-util-gfm-footnote — receives `options`
    gfmStrikethroughToMarkdown(),    // mdast-util-gfm-strikethrough
    gfmTableToMarkdown(options),     // mdast-util-gfm-table — receives `options`
    gfmTaskListItemToMarkdown()      // mdast-util-gfm-task-list-item
  ]
}
```

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

### Serialized markdown output

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/readme.md

Result of converting the parsed tree back to markdown using gfmToMarkdown.

```markdown
# GFM

## Autolink literals

[www.example.com](http://www.example.com), <https://example.com>, and <contact@example.com>.

## Footnote

A note[^1]

[^1]: Big note.

## Strikethrough

~~one~~ or ~~two~~ tildes.

## Table

| a | b  |  c |  d  |
| - | :- | -: | :-: |

## Tasklist

*   [ ] to do
*   [x] done
```

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

### index.d.ts type declarations

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/index.md

Defines the Options interface combining footnote and table options, and re-exports the public functions.

```ts
import type {ToMarkdownOptions as FootnoteOptions} from 'mdast-util-gfm-footnote'
import type {Options as TableOptions} from 'mdast-util-gfm-table'

/**
 * Configuration for `gfmToMarkdown` from `mdast-util-gfm`.
 *
 * Currently supports options for `mdast-util-gfm-footnote` and
 * `mdast-util-gfm-table`.
 */
export interface Options extends FootnoteOptions, TableOptions {}

export {gfmFromMarkdown, gfmToMarkdown} from './lib/index.js'
```

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

### gfmToMarkdown function source (lib/index.js)

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-to-markdown.md

Exact source of the gfmToMarkdown function from lib/index.js lines 43-63. It returns an extension object with sub-extensions for each GFM feature. The options parameter is optional and passed to the footnote and table sub-extensions.

```javascript
/**
 * Create an extension for `mdast-util-to-markdown` to enable GFM (autolink
 * literals, footnotes, strikethrough, tables, tasklists).
 *
 * @param {Options | null | undefined} [options]
 *   Configuration (optional).
 * @returns {ToMarkdownExtension}
 *   Extension for `mdast-util-to-markdown` to enable GFM (autolink literals,
 *   footnotes, strikethrough, tables, tasklists).
 */
export function gfmToMarkdown(options) {
  return {
    extensions: [
      gfmAutolinkLiteralToMarkdown(),
      gfmFootnoteToMarkdown(options),
      gfmStrikethroughToMarkdown(),
      gfmTableToMarkdown(options),
      gfmTaskListItemToMarkdown()
    ]
  }
}
```

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

### TypeScript signature for gfmFromMarkdown()

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-from-markdown.md

Equivalent TypeScript signature derived from the JSDoc annotations. Shows the return type as an array of `Extension` from `mdast-util-from-markdown`.

```ts
export function gfmFromMarkdown(): Array<import('mdast-util-from-markdown').Extension>
```

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

### TypeScript signature for gfmToMarkdown

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/api-reference/gfm-to-markdown.md

Equivalent TypeScript signature derived from the JSDoc annotations. The function accepts an optional Options parameter and returns the Options type of mdast-util-to-markdown.

```typescript
export function gfmToMarkdown(options?: Options | null | undefined): Options
```

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

### FromMarkdownExtension type alias

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/types.md

Type alias for the return value of `gfmFromMarkdown()`. It is not exported by this package; it represents a single element of the `extensions` array used by `mdast-util-from-markdown`.

```ts
type FromMarkdownExtension = import('mdast-util-from-markdown').Extension
```

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

### ToMarkdownExtension type alias

Source: https://github.com/syntax-tree/mdast-util-gfm/blob/main/_autodocs/types.md

Type alias for the return value of `gfmToMarkdown()`. It is not exported by this package; the runtime value is an object of shape `{extensions: Array<ToMarkdownExtension>}`.

```ts
type ToMarkdownExtension = import('mdast-util-to-markdown').Options
```
Tokens:
Raw