up n_m

node_modules/micromark-extension-directive/dev/index.d.ts

@@ -0,0 +1,80 @@
+import type {Attribute, Directive} from './lib/html.js'
+
+export {directive} from './lib/syntax.js'
+export {
+  directiveHtml,
+  type Directive,
+  type Handle,
+  type HtmlOptions
+} from './lib/html.js'
+
+declare module 'micromark-util-types' {
+  interface TokenTypeMap {
+    directiveContainer: 'directiveContainer'
+    directiveContainerAttributes: 'directiveContainerAttributes'
+    directiveContainerAttributesMarker: 'directiveContainerAttributesMarker'
+    directiveContainerAttribute: 'directiveContainerAttribute'
+    directiveContainerAttributeId: 'directiveContainerAttributeId'
+    directiveContainerAttributeIdValue: 'directiveContainerAttributeIdValue'
+    directiveContainerAttributeClass: 'directiveContainerAttributeClass'
+    directiveContainerAttributeClassValue: 'directiveContainerAttributeClassValue'
+    directiveContainerAttributeName: 'directiveContainerAttributeName'
+    directiveContainerAttributeInitializerMarker: 'directiveContainerAttributeInitializerMarker'
+    directiveContainerAttributeValueLiteral: 'directiveContainerAttributeValueLiteral'
+    directiveContainerAttributeValue: 'directiveContainerAttributeValue'
+    directiveContainerAttributeValueMarker: 'directiveContainerAttributeValueMarker'
+    directiveContainerAttributeValueData: 'directiveContainerAttributeValueData'
+    directiveContainerContent: 'directiveContainerContent'
+    directiveContainerFence: 'directiveContainerFence'
+    directiveContainerLabel: 'directiveContainerLabel'
+    directiveContainerLabelMarker: 'directiveContainerLabelMarker'
+    directiveContainerLabelString: 'directiveContainerLabelString'
+    directiveContainerName: 'directiveContainerName'
+    directiveContainerSequence: 'directiveContainerSequence'
+
+    directiveLeaf: 'directiveLeaf'
+    directiveLeafAttributes: 'directiveLeafAttributes'
+    directiveLeafAttributesMarker: 'directiveLeafAttributesMarker'
+    directiveLeafAttribute: 'directiveLeafAttribute'
+    directiveLeafAttributeId: 'directiveLeafAttributeId'
+    directiveLeafAttributeIdValue: 'directiveLeafAttributeIdValue'
+    directiveLeafAttributeClass: 'directiveLeafAttributeClass'
+    directiveLeafAttributeClassValue: 'directiveLeafAttributeClassValue'
+    directiveLeafAttributeName: 'directiveLeafAttributeName'
+    directiveLeafAttributeInitializerMarker: 'directiveLeafAttributeInitializerMarker'
+    directiveLeafAttributeValueLiteral: 'directiveLeafAttributeValueLiteral'
+    directiveLeafAttributeValue: 'directiveLeafAttributeValue'
+    directiveLeafAttributeValueMarker: 'directiveLeafAttributeValueMarker'
+    directiveLeafAttributeValueData: 'directiveLeafAttributeValueData'
+    directiveLeafLabel: 'directiveLeafLabel'
+    directiveLeafLabelMarker: 'directiveLeafLabelMarker'
+    directiveLeafLabelString: 'directiveLeafLabelString'
+    directiveLeafName: 'directiveLeafName'
+    directiveLeafSequence: 'directiveLeafSequence'
+
+    directiveText: 'directiveText'
+    directiveTextAttributes: 'directiveTextAttributes'
+    directiveTextAttributesMarker: 'directiveTextAttributesMarker'
+    directiveTextAttribute: 'directiveTextAttribute'
+    directiveTextAttributeId: 'directiveTextAttributeId'
+    directiveTextAttributeIdValue: 'directiveTextAttributeIdValue'
+    directiveTextAttributeClass: 'directiveTextAttributeClass'
+    directiveTextAttributeClassValue: 'directiveTextAttributeClassValue'
+    directiveTextAttributeName: 'directiveTextAttributeName'
+    directiveTextAttributeInitializerMarker: 'directiveTextAttributeInitializerMarker'
+    directiveTextAttributeValueLiteral: 'directiveTextAttributeValueLiteral'
+    directiveTextAttributeValue: 'directiveTextAttributeValue'
+    directiveTextAttributeValueMarker: 'directiveTextAttributeValueMarker'
+    directiveTextAttributeValueData: 'directiveTextAttributeValueData'
+    directiveTextLabel: 'directiveTextLabel'
+    directiveTextLabelMarker: 'directiveTextLabelMarker'
+    directiveTextLabelString: 'directiveTextLabelString'
+    directiveTextMarker: 'directiveTextMarker'
+    directiveTextName: 'directiveTextName'
+  }
+
+  interface CompileData {
+    directiveAttributes?: Attribute[]
+    directiveStack?: Directive[]
+  }
+}

node_modules/micromark-extension-directive/dev/index.js

@@ -0,0 +1,3 @@
+// Note: more types exported from `index.d.ts`.
+export {directive} from './lib/syntax.js'
+export {directiveHtml} from './lib/html.js'

node_modules/micromark-extension-directive/dev/lib/directive-container.d.ts

@@ -0,0 +1,7 @@
+/** @type {Construct} */
+export const directiveContainer: Construct
+export type Construct = import('micromark-util-types').Construct
+export type State = import('micromark-util-types').State
+export type Token = import('micromark-util-types').Token
+export type TokenizeContext = import('micromark-util-types').TokenizeContext
+export type Tokenizer = import('micromark-util-types').Tokenizer

node_modules/micromark-extension-directive/dev/lib/directive-container.js

@@ -0,0 +1,308 @@
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpace} from 'micromark-factory-space'
+import {markdownLineEnding} from 'micromark-util-character'
+import {codes, constants, types} from 'micromark-util-symbol'
+import {factoryAttributes} from './factory-attributes.js'
+import {factoryLabel} from './factory-label.js'
+import {factoryName} from './factory-name.js'
+
+/** @type {Construct} */
+export const directiveContainer = {
+  tokenize: tokenizeDirectiveContainer,
+  concrete: true
+}
+
+const label = {tokenize: tokenizeLabel, partial: true}
+const attributes = {tokenize: tokenizeAttributes, partial: true}
+const nonLazyLine = {tokenize: tokenizeNonLazyLine, partial: true}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeDirectiveContainer(effects, ok, nok) {
+  const self = this
+  const tail = self.events[self.events.length - 1]
+  const initialSize =
+    tail && tail[1].type === types.linePrefix
+      ? tail[2].sliceSerialize(tail[1], true).length
+      : 0
+  let sizeOpen = 0
+  /** @type {Token} */
+  let previous
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(code === codes.colon, 'expected `:`')
+    effects.enter('directiveContainer')
+    effects.enter('directiveContainerFence')
+    effects.enter('directiveContainerSequence')
+    return sequenceOpen(code)
+  }
+
+  /** @type {State} */
+  function sequenceOpen(code) {
+    if (code === codes.colon) {
+      effects.consume(code)
+      sizeOpen++
+      return sequenceOpen
+    }
+
+    if (sizeOpen < constants.codeFencedSequenceSizeMin) {
+      return nok(code)
+    }
+
+    effects.exit('directiveContainerSequence')
+    return factoryName.call(
+      self,
+      effects,
+      afterName,
+      nok,
+      'directiveContainerName'
+    )(code)
+  }
+
+  /** @type {State} */
+  function afterName(code) {
+    return code === codes.leftSquareBracket
+      ? effects.attempt(label, afterLabel, afterLabel)(code)
+      : afterLabel(code)
+  }
+
+  /** @type {State} */
+  function afterLabel(code) {
+    return code === codes.leftCurlyBrace
+      ? effects.attempt(attributes, afterAttributes, afterAttributes)(code)
+      : afterAttributes(code)
+  }
+
+  /** @type {State} */
+  function afterAttributes(code) {
+    return factorySpace(effects, openAfter, types.whitespace)(code)
+  }
+
+  /** @type {State} */
+  function openAfter(code) {
+    effects.exit('directiveContainerFence')
+
+    if (code === codes.eof) {
+      return afterOpening(code)
+    }
+
+    if (markdownLineEnding(code)) {
+      if (self.interrupt) {
+        return ok(code)
+      }
+
+      return effects.attempt(nonLazyLine, contentStart, afterOpening)(code)
+    }
+
+    return nok(code)
+  }
+
+  /** @type {State} */
+  function afterOpening(code) {
+    effects.exit('directiveContainer')
+    return ok(code)
+  }
+
+  /** @type {State} */
+  function contentStart(code) {
+    if (code === codes.eof) {
+      effects.exit('directiveContainer')
+      return ok(code)
+    }
+
+    effects.enter('directiveContainerContent')
+    return lineStart(code)
+  }
+
+  /** @type {State} */
+  function lineStart(code) {
+    if (code === codes.eof) {
+      return after(code)
+    }
+
+    return effects.attempt(
+      {tokenize: tokenizeClosingFence, partial: true},
+      after,
+      initialSize
+        ? factorySpace(effects, chunkStart, types.linePrefix, initialSize + 1)
+        : chunkStart
+    )(code)
+  }
+
+  /** @type {State} */
+  function chunkStart(code) {
+    if (code === codes.eof) {
+      return after(code)
+    }
+
+    const token = effects.enter(types.chunkDocument, {
+      contentType: constants.contentTypeDocument,
+      previous
+    })
+    if (previous) previous.next = token
+    previous = token
+    return contentContinue(code)
+  }
+
+  /** @type {State} */
+  function contentContinue(code) {
+    if (code === codes.eof) {
+      const t = effects.exit(types.chunkDocument)
+      self.parser.lazy[t.start.line] = false
+      return after(code)
+    }
+
+    if (markdownLineEnding(code)) {
+      return effects.check(nonLazyLine, nonLazyLineAfter, lineAfter)(code)
+    }
+
+    effects.consume(code)
+    return contentContinue
+  }
+
+  /** @type {State} */
+  function nonLazyLineAfter(code) {
+    effects.consume(code)
+    const t = effects.exit(types.chunkDocument)
+    self.parser.lazy[t.start.line] = false
+    return lineStart
+  }
+
+  /** @type {State} */
+  function lineAfter(code) {
+    const t = effects.exit(types.chunkDocument)
+    self.parser.lazy[t.start.line] = false
+    return after(code)
+  }
+
+  /** @type {State} */
+  function after(code) {
+    effects.exit('directiveContainerContent')
+    effects.exit('directiveContainer')
+    return ok(code)
+  }
+
+  /**
+   * @this {TokenizeContext}
+   * @type {Tokenizer}
+   */
+  function tokenizeClosingFence(effects, ok, nok) {
+    let size = 0
+
+    return factorySpace(
+      effects,
+      closingPrefixAfter,
+      types.linePrefix,
+      constants.tabSize
+    )
+
+    /** @type {State} */
+    function closingPrefixAfter(code) {
+      effects.enter('directiveContainerFence')
+      effects.enter('directiveContainerSequence')
+      return closingSequence(code)
+    }
+
+    /** @type {State} */
+    function closingSequence(code) {
+      if (code === codes.colon) {
+        effects.consume(code)
+        size++
+        return closingSequence
+      }
+
+      if (size < sizeOpen) return nok(code)
+      effects.exit('directiveContainerSequence')
+      return factorySpace(effects, closingSequenceEnd, types.whitespace)(code)
+    }
+
+    /** @type {State} */
+    function closingSequenceEnd(code) {
+      if (code === codes.eof || markdownLineEnding(code)) {
+        effects.exit('directiveContainerFence')
+        return ok(code)
+      }
+
+      return nok(code)
+    }
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeLabel(effects, ok, nok) {
+  // Always a `[`
+  return factoryLabel(
+    effects,
+    ok,
+    nok,
+    'directiveContainerLabel',
+    'directiveContainerLabelMarker',
+    'directiveContainerLabelString',
+    true
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeAttributes(effects, ok, nok) {
+  // Always a `{`
+  return factoryAttributes(
+    effects,
+    ok,
+    nok,
+    'directiveContainerAttributes',
+    'directiveContainerAttributesMarker',
+    'directiveContainerAttribute',
+    'directiveContainerAttributeId',
+    'directiveContainerAttributeClass',
+    'directiveContainerAttributeName',
+    'directiveContainerAttributeInitializerMarker',
+    'directiveContainerAttributeValueLiteral',
+    'directiveContainerAttributeValue',
+    'directiveContainerAttributeValueMarker',
+    'directiveContainerAttributeValueData',
+    true
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeNonLazyLine(effects, ok, nok) {
+  const self = this
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(markdownLineEnding(code), 'expected eol')
+    effects.enter(types.lineEnding)
+    effects.consume(code)
+    effects.exit(types.lineEnding)
+    return lineStart
+  }
+
+  /** @type {State} */
+  function lineStart(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
+  }
+}

node_modules/micromark-extension-directive/dev/lib/directive-leaf.d.ts

@@ -0,0 +1,6 @@
+/** @type {Construct} */
+export const directiveLeaf: Construct
+export type Construct = import('micromark-util-types').Construct
+export type State = import('micromark-util-types').State
+export type TokenizeContext = import('micromark-util-types').TokenizeContext
+export type Tokenizer = import('micromark-util-types').Tokenizer

node_modules/micromark-extension-directive/dev/lib/directive-leaf.js

@@ -0,0 +1,127 @@
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpace} from 'micromark-factory-space'
+import {markdownLineEnding} from 'micromark-util-character'
+import {codes, types} from 'micromark-util-symbol'
+import {factoryAttributes} from './factory-attributes.js'
+import {factoryLabel} from './factory-label.js'
+import {factoryName} from './factory-name.js'
+
+/** @type {Construct} */
+export const directiveLeaf = {tokenize: tokenizeDirectiveLeaf}
+
+const label = {tokenize: tokenizeLabel, partial: true}
+const attributes = {tokenize: tokenizeAttributes, partial: true}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeDirectiveLeaf(effects, ok, nok) {
+  const self = this
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(code === codes.colon, 'expected `:`')
+    effects.enter('directiveLeaf')
+    effects.enter('directiveLeafSequence')
+    effects.consume(code)
+    return inStart
+  }
+
+  /** @type {State} */
+  function inStart(code) {
+    if (code === codes.colon) {
+      effects.consume(code)
+      effects.exit('directiveLeafSequence')
+      return factoryName.call(
+        self,
+        effects,
+        afterName,
+        nok,
+        'directiveLeafName'
+      )
+    }
+
+    return nok(code)
+  }
+
+  /** @type {State} */
+  function afterName(code) {
+    return code === codes.leftSquareBracket
+      ? effects.attempt(label, afterLabel, afterLabel)(code)
+      : afterLabel(code)
+  }
+
+  /** @type {State} */
+  function afterLabel(code) {
+    return code === codes.leftCurlyBrace
+      ? effects.attempt(attributes, afterAttributes, afterAttributes)(code)
+      : afterAttributes(code)
+  }
+
+  /** @type {State} */
+  function afterAttributes(code) {
+    return factorySpace(effects, end, types.whitespace)(code)
+  }
+
+  /** @type {State} */
+  function end(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit('directiveLeaf')
+      return ok(code)
+    }
+
+    return nok(code)
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeLabel(effects, ok, nok) {
+  // Always a `[`
+  return factoryLabel(
+    effects,
+    ok,
+    nok,
+    'directiveLeafLabel',
+    'directiveLeafLabelMarker',
+    'directiveLeafLabelString',
+    true
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeAttributes(effects, ok, nok) {
+  // Always a `{`
+  return factoryAttributes(
+    effects,
+    ok,
+    nok,
+    'directiveLeafAttributes',
+    'directiveLeafAttributesMarker',
+    'directiveLeafAttribute',
+    'directiveLeafAttributeId',
+    'directiveLeafAttributeClass',
+    'directiveLeafAttributeName',
+    'directiveLeafAttributeInitializerMarker',
+    'directiveLeafAttributeValueLiteral',
+    'directiveLeafAttributeValue',
+    'directiveLeafAttributeValueMarker',
+    'directiveLeafAttributeValueData',
+    true
+  )
+}

node_modules/micromark-extension-directive/dev/lib/directive-text.d.ts

@@ -0,0 +1,7 @@
+/** @type {Construct} */
+export const directiveText: Construct
+export type Construct = import('micromark-util-types').Construct
+export type Previous = import('micromark-util-types').Previous
+export type State = import('micromark-util-types').State
+export type TokenizeContext = import('micromark-util-types').TokenizeContext
+export type Tokenizer = import('micromark-util-types').Tokenizer

node_modules/micromark-extension-directive/dev/lib/directive-text.js

@@ -0,0 +1,117 @@
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Previous} Previous
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ */
+
+import {ok as assert} from 'devlop'
+import {codes, types} from 'micromark-util-symbol'
+import {factoryAttributes} from './factory-attributes.js'
+import {factoryLabel} from './factory-label.js'
+import {factoryName} from './factory-name.js'
+
+/** @type {Construct} */
+export const directiveText = {
+  tokenize: tokenizeDirectiveText,
+  previous
+}
+
+const label = {tokenize: tokenizeLabel, partial: true}
+const attributes = {tokenize: tokenizeAttributes, partial: true}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Previous}
+ */
+function previous(code) {
+  // If there is a previous code, there will always be a tail.
+  return (
+    code !== codes.colon ||
+    this.events[this.events.length - 1][1].type === types.characterEscape
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeDirectiveText(effects, ok, nok) {
+  const self = this
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(code === codes.colon, 'expected `:`')
+    assert(previous.call(self, self.previous), 'expected correct previous')
+    effects.enter('directiveText')
+    effects.enter('directiveTextMarker')
+    effects.consume(code)
+    effects.exit('directiveTextMarker')
+    return factoryName.call(self, effects, afterName, nok, 'directiveTextName')
+  }
+
+  /** @type {State} */
+  function afterName(code) {
+    return code === codes.colon
+      ? nok(code)
+      : code === codes.leftSquareBracket
+      ? effects.attempt(label, afterLabel, afterLabel)(code)
+      : afterLabel(code)
+  }
+
+  /** @type {State} */
+  function afterLabel(code) {
+    return code === codes.leftCurlyBrace
+      ? effects.attempt(attributes, afterAttributes, afterAttributes)(code)
+      : afterAttributes(code)
+  }
+
+  /** @type {State} */
+  function afterAttributes(code) {
+    effects.exit('directiveText')
+    return ok(code)
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeLabel(effects, ok, nok) {
+  // Always a `[`
+  return factoryLabel(
+    effects,
+    ok,
+    nok,
+    'directiveTextLabel',
+    'directiveTextLabelMarker',
+    'directiveTextLabelString'
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeAttributes(effects, ok, nok) {
+  // Always a `{`
+  return factoryAttributes(
+    effects,
+    ok,
+    nok,
+    'directiveTextAttributes',
+    'directiveTextAttributesMarker',
+    'directiveTextAttribute',
+    'directiveTextAttributeId',
+    'directiveTextAttributeClass',
+    'directiveTextAttributeName',
+    'directiveTextAttributeInitializerMarker',
+    'directiveTextAttributeValueLiteral',
+    'directiveTextAttributeValue',
+    'directiveTextAttributeValueMarker',
+    'directiveTextAttributeValueData'
+  )
+}

node_modules/micromark-extension-directive/dev/lib/factory-attributes.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} attributesType
+ * @param {TokenType} attributesMarkerType
+ * @param {TokenType} attributeType
+ * @param {TokenType} attributeIdType
+ * @param {TokenType} attributeClassType
+ * @param {TokenType} attributeNameType
+ * @param {TokenType} attributeInitializerType
+ * @param {TokenType} attributeValueLiteralType
+ * @param {TokenType} attributeValueType
+ * @param {TokenType} attributeValueMarker
+ * @param {TokenType} attributeValueData
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryAttributes(
+  effects: Effects,
+  ok: State,
+  nok: State,
+  attributesType: TokenType,
+  attributesMarkerType: TokenType,
+  attributeType: TokenType,
+  attributeIdType: TokenType,
+  attributeClassType: TokenType,
+  attributeNameType: TokenType,
+  attributeInitializerType: TokenType,
+  attributeValueLiteralType: TokenType,
+  attributeValueType: TokenType,
+  attributeValueMarker: TokenType,
+  attributeValueData: TokenType,
+  disallowEol?: boolean | undefined
+): (
+  code: import('micromark-util-types').Code
+) => import('micromark-util-types').State | undefined
+export type Code = import('micromark-util-types').Code
+export type Effects = import('micromark-util-types').Effects
+export type State = import('micromark-util-types').State
+export type TokenType = import('micromark-util-types').TokenType

node_modules/micromark-extension-directive/dev/lib/factory-attributes.js

@@ -0,0 +1,341 @@
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenType} TokenType
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpace} from 'micromark-factory-space'
+import {factoryWhitespace} from 'micromark-factory-whitespace'
+import {
+  asciiAlpha,
+  asciiAlphanumeric,
+  markdownLineEnding,
+  markdownLineEndingOrSpace,
+  markdownSpace
+} from 'micromark-util-character'
+import {codes, types} from 'micromark-util-symbol'
+
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} attributesType
+ * @param {TokenType} attributesMarkerType
+ * @param {TokenType} attributeType
+ * @param {TokenType} attributeIdType
+ * @param {TokenType} attributeClassType
+ * @param {TokenType} attributeNameType
+ * @param {TokenType} attributeInitializerType
+ * @param {TokenType} attributeValueLiteralType
+ * @param {TokenType} attributeValueType
+ * @param {TokenType} attributeValueMarker
+ * @param {TokenType} attributeValueData
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryAttributes(
+  effects,
+  ok,
+  nok,
+  attributesType,
+  attributesMarkerType,
+  attributeType,
+  attributeIdType,
+  attributeClassType,
+  attributeNameType,
+  attributeInitializerType,
+  attributeValueLiteralType,
+  attributeValueType,
+  attributeValueMarker,
+  attributeValueData,
+  disallowEol
+) {
+  /** @type {TokenType} */
+  let type
+  /** @type {Code | undefined} */
+  let marker
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(code === codes.leftCurlyBrace, 'expected `{`')
+    effects.enter(attributesType)
+    effects.enter(attributesMarkerType)
+    effects.consume(code)
+    effects.exit(attributesMarkerType)
+    return between
+  }
+
+  /** @type {State} */
+  function between(code) {
+    if (code === codes.numberSign) {
+      type = attributeIdType
+      return shortcutStart(code)
+    }
+
+    if (code === codes.dot) {
+      type = attributeClassType
+      return shortcutStart(code)
+    }
+
+    if (code === codes.colon || code === codes.underscore || asciiAlpha(code)) {
+      effects.enter(attributeType)
+      effects.enter(attributeNameType)
+      effects.consume(code)
+      return name
+    }
+
+    if (disallowEol && markdownSpace(code)) {
+      return factorySpace(effects, between, types.whitespace)(code)
+    }
+
+    if (!disallowEol && markdownLineEndingOrSpace(code)) {
+      return factoryWhitespace(effects, between)(code)
+    }
+
+    return end(code)
+  }
+
+  /** @type {State} */
+  function shortcutStart(code) {
+    // Assume it’s registered.
+    const markerType = /** @type {TokenType} */ (type + 'Marker')
+    effects.enter(attributeType)
+    effects.enter(type)
+    effects.enter(markerType)
+    effects.consume(code)
+    effects.exit(markerType)
+    return shortcutStartAfter
+  }
+
+  /** @type {State} */
+  function shortcutStartAfter(code) {
+    if (
+      code === codes.eof ||
+      code === codes.quotationMark ||
+      code === codes.numberSign ||
+      code === codes.apostrophe ||
+      code === codes.dot ||
+      code === codes.lessThan ||
+      code === codes.equalsTo ||
+      code === codes.greaterThan ||
+      code === codes.graveAccent ||
+      code === codes.rightCurlyBrace ||
+      markdownLineEndingOrSpace(code)
+    ) {
+      return nok(code)
+    }
+
+    // Assume it’s registered.
+    const valueType = /** @type {TokenType} */ (type + 'Value')
+    effects.enter(valueType)
+    effects.consume(code)
+    return shortcut
+  }
+
+  /** @type {State} */
+  function shortcut(code) {
+    if (
+      code === codes.eof ||
+      code === codes.quotationMark ||
+      code === codes.apostrophe ||
+      code === codes.lessThan ||
+      code === codes.equalsTo ||
+      code === codes.greaterThan ||
+      code === codes.graveAccent
+    ) {
+      return nok(code)
+    }
+
+    if (
+      code === codes.numberSign ||
+      code === codes.dot ||
+      code === codes.rightCurlyBrace ||
+      markdownLineEndingOrSpace(code)
+    ) {
+      // Assume it’s registered.
+      const valueType = /** @type {TokenType} */ (type + 'Value')
+      effects.exit(valueType)
+      effects.exit(type)
+      effects.exit(attributeType)
+      return between(code)
+    }
+
+    effects.consume(code)
+    return shortcut
+  }
+
+  /** @type {State} */
+  function name(code) {
+    if (
+      code === codes.dash ||
+      code === codes.dot ||
+      code === codes.colon ||
+      code === codes.underscore ||
+      asciiAlphanumeric(code)
+    ) {
+      effects.consume(code)
+      return name
+    }
+
+    effects.exit(attributeNameType)
+
+    if (disallowEol && markdownSpace(code)) {
+      return factorySpace(effects, nameAfter, types.whitespace)(code)
+    }
+
+    if (!disallowEol && markdownLineEndingOrSpace(code)) {
+      return factoryWhitespace(effects, nameAfter)(code)
+    }
+
+    return nameAfter(code)
+  }
+
+  /** @type {State} */
+  function nameAfter(code) {
+    if (code === codes.equalsTo) {
+      effects.enter(attributeInitializerType)
+      effects.consume(code)
+      effects.exit(attributeInitializerType)
+      return valueBefore
+    }
+
+    // Attribute w/o value.
+    effects.exit(attributeType)
+    return between(code)
+  }
+
+  /** @type {State} */
+  function valueBefore(code) {
+    if (
+      code === codes.eof ||
+      code === codes.lessThan ||
+      code === codes.equalsTo ||
+      code === codes.greaterThan ||
+      code === codes.graveAccent ||
+      code === codes.rightCurlyBrace ||
+      (disallowEol && markdownLineEnding(code))
+    ) {
+      return nok(code)
+    }
+
+    if (code === codes.quotationMark || code === codes.apostrophe) {
+      effects.enter(attributeValueLiteralType)
+      effects.enter(attributeValueMarker)
+      effects.consume(code)
+      effects.exit(attributeValueMarker)
+      marker = code
+      return valueQuotedStart
+    }
+
+    if (disallowEol && markdownSpace(code)) {
+      return factorySpace(effects, valueBefore, types.whitespace)(code)
+    }
+
+    if (!disallowEol && markdownLineEndingOrSpace(code)) {
+      return factoryWhitespace(effects, valueBefore)(code)
+    }
+
+    effects.enter(attributeValueType)
+    effects.enter(attributeValueData)
+    effects.consume(code)
+    marker = undefined
+    return valueUnquoted
+  }
+
+  /** @type {State} */
+  function valueUnquoted(code) {
+    if (
+      code === codes.eof ||
+      code === codes.quotationMark ||
+      code === codes.apostrophe ||
+      code === codes.lessThan ||
+      code === codes.equalsTo ||
+      code === codes.greaterThan ||
+      code === codes.graveAccent
+    ) {
+      return nok(code)
+    }
+
+    if (code === codes.rightCurlyBrace || markdownLineEndingOrSpace(code)) {
+      effects.exit(attributeValueData)
+      effects.exit(attributeValueType)
+      effects.exit(attributeType)
+      return between(code)
+    }
+
+    effects.consume(code)
+    return valueUnquoted
+  }
+
+  /** @type {State} */
+  function valueQuotedStart(code) {
+    if (code === marker) {
+      effects.enter(attributeValueMarker)
+      effects.consume(code)
+      effects.exit(attributeValueMarker)
+      effects.exit(attributeValueLiteralType)
+      effects.exit(attributeType)
+      return valueQuotedAfter
+    }
+
+    effects.enter(attributeValueType)
+    return valueQuotedBetween(code)
+  }
+
+  /** @type {State} */
+  function valueQuotedBetween(code) {
+    if (code === marker) {
+      effects.exit(attributeValueType)
+      return valueQuotedStart(code)
+    }
+
+    if (code === codes.eof) {
+      return nok(code)
+    }
+
+    // Note: blank lines can’t exist in content.
+    if (markdownLineEnding(code)) {
+      return disallowEol
+        ? nok(code)
+        : factoryWhitespace(effects, valueQuotedBetween)(code)
+    }
+
+    effects.enter(attributeValueData)
+    effects.consume(code)
+    return valueQuoted
+  }
+
+  /** @type {State} */
+  function valueQuoted(code) {
+    if (code === marker || code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(attributeValueData)
+      return valueQuotedBetween(code)
+    }
+
+    effects.consume(code)
+    return valueQuoted
+  }
+
+  /** @type {State} */
+  function valueQuotedAfter(code) {
+    return code === codes.rightCurlyBrace || markdownLineEndingOrSpace(code)
+      ? between(code)
+      : end(code)
+  }
+
+  /** @type {State} */
+  function end(code) {
+    if (code === codes.rightCurlyBrace) {
+      effects.enter(attributesMarkerType)
+      effects.consume(code)
+      effects.exit(attributesMarkerType)
+      effects.exit(attributesType)
+      return ok
+    }
+
+    return nok(code)
+  }
+}

node_modules/micromark-extension-directive/dev/lib/factory-label.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} type
+ * @param {TokenType} markerType
+ * @param {TokenType} stringType
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryLabel(
+  effects: Effects,
+  ok: State,
+  nok: State,
+  type: TokenType,
+  markerType: TokenType,
+  stringType: TokenType,
+  disallowEol?: boolean | undefined
+): (
+  code: import('micromark-util-types').Code
+) => import('micromark-util-types').State | undefined
+export type Effects = import('micromark-util-types').Effects
+export type State = import('micromark-util-types').State
+export type Token = import('micromark-util-types').Token
+export type TokenType = import('micromark-util-types').TokenType

node_modules/micromark-extension-directive/dev/lib/factory-label.js

@@ -0,0 +1,137 @@
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').TokenType} TokenType
+ */
+
+import {ok as assert} from 'devlop'
+import {markdownLineEnding} from 'micromark-util-character'
+import {codes, constants, types} from 'micromark-util-symbol'
+
+// This is a fork of:
+// <https://github.com/micromark/micromark/tree/main/packages/micromark-factory-label>
+// to allow empty labels, balanced brackets (such as for nested directives),
+// text instead of strings, and optionally disallows EOLs.
+
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} type
+ * @param {TokenType} markerType
+ * @param {TokenType} stringType
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryLabel(
+  effects,
+  ok,
+  nok,
+  type,
+  markerType,
+  stringType,
+  disallowEol
+) {
+  let size = 0
+  let balance = 0
+  /** @type {Token | undefined} */
+  let previous
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(code === codes.leftSquareBracket, 'expected `[`')
+    effects.enter(type)
+    effects.enter(markerType)
+    effects.consume(code)
+    effects.exit(markerType)
+    return afterStart
+  }
+
+  /** @type {State} */
+  function afterStart(code) {
+    if (code === codes.rightSquareBracket) {
+      effects.enter(markerType)
+      effects.consume(code)
+      effects.exit(markerType)
+      effects.exit(type)
+      return ok
+    }
+
+    effects.enter(stringType)
+    return lineStart(code)
+  }
+
+  /** @type {State} */
+  function lineStart(code) {
+    if (code === codes.rightSquareBracket && !balance) {
+      return atClosingBrace(code)
+    }
+
+    const token = effects.enter(types.chunkText, {
+      contentType: constants.contentTypeText,
+      previous
+    })
+    if (previous) previous.next = token
+    previous = token
+    return data(code)
+  }
+
+  /** @type {State} */
+  function data(code) {
+    if (code === codes.eof || size > constants.linkReferenceSizeMax) {
+      return nok(code)
+    }
+
+    if (
+      code === codes.leftSquareBracket &&
+      ++balance > constants.linkResourceDestinationBalanceMax
+    ) {
+      return nok(code)
+    }
+
+    if (code === codes.rightSquareBracket && !balance--) {
+      effects.exit(types.chunkText)
+      return atClosingBrace(code)
+    }
+
+    if (markdownLineEnding(code)) {
+      if (disallowEol) {
+        return nok(code)
+      }
+
+      effects.consume(code)
+      effects.exit(types.chunkText)
+      return lineStart
+    }
+
+    effects.consume(code)
+    return code === codes.backslash ? dataEscape : data
+  }
+
+  /** @type {State} */
+  function dataEscape(code) {
+    if (
+      code === codes.leftSquareBracket ||
+      code === codes.backslash ||
+      code === codes.rightSquareBracket
+    ) {
+      effects.consume(code)
+      size++
+      return data
+    }
+
+    return data(code)
+  }
+
+  /** @type {State} */
+  function atClosingBrace(code) {
+    effects.exit(stringType)
+    effects.enter(markerType)
+    effects.consume(code)
+    effects.exit(markerType)
+    effects.exit(type)
+    return ok
+  }
+}

