language-plugin.js

import assert from 'node:assert/strict'
import {test} from 'node:test'
import remarkFrontmatter from 'remark-frontmatter'
import typescript from 'typescript'
import {VFileMessage} from 'vfile-message'
import {ScriptSnapshot} from '../lib/script-snapshot.js'
import {VirtualMdxCode} from '../lib/virtual-code.js'
import {recmaExportFilepath} from '../lib/plugins/recma-export-filepath.js'
import {rehypeMdxTitle} from '../lib/plugins/rehype-mdx-title.js'
import {remarkMdxFrontmatter} from '../lib/plugins/remark-mdx-frontmatter.js'
import {createMdxLanguagePlugin} from '@mdx-js/language-service'

test('create virtual code w/ mdxjsEsm', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('import {Planet} from "./Planet.js"', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [51],
          lengths: [35],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'import {Planet} from "./Planet.js"',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link Planet} */',
        '    Planet',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [34],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ mdxjsEsm and CRLF', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('import {Planet} from "./Planet.js"\r', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [51],
          lengths: [36],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'import {Planet} from "./Planet.js"\r',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link Planet} */',
        '    Planet',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [34],
          generatedOffsets: [0],
          lengths: [2],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('\r', '')
    }
  ])
})

test('create virtual code w/o MDX layout in case of named re-export', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('export {named} from "./Layout.js"', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0],
          generatedOffsets: [27, 78],
          lengths: [0, 34],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export {named} from "./Layout.js"',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [33],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ MDX layout in case of default re-export', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('export {default} from "./Layout.js"', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0, 15],
          generatedOffsets: [27, 78, 86],
          lengths: [0, 8, 21],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export {} from "./Layout.js"',
        '',
        'import {default as MDXLayout} from "./Layout.js"',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [35],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ MDX layout in case of named and default re-export', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export {named, default} from "./Layout.js"',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0, 22],
          generatedOffsets: [27, 78, 93],
          lengths: [0, 15, 21],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export {named, } from "./Layout.js"',
        '',
        'import {default as MDXLayout} from "./Layout.js"',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [42],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ MDX layout in case of default and named re-export', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export {default, named} from "./Layout.js"',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0, 16],
          generatedOffsets: [27, 78, 86],
          lengths: [0, 8, 27],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export { named} from "./Layout.js"',
        '',
        'import {default as MDXLayout} from "./Layout.js"',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [42],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ MDX layout in case of a default exported arrow function', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('export default () => {}', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 15],
          generatedOffsets: [27, 748],
          lengths: [0, 9],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** @typedef {MDXContentProps & { children: JSX.Element }} MDXLayoutProps */',
        '',
        '/**',
        ' * There is one special component: [MDX layout](https://mdxjs.com/docs/using-mdx/#layout).',
        ' * If it is defined, it’s used to wrap all content.',
        ' * A layout can be defined from within MDX using a default export.',
        ' *',
        ' * @param {{readonly [K in keyof MDXLayoutProps]: MDXLayoutProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' *   In addition, the MDX layout receives the `children` prop, which contains the rendered MDX content.',
        ' * @returns {JSX.Element}',
        ' *   The MDX content wrapped in the layout.',
        ' */',
        'const MDXLayout = () => {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [23],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ MDX layout in case of a default exported function declaration', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export default function MDXLayout() {}',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 15],
          generatedOffsets: [27, 748],
          lengths: [0, 24],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** @typedef {MDXContentProps & { children: JSX.Element }} MDXLayoutProps */',
        '',
        '/**',
        ' * There is one special component: [MDX layout](https://mdxjs.com/docs/using-mdx/#layout).',
        ' * If it is defined, it’s used to wrap all content.',
        ' * A layout can be defined from within MDX using a default export.',
        ' *',
        ' * @param {{readonly [K in keyof MDXLayoutProps]: MDXLayoutProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' *   In addition, the MDX layout receives the `children` prop, which contains the rendered MDX content.',
        ' * @returns {JSX.Element}',
        ' *   The MDX content wrapped in the layout.',
        ' */',
        'const MDXLayout = function MDXLayout() {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link MDXLayout} */',
        '    MDXLayout',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [38],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ MDX layout in case of a default exported constant', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('export default "main"', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 15],
          generatedOffsets: [27, 97],
          lengths: [0, 7],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        'const MDXLayout = "main"',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [21],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ MDX layout and matching argument name', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export default function MDXLayout(properties) {}',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 15],
          generatedOffsets: [27, 753],
          lengths: [0, 34],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** @typedef {MDXContentProps & { children: JSX.Element }} MDXLayoutProps */',
        '',
        '/**',
        ' * There is one special component: [MDX layout](https://mdxjs.com/docs/using-mdx/#layout).',
        ' * If it is defined, it’s used to wrap all content.',
        ' * A layout can be defined from within MDX using a default export.',
        ' *',
        ' * @param {{readonly [K in keyof MDXLayoutProps]: MDXLayoutProps[K]}} properties',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' *   In addition, the MDX layout receives the `children` prop, which contains the rendered MDX content.',
        ' * @returns {JSX.Element}',
        ' *   The MDX content wrapped in the layout.',
        ' */',
        'const MDXLayout = function MDXLayout(properties) {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link MDXLayout} */',
        '    MDXLayout',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [48],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ MDX layout in case of a default export followed by a named', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export default function MDXLayout() {}',
    'export function named() {}',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 15],
          generatedOffsets: [27, 748],
          lengths: [0, 51],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** @typedef {MDXContentProps & { children: JSX.Element }} MDXLayoutProps */',
        '',
        '/**',
        ' * There is one special component: [MDX layout](https://mdxjs.com/docs/using-mdx/#layout).',
        ' * If it is defined, it’s used to wrap all content.',
        ' * A layout can be defined from within MDX using a default export.',
        ' *',
        ' * @param {{readonly [K in keyof MDXLayoutProps]: MDXLayoutProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' *   In addition, the MDX layout receives the `children` prop, which contains the rendered MDX content.',
        ' * @returns {JSX.Element}',
        ' *   The MDX content wrapped in the layout.',
        ' */',
        'const MDXLayout = function MDXLayout() {}',
        'export function named() {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link MDXLayout} */',
        '    MDXLayout,',
        '    /** {@link named} */',
        '    named',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [65],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ MDX layout in case of a default export preceded by a named', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export function named() {}',
    'export default function MDXLayout() {}',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0, 42],
          generatedOffsets: [27, 78, 775],
          lengths: [0, 27, 24],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export function named() {}',
        '',
        '/** @typedef {MDXContentProps & { children: JSX.Element }} MDXLayoutProps */',
        '',
        '/**',
        ' * There is one special component: [MDX layout](https://mdxjs.com/docs/using-mdx/#layout).',
        ' * If it is defined, it’s used to wrap all content.',
        ' * A layout can be defined from within MDX using a default export.',
        ' *',
        ' * @param {{readonly [K in keyof MDXLayoutProps]: MDXLayoutProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' *   In addition, the MDX layout receives the `children` prop, which contains the rendered MDX content.',
        ' * @returns {JSX.Element}',
        ' *   The MDX content wrapped in the layout.',
        ' */',
        'const MDXLayout = function MDXLayout() {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link named} */',
        '    named,',
        '    /** {@link MDXLayout} */',
        '    MDXLayout',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [65],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ mdxFlowExpression', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('{Math.PI}', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [27],
          lengths: [0],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          sourceOffsets: [0],
          generatedOffsets: [806],
          lengths: [9],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '    {Math.PI}',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [9],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ empty mdxFlowExpression', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('{}', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [27],
          lengths: [0],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          sourceOffsets: [0],
          generatedOffsets: [807],
          lengths: [2],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '    {}',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [2],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ prefixed JSX expressions for mdxFlowExpression', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export function Local() {}',
    '',
    '{<div />}',
    '{<div>{""}</div>}',
    '{<Injected />}',
    '{<Injected>{""}</Injected>}',
    '{<Injected><Injected>{""}</Injected></Injected>}',
    '{<Local />}',
    '{<Local>{""}</Local>}',
    '{<Local><Local>{""}</Local></Local>}',
    '{<Local><Injected>{""}</Injected></Local>}',
    '{<Injected><Local>{""}</Local></Injected>}'
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0],
          generatedOffsets: [27, 78],
          lengths: [0, 27],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          sourceOffsets: [
            28, 38, 56, 58, 71, 73, 88, 99, 101, 111, 126, 137, 148, 160, 182,
            219, 228, 243, 262, 264, 294
          ],
          generatedOffsets: [
            870, 884, 906, 920, 937, 951, 978, 993, 1007, 1029, 1056, 1079,
            1094, 1110, 1136, 1177, 1198, 1225, 1248, 1262, 1304
          ],
          lengths: [
            9, 17, 2, 12, 2, 15, 10, 2, 10, 15, 11, 10, 11, 21, 36, 9, 15, 18,
            2, 30, 10
          ],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          generatedOffsets: [1748, 1771, 1794, 1817, 1840, 1863],
          lengths: [8, 8, 8, 8, 8, 8],
          sourceOffsets: [58, 73, 101, 111, 228, 264],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export function Local() {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link Local} */',
        '    Local',
        '  }',
        '  _components',
        '  return <>',
        '    {<div />}',
        '    {<div>{""}</div>}',
        '    {<_components.Injected />}',
        '    {<_components.Injected>{""}</_components.Injected>}',
        '    {<_components.Injected><_components.Injected>{""}</_components.Injected></_components.Injected>}',
        '    {<Local />}',
        '    {<Local>{""}</Local>}',
        '    {<Local><Local>{""}</Local></Local>}',
        '    {<Local><_components.Injected>{""}</_components.Injected></Local>}',
        '    {<_components.Injected><Local>{""}</Local></_components.Injected>}',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        '// @ts-ignore',
        'Injected',
        '// @ts-ignore',
        'Injected',
        '// @ts-ignore',
        'Injected',
        '// @ts-ignore',
        'Injected',
        '// @ts-ignore',
        'Injected',
        '// @ts-ignore',
        'Injected',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [26, 37, 55, 70, 98, 147, 159, 181, 218, 261],
          generatedOffsets: [0, 9, 17, 25, 33, 41, 49, 57, 65, 73],
          lengths: [2, 1, 1, 1, 1, 1, 1, 1, 1, 1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        '',
        '',
        '<!---->',
        '<!---->',
        '<!---->',
        '<!---->',
        '<!---->',
        '<!---->',
        '<!---->',
        '<!---->',
        '<!---->',
        '<!---->'
      )
    }
  ])
})