node_modules/micromark-extension-directive/dev/lib/factory-name.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @this {TokenizeContext}
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} type
+ */
+export function factoryName(
+  this: import('micromark-util-types').TokenizeContext,
+  effects: Effects,
+  ok: State,
+  nok: State,
+  type: TokenType
+): (
+  code: import('micromark-util-types').Code
+) => import('micromark-util-types').State | undefined
+export type Effects = import('micromark-util-types').Effects
+export type State = import('micromark-util-types').State
+export type TokenizeContext = import('micromark-util-types').TokenizeContext
+export type TokenType = import('micromark-util-types').TokenType

node_modules/micromark-extension-directive/dev/lib/factory-name.js

@@ -0,0 +1,50 @@
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').TokenType} TokenType
+ */
+
+import {asciiAlpha, asciiAlphanumeric} from 'micromark-util-character'
+import {codes} from 'micromark-util-symbol'
+
+/**
+ * @this {TokenizeContext}
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} type
+ */
+export function factoryName(effects, ok, nok, type) {
+  const self = this
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    if (asciiAlpha(code)) {
+      effects.enter(type)
+      effects.consume(code)
+      return name
+    }
+
+    return nok(code)
+  }
+
+  /** @type {State} */
+  function name(code) {
+    if (
+      code === codes.dash ||
+      code === codes.underscore ||
+      asciiAlphanumeric(code)
+    ) {
+      effects.consume(code)
+      return name
+    }
+
+    effects.exit(type)
+    return self.previous === codes.dash || self.previous === codes.underscore
+      ? nok(code)
+      : ok(code)
+  }
+}

node_modules/micromark-extension-directive/dev/lib/html.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Create an extension for `micromark` to support directives when serializing
+ * to HTML.
+ *
+ * @param {HtmlOptions | null | undefined} [options={}]
+ *   Configuration (default: `{}`).
+ * @returns {HtmlExtension}
+ *   Extension for `micromark` that can be passed in `htmlExtensions`, to
+ *   support directives when serializing to HTML.
+ */
+export function directiveHtml(
+  options?: HtmlOptions | null | undefined
+): HtmlExtension
+export type CompileContext = import('micromark-util-types').CompileContext
+export type _Handle = import('micromark-util-types').Handle
+export type HtmlExtension = import('micromark-util-types').HtmlExtension
+/**
+ * Internal tuple representing an attribute.
+ */
+export type Attribute = [string, string]
+/**
+ * Configuration.
+ *
+ * > 👉 **Note**: the special field `'*'` can be used to specify a fallback
+ * > handle to handle all otherwise unhandled directives.
+ */
+export type HtmlOptions = Record<string, Handle>
+/**
+ * Handle a directive.
+ */
+export type Handle = (
+  this: CompileContext,
+  directive: Directive
+) => boolean | undefined
+/**
+ * Structure representing a directive.
+ */
+export type Directive = {
+  /**
+   *   Kind.
+   */
+  type: DirectiveType
+  /**
+   *   Name of directive.
+   */
+  name: string
+  /**
+   * Compiled HTML content that was in `[brackets]`.
+   */
+  label?: string | undefined
+  /**
+   * Object w/ HTML attributes.
+   */
+  attributes?: Record<string, string> | undefined
+  /**
+   * Compiled HTML content inside container directive.
+   */
+  content?: string | undefined
+  /**
+   * Private :)
+   */
+  _fenceCount?: number | undefined
+}
+/**
+ * Kind.
+ */
+export type DirectiveType =
+  | 'containerDirective'
+  | 'leafDirective'
+  | 'textDirective'

node_modules/micromark-extension-directive/dev/lib/html.js