test('create virtual code w/ prefixed JSX expressions in attributes', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export function Local() {}',
    '',
    '<div local={<Local />} injected={<Injected />} string="string" boolean />',
    '',
    '<div local={<Local>{null}</Local>} injected={<Injected>{null}</Injected>} string="string" boolean>',
    '  paragraph',
    '</div>'
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0],
          generatedOffsets: [27, 78],
          lengths: [0, 27],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          sourceOffsets: [28, 62, 103, 149, 166, 214],
          generatedOffsets: [870, 916, 960, 1018, 1047, 1113],
          lengths: [34, 39, 46, 17, 35, 6],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          generatedOffsets: [1553, 1576],
          lengths: [8, 8],
          sourceOffsets: [62, 149],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export function Local() {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link Local} */',
        '    Local',
        '  }',
        '  _components',
        '  return <>',
        '    <div local={<Local />} injected={<_components.Injected />} string="string" boolean />',
        '    <div local={<Local>{null}</Local>} injected={<_components.Injected>{null}</_components.Injected>} string="string" boolean>',
        '    <p>',
        "    {''}",
        '    </p>',
        '    </div>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        '// @ts-ignore',
        'Injected',
        '// @ts-ignore',
        'Injected',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [26, 101, 201, 204],
          generatedOffsets: [0, 9, 18, 19],
          lengths: [2, 2, 1, 10],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        '',
        '',
        '<!---->',
        '',
        '<!---->',
        'paragraph',
        '<!---->'
      )
    }
  ])
})

test('create virtual code w/ mdxJsxFlowElement w/ children', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export function Local() {}',
    '',
    '<div>',
    '',
    '  This content should not be part of the JSX embed',
    '',
    '</div>',
    '<Injected>',
    '',
    '  This content should not be part of the JSX embed',
    '',
    '</Injected>',
    '<Local>',
    '',
    '  This content should not be part of the JSX embed',
    '',
    '</Local>',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0],
          generatedOffsets: [27, 78],
          lengths: [0, 27],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          sourceOffsets: [28, 87, 94, 95, 158, 160, 170, 231],
          generatedOffsets: [870, 906, 917, 930, 970, 984, 998, 1036],
          lengths: [5, 6, 1, 9, 2, 9, 7, 8],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [1478],
          lengths: [8],
          sourceOffsets: [95]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export function Local() {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link Local} */',
        '    Local',
        '  }',
        '  _components',
        '  return <>',
        '    <div>',
        '    <p>',
        "    {''}",
        '    </p>',
        '    </div>',
        '    <_components.Injected>',
        '    <p>',
        "    {''}",
        '    </p>',
        '    </_components.Injected>',
        '    <Local>',
        '    <p>',
        "    {''}",
        '    </p>',
        '    </Local>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        '// @ts-ignore',
        'Injected',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [26, 33, 37, 93, 104, 108, 169, 177, 181, 239],
          generatedOffsets: [0, 9, 11, 68, 76, 78, 135, 143, 145, 202],
          lengths: [2, 2, 50, 1, 2, 50, 1, 2, 50, 1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        '',
        '',
        '<!---->',
        '',
        'This content should not be part of the JSX embed',
        '',
        '<!---->',
        '<!---->',
        '',
        'This content should not be part of the JSX embed',
        '',
        '<!---->',
        '<!---->',
        '',
        'This content should not be part of the JSX embed',
        '',
        '<!---->',
        ''
      )
    }
  ])
})