@@ -0,0 +1,308 @@
+/**
+ * @typedef {import('micromark-util-types').CompileContext} CompileContext
+ * @typedef {import('micromark-util-types').Handle} _Handle
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ */
+
+/**
+ * @typedef {[string, string]} Attribute
+ *   Internal tuple representing an attribute.
+ */
+
+/**
+ * @typedef {Record<string, Handle>} HtmlOptions
+ *   Configuration.
+ *
+ *   > 👉 **Note**: the special field `'*'` can be used to specify a fallback
+ *   > handle to handle all otherwise unhandled directives.
+ *
+ * @callback Handle
+ *   Handle a directive.
+ * @param {CompileContext} this
+ *   Current context.
+ * @param {Directive} directive
+ *   Directive.
+ * @returns {boolean | undefined}
+ *   Signal whether the directive was handled.
+ *
+ *   Yield `false` to let the fallback (a special handle for `'*'`) handle it.
+ *
+ * @typedef Directive
+ *   Structure representing a directive.
+ * @property {DirectiveType} type
+ *   Kind.
+ * @property {string} name
+ *   Name of directive.
+ * @property {string | undefined} [label]
+ *   Compiled HTML content that was in `[brackets]`.
+ * @property {Record<string, string> | undefined} [attributes]
+ *   Object w/ HTML attributes.
+ * @property {string | undefined} [content]
+ *   Compiled HTML content inside container directive.
+ * @property {number | undefined} [_fenceCount]
+ *   Private :)
+ *
+ * @typedef {'containerDirective' | 'leafDirective' | 'textDirective'} DirectiveType
+ *   Kind.
+ */
+
+import {ok as assert} from 'devlop'
+import {parseEntities} from 'parse-entities'
+
+const own = {}.hasOwnProperty
+
+/**
+ * Create an extension for `micromark` to support directives when serializing
+ * to HTML.
+ *
+ * @param {HtmlOptions | null | undefined} [options={}]
+ *   Configuration (default: `{}`).
+ * @returns {HtmlExtension}
+ *   Extension for `micromark` that can be passed in `htmlExtensions`, to
+ *   support directives when serializing to HTML.
+ */
+export function directiveHtml(options) {
+  const options_ = options || {}
+  return {
+    enter: {
+      directiveContainer() {
+        enter.call(this, 'containerDirective')
+      },
+      directiveContainerAttributes: enterAttributes,
+      directiveContainerLabel: enterLabel,
+      directiveContainerContent() {
+        this.buffer()
+      },
+
+      directiveLeaf() {
+        enter.call(this, 'leafDirective')
+      },
+      directiveLeafAttributes: enterAttributes,
+      directiveLeafLabel: enterLabel,
+
+      directiveText() {
+        enter.call(this, 'textDirective')
+      },
+      directiveTextAttributes: enterAttributes,
+      directiveTextLabel: enterLabel
+    },
+    exit: {
+      directiveContainer: exit,
+      directiveContainerAttributeClassValue: exitAttributeClassValue,
+      directiveContainerAttributeIdValue: exitAttributeIdValue,
+      directiveContainerAttributeName: exitAttributeName,
+      directiveContainerAttributeValue: exitAttributeValue,
+      directiveContainerAttributes: exitAttributes,
+      directiveContainerContent: exitContainerContent,
+      directiveContainerFence: exitContainerFence,
+      directiveContainerLabel: exitLabel,
+      directiveContainerName: exitName,
+
+      directiveLeaf: exit,
+      directiveLeafAttributeClassValue: exitAttributeClassValue,
+      directiveLeafAttributeIdValue: exitAttributeIdValue,
+      directiveLeafAttributeName: exitAttributeName,
+      directiveLeafAttributeValue: exitAttributeValue,
+      directiveLeafAttributes: exitAttributes,
+      directiveLeafLabel: exitLabel,
+      directiveLeafName: exitName,
+
+      directiveText: exit,
+      directiveTextAttributeClassValue: exitAttributeClassValue,
+      directiveTextAttributeIdValue: exitAttributeIdValue,
+      directiveTextAttributeName: exitAttributeName,
+      directiveTextAttributeValue: exitAttributeValue,
+      directiveTextAttributes: exitAttributes,
+      directiveTextLabel: exitLabel,
+      directiveTextName: exitName
+    }
+  }
+
+  /**
+   * @this {CompileContext}
+   * @param {DirectiveType} type
+   */
+  function enter(type) {
+    let stack = this.getData('directiveStack')
+    if (!stack) this.setData('directiveStack', (stack = []))
+    stack.push({type, name: ''})
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitName(token) {
+    const stack = this.getData('directiveStack')
+    assert(stack, 'expected directive stack')
+    stack[stack.length - 1].name = this.sliceSerialize(token)
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function enterLabel() {
+    this.buffer()
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitLabel() {
+    const data = this.resume()
+    const stack = this.getData('directiveStack')
+    assert(stack, 'expected directive stack')
+    stack[stack.length - 1].label = data
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function enterAttributes() {
+    this.buffer()
+    this.setData('directiveAttributes', [])
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributeIdValue(token) {
+    const attributes = this.getData('directiveAttributes')
+    assert(attributes, 'expected attributes')
+    attributes.push([
+      'id',
+      parseEntities(this.sliceSerialize(token), {
+        attribute: true
+      })
+    ])
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributeClassValue(token) {
+    const attributes = this.getData('directiveAttributes')
+    assert(attributes, 'expected attributes')
+
+    attributes.push([
+      'class',
+      parseEntities(this.sliceSerialize(token), {
+        attribute: true
+      })
+    ])
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributeName(token) {
+    // Attribute names in CommonMark are significantly limited, so character
+    // references can’t exist.
+    const attributes = this.getData('directiveAttributes')
+    assert(attributes, 'expected attributes')
+
+    attributes.push([this.sliceSerialize(token), ''])
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributeValue(token) {
+    const attributes = this.getData('directiveAttributes')
+    assert(attributes, 'expected attributes')
+    attributes[attributes.length - 1][1] = parseEntities(
+      this.sliceSerialize(token),
+      {attribute: true}
+    )
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributes() {
+    const stack = this.getData('directiveStack')
+    assert(stack, 'expected directive stack')
+    const attributes = this.getData('directiveAttributes')
+    assert(attributes, 'expected attributes')
+    /** @type {Directive['attributes']} */
+    const cleaned = {}
+    let index = -1
+
+    while (++index < attributes.length) {
+      const attribute = attributes[index]
+
+      if (attribute[0] === 'class' && cleaned.class) {
+        cleaned.class += ' ' + attribute[1]
+      } else {
+        cleaned[attribute[0]] = attribute[1]
+      }
+    }
+
+    this.resume()
+    this.setData('directiveAttributes')
+    stack[stack.length - 1].attributes = cleaned
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitContainerContent() {
+    const data = this.resume()
+    const stack = this.getData('directiveStack')
+    assert(stack, 'expected directive stack')
+    stack[stack.length - 1].content = data
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitContainerFence() {
+    const stack = this.getData('directiveStack')
+    assert(stack, 'expected directive stack')
+    const directive = stack[stack.length - 1]
+    if (!directive._fenceCount) directive._fenceCount = 0
+    directive._fenceCount++
+    if (directive._fenceCount === 1) this.setData('slurpOneLineEnding', true)
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exit() {
+    const stack = this.getData('directiveStack')
+    assert(stack, 'expected directive stack')
+    const directive = stack.pop()
+    assert(directive, 'expected directive')
+    /** @type {boolean | undefined} */
+    let found
+    /** @type {boolean | undefined} */
+    let result
+
+    assert(directive.name, 'expected `name`')
+
+    if (own.call(options_, directive.name)) {
+      result = options_[directive.name].call(this, directive)
+      found = result !== false
+    }
+
+    if (!found && own.call(options_, '*')) {
+      result = options_['*'].call(this, directive)
+      found = result !== false
+    }
+
+    if (!found && directive.type !== 'textDirective') {
+      this.setData('slurpOneLineEnding', true)
+    }
+  }
+}

node_modules/micromark-extension-directive/dev/lib/syntax.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Create an extension for `micromark` to enable directive syntax.
+ *
+ * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions`, to
+ *   enable directive syntax.
+ */
+export function directive(): Extension
+export type Extension = import('micromark-util-types').Extension

node_modules/micromark-extension-directive/dev/lib/syntax.js

@@ -0,0 +1,22 @@
+/**
+ * @typedef {import('micromark-util-types').Extension} Extension
+ */
+
+import {codes} from 'micromark-util-symbol'
+import {directiveContainer} from './directive-container.js'
+import {directiveLeaf} from './directive-leaf.js'
+import {directiveText} from './directive-text.js'
+
+/**
+ * Create an extension for `micromark` to enable directive syntax.
+ *
+ * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions`, to
+ *   enable directive syntax.
+ */
+export function directive() {
+  return {
+    text: {[codes.colon]: directiveText},
+    flow: {[codes.colon]: [directiveContainer, directiveLeaf]}
+  }
+}

node_modules/micromark-extension-directive/index.d.ts

@@ -0,0 +1,80 @@
+import type {Attribute, Directive} from './lib/html.js'
+
+export {directive} from './lib/syntax.js'
+export {
+  directiveHtml,
+  type Directive,
+  type Handle,
+  type HtmlOptions
+} from './lib/html.js'
+
+declare module 'micromark-util-types' {
+  interface TokenTypeMap {
+    directiveContainer: 'directiveContainer'
+    directiveContainerAttributes: 'directiveContainerAttributes'
+    directiveContainerAttributesMarker: 'directiveContainerAttributesMarker'
+    directiveContainerAttribute: 'directiveContainerAttribute'
+    directiveContainerAttributeId: 'directiveContainerAttributeId'
+    directiveContainerAttributeIdValue: 'directiveContainerAttributeIdValue'
+    directiveContainerAttributeClass: 'directiveContainerAttributeClass'
+    directiveContainerAttributeClassValue: 'directiveContainerAttributeClassValue'
+    directiveContainerAttributeName: 'directiveContainerAttributeName'
+    directiveContainerAttributeInitializerMarker: 'directiveContainerAttributeInitializerMarker'
+    directiveContainerAttributeValueLiteral: 'directiveContainerAttributeValueLiteral'
+    directiveContainerAttributeValue: 'directiveContainerAttributeValue'
+    directiveContainerAttributeValueMarker: 'directiveContainerAttributeValueMarker'
+    directiveContainerAttributeValueData: 'directiveContainerAttributeValueData'
+    directiveContainerContent: 'directiveContainerContent'
+    directiveContainerFence: 'directiveContainerFence'
+    directiveContainerLabel: 'directiveContainerLabel'
+    directiveContainerLabelMarker: 'directiveContainerLabelMarker'
+    directiveContainerLabelString: 'directiveContainerLabelString'
+    directiveContainerName: 'directiveContainerName'
+    directiveContainerSequence: 'directiveContainerSequence'
+
+    directiveLeaf: 'directiveLeaf'
+    directiveLeafAttributes: 'directiveLeafAttributes'
+    directiveLeafAttributesMarker: 'directiveLeafAttributesMarker'
+    directiveLeafAttribute: 'directiveLeafAttribute'
+    directiveLeafAttributeId: 'directiveLeafAttributeId'
+    directiveLeafAttributeIdValue: 'directiveLeafAttributeIdValue'
+    directiveLeafAttributeClass: 'directiveLeafAttributeClass'
+    directiveLeafAttributeClassValue: 'directiveLeafAttributeClassValue'
+    directiveLeafAttributeName: 'directiveLeafAttributeName'
+    directiveLeafAttributeInitializerMarker: 'directiveLeafAttributeInitializerMarker'
+    directiveLeafAttributeValueLiteral: 'directiveLeafAttributeValueLiteral'
+    directiveLeafAttributeValue: 'directiveLeafAttributeValue'
+    directiveLeafAttributeValueMarker: 'directiveLeafAttributeValueMarker'
+    directiveLeafAttributeValueData: 'directiveLeafAttributeValueData'
+    directiveLeafLabel: 'directiveLeafLabel'
+    directiveLeafLabelMarker: 'directiveLeafLabelMarker'
+    directiveLeafLabelString: 'directiveLeafLabelString'
+    directiveLeafName: 'directiveLeafName'
+    directiveLeafSequence: 'directiveLeafSequence'
+
+    directiveText: 'directiveText'
+    directiveTextAttributes: 'directiveTextAttributes'
+    directiveTextAttributesMarker: 'directiveTextAttributesMarker'
+    directiveTextAttribute: 'directiveTextAttribute'
+    directiveTextAttributeId: 'directiveTextAttributeId'
+    directiveTextAttributeIdValue: 'directiveTextAttributeIdValue'
+    directiveTextAttributeClass: 'directiveTextAttributeClass'
+    directiveTextAttributeClassValue: 'directiveTextAttributeClassValue'
+    directiveTextAttributeName: 'directiveTextAttributeName'
+    directiveTextAttributeInitializerMarker: 'directiveTextAttributeInitializerMarker'
+    directiveTextAttributeValueLiteral: 'directiveTextAttributeValueLiteral'
+    directiveTextAttributeValue: 'directiveTextAttributeValue'
+    directiveTextAttributeValueMarker: 'directiveTextAttributeValueMarker'
+    directiveTextAttributeValueData: 'directiveTextAttributeValueData'
+    directiveTextLabel: 'directiveTextLabel'
+    directiveTextLabelMarker: 'directiveTextLabelMarker'
+    directiveTextLabelString: 'directiveTextLabelString'
+    directiveTextMarker: 'directiveTextMarker'
+    directiveTextName: 'directiveTextName'
+  }
+
+  interface CompileData {
+    directiveAttributes?: Attribute[]
+    directiveStack?: Directive[]
+  }
+}

node_modules/micromark-extension-directive/index.js

@@ -0,0 +1,3 @@
+// Note: more types exported from `index.d.ts`.
+export {directive} from './lib/syntax.js'
+export {directiveHtml} from './lib/html.js'

node_modules/micromark-extension-directive/lib/directive-container.d.ts

@@ -0,0 +1,7 @@
+/** @type {Construct} */
+export const directiveContainer: Construct
+export type Construct = import('micromark-util-types').Construct
+export type State = import('micromark-util-types').State
+export type Token = import('micromark-util-types').Token
+export type TokenizeContext = import('micromark-util-types').TokenizeContext
+export type Tokenizer = import('micromark-util-types').Tokenizer

node_modules/micromark-extension-directive/lib/directive-container.js

@@ -0,0 +1,294 @@
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ */
+
+import {factorySpace} from 'micromark-factory-space'
+import {markdownLineEnding} from 'micromark-util-character'
+import {factoryAttributes} from './factory-attributes.js'
+import {factoryLabel} from './factory-label.js'
+import {factoryName} from './factory-name.js'
+
+/** @type {Construct} */
+export const directiveContainer = {
+  tokenize: tokenizeDirectiveContainer,
+  concrete: true
+}
+const label = {
+  tokenize: tokenizeLabel,
+  partial: true
+}
+const attributes = {
+  tokenize: tokenizeAttributes,
+  partial: true
+}
+const nonLazyLine = {
+  tokenize: tokenizeNonLazyLine,
+  partial: true
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeDirectiveContainer(effects, ok, nok) {
+  const self = this
+  const tail = self.events[self.events.length - 1]
+  const initialSize =
+    tail && tail[1].type === 'linePrefix'
+      ? tail[2].sliceSerialize(tail[1], true).length
+      : 0
+  let sizeOpen = 0
+  /** @type {Token} */
+  let previous
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    effects.enter('directiveContainer')
+    effects.enter('directiveContainerFence')
+    effects.enter('directiveContainerSequence')
+    return sequenceOpen(code)
+  }
+
+  /** @type {State} */
+  function sequenceOpen(code) {
+    if (code === 58) {
+      effects.consume(code)
+      sizeOpen++
+      return sequenceOpen
+    }
+    if (sizeOpen < 3) {
+      return nok(code)
+    }
+    effects.exit('directiveContainerSequence')
+    return factoryName.call(
+      self,
+      effects,
+      afterName,
+      nok,
+      'directiveContainerName'
+    )(code)
+  }
+
+  /** @type {State} */
+  function afterName(code) {
+    return code === 91
+      ? effects.attempt(label, afterLabel, afterLabel)(code)
+      : afterLabel(code)
+  }
+
+  /** @type {State} */
+  function afterLabel(code) {
+    return code === 123
+      ? effects.attempt(attributes, afterAttributes, afterAttributes)(code)
+      : afterAttributes(code)
+  }
+
+  /** @type {State} */
+  function afterAttributes(code) {
+    return factorySpace(effects, openAfter, 'whitespace')(code)
+  }
+
+  /** @type {State} */
+  function openAfter(code) {
+    effects.exit('directiveContainerFence')
+    if (code === null) {
+      return afterOpening(code)
+    }
+    if (markdownLineEnding(code)) {
+      if (self.interrupt) {
+        return ok(code)
+      }
+      return effects.attempt(nonLazyLine, contentStart, afterOpening)(code)
+    }
+    return nok(code)
+  }
+
+  /** @type {State} */
+  function afterOpening(code) {
+    effects.exit('directiveContainer')
+    return ok(code)
+  }
+
+  /** @type {State} */
+  function contentStart(code) {
+    if (code === null) {
+      effects.exit('directiveContainer')
+      return ok(code)
+    }
+    effects.enter('directiveContainerContent')
+    return lineStart(code)
+  }
+
+  /** @type {State} */
+  function lineStart(code) {
+    if (code === null) {
+      return after(code)
+    }
+    return effects.attempt(
+      {
+        tokenize: tokenizeClosingFence,
+        partial: true
+      },
+      after,
+      initialSize
+        ? factorySpace(effects, chunkStart, 'linePrefix', initialSize + 1)
+        : chunkStart
+    )(code)
+  }
+
+  /** @type {State} */
+  function chunkStart(code) {
+    if (code === null) {
+      return after(code)
+    }
+    const token = effects.enter('chunkDocument', {
+      contentType: 'document',
+      previous
+    })
+    if (previous) previous.next = token
+    previous = token
+    return contentContinue(code)
+  }
+
+  /** @type {State} */
+  function contentContinue(code) {
+    if (code === null) {
+      const t = effects.exit('chunkDocument')
+      self.parser.lazy[t.start.line] = false
+      return after(code)
+    }
+    if (markdownLineEnding(code)) {
+      return effects.check(nonLazyLine, nonLazyLineAfter, lineAfter)(code)
+    }
+    effects.consume(code)
+    return contentContinue
+  }
+
+  /** @type {State} */
+  function nonLazyLineAfter(code) {
+    effects.consume(code)
+    const t = effects.exit('chunkDocument')
+    self.parser.lazy[t.start.line] = false
+    return lineStart
+  }
+
+  /** @type {State} */
+  function lineAfter(code) {
+    const t = effects.exit('chunkDocument')
+    self.parser.lazy[t.start.line] = false
+    return after(code)
+  }
+
+  /** @type {State} */
+  function after(code) {
+    effects.exit('directiveContainerContent')
+    effects.exit('directiveContainer')
+    return ok(code)
+  }
+
+  /**
+   * @this {TokenizeContext}
+   * @type {Tokenizer}
+   */
+  function tokenizeClosingFence(effects, ok, nok) {
+    let size = 0
+    return factorySpace(effects, closingPrefixAfter, 'linePrefix', 4)
+
+    /** @type {State} */
+    function closingPrefixAfter(code) {
+      effects.enter('directiveContainerFence')
+      effects.enter('directiveContainerSequence')
+      return closingSequence(code)
+    }
+
+    /** @type {State} */
+    function closingSequence(code) {
+      if (code === 58) {
+        effects.consume(code)
+        size++
+        return closingSequence
+      }
+      if (size < sizeOpen) return nok(code)
+      effects.exit('directiveContainerSequence')
+      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)
+    }
+
+    /** @type {State} */
+    function closingSequenceEnd(code) {
+      if (code === null || markdownLineEnding(code)) {
+        effects.exit('directiveContainerFence')
+        return ok(code)
+      }
+      return nok(code)
+    }
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeLabel(effects, ok, nok) {
+  // Always a `[`
+  return factoryLabel(
+    effects,
+    ok,
+    nok,
+    'directiveContainerLabel',
+    'directiveContainerLabelMarker',
+    'directiveContainerLabelString',
+    true
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeAttributes(effects, ok, nok) {
+  // Always a `{`
+  return factoryAttributes(
+    effects,
+    ok,
+    nok,
+    'directiveContainerAttributes',
+    'directiveContainerAttributesMarker',
+    'directiveContainerAttribute',
+    'directiveContainerAttributeId',
+    'directiveContainerAttributeClass',
+    'directiveContainerAttributeName',
+    'directiveContainerAttributeInitializerMarker',
+    'directiveContainerAttributeValueLiteral',
+    'directiveContainerAttributeValue',
+    'directiveContainerAttributeValueMarker',
+    'directiveContainerAttributeValueData',
+    true
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeNonLazyLine(effects, ok, nok) {
+  const self = this
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    effects.enter('lineEnding')
+    effects.consume(code)
+    effects.exit('lineEnding')
+    return lineStart
+  }
+
+  /** @type {State} */
+  function lineStart(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
+  }
+}

node_modules/micromark-extension-directive/lib/directive-leaf.d.ts

@@ -0,0 +1,6 @@
+/** @type {Construct} */
+export const directiveLeaf: Construct
+export type Construct = import('micromark-util-types').Construct
+export type State = import('micromark-util-types').State
+export type TokenizeContext = import('micromark-util-types').TokenizeContext
+export type Tokenizer = import('micromark-util-types').Tokenizer

node_modules/micromark-extension-directive/lib/directive-leaf.js

@@ -0,0 +1,128 @@
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ */
+
+import {factorySpace} from 'micromark-factory-space'
+import {markdownLineEnding} from 'micromark-util-character'
+import {factoryAttributes} from './factory-attributes.js'
+import {factoryLabel} from './factory-label.js'
+import {factoryName} from './factory-name.js'
+
+/** @type {Construct} */
+export const directiveLeaf = {
+  tokenize: tokenizeDirectiveLeaf
+}
+const label = {
+  tokenize: tokenizeLabel,
+  partial: true
+}
+const attributes = {
+  tokenize: tokenizeAttributes,
+  partial: true
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeDirectiveLeaf(effects, ok, nok) {
+  const self = this
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    effects.enter('directiveLeaf')
+    effects.enter('directiveLeafSequence')
+    effects.consume(code)
+    return inStart
+  }
+
+  /** @type {State} */
+  function inStart(code) {
+    if (code === 58) {
+      effects.consume(code)
+      effects.exit('directiveLeafSequence')
+      return factoryName.call(
+        self,
+        effects,
+        afterName,
+        nok,
+        'directiveLeafName'
+      )
+    }
+    return nok(code)
+  }
+
+  /** @type {State} */
+  function afterName(code) {
+    return code === 91
+      ? effects.attempt(label, afterLabel, afterLabel)(code)
+      : afterLabel(code)
+  }
+
+  /** @type {State} */
+  function afterLabel(code) {
+    return code === 123
+      ? effects.attempt(attributes, afterAttributes, afterAttributes)(code)
+      : afterAttributes(code)
+  }
+
+  /** @type {State} */
+  function afterAttributes(code) {
+    return factorySpace(effects, end, 'whitespace')(code)
+  }
+
+  /** @type {State} */
+  function end(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit('directiveLeaf')
+      return ok(code)
+    }
+    return nok(code)
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeLabel(effects, ok, nok) {
+  // Always a `[`
+  return factoryLabel(
+    effects,
+    ok,
+    nok,
+    'directiveLeafLabel',
+    'directiveLeafLabelMarker',
+    'directiveLeafLabelString',
+    true
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeAttributes(effects, ok, nok) {
+  // Always a `{`
+  return factoryAttributes(
+    effects,
+    ok,
+    nok,
+    'directiveLeafAttributes',
+    'directiveLeafAttributesMarker',
+    'directiveLeafAttribute',
+    'directiveLeafAttributeId',
+    'directiveLeafAttributeClass',
+    'directiveLeafAttributeName',
+    'directiveLeafAttributeInitializerMarker',
+    'directiveLeafAttributeValueLiteral',
+    'directiveLeafAttributeValue',
+    'directiveLeafAttributeValueMarker',
+    'directiveLeafAttributeValueData',
+    true
+  )
+}

node_modules/micromark-extension-directive/lib/directive-text.d.ts

@@ -0,0 +1,7 @@
+/** @type {Construct} */
+export const directiveText: Construct
+export type Construct = import('micromark-util-types').Construct
+export type Previous = import('micromark-util-types').Previous
+export type State = import('micromark-util-types').State
+export type TokenizeContext = import('micromark-util-types').TokenizeContext
+export type Tokenizer = import('micromark-util-types').Tokenizer

node_modules/micromark-extension-directive/lib/directive-text.js

@@ -0,0 +1,117 @@
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Previous} Previous
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ */
+
+import {factoryAttributes} from './factory-attributes.js'
+import {factoryLabel} from './factory-label.js'
+import {factoryName} from './factory-name.js'
+
+/** @type {Construct} */
+export const directiveText = {
+  tokenize: tokenizeDirectiveText,
+  previous
+}
+const label = {
+  tokenize: tokenizeLabel,
+  partial: true
+}
+const attributes = {
+  tokenize: tokenizeAttributes,
+  partial: true
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Previous}
+ */
+function previous(code) {
+  // If there is a previous code, there will always be a tail.
+  return (
+    code !== 58 ||
+    this.events[this.events.length - 1][1].type === 'characterEscape'
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeDirectiveText(effects, ok, nok) {
+  const self = this
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    effects.enter('directiveText')
+    effects.enter('directiveTextMarker')
+    effects.consume(code)
+    effects.exit('directiveTextMarker')
+    return factoryName.call(self, effects, afterName, nok, 'directiveTextName')
+  }
+
+  /** @type {State} */
+  function afterName(code) {
+    return code === 58
+      ? nok(code)
+      : code === 91
+      ? effects.attempt(label, afterLabel, afterLabel)(code)
+      : afterLabel(code)
+  }
+
+  /** @type {State} */
+  function afterLabel(code) {
+    return code === 123
+      ? effects.attempt(attributes, afterAttributes, afterAttributes)(code)
+      : afterAttributes(code)
+  }
+
+  /** @type {State} */
+  function afterAttributes(code) {
+    effects.exit('directiveText')
+    return ok(code)
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeLabel(effects, ok, nok) {
+  // Always a `[`
+  return factoryLabel(
+    effects,
+    ok,
+    nok,
+    'directiveTextLabel',
+    'directiveTextLabelMarker',
+    'directiveTextLabelString'
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeAttributes(effects, ok, nok) {
+  // Always a `{`
+  return factoryAttributes(
+    effects,
+    ok,
+    nok,
+    'directiveTextAttributes',
+    'directiveTextAttributesMarker',
+    'directiveTextAttribute',
+    'directiveTextAttributeId',
+    'directiveTextAttributeClass',
+    'directiveTextAttributeName',
+    'directiveTextAttributeInitializerMarker',
+    'directiveTextAttributeValueLiteral',
+    'directiveTextAttributeValue',
+    'directiveTextAttributeValueMarker',
+    'directiveTextAttributeValueData'
+  )
+}

node_modules/micromark-extension-directive/lib/factory-attributes.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} attributesType
+ * @param {TokenType} attributesMarkerType
+ * @param {TokenType} attributeType
+ * @param {TokenType} attributeIdType
+ * @param {TokenType} attributeClassType
+ * @param {TokenType} attributeNameType
+ * @param {TokenType} attributeInitializerType
+ * @param {TokenType} attributeValueLiteralType
+ * @param {TokenType} attributeValueType
+ * @param {TokenType} attributeValueMarker
+ * @param {TokenType} attributeValueData
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryAttributes(
+  effects: Effects,
+  ok: State,
+  nok: State,
+  attributesType: TokenType,
+  attributesMarkerType: TokenType,
+  attributeType: TokenType,
+  attributeIdType: TokenType,
+  attributeClassType: TokenType,
+  attributeNameType: TokenType,
+  attributeInitializerType: TokenType,
+  attributeValueLiteralType: TokenType,
+  attributeValueType: TokenType,
+  attributeValueMarker: TokenType,
+  attributeValueData: TokenType,
+  disallowEol?: boolean | undefined
+): (
+  code: import('micromark-util-types').Code
+) => import('micromark-util-types').State | undefined
+export type Code = import('micromark-util-types').Code
+export type Effects = import('micromark-util-types').Effects
+export type State = import('micromark-util-types').State
+export type TokenType = import('micromark-util-types').TokenType

node_modules/micromark-extension-directive/lib/factory-attributes.js

@@ -0,0 +1,314 @@
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenType} TokenType
+ */
+
+import {factorySpace} from 'micromark-factory-space'
+import {factoryWhitespace} from 'micromark-factory-whitespace'
+import {
+  asciiAlpha,
+  asciiAlphanumeric,
+  markdownLineEnding,
+  markdownLineEndingOrSpace,
+  markdownSpace
+} from 'micromark-util-character'
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} attributesType
+ * @param {TokenType} attributesMarkerType
+ * @param {TokenType} attributeType
+ * @param {TokenType} attributeIdType
+ * @param {TokenType} attributeClassType
+ * @param {TokenType} attributeNameType
+ * @param {TokenType} attributeInitializerType
+ * @param {TokenType} attributeValueLiteralType
+ * @param {TokenType} attributeValueType
+ * @param {TokenType} attributeValueMarker
+ * @param {TokenType} attributeValueData
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryAttributes(
+  effects,
+  ok,
+  nok,
+  attributesType,
+  attributesMarkerType,
+  attributeType,
+  attributeIdType,
+  attributeClassType,
+  attributeNameType,
+  attributeInitializerType,
+  attributeValueLiteralType,
+  attributeValueType,
+  attributeValueMarker,
+  attributeValueData,
+  disallowEol
+) {
+  /** @type {TokenType} */
+  let type
+  /** @type {Code | undefined} */
+  let marker
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    effects.enter(attributesType)
+    effects.enter(attributesMarkerType)
+    effects.consume(code)
+    effects.exit(attributesMarkerType)
+    return between
+  }
+
+  /** @type {State} */
+  function between(code) {
+    if (code === 35) {
+      type = attributeIdType
+      return shortcutStart(code)
+    }
+    if (code === 46) {
+      type = attributeClassType
+      return shortcutStart(code)
+    }
+    if (code === 58 || code === 95 || asciiAlpha(code)) {
+      effects.enter(attributeType)
+      effects.enter(attributeNameType)
+      effects.consume(code)
+      return name
+    }
+    if (disallowEol && markdownSpace(code)) {
+      return factorySpace(effects, between, 'whitespace')(code)
+    }
+    if (!disallowEol && markdownLineEndingOrSpace(code)) {
+      return factoryWhitespace(effects, between)(code)
+    }
+    return end(code)
+  }
+
+  /** @type {State} */
+  function shortcutStart(code) {
+    // Assume it’s registered.
+    const markerType = /** @type {TokenType} */ type + 'Marker'
+    effects.enter(attributeType)
+    effects.enter(type)
+    effects.enter(markerType)
+    effects.consume(code)
+    effects.exit(markerType)
+    return shortcutStartAfter
+  }
+
+  /** @type {State} */
+  function shortcutStartAfter(code) {
+    if (
+      code === null ||
+      code === 34 ||
+      code === 35 ||
+      code === 39 ||
+      code === 46 ||
+      code === 60 ||
+      code === 61 ||
+      code === 62 ||
+      code === 96 ||
+      code === 125 ||
+      markdownLineEndingOrSpace(code)
+    ) {
+      return nok(code)
+    }
+
+    // Assume it’s registered.
+    const valueType = /** @type {TokenType} */ type + 'Value'
+    effects.enter(valueType)
+    effects.consume(code)
+    return shortcut
+  }
+
+  /** @type {State} */
+  function shortcut(code) {
+    if (
+      code === null ||
+      code === 34 ||
+      code === 39 ||
+      code === 60 ||
+      code === 61 ||
+      code === 62 ||
+      code === 96
+    ) {
+      return nok(code)
+    }
+    if (
+      code === 35 ||
+      code === 46 ||
+      code === 125 ||
+      markdownLineEndingOrSpace(code)
+    ) {
+      // Assume it’s registered.
+      const valueType = /** @type {TokenType} */ type + 'Value'
+      effects.exit(valueType)
+      effects.exit(type)
+      effects.exit(attributeType)
+      return between(code)
+    }
+    effects.consume(code)
+    return shortcut
+  }
+
+  /** @type {State} */
+  function name(code) {
+    if (
+      code === 45 ||
+      code === 46 ||
+      code === 58 ||
+      code === 95 ||
+      asciiAlphanumeric(code)
+    ) {
+      effects.consume(code)
+      return name
+    }
+    effects.exit(attributeNameType)
+    if (disallowEol && markdownSpace(code)) {
+      return factorySpace(effects, nameAfter, 'whitespace')(code)
+    }
+    if (!disallowEol && markdownLineEndingOrSpace(code)) {
+      return factoryWhitespace(effects, nameAfter)(code)
+    }
+    return nameAfter(code)
+  }
+
+  /** @type {State} */
+  function nameAfter(code) {
+    if (code === 61) {
+      effects.enter(attributeInitializerType)
+      effects.consume(code)
+      effects.exit(attributeInitializerType)
+      return valueBefore
+    }
+
+    // Attribute w/o value.
+    effects.exit(attributeType)
+    return between(code)
+  }
+
+  /** @type {State} */
+  function valueBefore(code) {
+    if (
+      code === null ||
+      code === 60 ||
+      code === 61 ||
+      code === 62 ||
+      code === 96 ||
+      code === 125 ||
+      (disallowEol && markdownLineEnding(code))
+    ) {
+      return nok(code)
+    }
+    if (code === 34 || code === 39) {
+      effects.enter(attributeValueLiteralType)
+      effects.enter(attributeValueMarker)
+      effects.consume(code)
+      effects.exit(attributeValueMarker)
+      marker = code
+      return valueQuotedStart
+    }
+    if (disallowEol && markdownSpace(code)) {
+      return factorySpace(effects, valueBefore, 'whitespace')(code)
+    }
+    if (!disallowEol && markdownLineEndingOrSpace(code)) {
+      return factoryWhitespace(effects, valueBefore)(code)
+    }
+    effects.enter(attributeValueType)
+    effects.enter(attributeValueData)
+    effects.consume(code)
+    marker = undefined
+    return valueUnquoted
+  }
+
+  /** @type {State} */
+  function valueUnquoted(code) {
+    if (
+      code === null ||
+      code === 34 ||
+      code === 39 ||
+      code === 60 ||
+      code === 61 ||
+      code === 62 ||
+      code === 96
+    ) {
+      return nok(code)
+    }
+    if (code === 125 || markdownLineEndingOrSpace(code)) {
+      effects.exit(attributeValueData)
+      effects.exit(attributeValueType)
+      effects.exit(attributeType)
+      return between(code)
+    }
+    effects.consume(code)
+    return valueUnquoted
+  }
+
+  /** @type {State} */
+  function valueQuotedStart(code) {
+    if (code === marker) {
+      effects.enter(attributeValueMarker)
+      effects.consume(code)
+      effects.exit(attributeValueMarker)
+      effects.exit(attributeValueLiteralType)
+      effects.exit(attributeType)
+      return valueQuotedAfter
+    }
+    effects.enter(attributeValueType)
+    return valueQuotedBetween(code)
+  }
+
+  /** @type {State} */
+  function valueQuotedBetween(code) {
+    if (code === marker) {
+      effects.exit(attributeValueType)
+      return valueQuotedStart(code)
+    }
+    if (code === null) {
+      return nok(code)
+    }
+
+    // Note: blank lines can’t exist in content.
+    if (markdownLineEnding(code)) {
+      return disallowEol
+        ? nok(code)
+        : factoryWhitespace(effects, valueQuotedBetween)(code)
+    }
+    effects.enter(attributeValueData)
+    effects.consume(code)
+    return valueQuoted
+  }
+
+  /** @type {State} */
+  function valueQuoted(code) {
+    if (code === marker || code === null || markdownLineEnding(code)) {
+      effects.exit(attributeValueData)
+      return valueQuotedBetween(code)
+    }
+    effects.consume(code)
+    return valueQuoted
+  }
+
+  /** @type {State} */
+  function valueQuotedAfter(code) {
+    return code === 125 || markdownLineEndingOrSpace(code)
+      ? between(code)
+      : end(code)
+  }
+
+  /** @type {State} */
+  function end(code) {
+    if (code === 125) {
+      effects.enter(attributesMarkerType)
+      effects.consume(code)
+      effects.exit(attributesMarkerType)
+      effects.exit(attributesType)
+      return ok
+    }
+    return nok(code)
+  }
+}

node_modules/micromark-extension-directive/lib/factory-label.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} type
+ * @param {TokenType} markerType
+ * @param {TokenType} stringType
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryLabel(
+  effects: Effects,
+  ok: State,
+  nok: State,
+  type: TokenType,
+  markerType: TokenType,
+  stringType: TokenType,
+  disallowEol?: boolean | undefined
+): (
+  code: import('micromark-util-types').Code
+) => import('micromark-util-types').State | undefined
+export type Effects = import('micromark-util-types').Effects
+export type State = import('micromark-util-types').State
+export type Token = import('micromark-util-types').Token
+export type TokenType = import('micromark-util-types').TokenType

node_modules/micromark-extension-directive/lib/factory-label.js

@@ -0,0 +1,116 @@
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').TokenType} TokenType
+ */
+
+import {markdownLineEnding} from 'micromark-util-character'
+// This is a fork of:
+// <https://github.com/micromark/micromark/tree/main/packages/micromark-factory-label>
+// to allow empty labels, balanced brackets (such as for nested directives),
+// text instead of strings, and optionally disallows EOLs.
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} type
+ * @param {TokenType} markerType
+ * @param {TokenType} stringType
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryLabel(
+  effects,
+  ok,
+  nok,
+  type,
+  markerType,
+  stringType,
+  disallowEol
+) {
+  let size = 0
+  let balance = 0
+  /** @type {Token | undefined} */
+  let previous
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    effects.enter(type)
+    effects.enter(markerType)
+    effects.consume(code)
+    effects.exit(markerType)
+    return afterStart
+  }
+
+  /** @type {State} */
+  function afterStart(code) {
+    if (code === 93) {
+      effects.enter(markerType)
+      effects.consume(code)
+      effects.exit(markerType)
+      effects.exit(type)
+      return ok
+    }
+    effects.enter(stringType)
+    return lineStart(code)
+  }
+
+  /** @type {State} */
+  function lineStart(code) {
+    if (code === 93 && !balance) {
+      return atClosingBrace(code)
+    }
+    const token = effects.enter('chunkText', {
+      contentType: 'text',
+      previous
+    })
+    if (previous) previous.next = token
+    previous = token
+    return data(code)
+  }
+
+  /** @type {State} */
+  function data(code) {
+    if (code === null || size > 999) {
+      return nok(code)
+    }
+    if (code === 91 && ++balance > 32) {
+      return nok(code)
+    }
+    if (code === 93 && !balance--) {
+      effects.exit('chunkText')
+      return atClosingBrace(code)
+    }
+    if (markdownLineEnding(code)) {
+      if (disallowEol) {
+        return nok(code)
+      }
+      effects.consume(code)
+      effects.exit('chunkText')
+      return lineStart
+    }
+    effects.consume(code)
+    return code === 92 ? dataEscape : data
+  }
+
+  /** @type {State} */
+  function dataEscape(code) {
+    if (code === 91 || code === 92 || code === 93) {
+      effects.consume(code)
+      size++
+      return data
+    }
+    return data(code)
+  }
+
+  /** @type {State} */
+  function atClosingBrace(code) {
+    effects.exit(stringType)
+    effects.enter(markerType)
+    effects.consume(code)
+    effects.exit(markerType)
+    effects.exit(type)
+    return ok
+  }
+}

node_modules/micromark-extension-directive/lib/factory-name.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @this {TokenizeContext}
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} type
+ */
+export function factoryName(
+  this: import('micromark-util-types').TokenizeContext,
+  effects: Effects,
+  ok: State,
+  nok: State,
+  type: TokenType
+): (
+  code: import('micromark-util-types').Code
+) => import('micromark-util-types').State | undefined
+export type Effects = import('micromark-util-types').Effects
+export type State = import('micromark-util-types').State
+export type TokenizeContext = import('micromark-util-types').TokenizeContext
+export type TokenType = import('micromark-util-types').TokenType

node_modules/micromark-extension-directive/lib/factory-name.js

@@ -0,0 +1,39 @@
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').TokenType} TokenType
+ */
+
+import {asciiAlpha, asciiAlphanumeric} from 'micromark-util-character'
+/**
+ * @this {TokenizeContext}
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} type
+ */
+export function factoryName(effects, ok, nok, type) {
+  const self = this
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    if (asciiAlpha(code)) {
+      effects.enter(type)
+      effects.consume(code)
+      return name
+    }
+    return nok(code)
+  }
+
+  /** @type {State} */
+  function name(code) {
+    if (code === 45 || code === 95 || asciiAlphanumeric(code)) {
+      effects.consume(code)
+      return name
+    }
+    effects.exit(type)
+    return self.previous === 45 || self.previous === 95 ? nok(code) : ok(code)
+  }
+}

node_modules/micromark-extension-directive/lib/html.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Create an extension for `micromark` to support directives when serializing
+ * to HTML.
+ *
+ * @param {HtmlOptions | null | undefined} [options={}]
+ *   Configuration (default: `{}`).
+ * @returns {HtmlExtension}
+ *   Extension for `micromark` that can be passed in `htmlExtensions`, to
+ *   support directives when serializing to HTML.
+ */
+export function directiveHtml(
+  options?: HtmlOptions | null | undefined
+): HtmlExtension
+export type CompileContext = import('micromark-util-types').CompileContext
+export type _Handle = import('micromark-util-types').Handle
+export type HtmlExtension = import('micromark-util-types').HtmlExtension
+/**
+ * Internal tuple representing an attribute.
+ */
+export type Attribute = [string, string]
+/**
+ * Configuration.
+ *
+ * > 👉 **Note**: the special field `'*'` can be used to specify a fallback
+ * > handle to handle all otherwise unhandled directives.
+ */
+export type HtmlOptions = Record<string, Handle>
+/**
+ * Handle a directive.
+ */
+export type Handle = (
+  this: CompileContext,
+  directive: Directive
+) => boolean | undefined
+/**
+ * Structure representing a directive.
+ */
+export type Directive = {
+  /**
+   *   Kind.
+   */
+  type: DirectiveType
+  /**
+   *   Name of directive.
+   */
+  name: string
+  /**
+   * Compiled HTML content that was in `[brackets]`.
+   */
+  label?: string | undefined
+  /**
+   * Object w/ HTML attributes.
+   */
+  attributes?: Record<string, string> | undefined
+  /**
+   * Compiled HTML content inside container directive.
+   */
+  content?: string | undefined
+  /**
+   * Private :)
+   */
+  _fenceCount?: number | undefined
+}
+/**
+ * Kind.
+ */
+export type DirectiveType =
+  | 'containerDirective'
+  | 'leafDirective'
+  | 'textDirective'

node_modules/micromark-extension-directive/lib/html.js

@@ -0,0 +1,285 @@
+/**
+ * @typedef {import('micromark-util-types').CompileContext} CompileContext
+ * @typedef {import('micromark-util-types').Handle} _Handle
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ */
+
+/**
+ * @typedef {[string, string]} Attribute
+ *   Internal tuple representing an attribute.
+ */
+
+/**
+ * @typedef {Record<string, Handle>} HtmlOptions
+ *   Configuration.
+ *
+ *   > 👉 **Note**: the special field `'*'` can be used to specify a fallback
+ *   > handle to handle all otherwise unhandled directives.
+ *
+ * @callback Handle
+ *   Handle a directive.
+ * @param {CompileContext} this
+ *   Current context.
+ * @param {Directive} directive
+ *   Directive.
+ * @returns {boolean | undefined}
+ *   Signal whether the directive was handled.
+ *
+ *   Yield `false` to let the fallback (a special handle for `'*'`) handle it.
+ *
+ * @typedef Directive
+ *   Structure representing a directive.
+ * @property {DirectiveType} type
+ *   Kind.
+ * @property {string} name
+ *   Name of directive.
+ * @property {string | undefined} [label]
+ *   Compiled HTML content that was in `[brackets]`.
+ * @property {Record<string, string> | undefined} [attributes]
+ *   Object w/ HTML attributes.
+ * @property {string | undefined} [content]
+ *   Compiled HTML content inside container directive.
+ * @property {number | undefined} [_fenceCount]
+ *   Private :)
+ *
+ * @typedef {'containerDirective' | 'leafDirective' | 'textDirective'} DirectiveType
+ *   Kind.
+ */
+
+import {parseEntities} from 'parse-entities'
+const own = {}.hasOwnProperty
+
+/**
+ * Create an extension for `micromark` to support directives when serializing
+ * to HTML.
+ *
+ * @param {HtmlOptions | null | undefined} [options={}]
+ *   Configuration (default: `{}`).
+ * @returns {HtmlExtension}
+ *   Extension for `micromark` that can be passed in `htmlExtensions`, to
+ *   support directives when serializing to HTML.
+ */
+export function directiveHtml(options) {
+  const options_ = options || {}
+  return {
+    enter: {
+      directiveContainer() {
+        enter.call(this, 'containerDirective')
+      },
+      directiveContainerAttributes: enterAttributes,
+      directiveContainerLabel: enterLabel,
+      directiveContainerContent() {
+        this.buffer()
+      },
+      directiveLeaf() {
+        enter.call(this, 'leafDirective')
+      },
+      directiveLeafAttributes: enterAttributes,
+      directiveLeafLabel: enterLabel,
+      directiveText() {
+        enter.call(this, 'textDirective')
+      },
+      directiveTextAttributes: enterAttributes,
+      directiveTextLabel: enterLabel
+    },
+    exit: {
+      directiveContainer: exit,
+      directiveContainerAttributeClassValue: exitAttributeClassValue,
+      directiveContainerAttributeIdValue: exitAttributeIdValue,
+      directiveContainerAttributeName: exitAttributeName,
+      directiveContainerAttributeValue: exitAttributeValue,
+      directiveContainerAttributes: exitAttributes,
+      directiveContainerContent: exitContainerContent,
+      directiveContainerFence: exitContainerFence,
+      directiveContainerLabel: exitLabel,
+      directiveContainerName: exitName,
+      directiveLeaf: exit,
+      directiveLeafAttributeClassValue: exitAttributeClassValue,
+      directiveLeafAttributeIdValue: exitAttributeIdValue,
+      directiveLeafAttributeName: exitAttributeName,
+      directiveLeafAttributeValue: exitAttributeValue,
+      directiveLeafAttributes: exitAttributes,
+      directiveLeafLabel: exitLabel,
+      directiveLeafName: exitName,
+      directiveText: exit,
+      directiveTextAttributeClassValue: exitAttributeClassValue,
+      directiveTextAttributeIdValue: exitAttributeIdValue,
+      directiveTextAttributeName: exitAttributeName,
+      directiveTextAttributeValue: exitAttributeValue,
+      directiveTextAttributes: exitAttributes,
+      directiveTextLabel: exitLabel,
+      directiveTextName: exitName
+    }
+  }
+
+  /**
+   * @this {CompileContext}
+   * @param {DirectiveType} type
+   */
+  function enter(type) {
+    let stack = this.getData('directiveStack')
+    if (!stack) this.setData('directiveStack', (stack = []))
+    stack.push({
+      type,
+      name: ''
+    })
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitName(token) {
+    const stack = this.getData('directiveStack')
+    stack[stack.length - 1].name = this.sliceSerialize(token)
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function enterLabel() {
+    this.buffer()
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitLabel() {
+    const data = this.resume()
+    const stack = this.getData('directiveStack')
+    stack[stack.length - 1].label = data
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function enterAttributes() {
+    this.buffer()
+    this.setData('directiveAttributes', [])
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributeIdValue(token) {
+    const attributes = this.getData('directiveAttributes')
+    attributes.push([
+      'id',
+      parseEntities(this.sliceSerialize(token), {
+        attribute: true
+      })
+    ])
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributeClassValue(token) {
+    const attributes = this.getData('directiveAttributes')
+    attributes.push([
+      'class',
+      parseEntities(this.sliceSerialize(token), {
+        attribute: true
+      })
+    ])
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributeName(token) {
+    // Attribute names in CommonMark are significantly limited, so character
+    // references can’t exist.
+    const attributes = this.getData('directiveAttributes')
+    attributes.push([this.sliceSerialize(token), ''])
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributeValue(token) {
+    const attributes = this.getData('directiveAttributes')
+    attributes[attributes.length - 1][1] = parseEntities(
+      this.sliceSerialize(token),
+      {
+        attribute: true
+      }
+    )
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitAttributes() {
+    const stack = this.getData('directiveStack')
+    const attributes = this.getData('directiveAttributes')
+    /** @type {Directive['attributes']} */
+    const cleaned = {}
+    let index = -1
+    while (++index < attributes.length) {
+      const attribute = attributes[index]
+      if (attribute[0] === 'class' && cleaned.class) {
+        cleaned.class += ' ' + attribute[1]
+      } else {
+        cleaned[attribute[0]] = attribute[1]
+      }
+    }
+    this.resume()
+    this.setData('directiveAttributes')
+    stack[stack.length - 1].attributes = cleaned
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitContainerContent() {
+    const data = this.resume()
+    const stack = this.getData('directiveStack')
+    stack[stack.length - 1].content = data
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exitContainerFence() {
+    const stack = this.getData('directiveStack')
+    const directive = stack[stack.length - 1]
+    if (!directive._fenceCount) directive._fenceCount = 0
+    directive._fenceCount++
+    if (directive._fenceCount === 1) this.setData('slurpOneLineEnding', true)
+  }
+
+  /**
+   * @this {CompileContext}
+   * @type {_Handle}
+   */
+  function exit() {
+    const stack = this.getData('directiveStack')
+    const directive = stack.pop()
+    /** @type {boolean | undefined} */
+    let found
+    /** @type {boolean | undefined} */
+    let result
+    if (own.call(options_, directive.name)) {
+      result = options_[directive.name].call(this, directive)
+      found = result !== false
+    }
+    if (!found && own.call(options_, '*')) {
+      result = options_['*'].call(this, directive)
+      found = result !== false
+    }
+    if (!found && directive.type !== 'textDirective') {
+      this.setData('slurpOneLineEnding', true)
+    }
+  }
+}

node_modules/micromark-extension-directive/lib/syntax.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Create an extension for `micromark` to enable directive syntax.
+ *
+ * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions`, to
+ *   enable directive syntax.
+ */
+export function directive(): Extension
+export type Extension = import('micromark-util-types').Extension

node_modules/micromark-extension-directive/lib/syntax.js

@@ -0,0 +1,25 @@
+/**
+ * @typedef {import('micromark-util-types').Extension} Extension
+ */
+
+import {directiveContainer} from './directive-container.js'
+import {directiveLeaf} from './directive-leaf.js'
+import {directiveText} from './directive-text.js'
+
+/**
+ * Create an extension for `micromark` to enable directive syntax.
+ *
+ * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions`, to
+ *   enable directive syntax.
+ */
+export function directive() {
+  return {
+    text: {
+      [58]: directiveText
+    },
+    flow: {
+      [58]: [directiveContainer, directiveLeaf]
+    }
+  }
+}

node_modules/micromark-extension-directive/license

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2020 Titus Wormer <tituswormer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/micromark-extension-directive/node_modules/micromark-factory-space/dev/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Parse spaces and tabs.
+ *
+ * There is no `nok` parameter:
+ *
+ * *   spaces in markdown are often optional, in which case this factory can be
+ *     used and `ok` will be switched to whether spaces were found or not
+ * *   one line ending or space can be detected with `markdownSpace(code)` right
+ *     before using `factorySpace`
+ *
+ * ###### Examples
+ *
+ * Where `␉` represents a tab (plus how much it expands) and `␠` represents a
+ * single space.
+ *
+ * ```markdown
+ * ␉
+ * ␠␠␠␠
+ * ␉␠
+ * ```
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {TokenType} type
+ *   Type (`' \t'`).
+ * @param {number | undefined} [max=Infinity]
+ *   Max (exclusive).
+ * @returns {State}
+ *   Start state.
+ */
+export function factorySpace(
+  effects: Effects,
+  ok: State,
+  type: TokenType,
+  max?: number | undefined
+): State
+export type Effects = import('micromark-util-types').Effects
+export type State = import('micromark-util-types').State
+export type TokenType = import('micromark-util-types').TokenType

node_modules/micromark-extension-directive/node_modules/micromark-factory-space/dev/index.js

@@ -0,0 +1,69 @@
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenType} TokenType
+ */
+
+import {markdownSpace} from 'micromark-util-character'
+
+// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.
+
+/**
+ * Parse spaces and tabs.
+ *
+ * There is no `nok` parameter:
+ *
+ * *   spaces in markdown are often optional, in which case this factory can be
+ *     used and `ok` will be switched to whether spaces were found or not
+ * *   one line ending or space can be detected with `markdownSpace(code)` right
+ *     before using `factorySpace`
+ *
+ * ###### Examples
+ *
+ * Where `␉` represents a tab (plus how much it expands) and `␠` represents a
+ * single space.
+ *
+ * ```markdown
+ * ␉
+ * ␠␠␠␠
+ * ␉␠
+ * ```
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {TokenType} type
+ *   Type (`' \t'`).
+ * @param {number | undefined} [max=Infinity]
+ *   Max (exclusive).
+ * @returns {State}
+ *   Start state.
+ */
+export function factorySpace(effects, ok, type, max) {
+  const limit = max ? max - 1 : Number.POSITIVE_INFINITY
+  let size = 0
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    if (markdownSpace(code)) {
+      effects.enter(type)
+      return prefix(code)
+    }
+
+    return ok(code)
+  }
+
+  /** @type {State} */
+  function prefix(code) {
+    if (markdownSpace(code) && size++ < limit) {
+      effects.consume(code)
+      return prefix
+    }
+
+    effects.exit(type)
+    return ok(code)
+  }
+}

node_modules/micromark-extension-directive/node_modules/micromark-factory-space/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Parse spaces and tabs.
+ *
+ * There is no `nok` parameter:
+ *
+ * *   spaces in markdown are often optional, in which case this factory can be
+ *     used and `ok` will be switched to whether spaces were found or not
+ * *   one line ending or space can be detected with `markdownSpace(code)` right
+ *     before using `factorySpace`
+ *
+ * ###### Examples
+ *
+ * Where `␉` represents a tab (plus how much it expands) and `␠` represents a
+ * single space.
+ *
+ * ```markdown
+ * ␉
+ * ␠␠␠␠
+ * ␉␠
+ * ```
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {TokenType} type
+ *   Type (`' \t'`).
+ * @param {number | undefined} [max=Infinity]
+ *   Max (exclusive).
+ * @returns {State}
+ *   Start state.
+ */
+export function factorySpace(
+  effects: Effects,
+  ok: State,
+  type: TokenType,
+  max?: number | undefined
+): State
+export type Effects = import('micromark-util-types').Effects
+export type State = import('micromark-util-types').State
+export type TokenType = import('micromark-util-types').TokenType

node_modules/micromark-extension-directive/node_modules/micromark-factory-space/index.js

@@ -0,0 +1,66 @@
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenType} TokenType
+ */
+
+import {markdownSpace} from 'micromark-util-character'
+
+// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.
+
+/**
+ * Parse spaces and tabs.
+ *
+ * There is no `nok` parameter:
+ *
+ * *   spaces in markdown are often optional, in which case this factory can be
+ *     used and `ok` will be switched to whether spaces were found or not
+ * *   one line ending or space can be detected with `markdownSpace(code)` right
+ *     before using `factorySpace`
+ *
+ * ###### Examples
+ *
+ * Where `␉` represents a tab (plus how much it expands) and `␠` represents a
+ * single space.
+ *
+ * ```markdown
+ * ␉
+ * ␠␠␠␠
+ * ␉␠
+ * ```
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {TokenType} type
+ *   Type (`' \t'`).
+ * @param {number | undefined} [max=Infinity]
+ *   Max (exclusive).
+ * @returns {State}
+ *   Start state.
+ */
+export function factorySpace(effects, ok, type, max) {
+  const limit = max ? max - 1 : Number.POSITIVE_INFINITY
+  let size = 0
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    if (markdownSpace(code)) {
+      effects.enter(type)
+      return prefix(code)
+    }
+    return ok(code)
+  }
+
+  /** @type {State} */
+  function prefix(code) {
+    if (markdownSpace(code) && size++ < limit) {
+      effects.consume(code)
+      return prefix
+    }
+    effects.exit(type)
+    return ok(code)
+  }
+}

node_modules/micromark-extension-directive/node_modules/micromark-factory-space/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "micromark-factory-space",
+  "version": "2.0.0",
+  "description": "micromark factory to parse markdown space (found in lots of places)",
+  "license": "MIT",
+  "keywords": [
+    "micromark",
+    "factory",
+    "space"
+  ],
+  "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-factory-space",
+  "bugs": "https://github.com/micromark/micromark/issues",
+  "funding": [
+    {
+      "type": "GitHub Sponsors",
+      "url": "https://github.com/sponsors/unifiedjs"
+    },
+    {
+      "type": "OpenCollective",
+      "url": "https://opencollective.com/unified"
+    }
+  ],
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "files": [
+    "dev/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "exports": {
+    "development": "./dev/index.js",
+    "default": "./index.js"
+  },
+  "dependencies": {
+    "micromark-util-character": "^2.0.0",
+    "micromark-util-types": "^2.0.0"
+  },
+  "scripts": {
+    "build": "micromark-build"
+  },
+  "xo": false
+}

node_modules/micromark-extension-directive/node_modules/micromark-factory-space/readme.md

@@ -0,0 +1,224 @@
+# micromark-factory-space
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][bundle-size-badge]][bundle-size]
+[![Sponsors][sponsors-badge]][opencollective]
+[![Backers][backers-badge]][opencollective]
+[![Chat][chat-badge]][chat]
+
+[micromark][] factory to parse [markdown space][markdown-space] (found in lots
+of places).
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`factorySpace(…)`](#factoryspace)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This package exposes states to parse spaces and/or tabs.
+
+## When should I use this?
+
+This package is useful when you are making your own micromark extensions.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install micromark-factory-space
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import {factorySpace} from 'https://esm.sh/micromark-factory-space@1'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+<script type="module">
+  import {factorySpace} from 'https://esm.sh/micromark-factory-space@1?bundle'
+</script>
+```
+
+## Use
+
+```js
+import {factorySpace} from 'micromark-factory-space'
+import {codes, types} from 'micromark-util-symbol'
+
+// A micromark tokenizer that uses the factory:
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeCodeFenced(effects, ok, nok) {
+  return start
+
+  // …
+
+  /** @type {State} */
+  function info(code) {
+    if (code === codes.eof || markdownLineEndingOrSpace(code)) {
+      effects.exit(types.chunkString)
+      effects.exit(types.codeFencedFenceInfo)
+      return factorySpace(effects, infoAfter, types.whitespace)(code)
+    }
+
+    if (code === codes.graveAccent && code === marker) return nok(code)
+    effects.consume(code)
+    return info
+  }
+
+  // …
+}
+```
+
+## API
+
+This module exports the identifier [`factorySpace`][api-factory-space].
+There is no default export.
+
+### `factorySpace(…)`
+
+Parse spaces and tabs.
+
+There is no `nok` parameter:
+
+*   spaces in markdown are often optional, in which case this factory can be
+    used and `ok` will be switched to whether spaces were found or not
+*   one line ending or space can be detected with `markdownSpace(code)` right
+    before using `factorySpace`
+
+###### Examples
+
+Where `␉` represents a tab (plus how much it expands) and `␠` represents a
+single space.
+
+```markdown
+␉
+␠␠␠␠
+␉␠
+```
+
+###### Parameters
+
+*   `effects` (`Effects`)
+    — context
+*   `ok` (`State`)
+    — state switched to when successful
+*   `type` (`string`)
+    — type (`' \t'`)
+*   `max` (`number`, default: `Infinity`)
+    — max (exclusive)
+
+###### Returns
+
+Start state (`State`).
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports no additional types.
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line,
+`micromark-factory-space@^2`, compatible with Node.js 16.
+This package works with `micromark@^3`.
+
+## Security
+
+This package is safe.
+See [`security.md`][securitymd] in [`micromark/.github`][health] for how to
+submit a security report.
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`micromark/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organisation, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+<!-- Definitions -->
+
+[build-badge]: https://github.com/micromark/micromark/workflows/main/badge.svg
+
+[build]: https://github.com/micromark/micromark/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/micromark/micromark.svg
+
+[coverage]: https://codecov.io/github/micromark/micromark
+
+[downloads-badge]: https://img.shields.io/npm/dm/micromark-factory-space.svg
+
+[downloads]: https://www.npmjs.com/package/micromark-factory-space
+
+[bundle-size-badge]: https://img.shields.io/badge/dynamic/json?label=minzipped%20size&query=$.size.compressedSize&url=https://deno.bundlejs.com/?q=micromark-factory-space
+
+[bundle-size]: https://bundlejs.com/?q=micromark-factory-space
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[opencollective]: https://opencollective.com/unified
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/micromark/micromark/discussions
+
+[license]: https://github.com/micromark/micromark/blob/main/license
+
+[author]: https://wooorm.com
+
+[health]: https://github.com/micromark/.github
+
+[securitymd]: https://github.com/micromark/.github/blob/main/security.md
+
+[contributing]: https://github.com/micromark/.github/blob/main/contributing.md
+
+[support]: https://github.com/micromark/.github/blob/main/support.md
+
+[coc]: https://github.com/micromark/.github/blob/main/code-of-conduct.md
+
+[markdown-space]: https://github.com/micromark/micromark/tree/main/packages/micromark-util-character#markdownspacecode
+
+[typescript]: https://www.typescriptlang.org
+
+[micromark]: https://github.com/micromark/micromark
+
+[api-factory-space]: #factoryspace

node_modules/micromark-extension-directive/node_modules/micromark-util-character/dev/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Check whether a character code is an ASCII control character.
+ *
+ * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+ * to U+001F (US), or U+007F (DEL).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function asciiControl(code: Code): boolean;
+/**
+ * Check whether a character code is a markdown line ending.
+ *
+ * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+ * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+ *
+ * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+ * RETURN (CR) are replaced by these virtual characters depending on whether
+ * they occurred together.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownLineEnding(code: Code): boolean;
+/**
+ * Check whether a character code is a markdown line ending (see
+ * `markdownLineEnding`) or markdown space (see `markdownSpace`).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownLineEndingOrSpace(code: Code): boolean;
+/**
+ * Check whether a character code is a markdown space.
+ *
+ * A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+ * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+ *
+ * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+ * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+ * SPACE (VS) characters, depending on the column at which the tab occurred.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownSpace(code: Code): boolean;
+export function asciiAlpha(code: Code): boolean;
+export function asciiAlphanumeric(code: Code): boolean;
+export function asciiAtext(code: Code): boolean;
+export function asciiDigit(code: Code): boolean;
+export function asciiHexDigit(code: Code): boolean;
+export function asciiPunctuation(code: Code): boolean;
+export function unicodePunctuation(code: Code): boolean;
+export function unicodeWhitespace(code: Code): boolean;
+export type Code = import('micromark-util-types').Code;
+//# sourceMappingURL=index.d.ts.map

node_modules/micromark-extension-directive/node_modules/micromark-util-character/dev/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;GAUG;AACH,mCALW,IAAI,GAEF,OAAO,CASnB;AAkDD;;;;;;;;;;;;;;GAcG;AACH,yCALW,IAAI,GAEF,OAAO,CAKnB;AAED;;;;;;;;GAQG;AACH,gDALW,IAAI,GAEF,OAAO,CAKnB;AAED;;;;;;;;;;;;;;GAcG;AACH,oCALW,IAAI,GAEF,OAAO,CASnB;AAmDY,iCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,wCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,iCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,iCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,oCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,uCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,yCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,wCAAO,IAAI,GAAK,OAAO,CAAA;mBAxOvB,OAAO,sBAAsB,EAAE,IAAI"}

node_modules/micromark-extension-directive/node_modules/micromark-util-character/dev/index.js

@@ -0,0 +1,250 @@
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+
+import {codes} from 'micromark-util-symbol'
+
+/**
+ * Check whether the character code represents an ASCII alpha (`a` through `z`,
+ * case insensitive).
+ *
+ * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
+ *
+ * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
+ * to U+005A (`Z`).
+ *
+ * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
+ * to U+007A (`z`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiAlpha = regexCheck(/[A-Za-z]/)
+
+/**
+ * Check whether the character code represents an ASCII alphanumeric (`a`
+ * through `z`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
+ * (see `asciiAlpha`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/)
+
+/**
+ * Check whether the character code represents an ASCII atext.
+ *
+ * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in
+ * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),
+ * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F
+ * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E
+ * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE
+ * (`{`) to U+007E TILDE (`~`).
+ *
+ * See:
+ * **\[RFC5322]**:
+ * [Internet Message Format](https://tools.ietf.org/html/rfc5322).
+ * P. Resnick.
+ * IETF.
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/)
+
+/**
+ * Check whether a character code is an ASCII control character.
+ *
+ * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+ * to U+001F (US), or U+007F (DEL).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function asciiControl(code) {
+  return (
+    // Special whitespace codes (which have negative values), C0 and Control
+    // character DEL
+    code !== null && (code < codes.space || code === codes.del)
+  )
+}
+
+/**
+ * Check whether the character code represents an ASCII digit (`0` through `9`).
+ *
+ * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
+ * U+0039 (`9`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiDigit = regexCheck(/\d/)
+
+/**
+ * Check whether the character code represents an ASCII hex digit (`a` through
+ * `f`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex
+ * digit, or an ASCII lower hex digit.
+ *
+ * An **ASCII upper hex digit** is a character in the inclusive range U+0041
+ * (`A`) to U+0046 (`F`).
+ *
+ * An **ASCII lower hex digit** is a character in the inclusive range U+0061
+ * (`a`) to U+0066 (`f`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiHexDigit = regexCheck(/[\dA-Fa-f]/)
+
+/**
+ * Check whether the character code represents ASCII punctuation.
+ *
+ * An **ASCII punctuation** is a character in the inclusive ranges U+0021
+ * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT
+ * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT
+ * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)
+
+/**
+ * Check whether a character code is a markdown line ending.
+ *
+ * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+ * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+ *
+ * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+ * RETURN (CR) are replaced by these virtual characters depending on whether
+ * they occurred together.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownLineEnding(code) {
+  return code !== null && code < codes.horizontalTab
+}
+
+/**
+ * Check whether a character code is a markdown line ending (see
+ * `markdownLineEnding`) or markdown space (see `markdownSpace`).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownLineEndingOrSpace(code) {
+  return code !== null && (code < codes.nul || code === codes.space)
+}
+
+/**
+ * Check whether a character code is a markdown space.
+ *
+ * A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+ * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+ *
+ * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+ * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+ * SPACE (VS) characters, depending on the column at which the tab occurred.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownSpace(code) {
+  return (
+    code === codes.horizontalTab ||
+    code === codes.virtualSpace ||
+    code === codes.space
+  )
+}
+
+// Size note: removing ASCII from the regex and using `asciiPunctuation` here
+// In fact adds to the bundle size.
+/**
+ * Check whether the character code represents Unicode punctuation.
+ *
+ * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
+ * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
+ * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
+ * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
+ * punctuation (see `asciiPunctuation`).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ *
+ * @param code
+ *   Code.
+ * @returns
+ *   Whether it matches.
+ */
+export const unicodePunctuation = regexCheck(/\p{P}|\p{S}/u)
+
+/**
+ * Check whether the character code represents Unicode whitespace.
+ *
+ * Note that this does handle micromark specific markdown whitespace characters.
+ * See `markdownLineEndingOrSpace` to check that.
+ *
+ * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
+ * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
+ * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ *
+ * @param code
+ *   Code.
+ * @returns
+ *   Whether it matches.
+ */
+export const unicodeWhitespace = regexCheck(/\s/)
+
+/**
+ * Create a code check from a regex.
+ *
+ * @param {RegExp} regex
+ * @returns {(code: Code) => boolean}
+ */
+function regexCheck(regex) {
+  return check
+
+  /**
+   * Check whether a code matches the bound regex.
+   *
+   * @param {Code} code
+   *   Character code.
+   * @returns {boolean}
+   *   Whether the character code matches the bound regex.
+   */
+  function check(code) {
+    return code !== null && code > -1 && regex.test(String.fromCharCode(code))
+  }
+}

node_modules/micromark-extension-directive/node_modules/micromark-util-character/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Check whether a character code is an ASCII control character.
+ *
+ * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+ * to U+001F (US), or U+007F (DEL).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function asciiControl(code: Code): boolean;
+/**
+ * Check whether a character code is a markdown line ending.
+ *
+ * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+ * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+ *
+ * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+ * RETURN (CR) are replaced by these virtual characters depending on whether
+ * they occurred together.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownLineEnding(code: Code): boolean;
+/**
+ * Check whether a character code is a markdown line ending (see
+ * `markdownLineEnding`) or markdown space (see `markdownSpace`).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownLineEndingOrSpace(code: Code): boolean;
+/**
+ * Check whether a character code is a markdown space.
+ *
+ * A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+ * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+ *
+ * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+ * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+ * SPACE (VS) characters, depending on the column at which the tab occurred.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownSpace(code: Code): boolean;
+export function asciiAlpha(code: Code): boolean;
+export function asciiAlphanumeric(code: Code): boolean;
+export function asciiAtext(code: Code): boolean;
+export function asciiDigit(code: Code): boolean;
+export function asciiHexDigit(code: Code): boolean;
+export function asciiPunctuation(code: Code): boolean;
+export function unicodePunctuation(code: Code): boolean;
+export function unicodeWhitespace(code: Code): boolean;
+export type Code = import('micromark-util-types').Code;
+//# sourceMappingURL=index.d.ts.map

node_modules/micromark-extension-directive/node_modules/micromark-util-character/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;GAUG;AACH,mCALW,IAAI,GAEF,OAAO,CASnB;AAkDD;;;;;;;;;;;;;;GAcG;AACH,yCALW,IAAI,GAEF,OAAO,CAKnB;AAED;;;;;;;;GAQG;AACH,gDALW,IAAI,GAEF,OAAO,CAKnB;AAED;;;;;;;;;;;;;;GAcG;AACH,oCALW,IAAI,GAEF,OAAO,CASnB;AAmDY,iCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,wCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,iCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,iCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,oCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,uCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,yCAAO,IAAI,GAAK,OAAO,CAAA;AAAvB,wCAAO,IAAI,GAAK,OAAO,CAAA;mBAxOvB,OAAO,sBAAsB,EAAE,IAAI"}

node_modules/micromark-extension-directive/node_modules/micromark-util-character/index.js

@@ -0,0 +1,244 @@
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+
+/**
+ * Check whether the character code represents an ASCII alpha (`a` through `z`,
+ * case insensitive).
+ *
+ * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
+ *
+ * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
+ * to U+005A (`Z`).
+ *
+ * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
+ * to U+007A (`z`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiAlpha = regexCheck(/[A-Za-z]/);
+
+/**
+ * Check whether the character code represents an ASCII alphanumeric (`a`
+ * through `z`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
+ * (see `asciiAlpha`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
+
+/**
+ * Check whether the character code represents an ASCII atext.
+ *
+ * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in
+ * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),
+ * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F
+ * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E
+ * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE
+ * (`{`) to U+007E TILDE (`~`).
+ *
+ * See:
+ * **\[RFC5322]**:
+ * [Internet Message Format](https://tools.ietf.org/html/rfc5322).
+ * P. Resnick.
+ * IETF.
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
+
+/**
+ * Check whether a character code is an ASCII control character.
+ *
+ * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+ * to U+001F (US), or U+007F (DEL).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function asciiControl(code) {
+  return (
+    // Special whitespace codes (which have negative values), C0 and Control
+    // character DEL
+    code !== null && (code < 32 || code === 127)
+  );
+}
+
+/**
+ * Check whether the character code represents an ASCII digit (`0` through `9`).
+ *
+ * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
+ * U+0039 (`9`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiDigit = regexCheck(/\d/);
+
+/**
+ * Check whether the character code represents an ASCII hex digit (`a` through
+ * `f`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex
+ * digit, or an ASCII lower hex digit.
+ *
+ * An **ASCII upper hex digit** is a character in the inclusive range U+0041
+ * (`A`) to U+0046 (`F`).
+ *
+ * An **ASCII lower hex digit** is a character in the inclusive range U+0061
+ * (`a`) to U+0066 (`f`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
+
+/**
+ * Check whether the character code represents ASCII punctuation.
+ *
+ * An **ASCII punctuation** is a character in the inclusive ranges U+0021
+ * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT
+ * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT
+ * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
+
+/**
+ * Check whether a character code is a markdown line ending.
+ *
+ * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+ * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+ *
+ * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+ * RETURN (CR) are replaced by these virtual characters depending on whether
+ * they occurred together.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownLineEnding(code) {
+  return code !== null && code < -2;
+}
+
+/**
+ * Check whether a character code is a markdown line ending (see
+ * `markdownLineEnding`) or markdown space (see `markdownSpace`).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownLineEndingOrSpace(code) {
+  return code !== null && (code < 0 || code === 32);
+}
+
+/**
+ * Check whether a character code is a markdown space.
+ *
+ * A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+ * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+ *
+ * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+ * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+ * SPACE (VS) characters, depending on the column at which the tab occurred.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+export function markdownSpace(code) {
+  return code === -2 || code === -1 || code === 32;
+}
+
+// Size note: removing ASCII from the regex and using `asciiPunctuation` here
+// In fact adds to the bundle size.
+/**
+ * Check whether the character code represents Unicode punctuation.
+ *
+ * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
+ * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
+ * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
+ * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
+ * punctuation (see `asciiPunctuation`).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ *
+ * @param code
+ *   Code.
+ * @returns
+ *   Whether it matches.
+ */
+export const unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
+
+/**
+ * Check whether the character code represents Unicode whitespace.
+ *
+ * Note that this does handle micromark specific markdown whitespace characters.
+ * See `markdownLineEndingOrSpace` to check that.
+ *
+ * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
+ * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
+ * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ *
+ * @param code
+ *   Code.
+ * @returns
+ *   Whether it matches.
+ */
+export const unicodeWhitespace = regexCheck(/\s/);
+
+/**
+ * Create a code check from a regex.
+ *
+ * @param {RegExp} regex
+ * @returns {(code: Code) => boolean}
+ */
+function regexCheck(regex) {
+  return check;
+
+  /**
+   * Check whether a code matches the bound regex.
+   *
+   * @param {Code} code
+   *   Character code.
+   * @returns {boolean}
+   *   Whether the character code matches the bound regex.
+   */
+  function check(code) {
+    return code !== null && code > -1 && regex.test(String.fromCharCode(code));
+  }
+}

node_modules/micromark-extension-directive/node_modules/micromark-util-character/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "micromark-util-character",
+  "version": "2.1.0",
+  "description": "micromark utility to handle character codes",
+  "license": "MIT",
+  "keywords": [
+    "micromark",
+    "util",
+    "utility",
+    "character"
+  ],
+  "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-character",
+  "bugs": "https://github.com/micromark/micromark/issues",
+  "funding": [
+    {
+      "type": "GitHub Sponsors",
+      "url": "https://github.com/sponsors/unifiedjs"
+    },
+    {
+      "type": "OpenCollective",
+      "url": "https://opencollective.com/unified"
+    }
+  ],
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "files": [
+    "dev/",
+    "lib/",
+    "index.d.ts.map",
+    "index.d.ts",
+    "index.js"
+  ],
+  "exports": {
+    "development": "./dev/index.js",
+    "default": "./index.js"
+  },
+  "dependencies": {
+    "micromark-util-symbol": "^2.0.0",
+    "micromark-util-types": "^2.0.0"
+  },
+  "scripts": {
+    "build": "micromark-build"
+  },
+  "xo": {
+    "envs": [
+      "shared-node-browser"
+    ],
+    "prettier": true,
+    "rules": {
+      "unicorn/prefer-code-point": "off"
+    }
+  }
+}

node_modules/micromark-extension-directive/node_modules/micromark-util-character/readme.md

@@ -0,0 +1,446 @@
+# micromark-util-character
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][bundle-size-badge]][bundle-size]
+[![Sponsors][sponsors-badge]][opencollective]
+[![Backers][backers-badge]][opencollective]
+[![Chat][chat-badge]][chat]
+
+[micromark][] utility to handle [character codes][code].
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`asciiAlpha(code)`](#asciialphacode)
+    *   [`asciiAlphanumeric(code)`](#asciialphanumericcode)
+    *   [`asciiAtext(code)`](#asciiatextcode)
+    *   [`asciiControl(code)`](#asciicontrolcode)
+    *   [`asciiDigit(code)`](#asciidigitcode)
+    *   [`asciiHexDigit(code)`](#asciihexdigitcode)
+    *   [`asciiPunctuation(code)`](#asciipunctuationcode)
+    *   [`markdownLineEnding(code)`](#markdownlineendingcode)
+    *   [`markdownLineEndingOrSpace(code)`](#markdownlineendingorspacecode)
+    *   [`markdownSpace(code)`](#markdownspacecode)
+    *   [`unicodePunctuation(code)`](#unicodepunctuationcode)
+    *   [`unicodeWhitespace(code)`](#unicodewhitespacecode)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This package exposes algorithms to check whether characters match groups.
+
+## When should I use this?
+
+This package might be useful when you are making your own micromark extensions.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install micromark-util-character
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import * as character from 'https://esm.sh/micromark-util-character@1'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+<script type="module">
+  import * as character from 'https://esm.sh/micromark-util-character@1?bundle'
+</script>
+```
+
+## Use
+
+```js
+import {asciiAlpha} from 'micromark-util-character'
+
+console.log(asciiAlpha(64)) // false
+console.log(asciiAlpha(65)) // true
+```
+
+## API
+
+This module exports the identifiers
+[`asciiAlpha`][api-ascii-alpha],
+[`asciiAlphanumeric`][api-ascii-alphanumeric],
+[`asciiAtext`][api-ascii-atext],
+[`asciiControl`][api-ascii-control],
+[`asciiDigit`][api-ascii-digit],
+[`asciiHexDigit`][api-ascii-hex-digit],
+[`asciiPunctuation`][api-ascii-punctuation],
+[`markdownLineEnding`][api-markdown-line-ending],
+[`markdownLineEndingOrSpace`][api-markdown-line-ending-or-space],
+[`markdownSpace`][api-markdown-space],
+[`unicodePunctuation`][api-unicode-punctuation],
+[`unicodeWhitespace`][api-unicode-whitespace].
+There is no default export.
+
+### `asciiAlpha(code)`
+
+Check whether the [character code][code] represents an ASCII alpha (`a` through
+`z`, case insensitive).
+
+An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
+
+An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
+to U+005A (`Z`).
+
+An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
+to U+007A (`z`).
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `asciiAlphanumeric(code)`
+
+Check whether the [character code][code] represents an ASCII alphanumeric (`a`
+through `z`, case insensitive, or `0` through `9`).
+
+An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
+(see `asciiAlpha`).
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `asciiAtext(code)`
+
+Check whether the [character code][code] represents an ASCII atext.
+
+atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in
+the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),
+U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F
+SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E
+CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE
+(`{`) to U+007E TILDE (`~`) (**\[RFC5322]**).
+
+See **\[RFC5322]**:\
+[Internet Message Format](https://tools.ietf.org/html/rfc5322).\
+P. Resnick.\
+IETF.
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `asciiControl(code)`
+
+Check whether a [character code][code] is an ASCII control character.
+
+An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+to U+001F (US), or U+007F (DEL).
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `asciiDigit(code)`
+
+Check whether the [character code][code] represents an ASCII digit (`0` through
+`9`).
+
+An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
+U+0039 (`9`).
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `asciiHexDigit(code)`
+
+Check whether the [character code][code] represents an ASCII hex digit (`a`
+through `f`, case insensitive, or `0` through `9`).
+
+An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex
+digit, or an ASCII lower hex digit.
+
+An **ASCII upper hex digit** is a character in the inclusive range U+0041
+(`A`) to U+0046 (`F`).
+
+An **ASCII lower hex digit** is a character in the inclusive range U+0061
+(`a`) to U+0066 (`f`).
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `asciiPunctuation(code)`
+
+Check whether the [character code][code] represents ASCII punctuation.
+
+An **ASCII punctuation** is a character in the inclusive ranges U+0021
+EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT
+SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT
+(`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `markdownLineEnding(code)`
+
+Check whether a [character code][code] is a markdown line ending.
+
+A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+
+In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+RETURN (CR) are replaced by these virtual characters depending on whether
+they occurred together.
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `markdownLineEndingOrSpace(code)`
+
+Check whether a [character code][code] is a markdown line ending (see
+`markdownLineEnding`) or markdown space (see `markdownSpace`).
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `markdownSpace(code)`
+
+Check whether a [character code][code] is a markdown space.
+
+A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+
+In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+SPACE (VS) characters, depending on the column at which the tab occurred.
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `unicodePunctuation(code)`
+
+Check whether the [character code][code] represents Unicode punctuation.
+
+A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
+Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
+(Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
+(Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
+punctuation (see `asciiPunctuation`) (**\[UNICODE]**).
+
+See **\[UNICODE]**:\
+[The Unicode Standard](https://www.unicode.org/versions/).\
+Unicode Consortium.
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+### `unicodeWhitespace(code)`
+
+Check whether the [character code][code] represents Unicode whitespace.
+
+Note that this does handle micromark specific markdown whitespace characters.
+See `markdownLineEndingOrSpace` to check that.
+
+A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
+Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
+U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
+
+See **\[UNICODE]**:\
+[The Unicode Standard](https://www.unicode.org/versions/).\
+Unicode Consortium.
+
+###### Parameters
+
+*   `code` (`Code`)
+    — code
+
+###### Returns
+
+Whether it matches (`boolean`).
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports no additional types.
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line,
+`micromark-util-character@^2`, compatible with Node.js 16.
+This package works with `micromark@^3`.
+
+## Security
+
+This package is safe.
+See [`security.md`][securitymd] in [`micromark/.github`][health] for how to
+submit a security report.
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`micromark/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organisation, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+<!-- Definitions -->
+
+[build-badge]: https://github.com/micromark/micromark/workflows/main/badge.svg
+
+[build]: https://github.com/micromark/micromark/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/micromark/micromark.svg
+
+[coverage]: https://codecov.io/github/micromark/micromark
+
+[downloads-badge]: https://img.shields.io/npm/dm/micromark-util-character.svg
+
+[downloads]: https://www.npmjs.com/package/micromark-util-character
+
+[bundle-size-badge]: https://img.shields.io/badge/dynamic/json?label=minzipped%20size&query=$.size.compressedSize&url=https://deno.bundlejs.com/?q=micromark-util-character
+
+[bundle-size]: https://bundlejs.com/?q=micromark-util-character
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[opencollective]: https://opencollective.com/unified
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/micromark/micromark/discussions
+
+[license]: https://github.com/micromark/micromark/blob/main/license
+
+[author]: https://wooorm.com
+
+[health]: https://github.com/micromark/.github
+
+[securitymd]: https://github.com/micromark/.github/blob/main/security.md
+
+[contributing]: https://github.com/micromark/.github/blob/main/contributing.md
+
+[support]: https://github.com/micromark/.github/blob/main/support.md
+
+[coc]: https://github.com/micromark/.github/blob/main/code-of-conduct.md
+
+[typescript]: https://www.typescriptlang.org
+
+[micromark]: https://github.com/micromark/micromark
+
+[code]: https://github.com/micromark/micromark#preprocess
+
+[api-ascii-alpha]: #asciialphacode
+
+[api-ascii-alphanumeric]: #asciialphanumericcode
+
+[api-ascii-atext]: #asciiatextcode
+
+[api-ascii-control]: #asciicontrolcode
+
+[api-ascii-digit]: #asciidigitcode
+
+[api-ascii-hex-digit]: #asciihexdigitcode
+
+[api-ascii-punctuation]: #asciipunctuationcode
+
+[api-markdown-line-ending]: #markdownlineendingcode
+
+[api-markdown-line-ending-or-space]: #markdownlineendingorspacecode
+
+[api-markdown-space]: #markdownspacecode
+
+[api-unicode-punctuation]: #unicodepunctuationcode
+
+[api-unicode-whitespace]: #unicodewhitespacecode

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/codes.d.ts

@@ -0,0 +1,138 @@
+export namespace codes {
+  let carriageReturn: -5
+  let lineFeed: -4
+  let carriageReturnLineFeed: -3
+  let horizontalTab: -2
+  let virtualSpace: -1
+  let eof: null
+  let nul: 0
+  let soh: 1
+  let stx: 2
+  let etx: 3
+  let eot: 4
+  let enq: 5
+  let ack: 6
+  let bel: 7
+  let bs: 8
+  let ht: 9
+  let lf: 10
+  let vt: 11
+  let ff: 12
+  let cr: 13
+  let so: 14
+  let si: 15
+  let dle: 16
+  let dc1: 17
+  let dc2: 18
+  let dc3: 19
+  let dc4: 20
+  let nak: 21
+  let syn: 22
+  let etb: 23
+  let can: 24
+  let em: 25
+  let sub: 26
+  let esc: 27
+  let fs: 28
+  let gs: 29
+  let rs: 30
+  let us: 31
+  let space: 32
+  let exclamationMark: 33
+  let quotationMark: 34
+  let numberSign: 35
+  let dollarSign: 36
+  let percentSign: 37
+  let ampersand: 38
+  let apostrophe: 39
+  let leftParenthesis: 40
+  let rightParenthesis: 41
+  let asterisk: 42
+  let plusSign: 43
+  let comma: 44
+  let dash: 45
+  let dot: 46
+  let slash: 47
+  let digit0: 48
+  let digit1: 49
+  let digit2: 50
+  let digit3: 51
+  let digit4: 52
+  let digit5: 53
+  let digit6: 54
+  let digit7: 55
+  let digit8: 56
+  let digit9: 57
+  let colon: 58
+  let semicolon: 59
+  let lessThan: 60
+  let equalsTo: 61
+  let greaterThan: 62
+  let questionMark: 63
+  let atSign: 64
+  let uppercaseA: 65
+  let uppercaseB: 66
+  let uppercaseC: 67
+  let uppercaseD: 68
+  let uppercaseE: 69
+  let uppercaseF: 70
+  let uppercaseG: 71
+  let uppercaseH: 72
+  let uppercaseI: 73
+  let uppercaseJ: 74
+  let uppercaseK: 75
+  let uppercaseL: 76
+  let uppercaseM: 77
+  let uppercaseN: 78
+  let uppercaseO: 79
+  let uppercaseP: 80
+  let uppercaseQ: 81
+  let uppercaseR: 82
+  let uppercaseS: 83
+  let uppercaseT: 84
+  let uppercaseU: 85
+  let uppercaseV: 86
+  let uppercaseW: 87
+  let uppercaseX: 88
+  let uppercaseY: 89
+  let uppercaseZ: 90
+  let leftSquareBracket: 91
+  let backslash: 92
+  let rightSquareBracket: 93
+  let caret: 94
+  let underscore: 95
+  let graveAccent: 96
+  let lowercaseA: 97
+  let lowercaseB: 98
+  let lowercaseC: 99
+  let lowercaseD: 100
+  let lowercaseE: 101
+  let lowercaseF: 102
+  let lowercaseG: 103
+  let lowercaseH: 104
+  let lowercaseI: 105
+  let lowercaseJ: 106
+  let lowercaseK: 107
+  let lowercaseL: 108
+  let lowercaseM: 109
+  let lowercaseN: 110
+  let lowercaseO: 111
+  let lowercaseP: 112
+  let lowercaseQ: 113
+  let lowercaseR: 114
+  let lowercaseS: 115
+  let lowercaseT: 116
+  let lowercaseU: 117
+  let lowercaseV: 118
+  let lowercaseW: 119
+  let lowercaseX: 120
+  let lowercaseY: 121
+  let lowercaseZ: 122
+  let leftCurlyBrace: 123
+  let verticalBar: 124
+  let rightCurlyBrace: 125
+  let tilde: 126
+  let del: 127
+  let byteOrderMarker: 65279
+  let replacementCharacter: 65533
+}

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/codes.js

@@ -0,0 +1,158 @@
+/**
+ * Character codes.
+ *
+ * This module is compiled away!
+ *
+ * micromark works based on character codes.
+ * This module contains constants for the ASCII block and the replacement
+ * character.
+ * A couple of them are handled in a special way, such as the line endings
+ * (CR, LF, and CR+LF, commonly known as end-of-line: EOLs), the tab (horizontal
+ * tab) and its expansion based on what column it’s at (virtual space),
+ * and the end-of-file (eof) character.
+ * As values are preprocessed before handling them, the actual characters LF,
+ * CR, HT, and NUL (which is present as the replacement character), are
+ * guaranteed to not exist.
+ *
+ * Unicode basic latin block.
+ */
+export const codes = /** @type {const} */ ({
+  carriageReturn: -5,
+  lineFeed: -4,
+  carriageReturnLineFeed: -3,
+  horizontalTab: -2,
+  virtualSpace: -1,
+  eof: null,
+  nul: 0,
+  soh: 1,
+  stx: 2,
+  etx: 3,
+  eot: 4,
+  enq: 5,
+  ack: 6,
+  bel: 7,
+  bs: 8,
+  ht: 9, // `\t`
+  lf: 10, // `\n`
+  vt: 11, // `\v`
+  ff: 12, // `\f`
+  cr: 13, // `\r`
+  so: 14,
+  si: 15,
+  dle: 16,
+  dc1: 17,
+  dc2: 18,
+  dc3: 19,
+  dc4: 20,
+  nak: 21,
+  syn: 22,
+  etb: 23,
+  can: 24,
+  em: 25,
+  sub: 26,
+  esc: 27,
+  fs: 28,
+  gs: 29,
+  rs: 30,
+  us: 31,
+  space: 32,
+  exclamationMark: 33, // `!`
+  quotationMark: 34, // `"`
+  numberSign: 35, // `#`
+  dollarSign: 36, // `$`
+  percentSign: 37, // `%`
+  ampersand: 38, // `&`
+  apostrophe: 39, // `'`
+  leftParenthesis: 40, // `(`
+  rightParenthesis: 41, // `)`
+  asterisk: 42, // `*`
+  plusSign: 43, // `+`
+  comma: 44, // `,`
+  dash: 45, // `-`
+  dot: 46, // `.`
+  slash: 47, // `/`
+  digit0: 48, // `0`
+  digit1: 49, // `1`
+  digit2: 50, // `2`
+  digit3: 51, // `3`
+  digit4: 52, // `4`
+  digit5: 53, // `5`
+  digit6: 54, // `6`
+  digit7: 55, // `7`
+  digit8: 56, // `8`
+  digit9: 57, // `9`
+  colon: 58, // `:`
+  semicolon: 59, // `;`
+  lessThan: 60, // `<`
+  equalsTo: 61, // `=`
+  greaterThan: 62, // `>`
+  questionMark: 63, // `?`
+  atSign: 64, // `@`
+  uppercaseA: 65, // `A`
+  uppercaseB: 66, // `B`
+  uppercaseC: 67, // `C`
+  uppercaseD: 68, // `D`
+  uppercaseE: 69, // `E`
+  uppercaseF: 70, // `F`
+  uppercaseG: 71, // `G`
+  uppercaseH: 72, // `H`
+  uppercaseI: 73, // `I`
+  uppercaseJ: 74, // `J`
+  uppercaseK: 75, // `K`
+  uppercaseL: 76, // `L`
+  uppercaseM: 77, // `M`
+  uppercaseN: 78, // `N`
+  uppercaseO: 79, // `O`
+  uppercaseP: 80, // `P`
+  uppercaseQ: 81, // `Q`
+  uppercaseR: 82, // `R`
+  uppercaseS: 83, // `S`
+  uppercaseT: 84, // `T`
+  uppercaseU: 85, // `U`
+  uppercaseV: 86, // `V`
+  uppercaseW: 87, // `W`
+  uppercaseX: 88, // `X`
+  uppercaseY: 89, // `Y`
+  uppercaseZ: 90, // `Z`
+  leftSquareBracket: 91, // `[`
+  backslash: 92, // `\`
+  rightSquareBracket: 93, // `]`
+  caret: 94, // `^`
+  underscore: 95, // `_`
+  graveAccent: 96, // `` ` ``
+  lowercaseA: 97, // `a`
+  lowercaseB: 98, // `b`
+  lowercaseC: 99, // `c`
+  lowercaseD: 100, // `d`
+  lowercaseE: 101, // `e`
+  lowercaseF: 102, // `f`
+  lowercaseG: 103, // `g`
+  lowercaseH: 104, // `h`
+  lowercaseI: 105, // `i`
+  lowercaseJ: 106, // `j`
+  lowercaseK: 107, // `k`
+  lowercaseL: 108, // `l`
+  lowercaseM: 109, // `m`
+  lowercaseN: 110, // `n`
+  lowercaseO: 111, // `o`
+  lowercaseP: 112, // `p`
+  lowercaseQ: 113, // `q`
+  lowercaseR: 114, // `r`
+  lowercaseS: 115, // `s`
+  lowercaseT: 116, // `t`
+  lowercaseU: 117, // `u`
+  lowercaseV: 118, // `v`
+  lowercaseW: 119, // `w`
+  lowercaseX: 120, // `x`
+  lowercaseY: 121, // `y`
+  lowercaseZ: 122, // `z`
+  leftCurlyBrace: 123, // `{`
+  verticalBar: 124, // `|`
+  rightCurlyBrace: 125, // `}`
+  tilde: 126, // `~`
+  del: 127,
+  // Unicode Specials block.
+  byteOrderMarker: 65279,
+  // Unicode Specials block.
+  replacementCharacter: 65533 // `<60>`
+})

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/constants.d.ts

@@ -0,0 +1,36 @@
+export namespace constants {
+  let attentionSideBefore: 1
+  let attentionSideAfter: 2
+  let atxHeadingOpeningFenceSizeMax: 6
+  let autolinkDomainSizeMax: 63
+  let autolinkSchemeSizeMax: 32
+  let cdataOpeningString: 'CDATA['
+  let characterGroupWhitespace: 1
+  let characterGroupPunctuation: 2
+  let characterReferenceDecimalSizeMax: 7
+  let characterReferenceHexadecimalSizeMax: 6
+  let characterReferenceNamedSizeMax: 31
+  let codeFencedSequenceSizeMin: 3
+  let contentTypeDocument: 'document'
+  let contentTypeFlow: 'flow'
+  let contentTypeContent: 'content'
+  let contentTypeString: 'string'
+  let contentTypeText: 'text'
+  let hardBreakPrefixSizeMin: 2
+  let htmlRaw: 1
+  let htmlComment: 2
+  let htmlInstruction: 3
+  let htmlDeclaration: 4
+  let htmlCdata: 5
+  let htmlBasic: 6
+  let htmlComplete: 7
+  let htmlRawSizeMax: 8
+  let linkResourceDestinationBalanceMax: 32
+  let linkReferenceSizeMax: 999
+  let listItemValueSizeMax: 10
+  let numericBaseDecimal: 10
+  let numericBaseHexadecimal: 16
+  let tabSize: 4
+  let thematicBreakMarkerCountMin: 3
+  let v8MaxSafeChunkSize: 10000
+}

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/constants.js

@@ -0,0 +1,44 @@
+/**
+ * This module is compiled away!
+ *
+ * Parsing markdown comes with a couple of constants, such as minimum or maximum
+ * sizes of certain sequences.
+ * Additionally, there are a couple symbols used inside micromark.
+ * These are all defined here, but compiled away by scripts.
+ */
+export const constants = /** @type {const} */ ({
+  attentionSideBefore: 1, // Symbol to mark an attention sequence as before content: `*a`
+  attentionSideAfter: 2, // Symbol to mark an attention sequence as after content: `a*`
+  atxHeadingOpeningFenceSizeMax: 6, // 6 number signs is fine, 7 isn’t.
+  autolinkDomainSizeMax: 63, // 63 characters is fine, 64 is too many.
+  autolinkSchemeSizeMax: 32, // 32 characters is fine, 33 is too many.
+  cdataOpeningString: 'CDATA[', // And preceded by `<![`.
+  characterGroupWhitespace: 1, // Symbol used to indicate a character is whitespace
+  characterGroupPunctuation: 2, // Symbol used to indicate a character is punctuation
+  characterReferenceDecimalSizeMax: 7, // `&#9999999;`.
+  characterReferenceHexadecimalSizeMax: 6, // `&#xff9999;`.
+  characterReferenceNamedSizeMax: 31, // `&CounterClockwiseContourIntegral;`.
+  codeFencedSequenceSizeMin: 3, // At least 3 ticks or tildes are needed.
+  contentTypeDocument: 'document',
+  contentTypeFlow: 'flow',
+  contentTypeContent: 'content',
+  contentTypeString: 'string',
+  contentTypeText: 'text',
+  hardBreakPrefixSizeMin: 2, // At least 2 trailing spaces are needed.
+  htmlRaw: 1, // Symbol for `<script>`
+  htmlComment: 2, // Symbol for `<!---->`
+  htmlInstruction: 3, // Symbol for `<?php?>`
+  htmlDeclaration: 4, // Symbol for `<!doctype>`
+  htmlCdata: 5, // Symbol for `<![CDATA[]]>`
+  htmlBasic: 6, // Symbol for `<div`
+  htmlComplete: 7, // Symbol for `<x>`
+  htmlRawSizeMax: 8, // Length of `textarea`.
+  linkResourceDestinationBalanceMax: 32, // See: <https://spec.commonmark.org/0.30/#link-destination>, <https://github.com/remarkjs/react-markdown/issues/658#issuecomment-984345577>
+  linkReferenceSizeMax: 999, // See: <https://spec.commonmark.org/0.30/#link-label>
+  listItemValueSizeMax: 10, // See: <https://spec.commonmark.org/0.30/#ordered-list-marker>
+  numericBaseDecimal: 10,
+  numericBaseHexadecimal: 0x10,
+  tabSize: 4, // Tabs have a hard-coded size of 4, per CommonMark.
+  thematicBreakMarkerCountMin: 3, // At least 3 asterisks, dashes, or underscores are needed.
+  v8MaxSafeChunkSize: 10000 // V8 (and potentially others) have problems injecting giant arrays into other arrays, hence we operate in chunks.
+})

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/default.d.ts

@@ -0,0 +1,4 @@
+export {codes} from './codes.js'
+export {constants} from './constants.js'
+export {types} from './types.js'
+export {values} from './values.js'

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/default.js

@@ -0,0 +1,4 @@
+export {codes} from './codes.js'
+export {constants} from './constants.js'
+export {types} from './types.js'
+export {values} from './values.js'

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/types.d.ts

@@ -0,0 +1,105 @@
+export namespace types {
+  let data: 'data'
+  let whitespace: 'whitespace'
+  let lineEnding: 'lineEnding'
+  let lineEndingBlank: 'lineEndingBlank'
+  let linePrefix: 'linePrefix'
+  let lineSuffix: 'lineSuffix'
+  let atxHeading: 'atxHeading'
+  let atxHeadingSequence: 'atxHeadingSequence'
+  let atxHeadingText: 'atxHeadingText'
+  let autolink: 'autolink'
+  let autolinkEmail: 'autolinkEmail'
+  let autolinkMarker: 'autolinkMarker'
+  let autolinkProtocol: 'autolinkProtocol'
+  let characterEscape: 'characterEscape'
+  let characterEscapeValue: 'characterEscapeValue'
+  let characterReference: 'characterReference'
+  let characterReferenceMarker: 'characterReferenceMarker'
+  let characterReferenceMarkerNumeric: 'characterReferenceMarkerNumeric'
+  let characterReferenceMarkerHexadecimal: 'characterReferenceMarkerHexadecimal'
+  let characterReferenceValue: 'characterReferenceValue'
+  let codeFenced: 'codeFenced'
+  let codeFencedFence: 'codeFencedFence'
+  let codeFencedFenceSequence: 'codeFencedFenceSequence'
+  let codeFencedFenceInfo: 'codeFencedFenceInfo'
+  let codeFencedFenceMeta: 'codeFencedFenceMeta'
+  let codeFlowValue: 'codeFlowValue'
+  let codeIndented: 'codeIndented'
+  let codeText: 'codeText'
+  let codeTextData: 'codeTextData'
+  let codeTextPadding: 'codeTextPadding'
+  let codeTextSequence: 'codeTextSequence'
+  let content: 'content'
+  let definition: 'definition'
+  let definitionDestination: 'definitionDestination'
+  let definitionDestinationLiteral: 'definitionDestinationLiteral'
+  let definitionDestinationLiteralMarker: 'definitionDestinationLiteralMarker'
+  let definitionDestinationRaw: 'definitionDestinationRaw'
+  let definitionDestinationString: 'definitionDestinationString'
+  let definitionLabel: 'definitionLabel'
+  let definitionLabelMarker: 'definitionLabelMarker'
+  let definitionLabelString: 'definitionLabelString'
+  let definitionMarker: 'definitionMarker'
+  let definitionTitle: 'definitionTitle'
+  let definitionTitleMarker: 'definitionTitleMarker'
+  let definitionTitleString: 'definitionTitleString'
+  let emphasis: 'emphasis'
+  let emphasisSequence: 'emphasisSequence'
+  let emphasisText: 'emphasisText'
+  let escapeMarker: 'escapeMarker'
+  let hardBreakEscape: 'hardBreakEscape'
+  let hardBreakTrailing: 'hardBreakTrailing'
+  let htmlFlow: 'htmlFlow'
+  let htmlFlowData: 'htmlFlowData'
+  let htmlText: 'htmlText'
+  let htmlTextData: 'htmlTextData'
+  let image: 'image'
+  let label: 'label'
+  let labelText: 'labelText'
+  let labelLink: 'labelLink'
+  let labelImage: 'labelImage'
+  let labelMarker: 'labelMarker'
+  let labelImageMarker: 'labelImageMarker'
+  let labelEnd: 'labelEnd'
+  let link: 'link'
+  let paragraph: 'paragraph'
+  let reference: 'reference'
+  let referenceMarker: 'referenceMarker'
+  let referenceString: 'referenceString'
+  let resource: 'resource'
+  let resourceDestination: 'resourceDestination'
+  let resourceDestinationLiteral: 'resourceDestinationLiteral'
+  let resourceDestinationLiteralMarker: 'resourceDestinationLiteralMarker'
+  let resourceDestinationRaw: 'resourceDestinationRaw'
+  let resourceDestinationString: 'resourceDestinationString'
+  let resourceMarker: 'resourceMarker'
+  let resourceTitle: 'resourceTitle'
+  let resourceTitleMarker: 'resourceTitleMarker'
+  let resourceTitleString: 'resourceTitleString'
+  let setextHeading: 'setextHeading'
+  let setextHeadingText: 'setextHeadingText'
+  let setextHeadingLine: 'setextHeadingLine'
+  let setextHeadingLineSequence: 'setextHeadingLineSequence'
+  let strong: 'strong'
+  let strongSequence: 'strongSequence'
+  let strongText: 'strongText'
+  let thematicBreak: 'thematicBreak'
+  let thematicBreakSequence: 'thematicBreakSequence'
+  let blockQuote: 'blockQuote'
+  let blockQuotePrefix: 'blockQuotePrefix'
+  let blockQuoteMarker: 'blockQuoteMarker'
+  let blockQuotePrefixWhitespace: 'blockQuotePrefixWhitespace'
+  let listOrdered: 'listOrdered'
+  let listUnordered: 'listUnordered'
+  let listItemIndent: 'listItemIndent'
+  let listItemMarker: 'listItemMarker'
+  let listItemPrefix: 'listItemPrefix'
+  let listItemPrefixWhitespace: 'listItemPrefixWhitespace'
+  let listItemValue: 'listItemValue'
+  let chunkDocument: 'chunkDocument'
+  let chunkContent: 'chunkContent'
+  let chunkFlow: 'chunkFlow'
+  let chunkText: 'chunkText'
+  let chunkString: 'chunkString'
+}

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/types.js

@@ -0,0 +1,453 @@
+/**
+ * This module is compiled away!
+ *
+ * Here is the list of all types of tokens exposed by micromark, with a short
+ * explanation of what they include and where they are found.
+ * In picking names, generally, the rule is to be as explicit as possible
+ * instead of reusing names.
+ * For example, there is a `definitionDestination` and a `resourceDestination`,
+ * instead of one shared name.
+ */
+
+// Note: when changing the next record, you must also change `TokenTypeMap`
+// in `micromark-util-types/index.d.ts`.
+export const types = /** @type {const} */ ({
+  // Generic type for data, such as in a title, a destination, etc.
+  data: 'data',
+
+  // Generic type for syntactic whitespace (tabs, virtual spaces, spaces).
+  // Such as, between a fenced code fence and an info string.
+  whitespace: 'whitespace',
+
+  // Generic type for line endings (line feed, carriage return, carriage return +
+  // line feed).
+  lineEnding: 'lineEnding',
+
+  // A line ending, but ending a blank line.
+  lineEndingBlank: 'lineEndingBlank',
+
+  // Generic type for whitespace (tabs, virtual spaces, spaces) at the start of a
+  // line.
+  linePrefix: 'linePrefix',
+
+  // Generic type for whitespace (tabs, virtual spaces, spaces) at the end of a
+  // line.
+  lineSuffix: 'lineSuffix',
+
+  // Whole ATX heading:
+  //
+  // ```markdown
+  // #
+  // ## Alpha
+  // ### Bravo ###
+  // ```
+  //
+  // Includes `atxHeadingSequence`, `whitespace`, `atxHeadingText`.
+  atxHeading: 'atxHeading',
+
+  // Sequence of number signs in an ATX heading (`###`).
+  atxHeadingSequence: 'atxHeadingSequence',
+
+  // Content in an ATX heading (`alpha`).
+  // Includes text.
+  atxHeadingText: 'atxHeadingText',
+
+  // Whole autolink (`<https://example.com>` or `<admin@example.com>`)
+  // Includes `autolinkMarker` and `autolinkProtocol` or `autolinkEmail`.
+  autolink: 'autolink',
+
+  // Email autolink w/o markers (`admin@example.com`)
+  autolinkEmail: 'autolinkEmail',
+
+  // Marker around an `autolinkProtocol` or `autolinkEmail` (`<` or `>`).
+  autolinkMarker: 'autolinkMarker',
+
+  // Protocol autolink w/o markers (`https://example.com`)
+  autolinkProtocol: 'autolinkProtocol',
+
+  // A whole character escape (`\-`).
+  // Includes `escapeMarker` and `characterEscapeValue`.
+  characterEscape: 'characterEscape',
+
+  // The escaped character (`-`).
+  characterEscapeValue: 'characterEscapeValue',
+
+  // A whole character reference (`&amp;`, `&#8800;`, or `&#x1D306;`).
+  // Includes `characterReferenceMarker`, an optional
+  // `characterReferenceMarkerNumeric`, in which case an optional
+  // `characterReferenceMarkerHexadecimal`, and a `characterReferenceValue`.
+  characterReference: 'characterReference',
+
+  // The start or end marker (`&` or `;`).
+  characterReferenceMarker: 'characterReferenceMarker',
+
+  // Mark reference as numeric (`#`).
+  characterReferenceMarkerNumeric: 'characterReferenceMarkerNumeric',
+
+  // Mark reference as numeric (`x` or `X`).
+  characterReferenceMarkerHexadecimal: 'characterReferenceMarkerHexadecimal',
+
+  // Value of character reference w/o markers (`amp`, `8800`, or `1D306`).
+  characterReferenceValue: 'characterReferenceValue',
+
+  // Whole fenced code:
+  //
+  // ````markdown
+  // ```js
+  // alert(1)
+  // ```
+  // ````
+  codeFenced: 'codeFenced',
+
+  // A fenced code fence, including whitespace, sequence, info, and meta
+  // (` ```js `).
+  codeFencedFence: 'codeFencedFence',
+
+  // Sequence of grave accent or tilde characters (` ``` `) in a fence.
+  codeFencedFenceSequence: 'codeFencedFenceSequence',
+
+  // Info word (`js`) in a fence.
+  // Includes string.
+  codeFencedFenceInfo: 'codeFencedFenceInfo',
+
+  // Meta words (`highlight="1"`) in a fence.
+  // Includes string.
+  codeFencedFenceMeta: 'codeFencedFenceMeta',
+
+  // A line of code.
+  codeFlowValue: 'codeFlowValue',
+
+  // Whole indented code:
+  //
+  // ```markdown
+  //     alert(1)
+  // ```
+  //
+  // Includes `lineEnding`, `linePrefix`, and `codeFlowValue`.
+  codeIndented: 'codeIndented',
+
+  // A text code (``` `alpha` ```).
+  // Includes `codeTextSequence`, `codeTextData`, `lineEnding`, and can include
+  // `codeTextPadding`.
+  codeText: 'codeText',
+
+  codeTextData: 'codeTextData',
+
+  // A space or line ending right after or before a tick.
+  codeTextPadding: 'codeTextPadding',
+
+  // A text code fence (` `` `).
+  codeTextSequence: 'codeTextSequence',
+
+  // Whole content:
+  //
+  // ```markdown
+  // [a]: b
+  // c
+  // =
+  // d
+  // ```
+  //
+  // Includes `paragraph` and `definition`.
+  content: 'content',
+  // Whole definition:
+  //
+  // ```markdown
+  // [micromark]: https://github.com/micromark/micromark
+  // ```
+  //
+  // Includes `definitionLabel`, `definitionMarker`, `whitespace`,
+  // `definitionDestination`, and optionally `lineEnding` and `definitionTitle`.
+  definition: 'definition',
+
+  // Destination of a definition (`https://github.com/micromark/micromark` or
+  // `<https://github.com/micromark/micromark>`).
+  // Includes `definitionDestinationLiteral` or `definitionDestinationRaw`.
+  definitionDestination: 'definitionDestination',
+
+  // Enclosed destination of a definition
+  // (`<https://github.com/micromark/micromark>`).
+  // Includes `definitionDestinationLiteralMarker` and optionally
+  // `definitionDestinationString`.
+  definitionDestinationLiteral: 'definitionDestinationLiteral',
+
+  // Markers of an enclosed definition destination (`<` or `>`).
+  definitionDestinationLiteralMarker: 'definitionDestinationLiteralMarker',
+
+  // Unenclosed destination of a definition
+  // (`https://github.com/micromark/micromark`).
+  // Includes `definitionDestinationString`.
+  definitionDestinationRaw: 'definitionDestinationRaw',
+
+  // Text in an destination (`https://github.com/micromark/micromark`).
+  // Includes string.
+  definitionDestinationString: 'definitionDestinationString',
+
+  // Label of a definition (`[micromark]`).
+  // Includes `definitionLabelMarker` and `definitionLabelString`.
+  definitionLabel: 'definitionLabel',
+
+  // Markers of a definition label (`[` or `]`).
+  definitionLabelMarker: 'definitionLabelMarker',
+
+  // Value of a definition label (`micromark`).
+  // Includes string.
+  definitionLabelString: 'definitionLabelString',
+
+  // Marker between a label and a destination (`:`).
+  definitionMarker: 'definitionMarker',
+
+  // Title of a definition (`"x"`, `'y'`, or `(z)`).
+  // Includes `definitionTitleMarker` and optionally `definitionTitleString`.
+  definitionTitle: 'definitionTitle',
+
+  // Marker around a title of a definition (`"`, `'`, `(`, or `)`).
+  definitionTitleMarker: 'definitionTitleMarker',
+
+  // Data without markers in a title (`z`).
+  // Includes string.
+  definitionTitleString: 'definitionTitleString',
+
+  // Emphasis (`*alpha*`).
+  // Includes `emphasisSequence` and `emphasisText`.
+  emphasis: 'emphasis',
+
+  // Sequence of emphasis markers (`*` or `_`).
+  emphasisSequence: 'emphasisSequence',
+
+  // Emphasis text (`alpha`).
+  // Includes text.
+  emphasisText: 'emphasisText',
+
+  // The character escape marker (`\`).
+  escapeMarker: 'escapeMarker',
+
+  // A hard break created with a backslash (`\\n`).
+  // Note: does not include the line ending.
+  hardBreakEscape: 'hardBreakEscape',
+
+  // A hard break created with trailing spaces (`  \n`).
+  // Does not include the line ending.
+  hardBreakTrailing: 'hardBreakTrailing',
+
+  // Flow HTML:
+  //
+  // ```markdown
+  // <div
+  // ```
+  //
+  // Inlcudes `lineEnding`, `htmlFlowData`.
+  htmlFlow: 'htmlFlow',
+
+  htmlFlowData: 'htmlFlowData',
+
+  // HTML in text (the tag in `a <i> b`).
+  // Includes `lineEnding`, `htmlTextData`.
+  htmlText: 'htmlText',
+
+  htmlTextData: 'htmlTextData',
+
+  // Whole image (`![alpha](bravo)`, `![alpha][bravo]`, `![alpha][]`, or
+  // `![alpha]`).
+  // Includes `label` and an optional `resource` or `reference`.
+  image: 'image',
+
+  // Whole link label (`[*alpha*]`).
+  // Includes `labelLink` or `labelImage`, `labelText`, and `labelEnd`.
+  label: 'label',
+
+  // Text in an label (`*alpha*`).
+  // Includes text.
+  labelText: 'labelText',
+
+  // Start a link label (`[`).
+  // Includes a `labelMarker`.
+  labelLink: 'labelLink',
+
+  // Start an image label (`![`).
+  // Includes `labelImageMarker` and `labelMarker`.
+  labelImage: 'labelImage',
+
+  // Marker of a label (`[` or `]`).
+  labelMarker: 'labelMarker',
+
+  // Marker to start an image (`!`).
+  labelImageMarker: 'labelImageMarker',
+
+  // End a label (`]`).
+  // Includes `labelMarker`.
+  labelEnd: 'labelEnd',
+
+  // Whole link (`[alpha](bravo)`, `[alpha][bravo]`, `[alpha][]`, or `[alpha]`).
+  // Includes `label` and an optional `resource` or `reference`.
+  link: 'link',
+
+  // Whole paragraph:
+  //
+  // ```markdown
+  // alpha
+  // bravo.
+  // ```
+  //
+  // Includes text.
+  paragraph: 'paragraph',
+
+  // A reference (`[alpha]` or `[]`).
+  // Includes `referenceMarker` and an optional `referenceString`.
+  reference: 'reference',
+
+  // A reference marker (`[` or `]`).
+  referenceMarker: 'referenceMarker',
+
+  // Reference text (`alpha`).
+  // Includes string.
+  referenceString: 'referenceString',
+
+  // A resource (`(https://example.com "alpha")`).
+  // Includes `resourceMarker`, an optional `resourceDestination` with an optional
+  // `whitespace` and `resourceTitle`.
+  resource: 'resource',
+
+  // A resource destination (`https://example.com`).
+  // Includes `resourceDestinationLiteral` or `resourceDestinationRaw`.
+  resourceDestination: 'resourceDestination',
+
+  // A literal resource destination (`<https://example.com>`).
+  // Includes `resourceDestinationLiteralMarker` and optionally
+  // `resourceDestinationString`.
+  resourceDestinationLiteral: 'resourceDestinationLiteral',
+
+  // A resource destination marker (`<` or `>`).
+  resourceDestinationLiteralMarker: 'resourceDestinationLiteralMarker',
+
+  // A raw resource destination (`https://example.com`).
+  // Includes `resourceDestinationString`.
+  resourceDestinationRaw: 'resourceDestinationRaw',
+
+  // Resource destination text (`https://example.com`).
+  // Includes string.
+  resourceDestinationString: 'resourceDestinationString',
+
+  // A resource marker (`(` or `)`).
+  resourceMarker: 'resourceMarker',
+
+  // A resource title (`"alpha"`, `'alpha'`, or `(alpha)`).
+  // Includes `resourceTitleMarker` and optionally `resourceTitleString`.
+  resourceTitle: 'resourceTitle',
+
+  // A resource title marker (`"`, `'`, `(`, or `)`).
+  resourceTitleMarker: 'resourceTitleMarker',
+
+  // Resource destination title (`alpha`).
+  // Includes string.
+  resourceTitleString: 'resourceTitleString',
+
+  // Whole setext heading:
+  //
+  // ```markdown
+  // alpha
+  // bravo
+  // =====
+  // ```
+  //
+  // Includes `setextHeadingText`, `lineEnding`, `linePrefix`, and
+  // `setextHeadingLine`.
+  setextHeading: 'setextHeading',
+
+  // Content in a setext heading (`alpha\nbravo`).
+  // Includes text.
+  setextHeadingText: 'setextHeadingText',
+
+  // Underline in a setext heading, including whitespace suffix (`==`).
+  // Includes `setextHeadingLineSequence`.
+  setextHeadingLine: 'setextHeadingLine',
+
+  // Sequence of equals or dash characters in underline in a setext heading (`-`).
+  setextHeadingLineSequence: 'setextHeadingLineSequence',
+
+  // Strong (`**alpha**`).
+  // Includes `strongSequence` and `strongText`.
+  strong: 'strong',
+
+  // Sequence of strong markers (`**` or `__`).
+  strongSequence: 'strongSequence',
+
+  // Strong text (`alpha`).
+  // Includes text.
+  strongText: 'strongText',
+
+  // Whole thematic break:
+  //
+  // ```markdown
+  // * * *
+  // ```
+  //
+  // Includes `thematicBreakSequence` and `whitespace`.
+  thematicBreak: 'thematicBreak',
+
+  // A sequence of one or more thematic break markers (`***`).
+  thematicBreakSequence: 'thematicBreakSequence',
+
+  // Whole block quote:
+  //
+  // ```markdown
+  // > a
+  // >
+  // > b
+  // ```
+  //
+  // Includes `blockQuotePrefix` and flow.
+  blockQuote: 'blockQuote',
+  // The `>` or `> ` of a block quote.
+  blockQuotePrefix: 'blockQuotePrefix',
+  // The `>` of a block quote prefix.
+  blockQuoteMarker: 'blockQuoteMarker',
+  // The optional ` ` of a block quote prefix.
+  blockQuotePrefixWhitespace: 'blockQuotePrefixWhitespace',
+
+  // Whole unordered list:
+  //
+  // ```markdown
+  // - a
+  //   b
+  // ```
+  //
+  // Includes `listItemPrefix`, flow, and optionally  `listItemIndent` on further
+  // lines.
+  listOrdered: 'listOrdered',
+
+  // Whole ordered list:
+  //
+  // ```markdown
+  // 1. a
+  //    b
+  // ```
+  //
+  // Includes `listItemPrefix`, flow, and optionally  `listItemIndent` on further
+  // lines.
+  listUnordered: 'listUnordered',
+
+  // The indent of further list item lines.
+  listItemIndent: 'listItemIndent',
+
+  // A marker, as in, `*`, `+`, `-`, `.`, or `)`.
+  listItemMarker: 'listItemMarker',
+
+  // The thing that starts a list item, such as `1. `.
+  // Includes `listItemValue` if ordered, `listItemMarker`, and
+  // `listItemPrefixWhitespace` (unless followed by a line ending).
+  listItemPrefix: 'listItemPrefix',
+
+  // The whitespace after a marker.
+  listItemPrefixWhitespace: 'listItemPrefixWhitespace',
+
+  // The numerical value of an ordered item.
+  listItemValue: 'listItemValue',
+
+  // Internal types used for subtokenizers, compiled away
+  chunkDocument: 'chunkDocument',
+  chunkContent: 'chunkContent',
+  chunkFlow: 'chunkFlow',
+  chunkText: 'chunkText',
+  chunkString: 'chunkString'
+})

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/values.d.ts

@@ -0,0 +1,101 @@
+export namespace values {
+  let ht: '\t'
+  let lf: '\n'
+  let cr: '\r'
+  let space: ' '
+  let exclamationMark: '!'
+  let quotationMark: '"'
+  let numberSign: '#'
+  let dollarSign: '$'
+  let percentSign: '%'
+  let ampersand: '&'
+  let apostrophe: "'"
+  let leftParenthesis: '('
+  let rightParenthesis: ')'
+  let asterisk: '*'
+  let plusSign: '+'
+  let comma: ','
+  let dash: '-'
+  let dot: '.'
+  let slash: '/'
+  let digit0: '0'
+  let digit1: '1'
+  let digit2: '2'
+  let digit3: '3'
+  let digit4: '4'
+  let digit5: '5'
+  let digit6: '6'
+  let digit7: '7'
+  let digit8: '8'
+  let digit9: '9'
+  let colon: ':'
+  let semicolon: ';'
+  let lessThan: '<'
+  let equalsTo: '='
+  let greaterThan: '>'
+  let questionMark: '?'
+  let atSign: '@'
+  let uppercaseA: 'A'
+  let uppercaseB: 'B'
+  let uppercaseC: 'C'
+  let uppercaseD: 'D'
+  let uppercaseE: 'E'
+  let uppercaseF: 'F'
+  let uppercaseG: 'G'
+  let uppercaseH: 'H'
+  let uppercaseI: 'I'
+  let uppercaseJ: 'J'
+  let uppercaseK: 'K'
+  let uppercaseL: 'L'
+  let uppercaseM: 'M'
+  let uppercaseN: 'N'
+  let uppercaseO: 'O'
+  let uppercaseP: 'P'
+  let uppercaseQ: 'Q'
+  let uppercaseR: 'R'
+  let uppercaseS: 'S'
+  let uppercaseT: 'T'
+  let uppercaseU: 'U'
+  let uppercaseV: 'V'
+  let uppercaseW: 'W'
+  let uppercaseX: 'X'
+  let uppercaseY: 'Y'
+  let uppercaseZ: 'Z'
+  let leftSquareBracket: '['
+  let backslash: '\\'
+  let rightSquareBracket: ']'
+  let caret: '^'
+  let underscore: '_'
+  let graveAccent: '`'
+  let lowercaseA: 'a'
+  let lowercaseB: 'b'
+  let lowercaseC: 'c'
+  let lowercaseD: 'd'
+  let lowercaseE: 'e'
+  let lowercaseF: 'f'
+  let lowercaseG: 'g'
+  let lowercaseH: 'h'
+  let lowercaseI: 'i'
+  let lowercaseJ: 'j'
+  let lowercaseK: 'k'
+  let lowercaseL: 'l'
+  let lowercaseM: 'm'
+  let lowercaseN: 'n'
+  let lowercaseO: 'o'
+  let lowercaseP: 'p'
+  let lowercaseQ: 'q'
+  let lowercaseR: 'r'
+  let lowercaseS: 's'
+  let lowercaseT: 't'
+  let lowercaseU: 'u'
+  let lowercaseV: 'v'
+  let lowercaseW: 'w'
+  let lowercaseX: 'x'
+  let lowercaseY: 'y'
+  let lowercaseZ: 'z'
+  let leftCurlyBrace: '{'
+  let verticalBar: '|'
+  let rightCurlyBrace: '}'
+  let tilde: '~'
+  let replacementCharacter: '<27>'
+}

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/lib/values.js

@@ -0,0 +1,109 @@
+/**
+ * This module is compiled away!
+ *
+ * While micromark works based on character codes, this module includes the
+ * string versions of ’em.
+ * The C0 block, except for LF, CR, HT, and w/ the replacement character added,
+ * are available here.
+ */
+export const values = /** @type {const} */ ({
+  ht: '\t',
+  lf: '\n',
+  cr: '\r',
+  space: ' ',
+  exclamationMark: '!',
+  quotationMark: '"',
+  numberSign: '#',
+  dollarSign: '$',
+  percentSign: '%',
+  ampersand: '&',
+  apostrophe: "'",
+  leftParenthesis: '(',
+  rightParenthesis: ')',
+  asterisk: '*',
+  plusSign: '+',
+  comma: ',',
+  dash: '-',
+  dot: '.',
+  slash: '/',
+  digit0: '0',
+  digit1: '1',
+  digit2: '2',
+  digit3: '3',
+  digit4: '4',
+  digit5: '5',
+  digit6: '6',
+  digit7: '7',
+  digit8: '8',
+  digit9: '9',
+  colon: ':',
+  semicolon: ';',
+  lessThan: '<',
+  equalsTo: '=',
+  greaterThan: '>',
+  questionMark: '?',
+  atSign: '@',
+  uppercaseA: 'A',
+  uppercaseB: 'B',
+  uppercaseC: 'C',
+  uppercaseD: 'D',
+  uppercaseE: 'E',
+  uppercaseF: 'F',
+  uppercaseG: 'G',
+  uppercaseH: 'H',
+  uppercaseI: 'I',
+  uppercaseJ: 'J',
+  uppercaseK: 'K',
+  uppercaseL: 'L',
+  uppercaseM: 'M',
+  uppercaseN: 'N',
+  uppercaseO: 'O',
+  uppercaseP: 'P',
+  uppercaseQ: 'Q',
+  uppercaseR: 'R',
+  uppercaseS: 'S',
+  uppercaseT: 'T',
+  uppercaseU: 'U',
+  uppercaseV: 'V',
+  uppercaseW: 'W',
+  uppercaseX: 'X',
+  uppercaseY: 'Y',
+  uppercaseZ: 'Z',
+  leftSquareBracket: '[',
+  backslash: '\\',
+  rightSquareBracket: ']',
+  caret: '^',
+  underscore: '_',
+  graveAccent: '`',
+  lowercaseA: 'a',
+  lowercaseB: 'b',
+  lowercaseC: 'c',
+  lowercaseD: 'd',
+  lowercaseE: 'e',
+  lowercaseF: 'f',
+  lowercaseG: 'g',
+  lowercaseH: 'h',
+  lowercaseI: 'i',
+  lowercaseJ: 'j',
+  lowercaseK: 'k',
+  lowercaseL: 'l',
+  lowercaseM: 'm',
+  lowercaseN: 'n',
+  lowercaseO: 'o',
+  lowercaseP: 'p',
+  lowercaseQ: 'q',
+  lowercaseR: 'r',
+  lowercaseS: 's',
+  lowercaseT: 't',
+  lowercaseU: 'u',
+  lowercaseV: 'v',
+  lowercaseW: 'w',
+  lowercaseX: 'x',
+  lowercaseY: 'y',
+  lowercaseZ: 'z',
+  leftCurlyBrace: '{',
+  verticalBar: '|',
+  rightCurlyBrace: '}',
+  tilde: '~',
+  replacementCharacter: '<27>'
+})

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "micromark-util-symbol",
+  "version": "2.0.0",
+  "description": "micromark utility with symbols",
+  "license": "MIT",
+  "keywords": [
+    "micromark",
+    "util",
+    "utility",
+    "symbol"
+  ],
+  "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-symbol",
+  "bugs": "https://github.com/micromark/micromark/issues",
+  "funding": [
+    {
+      "type": "GitHub Sponsors",
+      "url": "https://github.com/sponsors/unifiedjs"
+    },
+    {
+      "type": "OpenCollective",
+      "url": "https://opencollective.com/unified"
+    }
+  ],
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "files": [
+    "lib/"
+  ],
+  "exports": "./lib/default.js",
+  "xo": false
+}

node_modules/micromark-extension-directive/node_modules/micromark-util-symbol/readme.md

@@ -0,0 +1,168 @@
+# micromark-util-symbol
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][bundle-size-badge]][bundle-size]
+[![Sponsors][sponsors-badge]][opencollective]
+[![Backers][backers-badge]][opencollective]
+[![Chat][chat-badge]][chat]
+
+[micromark][] utility with symbols.
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This package exposes constants used throughout the micromark ecosystem.
+
+## When should I use this?
+
+This package is useful when you are making your own micromark extensions.
+It’s useful to reference these constants by name instead of value while
+developing.
+[`micromark-build`][micromark-build] compiles them away for production code.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install micromark-util-symbol
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import * as symbol from 'https://esm.sh/micromark-util-symbol@1'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+<script type="module">
+  import * as symbol from 'https://esm.sh/micromark-util-symbol@1?bundle'
+</script>
+```
+
+## Use
+
+```js
+import {codes, constants, types, values} from 'micromark-util-symbol'
+
+console.log(codes.atSign) // 64
+console.log(constants.characterReferenceNamedSizeMax) // 31
+console.log(types.definitionDestinationRaw) // 'definitionDestinationRaw'
+console.log(values.atSign) // '@'
+```
+
+## API
+
+This package exports the identifiers `codes`, `constants`, `types`, and
+`values`.
+There is no default export.
+
+Each identifier is an object mapping strings to values.
+See the code for the exposed data.
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports no additional types.
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line,
+`micromark-util-symbol@^2`, compatible with Node.js 16.
+This package works with `micromark@^3`.
+
+## Security
+
+This package is safe.
+See [`security.md`][securitymd] in [`micromark/.github`][health] for how to
+submit a security report.
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`micromark/.github`][health] for ways
+to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organisation, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+<!-- Definitions -->
+
+[build-badge]: https://github.com/micromark/micromark/workflows/main/badge.svg
+
+[build]: https://github.com/micromark/micromark/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/micromark/micromark.svg
+
+[coverage]: https://codecov.io/github/micromark/micromark
+
+[downloads-badge]: https://img.shields.io/npm/dm/micromark-util-symbol.svg
+
+[downloads]: https://www.npmjs.com/package/micromark-util-symbol
+
+[bundle-size-badge]: https://img.shields.io/badge/dynamic/json?label=minzipped%20size&query=$.size.compressedSize&url=https://deno.bundlejs.com/?q=micromark-util-symbol
+
+[bundle-size]: https://bundlejs.com/?q=micromark-util-symbol
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[opencollective]: https://opencollective.com/unified
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/micromark/micromark/discussions
+
+[license]: https://github.com/micromark/micromark/blob/main/license
+
+[author]: https://wooorm.com
+
+[health]: https://github.com/micromark/.github
+
+[securitymd]: https://github.com/micromark/.github/blob/main/security.md
+
+[contributing]: https://github.com/micromark/.github/blob/main/contributing.md
+
+[support]: https://github.com/micromark/.github/blob/main/support.md
+
+[coc]: https://github.com/micromark/.github/blob/main/code-of-conduct.md
+
+[typescript]: https://www.typescriptlang.org
+
+[micromark]: https://github.com/micromark/micromark
+
+[micromark-build]: https://github.com/micromark/micromark/tree/main/packages/micromark-build

node_modules/micromark-extension-directive/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "micromark-extension-directive",
+  "version": "3.0.0",
+  "description": "micromark extension to support generic directives (`:cite[smith04]`)",
+  "license": "MIT",
+  "keywords": [
+    "micromark",
+    "micromark-extension",
+    "generic",
+    "directive",
+    "container",
+    "extension",
+    "markdown",
+    "unified"
+  ],
+  "repository": "micromark/micromark-extension-directive",
+  "bugs": "https://github.com/micromark/micromark-extension-directive/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "development": "./dev/index.js",
+    "default": "./index.js"
+  },
+  "files": [
+    "dev/",
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "devlop": "^1.0.0",
+    "micromark-factory-space": "^2.0.0",
+    "micromark-factory-whitespace": "^2.0.0",
+    "micromark-util-character": "^2.0.0",
+    "micromark-util-symbol": "^2.0.0",
+    "micromark-util-types": "^2.0.0",
+    "parse-entities": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "c8": "^8.0.0",
+    "html-void-elements": "^3.0.0",
+    "micromark": "^4.0.0",
+    "micromark-build": "^2.0.0",
+    "prettier": "^2.0.0",
+    "remark-cli": "^11.0.0",
+    "remark-preset-wooorm": "^9.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "xo": "^0.54.0"
+  },
+  "scripts": {
+    "prepack": "npm run build && npm run format",
+    "build": "tsc --build --clean && tsc --build && type-coverage && micromark-build",
+    "format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix",
+    "test-api-prod": "node --conditions production test/index.js",
+    "test-api-dev": "node --conditions development test/index.js",
+    "test-api": "npm run test-api-dev && npm run test-api-prod",
+    "test-coverage": "c8 --100 --reporter lcov npm run test-api",
+    "test": "npm run build && npm run format && npm run test-coverage"
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "**/*.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/consistent-type-definitions": "off"
+        }
+      }
+    ],
+    "prettier": true,
+    "rules": {
+      "max-params": "off",
+      "unicorn/no-this-assignment": "off"
+    }
+  }
+}

node_modules/micromark-extension-directive/readme.md

@@ -0,0 +1,419 @@
+# micromark-extension-directive
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+[micromark][] extensions to support [directives][prop] (`:cite[smith04]` and
+such).
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When to use this](#when-to-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`directive()`](#directive)
+    *   [`directiveHtml(options?)`](#directivehtmloptions)
+    *   [`Directive`](#directive-1)
+    *   [`Handle`](#handle)
+    *   [`HtmlOptions`](#htmloptions)
+*   [Authoring](#authoring)
+*   [HTML](#html)
+*   [CSS](#css)
+*   [Syntax](#syntax)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Related](#related)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This package contains two extensions that add support for directive syntax in
+markdown to [`micromark`][micromark].
+
+## When to use this
+
+This project is useful when you want to solve the need for an infinite number
+of potential extensions to markdown in a single markdown-esque way.
+
+You can use these extensions when you are working with [`micromark`][micromark]
+already.
+
+When you need a syntax tree, you can combine this package with
+[`mdast-util-directive`][mdast-util-directive].
+
+All these packages are used [`remark-directive`][remark-directive], which
+focusses on making it easier to transform content by abstracting these
+internals away.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+[npm][]:
+
+```sh
+npm install micromark-extension-directive
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import {directive, directiveHtml} from 'https://esm.sh/micromark-extension-directive@3'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+<script type="module">
+  import {directive, directiveHtml} from 'https://esm.sh/micromark-extension-directive@3?bundle'
+</script>
+```
+
+## Use
+
+Say our document `example.md` contains:
+
+```markdown
+A lovely language know as :abbr[HTML]{title="HyperText Markup Language"}.
+```
+
+…and our module `example.js` looks as follows:
+
+```js
+import fs from 'node:fs/promises'
+import {micromark} from 'micromark'
+import {directive, directiveHtml} from 'micromark-extension-directive'
+
+const output = micromark(await fs.readFile('example.md'), {
+  extensions: [directive()],
+  htmlExtensions: [directiveHtml({abbr})]
+})
+
+console.log(output)
+
+/**
+ * @this {import('micromark-util-types').CompileContext}
+ * @type {import('micromark-extension-directive').Handle}
+ * @returns {undefined}
+ */
+function abbr(d) {
+  if (d.type !== 'textDirective') return false
+
+  this.tag('<abbr')
+
+  if (d.attributes && 'title' in d.attributes) {
+    this.tag(' title="' + this.encode(d.attributes.title) + '"')
+  }
+
+  this.tag('>')
+  this.raw(d.label || '')
+  this.tag('</abbr>')
+}
+```
+
+…now running `node example.js` yields:
+
+```html
+<p>A lovely language know as <abbr title="HyperText Markup Language">HTML</abbr>.</p>
+```
+
+## API
+
+This package exports the identifiers [`directive`][api-directive] and
+[`directiveHtml`][api-directive-html].
+There is no default export.
+
+The export map supports the [`development` condition][development].
+Run `node --conditions development module.js` to get instrumented dev code.
+Without this condition, production code is loaded.
+
+### `directive()`
+
+Create an extension for `micromark` to enable directive syntax.
+
+###### Returns
+
+Extension for `micromark` that can be passed in `extensions`, to enable
+directive syntax ([`Extension`][micromark-extension]).
+
+### `directiveHtml(options?)`
+
+Create an extension for `micromark` to support directives when serializing to
+HTML.
+
+> 👉 **Note**: this uses KaTeX to render math.
+
+###### Parameters
+
+*   `options` ([`HtmlOptions`][api-html-options], default: `{}`)
+    — configuration
+
+###### Returns
+
+Extension for `micromark` that can be passed in `htmlExtensions`, to
+support directives when serializing to HTML
+([`HtmlExtension`][micromark-html-extension]).
+
+### `Directive`
+
+Structure representing a directive (TypeScript type).
+
+###### Fields
+
+*   `type` (`'containerDirective'`, `'leafDirective'`, or `'textDirective'`)
+    — kind
+*   `name` (`string`)
+    — name of directive
+*   `label` (`string` or `undefined`)
+    — compiled HTML content that was in `[brackets]`
+*   `attributes` (`Record<string, string>` or `undefined`)
+    — object w/ HTML attributes
+*   `content` (`string` or `undefined`)
+    — compiled HTML content inside container directive
+
+### `Handle`
+
+Handle a directive (TypeScript type).
+
+###### Parameters
+
+*   `this` ([`CompileContext`][micromark-compile-context])
+    — current context
+*   `directive` ([`Directive`][api-directive-type])
+    — directive
+
+###### Returns
+
+Signal whether the directive was handled (`boolean`, default: `true`).
+Yield `false` to let the fallback (a special handle for `'*'`) handle it.
+
+### `HtmlOptions`
+
+Configuration (TypeScript type).
+
+> 👉 **Note**: the special field `'*'` can be used to specify a fallback handle
+> to handle all otherwise unhandled directives.
+
+###### Type
+
+```ts
+type HtmlOptions = Record<string, Handle>
+```
+
+## Authoring
+
+When authoring markdown with directives, keep in mind that they don’t work in
+most places.
+On your own site it can be great!
+
+## HTML
+
+You can define how directives are turned into HTML.
+If directives are not handled, they do not emit anything.
+
+## CSS
+
+How to display directives is left as an exercise for the reader.
+
+## Syntax
+
+The syntax looks like this:
+
+```markdown
+Directives in text can form with a single colon, such as :cite[smith04].
+Their syntax is `:name[label]{attributes}`.
+
+Leafs (block without content) can form by using two colons:
+
+::youtube[Video of a cat in a box]{vid=01ab2cd3efg}
+
+Their syntax is `::name[label]{attributes}` on its own line.
+
+Containers (blocks with content) can form by using three colons:
+
+:::spoiler
+He dies.
+:::
+
+The `name` part is required.  The first character must be a letter, other
+characters can be alphanumerical, `-`, and `_`.
+`-` or `_` cannot end a name.
+
+The `[label]` part is optional (`:x` and `:x[]` are equivalent)†.
+When used, it can include text constructs such as emphasis and so on: `x[a *b*
+c]`.
+
+The `{attributes}` part is optional (`:x` and `:x{}` are equivalent)†.
+When used, it is handled like HTML attributes, such as that `{a}`, `{a=""}`,
+, `{a=''}` but also `{a=b}`, `{a="b"}`, and `{a='b'}` are equivalent.
+Shortcuts are available for `id=` (`{#readme}` for `{id=readme}`) and
+`class` (`{.big}` for `{class=big}`).
+When multiple ids are found, the last is used; when multiple classes are found,
+they are combined: `{.red class=green .blue}` is equivalent to
+`{.red .green .blue}` and `{class="red green blue"}`.
+
+† there is one case where a name must be followed by an empty label or empty
+attributes: a *text* directive that only has a name, cannot be followed by a
+colon. So, `:red:` doesn’t work. Use either `:red[]` or `:red{}` instead.
+The reason for this is to allow GitHub emoji (gemoji) and directives to coexist.
+
+Containers can be nested by using more colons outside:
+
+::::spoiler
+He dies.
+
+:::spoiler
+She is born.
+:::
+::::
+
+The closing fence must include the same or more colons as the opening.
+If no closing is found, the container runs to the end of its parent container
+(block quote, list item, document, or other container).
+
+::::spoiler
+These three are not enough to close
+:::
+So this line is also part of the container.
+```
+
+Note that while other implementations are sometimes loose in what they allow,
+this implementation mimics CommonMark as closely as possible:
+
+*   Whitespace is not allowed between colons and name (~~`: a`~~), name and
+    label (~~`:a []`~~), name and attributes (~~`:a {}`~~), or label and
+    attributes (~~`:a[] {}`~~) — because it’s not allowed in links either
+    (~~`[] ()`~~)
+*   No trailing colons allowed on the opening fence of a container
+    (~~`:::a:::`~~) — because it’s not allowed in fenced code either
+*   The label and attributes in a leaf or container cannot include line endings
+    (~~`::a[b\nc]`~~) — because it’s not allowed in fenced code either
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional types [`Directive`][api-directive-type],
+[`Handle`][api-handle], and [`HtmlOptions`][api-html-options].
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line,
+`micromark-extension-directive@^3`, compatible with Node.js 16.
+
+This package works with `micromark` version `3` and later.
+
+## Security
+
+This package is safe assuming that you write safe handlers.
+Any vulnerability in your code could open you to a
+[cross-site scripting (XSS)][xss] attack.
+
+## Related
+
+*   [`remark-directive`][remark-directive]
+    — remark plugin to support directives
+*   [`mdast-util-directive`][mdast-util-directive]
+    — mdast utility to support directives
+
+## Contribute
+
+See [`contributing.md` in `micromark/.github`][contributing] for ways to get
+started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+<!-- Definitions -->
+
+[build-badge]: https://github.com/micromark/micromark-extension-directive/workflows/main/badge.svg
+
+[build]: https://github.com/micromark/micromark-extension-directive/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/micromark/micromark-extension-directive.svg
+
+[coverage]: https://codecov.io/github/micromark/micromark-extension-directive
+
+[downloads-badge]: https://img.shields.io/npm/dm/micromark-extension-directive.svg
+
+[downloads]: https://www.npmjs.com/package/micromark-extension-directive
+
+[size-badge]: https://img.shields.io/badge/dynamic/json?label=minzipped%20size&query=$.size.compressedSize&url=https://deno.bundlejs.com/?q=micromark-extension-directive
+
+[size]: https://bundlejs.com/?q=micromark-extension-directive
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/micromark/micromark/discussions
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esmsh]: https://esm.sh
+
+[license]: license
+
+[author]: https://wooorm.com
+
+[contributing]: https://github.com/micromark/.github/blob/main/contributing.md
+
+[support]: https://github.com/micromark/.github/blob/main/support.md
+
+[coc]: https://github.com/micromark/.github/blob/main/code-of-conduct.md
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[typescript]: https://www.typescriptlang.org
+
+[development]: https://nodejs.org/api/packages.html#packages_resolving_user_conditions
+
+[micromark]: https://github.com/micromark/micromark
+
+[micromark-html-extension]: https://github.com/micromark/micromark#htmlextension
+
+[micromark-extension]: https://github.com/micromark/micromark#syntaxextension
+
+[micromark-compile-context]: https://github.com/micromark/micromark/blob/41e3c4c/packages/micromark-util-types/index.js#L457
+
+[mdast-util-directive]: https://github.com/syntax-tree/mdast-util-directive
+
+[remark-directive]: https://github.com/remarkjs/remark-directive
+
+[prop]: https://talk.commonmark.org/t/generic-directives-plugins-syntax/444
+
+[xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
+
+[api-directive]: #directive
+
+[api-directive-html]: #directivehtmloptions
+
+[api-directive-type]: #directive-1
+
+[api-handle]: #handle
+
+[api-html-options]: #htmloptions