test('create virtual code w/ mdxJsxFlowElement w/ blockquote child', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('<div>', '>', '</div>', '<div>></div>', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [27],
          lengths: [0],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          sourceOffsets: [0, 8, 15, 21],
          generatedOffsets: [806, 851, 870, 889],
          lengths: [5, 6, 5, 6],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '    <div>',
        '    <blockquote>',
        '    </blockquote>',
        '    </div>',
        '    <p>',
        '    <div>',
        "    {''}",
        '    </div>',
        '    </p>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [5, 14, 20, 27],
          generatedOffsets: [0, 10, 18, 26],
          lengths: [3, 1, 1, 1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '>', '<!---->', '<!---->><!---->', '')
    }
  ])
})

test('create virtual code w/ mdxJsxFlowElement w/o children', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export function Local() {}',
    '',
    '<div />',
    '<Injected />',
    '<Local />',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0],
          generatedOffsets: [27, 78],
          lengths: [0, 27],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          sourceOffsets: [28, 36, 37, 49],
          generatedOffsets: [870, 882, 895, 911],
          lengths: [7, 1, 11, 9],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          generatedOffsets: [1354],
          lengths: [8],
          sourceOffsets: [37],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export function Local() {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link Local} */',
        '    Local',
        '  }',
        '  _components',
        '  return <>',
        '    <div />',
        '    <_components.Injected />',
        '    <Local />',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        '// @ts-ignore',
        'Injected',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [26, 35, 48, 58],
          generatedOffsets: [0, 9, 17, 25],
          lengths: [2, 1, 1, 1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '', '<!---->', '<!---->', '<!---->', '')
    }
  ])
})

test('create virtual code w/ mdxJsxTextElement', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export function Local() {}',
    '',
    'A <div />',
    'An <Injected />',
    'A <Local />',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          sourceOffsets: [0, 0],
          generatedOffsets: [27, 78],
          lengths: [0, 27],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          sourceOffsets: [30, 41, 42, 56],
          generatedOffsets: [887, 908, 921, 946],
          lengths: [7, 1, 11, 9],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          generatedOffsets: [1398],
          lengths: [8],
          sourceOffsets: [42],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export function Local() {}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link Local} */',
        '    Local',
        '  }',
        '  _components',
        '  return <>',
        '    <p>',
        "    {''}",
        '    <div />',
        "    {''}",
        '    <_components.Injected />',
        "    {''}",
        '    <Local />',
        '    </p>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        '// @ts-ignore',
        'Injected',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [26, 37, 53, 65],
          generatedOffsets: [0, 11, 22, 32],
          lengths: [4, 4, 3, 1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        '',
        '',
        'A <!---->',
        'An <!---->',
        'A <!---->',
        ''
      )
    }
  ])
})

test('create virtual code w/ mdxTextExpression', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('3 < {Math.PI} < 4', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          generatedOffsets: [823],
          sourceOffsets: [4],
          lengths: [9],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '    <p>',
        "    {''}",
        '    {Math.PI}',
        "    {''}",
        '    </p>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [0, 13],
          generatedOffsets: [0, 11],
          lengths: [4, 5],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('3 < <!----> < 4', '')
    }
  ])
})

test('create virtual code w/ async mdxTextExpression', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    '3 < {await Promise.resolve(Math.PI)} < 4',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          generatedOffsets: [27],
          sourceOffsets: [0],
          lengths: [0],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          generatedOffsets: [829],
          sourceOffsets: [4],
          lengths: [32],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'async function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '    <p>',
        "    {''}",
        '    {await Promise.resolve(Math.PI)}',
        "    {''}",
        '    </p>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [0, 36],
          generatedOffsets: [0, 11],
          lengths: [4, 5],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('3 < <!----> < 4', '')
    }
  ])
})

test('ignore async functions in props or expressions', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'export const arrow = async () => {',
    '  await Promise.resolve(42)',
    '}',
    '',
    'export const expression = async function() {',
    '  await Promise.resolve(42)',
    '}',
    '',
    'export async function named() {',
    '  await Promise.resolve(42)',
    '}',
    '',
    '{async () => { await Promise.resolve(42) }}',
    '{async function() { await Promise.resolve(42) }}',
    '{async function local() { await Promise.resolve(42) }}',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          generatedOffsets: [27, 78, 144, 220],
          sourceOffsets: [0, 0, 66, 142],
          lengths: [0, 65, 75, 62],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        },
        {
          generatedOffsets: [1165, 1213, 1266],
          sourceOffsets: [205, 249, 298],
          lengths: [43, 48, 54],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        'export const arrow = async () => {',
        '  await Promise.resolve(42)',
        '}',
        '',
        'export const expression = async function() {',
        '  await Promise.resolve(42)',
        '}',
        '',
        'export async function named() {',
        '  await Promise.resolve(42)',
        '}',
        '',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props,',
        '    /** {@link arrow} */',
        '    arrow,',
        '    /** {@link expression} */',
        '    expression,',
        '    /** {@link named} */',
        '    named,',
        '    /** {@link local} */',
        '    local',
        '  }',
        '  _components',
        '  return <>',
        '    {async () => { await Promise.resolve(42) }}',
        '    {async function() { await Promise.resolve(42) }}',
        '    {async function local() { await Promise.resolve(42) }}',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [64, 140, 203, 248, 297, 352],
          generatedOffsets: [0, 9, 18, 27, 35, 43],
          lengths: [2, 2, 2, 1, 1, 1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        '',
        '',
        '<!---->',
        '',
        '<!---->',
        '',
        '<!---->',
        '<!---->',
        '<!---->',
        ''
      )
    }
  ])
})

test('support locally scoped components', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('{(Component) => <Component />}', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        },
        {
          generatedOffsets: [806],
          sourceOffsets: [0],
          lengths: [30],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '    {(Component) => <Component />}',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [30],
          generatedOffsets: [0],
          lengths: [1],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('', '')
    }
  ])
})

test('create virtual code w/ dedented markdown content', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    '     | Language |',
    ' | --- |',
    '            | MDX |',
    '     | JavaScript |',
    '| TypeScript |'
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '    <p>',
        "    {''}",
        '    </p>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [5, 19, 39, 52],
          generatedOffsets: [0, 13, 21, 29],
          lengths: [13, 8, 8, 29],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines(
        '| Language |',
        '| --- |',
        '| MDX |',
        '| JavaScript |',
        '| TypeScript |'
      )
    }
  ])
})

test('create virtual code w/ syntax error', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('<', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ok(code.error instanceof VFileMessage)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [],
      snapshot: snapshotFromLines(
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [],
      snapshot: snapshotFromLines('<', '')
    }
  ])
})

test('create virtual code w/ yaml frontmatter', () => {
  const plugin = createMdxLanguagePlugin([remarkFrontmatter])

  const snapshot = snapshotFromLines('---', 'hello: frontmatter', '---', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [0],
          lengths: [27],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('---', 'hello: frontmatter', '---', '')
    },
    {
      id: 'yaml',
      languageId: 'yaml',
      mappings: [
        {
          sourceOffsets: [4],
          generatedOffsets: [0],
          lengths: [18],
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('hello: frontmatter')
    }
  ])
})

test('update virtual code', () => {
  const plugin = createMdxLanguagePlugin()

  let code = plugin.createVirtualCode?.(
    '/test.mdx',
    'mdx',
    snapshotFromLines('Tihs lne haz tyops', ''),
    {getAssociatedScript: () => undefined}
  )

  assert.ok(code instanceof VirtualMdxCode)

  const snapshot = snapshotFromLines('This line is fixed', '')
  code = plugin.createVirtualCode?.('/text.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)

  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '    <p>',
        "    {''}",
        '    </p>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [0],
          lengths: [19],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('This line is fixed', '')
    }
  ])
})

test('compilation setting defaults', () => {
  const plugin = createMdxLanguagePlugin()

  // @ts-expect-error
  const host = plugin.typescript?.resolveLanguageServiceHost?.({
    getCompilationSettings: () => ({})
  })

  const compilerOptions = host?.getCompilationSettings()

  assert.deepEqual(compilerOptions, {
    allowJs: true
  })
})

test('compilation setting overrides', () => {
  const plugin = createMdxLanguagePlugin()

  // @ts-expect-error
  const host = plugin.typescript?.resolveLanguageServiceHost?.({
    getCompilationSettings: () => ({
      jsx: typescript.JsxEmit.React,
      jsxFactory: 'h',
      jsxFragmentFactory: 'Fragment',
      jsxImportSource: 'preact',
      allowJs: false
    })
  })

  const compilerOptions = host?.getCompilationSettings()

  assert.deepEqual(compilerOptions, {
    allowJs: true,
    jsx: typescript.JsxEmit.React,
    jsxFactory: 'h',
    jsxFragmentFactory: 'Fragment',
    jsxImportSource: 'preact'
  })
})

test('support checkMdx', () => {
  const plugin = createMdxLanguagePlugin(undefined, undefined, true)

  const snapshot = snapshotFromLines('')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [40],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        '// @ts-check',
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [],
          generatedOffsets: [],
          lengths: [],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('support custom jsxImportSource', () => {
  const plugin = createMdxLanguagePlugin(undefined, undefined, false, 'preact')

  const snapshot = snapshotFromLines('')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [28],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'preact/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource preact */',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [],
          generatedOffsets: [],
          lengths: [],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('recma-export-filepath', () => {
  const plugin = createMdxLanguagePlugin(
    undefined,
    [recmaExportFilepath(null)],
    false
  )

  const snapshot = snapshotFromLines('')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** Generated by [recma-export-filepath](https://github.com/remcohaszing/recma-export-filepath) */',
        "export const filepath = /** @type {string} */ ('')",
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [],
          generatedOffsets: [],
          lengths: [],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('recma-export-filepath custom name', () => {
  const plugin = createMdxLanguagePlugin(
    undefined,
    [recmaExportFilepath({name: 'custom'})],
    false
  )

  const snapshot = snapshotFromLines('')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** Generated by [recma-export-filepath](https://github.com/remcohaszing/recma-export-filepath) */',
        "export const custom = /** @type {string} */ ('')",
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [],
          generatedOffsets: [],
          lengths: [],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('remark-mdx-frontmatter', () => {
  const plugin = createMdxLanguagePlugin(
    [remarkFrontmatter],
    [remarkMdxFrontmatter(null)],
    false
  )

  const snapshot = snapshotFromLines('')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** Generated by [remark-mdx-frontmatter](https://github.com/remcohaszing/remark-mdx-frontmatter) */',
        'export const frontmatter = /** @type {undefined} */ (undefined)',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [],
          generatedOffsets: [],
          lengths: [],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('remark-mdx-frontmatter custom name', () => {
  const plugin = createMdxLanguagePlugin(
    [remarkFrontmatter],
    [remarkMdxFrontmatter({name: 'custom'})],
    false
  )

  const snapshot = snapshotFromLines('')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** Generated by [remark-mdx-frontmatter](https://github.com/remcohaszing/remark-mdx-frontmatter) */',
        'export const custom = /** @type {undefined} */ (undefined)',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [],
          generatedOffsets: [],
          lengths: [],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('remark-mdx-frontmatter yaml', () => {
  const plugin = createMdxLanguagePlugin(
    [remarkFrontmatter],
    [remarkMdxFrontmatter(null)],
    false
  )

  const snapshot = snapshotFromLines('---', '---')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** Generated by [remark-mdx-frontmatter](https://github.com/remcohaszing/remark-mdx-frontmatter) */',
        'export const frontmatter = /** @type {any} */ (undefined)',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [0],
          lengths: [7],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('---\n---')
    },
    {
      id: 'yaml',
      languageId: 'yaml',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [0],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('remark-mdx-frontmatter toml', () => {
  const plugin = createMdxLanguagePlugin(
    [[remarkFrontmatter, ['toml']]],
    [remarkMdxFrontmatter(null)],
    false
  )

  const snapshot = snapshotFromLines('+++', '+++')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** Generated by [remark-mdx-frontmatter](https://github.com/remcohaszing/remark-mdx-frontmatter) */',
        'export const frontmatter = /** @type {any} */ (undefined)',
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [0],
          lengths: [7],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('+++\n+++')
    },
    {
      id: 'toml',
      languageId: 'toml',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [0],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('rehype-mdx-title', () => {
  const plugin = createMdxLanguagePlugin(
    undefined,
    [rehypeMdxTitle(null)],
    false
  )

  const snapshot = snapshotFromLines('')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** Generated by [rehype-mdx-title](https://github.com/remcohaszing/rehype-mdx-title) */',
        "export const title = /** @type {string | undefined} */ ('')",
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [],
          generatedOffsets: [],
          lengths: [],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('rehype-mdx-title custom name', () => {
  const plugin = createMdxLanguagePlugin(
    undefined,
    [rehypeMdxTitle({name: 'custom'})],
    false
  )

  const snapshot = snapshotFromLines('')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** Generated by [rehype-mdx-title](https://github.com/remcohaszing/rehype-mdx-title) */',
        "export const custom = /** @type {string | undefined} */ ('')",
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [],
          generatedOffsets: [],
          lengths: [],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('')
    }
  ])
})

test('rehype-mdx-title matching rank', () => {
  const plugin = createMdxLanguagePlugin(
    undefined,
    [rehypeMdxTitle(null)],
    false
  )

  const snapshot = snapshotFromLines('# Hello')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.equal(code.id, 'mdx')
  assert.equal(code.languageId, 'mdx')
  assert.ifError(code.error)
  assert.equal(code.snapshot, snapshot)
  assert.deepEqual(code.mappings, [
    {
      sourceOffsets: [0],
      generatedOffsets: [0],
      lengths: [snapshot.getLength()],
      data: {
        completion: true,
        format: true,
        navigation: true,
        semantic: true,
        structure: true,
        verification: true
      }
    }
  ])
  assert.deepEqual(code.embeddedCodes, [
    {
      id: 'jsx',
      languageId: 'javascriptreact',
      mappings: [
        {
          data: {
            completion: true,
            format: true,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          },
          generatedOffsets: [27],
          lengths: [0],
          sourceOffsets: [0]
        }
      ],
      snapshot: snapshotFromLines(
        "import 'react/jsx-runtime'",
        '/* @jsxRuntime automatic',
        '@jsxImportSource react */',
        '',
        '/** Generated by [rehype-mdx-title](https://github.com/remcohaszing/rehype-mdx-title) */',
        "export const title = /** @type {string} */ ('')",
        '',
        '/**',
        ' * @internal',
        ' *   **Do not use.** This function is generated by MDX for internal use.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'function _createMdxContent(props) {',
        '  /**',
        '   * @internal',
        '   *   **Do not use.** This variable is generated by MDX for internal use.',
        '   */',
        '  const _components = {',
        '    // @ts-ignore',
        '    .../** @type {0 extends 1 & MDXProvidedComponents ? {} : MDXProvidedComponents} */ ({}),',
        '    ...props.components,',
        '    /** The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component. */',
        '    props',
        '  }',
        '  _components',
        '  return <>',
        '    <h1>',
        "    {''}",
        '    </h1>',
        '  </>',
        '}',
        '',
        '/**',
        ' * Render the MDX contents.',
        ' *',
        ' * @param {{readonly [K in keyof MDXContentProps]: MDXContentProps[K]}} props',
        ' *   The [props](https://mdxjs.com/docs/using-mdx/#props) that have been passed to the MDX component.',
        ' */',
        'export default function MDXContent(props) {',
        '  return <_createMdxContent {...props} />',
        '}',
        '',
        '// @ts-ignore',
        '/** @typedef {(void extends Props ? {} : Props) & {components?: {}}} MDXContentProps */',
        ''
      )
    },
    {
      id: 'md',
      languageId: 'markdown',
      mappings: [
        {
          sourceOffsets: [0],
          generatedOffsets: [0],
          lengths: [7],
          data: {
            completion: true,
            format: false,
            navigation: true,
            semantic: true,
            structure: true,
            verification: true
          }
        }
      ],
      snapshot: snapshotFromLines('# Hello')
    }
  ])
})

test('create virtual code w/ invalid ESM recovery', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('export const x =', '', 'Hello {true}', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.ifError(code.error)
  // The key assertion: embedded code has non-empty mappings despite broken ESM.
  // Before acorn-loose recovery, this would have empty mappings ([]).
  assert.ok(code.embeddedCodes[0].mappings.length > 0)
})

test('create virtual code w/ incomplete import recovery', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines('import { } from', '', '# Hello', '')

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.ifError(code.error)
  assert.ok(code.embeddedCodes[0].mappings.length > 0)
})

test('create virtual code w/ valid ESM after recovery support', () => {
  const plugin = createMdxLanguagePlugin()

  const snapshot = snapshotFromLines(
    'import {Planet} from "./Planet.js"',
    'export const greeting = "hello"',
    '',
    'Hello {greeting}',
    ''
  )

  const code = plugin.createVirtualCode?.('/test.mdx', 'mdx', snapshot, {
    getAssociatedScript: () => undefined
  })

  assert.ok(code instanceof VirtualMdxCode)
  assert.ifError(code.error)
  assert.ok(code.embeddedCodes[0].mappings.length > 0)
  // Verify the generated JS contains both the import and export
  const jsText = code.embeddedCodes[0].snapshot.getText(
    0,
    code.embeddedCodes[0].snapshot.getLength()
  )
  assert.ok(jsText.includes('import {Planet} from "./Planet.js"'))
  assert.ok(jsText.includes('export const greeting = "hello"'))
})

/**
 * @param {string[]} lines
 * @returns {typescript.IScriptSnapshot}
 */
function snapshotFromLines(...lines) {
  return new ScriptSnapshot(lines.join('\n'))
}