@readme/markdown 6.75.0-beta.26 → 6.75.0-beta.27

package/dist/main.js

@@ -14258,6 +14258,138 @@ module.exports = function extend() {
 };
 
 
+/***/ }),
+
+/***/ 6311:
+/***/ ((module) => {
+
+//
+// format - printf-like string formatting for JavaScript
+// github.com/samsonjs/format
+// @_sjs
+//
+// Copyright 2010 - 2013 Sami Samhuri <sami@samhuri.net>
+//
+// MIT License
+// http://sjs.mit-license.org
+//
+
+;(function() {
+
+  //// Export the API
+  var namespace;
+
+  // CommonJS / Node module
+  if (true) {
+    namespace = module.exports = format;
+  }
+
+  // Browsers and other environments
+  else {}
+
+  namespace.format = format;
+  namespace.vsprintf = vsprintf;
+
+  if (typeof console !== 'undefined' && typeof console.log === 'function') {
+    namespace.printf = printf;
+  }
+
+  function printf(/* ... */) {
+    console.log(format.apply(null, arguments));
+  }
+
+  function vsprintf(fmt, replacements) {
+    return format.apply(null, [fmt].concat(replacements));
+  }
+
+  function format(fmt) {
+    var argIndex = 1 // skip initial format argument
+      , args = [].slice.call(arguments)
+      , i = 0
+      , n = fmt.length
+      , result = ''
+      , c
+      , escaped = false
+      , arg
+      , tmp
+      , leadingZero = false
+      , precision
+      , nextArg = function() { return args[argIndex++]; }
+      , slurpNumber = function() {
+          var digits = '';
+          while (/\d/.test(fmt[i])) {
+            digits += fmt[i++];
+            c = fmt[i];
+          }
+          return digits.length > 0 ? parseInt(digits) : null;
+        }
+      ;
+    for (; i < n; ++i) {
+      c = fmt[i];
+      if (escaped) {
+        escaped = false;
+        if (c == '.') {
+          leadingZero = false;
+          c = fmt[++i];
+        }
+        else if (c == '0' && fmt[i + 1] == '.') {
+          leadingZero = true;
+          i += 2;
+          c = fmt[i];
+        }
+        else {
+          leadingZero = true;
+        }
+        precision = slurpNumber();
+        switch (c) {
+        case 'b': // number in binary
+          result += parseInt(nextArg(), 10).toString(2);
+          break;
+        case 'c': // character
+          arg = nextArg();
+          if (typeof arg === 'string' || arg instanceof String)
+            result += arg;
+          else
+            result += String.fromCharCode(parseInt(arg, 10));
+          break;
+        case 'd': // number in decimal
+          result += parseInt(nextArg(), 10);
+          break;
+        case 'f': // floating point number
+          tmp = String(parseFloat(nextArg()).toFixed(precision || 6));
+          result += leadingZero ? tmp : tmp.replace(/^0/, '');
+          break;
+        case 'j': // JSON
+          result += JSON.stringify(nextArg());
+          break;
+        case 'o': // number in octal
+          result += '0' + parseInt(nextArg(), 10).toString(8);
+          break;
+        case 's': // string
+          result += nextArg();
+          break;
+        case 'x': // lowercase hexadecimal
+          result += '0x' + parseInt(nextArg(), 10).toString(16);
+          break;
+        case 'X': // uppercase hexadecimal
+          result += '0x' + parseInt(nextArg(), 10).toString(16).toUpperCase();
+          break;
+        default:
+          result += c;
+          break;
+        }
+      } else if (c === '%') {
+        escaped = true;
+      } else {
+        result += c;
+      }
+    }
+    return result;
+  }
+
+}());
+
+
 /***/ }),
 
 /***/ 9788:
@@ -43487,6 +43619,812 @@ function remarkMdx(options) {
   toMarkdownExtensions.push(mdxToMarkdown(settings))
 }
 
+// EXTERNAL MODULE: ./node_modules/format/format.js
+var format_format = __webpack_require__(6311);
+var format_default = /*#__PURE__*/__webpack_require__.n(format_format);
+;// CONCATENATED MODULE: ./node_modules/fault/index.js
+// @ts-expect-error
+
+
+const fault = Object.assign(create(Error), {
+  eval: create(EvalError),
+  range: create(RangeError),
+  reference: create(ReferenceError),
+  syntax: create(SyntaxError),
+  type: create(TypeError),
+  uri: create(URIError)
+})
+
+/**
+ * Create a new `EConstructor`, with the formatted `format` as a first argument.
+ *
+ * @template {Error} Fault
+ * @template {new (reason: string) => Fault} Class
+ * @param {Class} Constructor
+ */
+function create(Constructor) {
+  /** @type {string} */
+  // @ts-expect-error
+  FormattedError.displayName = Constructor.displayName || Constructor.name
+
+  return FormattedError
+
+  /**
+   * Create an error with a printf-like formatted message.
+   *
+   * @param {string|null} [format]
+   *   Template string.
+   * @param {...unknown} values
+   *   Values to render in `format`.
+   * @returns {Fault}
+   */
+  function FormattedError(format, ...values) {
+    /** @type {string} */
+    const reason = format ? format_default()(format, ...values) : format
+    return new Constructor(reason)
+  }
+}
+
+;// CONCATENATED MODULE: ./node_modules/micromark-extension-frontmatter/lib/to-matters.js
+/**
+ * @typedef {'toml' | 'yaml'} Preset
+ *   Known name of a frontmatter style.
+ *
+ * @typedef Info
+ *   Sequence.
+ *
+ *   Depending on how this structure is used, it reflects a marker or a fence.
+ * @property {string} close
+ *   Closing.
+ * @property {string} open
+ *   Opening.
+ *
+ * @typedef MatterProps
+ *   Fields describing a kind of matter.
+ * @property {string} type
+ *   Node type to tokenize as.
+ * @property {boolean | null | undefined} [anywhere=false]
+ *   Whether matter can be found anywhere in the document, normally, only matter
+ *   at the start of the document is recognized.
+ *
+ *   > 👉 **Note**: using this is a terrible idea.
+ *   > It’s called frontmatter, not matter-in-the-middle or so.
+ *   > This makes your markdown less portable.
+ *
+ * @typedef MarkerProps
+ *   Marker configuration.
+ * @property {Info | string} marker
+ *   Character repeated 3 times, used as complete fences.
+ *
+ *   For example the character `'-'` will result in `'---'` being used as the
+ *   fence
+ *   Pass `open` and `close` to specify different characters for opening and
+ *   closing fences.
+ * @property {never} [fence]
+ *   If `marker` is set, `fence` must not be set.
+ *
+ * @typedef FenceProps
+ *   Fence configuration.
+ * @property {Info | string} fence
+ *   Complete fences.
+ *
+ *   This can be used when fences contain different characters or lengths
+ *   other than 3.
+ *   Pass `open` and `close` to interface to specify different characters for opening and
+ *   closing fences.
+ * @property {never} [marker]
+ *   If `fence` is set, `marker` must not be set.
+ *
+ * @typedef {(MatterProps & FenceProps) | (MatterProps & MarkerProps)} Matter
+ *   Fields describing a kind of matter.
+ *
+ *   > 👉 **Note**: using `anywhere` is a terrible idea.
+ *   > It’s called frontmatter, not matter-in-the-middle or so.
+ *   > This makes your markdown less portable.
+ *
+ *   > 👉 **Note**: `marker` and `fence` are mutually exclusive.
+ *   > If `marker` is set, `fence` must not be set, and vice versa.
+ *
+ * @typedef {Matter | Preset | Array<Matter | Preset>} Options
+ *   Configuration.
+ */
+
+
+const to_matters_own = {}.hasOwnProperty
+const markers = {
+  yaml: '-',
+  toml: '+'
+}
+
+/**
+ * Simplify options by normalizing them to an array of matters.
+ *
+ * @param {Options | null | undefined} [options='yaml']
+ *   Configuration (default: `'yaml'`).
+ * @returns {Array<Matter>}
+ *   List of matters.
+ */
+function toMatters(options) {
+  /** @type {Array<Matter>} */
+  const result = []
+  let index = -1
+
+  /** @type {Array<Matter | Preset>} */
+  const presetsOrMatters = Array.isArray(options)
+    ? options
+    : options
+    ? [options]
+    : ['yaml']
+  while (++index < presetsOrMatters.length) {
+    result[index] = matter(presetsOrMatters[index])
+  }
+  return result
+}
+
+/**
+ * Simplify an option.
+ *
+ * @param {Matter | Preset} option
+ *   Configuration.
+ * @returns {Matter}
+ *   Matter.
+ */
+function matter(option) {
+  let result = option
+  if (typeof result === 'string') {
+    if (!to_matters_own.call(markers, result)) {
+      throw fault('Missing matter definition for `%s`', result)
+    }
+    result = {
+      type: result,
+      marker: markers[result]
+    }
+  } else if (typeof result !== 'object') {
+    throw fault('Expected matter to be an object, not `%j`', result)
+  }
+  if (!to_matters_own.call(result, 'type')) {
+    throw fault('Missing `type` in matter `%j`', result)
+  }
+  if (!to_matters_own.call(result, 'fence') && !to_matters_own.call(result, 'marker')) {
+    throw fault('Missing `marker` or `fence` in matter `%j`', result)
+  }
+  return result
+}
+
+;// CONCATENATED MODULE: ./node_modules/mdast-util-frontmatter/node_modules/escape-string-regexp/index.js
+function escapeStringRegexp(string) {
+	if (typeof string !== 'string') {
+		throw new TypeError('Expected a string');
+	}
+
+	// Escape characters with special meaning either inside or outside character sets.
+	// Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+	return string
+		.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
+		.replace(/-/g, '\\x2d');
+}
+
+;// CONCATENATED MODULE: ./node_modules/mdast-util-frontmatter/lib/index.js
+/**
+ * @typedef {import('mdast').Literal} Literal
+ *
+ * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+ * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+ * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+ * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+ *
+ * @typedef {import('micromark-extension-frontmatter').Info} Info
+ * @typedef {import('micromark-extension-frontmatter').Matter} Matter
+ * @typedef {import('micromark-extension-frontmatter').Options} Options
+ */
+
+
+
+
+
+/**
+ * Create an extension for `mdast-util-from-markdown`.
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {FromMarkdownExtension}
+ *   Extension for `mdast-util-from-markdown`.
+ */
+function frontmatterFromMarkdown(options) {
+  const matters = toMatters(options)
+  /** @type {FromMarkdownExtension['enter']} */
+  const enter = {}
+  /** @type {FromMarkdownExtension['exit']} */
+  const exit = {}
+  let index = -1
+
+  while (++index < matters.length) {
+    const matter = matters[index]
+    enter[matter.type] = lib_opener(matter)
+    exit[matter.type] = lib_close
+    exit[matter.type + 'Value'] = value
+  }
+
+  return {enter, exit}
+}
+
+/**
+ * @param {Matter} matter
+ * @returns {FromMarkdownHandle} enter
+ */
+function lib_opener(matter) {
+  return open
+
+  /**
+   * @this {CompileContext}
+   * @type {FromMarkdownHandle}
+   */
+  function open(token) {
+    // @ts-expect-error: custom.
+    this.enter({type: matter.type, value: ''}, token)
+    this.buffer()
+  }
+}
+
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function lib_close(token) {
+  const data = this.resume()
+  const node = this.stack[this.stack.length - 1]
+  default_ok('value' in node)
+  this.exit(token)
+  // Remove the initial and final eol.
+  node.value = data.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, '')
+}
+
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function value(token) {
+  this.config.enter.data.call(this, token)
+  this.config.exit.data.call(this, token)
+}
+
+/**
+ * Create an extension for `mdast-util-to-markdown`.
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {ToMarkdownExtension}
+ *   Extension for `mdast-util-to-markdown`.
+ */
+function frontmatterToMarkdown(options) {
+  /** @type {ToMarkdownExtension['unsafe']} */
+  const unsafe = []
+  /** @type {ToMarkdownExtension['handlers']} */
+  const handlers = {}
+  const matters = toMatters(options)
+  let index = -1
+
+  while (++index < matters.length) {
+    const matter = matters[index]
+
+    // @ts-expect-error: this can add custom frontmatter nodes.
+    // Typing those is the responsibility of the end user.
+    handlers[matter.type] = handler(matter)
+
+    const open = fence(matter, 'open')
+
+    unsafe.push({
+      atBreak: true,
+      character: open.charAt(0),
+      after: escapeStringRegexp(open.charAt(1))
+    })
+  }
+
+  return {unsafe, handlers}
+}
+
+/**
+ * Create a handle that can serialize a frontmatter node as markdown.
+ *
+ * @param {Matter} matter
+ *   Structure.
+ * @returns {(node: Literal) => string} enter
+ *   Handler.
+ */
+function handler(matter) {
+  const open = fence(matter, 'open')
+  const close = fence(matter, 'close')
+
+  return handle
+
+  /**
+   * Serialize a frontmatter node as markdown.
+   *
+   * @param {Literal} node
+   *   Node to serialize.
+   * @returns {string}
+   *   Serialized node.
+   */
+  function handle(node) {
+    return open + (node.value ? '\n' + node.value : '') + '\n' + close
+  }
+}
+
+/**
+ * Get an `open` or `close` fence.
+ *
+ * @param {Matter} matter
+ *   Structure.
+ * @param {'close' | 'open'} prop
+ *   Field to get.
+ * @returns {string}
+ *   Fence.
+ */
+function fence(matter, prop) {
+  return matter.marker
+    ? pick(matter.marker, prop).repeat(3)
+    : // @ts-expect-error: They’re mutually exclusive.
+      pick(matter.fence, prop)
+}
+
+/**
+ * Take `open` or `close` fields when schema is an info object, or use the
+ * given value when it is a string.
+ *
+ * @param {Info | string} schema
+ *   Info object or value.
+ * @param {'close' | 'open'} prop
+ *   Field to get.
+ * @returns {string}
+ *   Thing to use for the opening or closing.
+ */
+function pick(schema, prop) {
+  return typeof schema === 'string' ? schema : schema[prop]
+}
+
+;// CONCATENATED MODULE: ./node_modules/micromark-extension-frontmatter/lib/syntax.js
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
+ * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').TokenType} TokenType
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ *
+ * @typedef {import('./to-matters.js').Info} Info
+ * @typedef {import('./to-matters.js').Matter} Matter
+ * @typedef {import('./to-matters.js').Options} Options
+ */
+
+
+
+
+/**
+ * Create an extension for `micromark` to enable frontmatter syntax.
+ *
+ * @param {Options | null | undefined} [options='yaml']
+ *   Configuration (default: `'yaml'`).
+ * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions`, to
+ *   enable frontmatter syntax.
+ */
+function frontmatter(options) {
+  const matters = toMatters(options)
+  /** @type {ConstructRecord} */
+  const flow = {}
+  let index = -1
+  while (++index < matters.length) {
+    const matter = matters[index]
+    const code = syntax_fence(matter, 'open').charCodeAt(0)
+    const construct = createConstruct(matter)
+    const existing = flow[code]
+    if (Array.isArray(existing)) {
+      existing.push(construct)
+    } else {
+      // Never a single object, always an array.
+      flow[code] = [construct]
+    }
+  }
+  return {
+    flow
+  }
+}
+
+/**
+ * @param {Matter} matter
+ * @returns {Construct}
+ */
+function createConstruct(matter) {
+  const anywhere = matter.anywhere
+  const frontmatterType = /** @type {TokenType} */ matter.type
+  const fenceType = /** @type {TokenType} */ frontmatterType + 'Fence'
+  const sequenceType = /** @type {TokenType} */ fenceType + 'Sequence'
+  const valueType = /** @type {TokenType} */ frontmatterType + 'Value'
+  const closingFenceConstruct = {
+    tokenize: tokenizeClosingFence,
+    partial: true
+  }
+
+  /**
+   * Fence to look for.
+   *
+   * @type {string}
+   */
+  let buffer
+  let bufferIndex = 0
+  return {
+    tokenize: tokenizeFrontmatter,
+    concrete: true
+  }
+
+  /**
+   * @this {TokenizeContext}
+   * @type {Tokenizer}
+   */
+  function tokenizeFrontmatter(effects, ok, nok) {
+    const self = this
+    return start
+
+    /**
+     * Start of frontmatter.
+     *
+     * ```markdown
+     * > | ---
+     *     ^
+     *   | title: "Venus"
+     *   | ---
+     * ```
+     *
+     * @type {State}
+     */
+    function start(code) {
+      const position = self.now()
+      if (
+        // Indent not allowed.
+        position.column === 1 &&
+        // Normally, only allowed in first line.
+        (position.line === 1 || anywhere)
+      ) {
+        buffer = syntax_fence(matter, 'open')
+        bufferIndex = 0
+        if (code === buffer.charCodeAt(bufferIndex)) {
+          effects.enter(frontmatterType)
+          effects.enter(fenceType)
+          effects.enter(sequenceType)
+          return openSequence(code)
+        }
+      }
+      return nok(code)
+    }
+
+    /**
+     * In open sequence.
+     *
+     * ```markdown
+     * > | ---
+     *     ^
+     *   | title: "Venus"
+     *   | ---
+     * ```
+     *
+     * @type {State}
+     */
+    function openSequence(code) {
+      if (bufferIndex === buffer.length) {
+        effects.exit(sequenceType)
+        if (markdownSpace(code)) {
+          effects.enter('whitespace')
+          return openSequenceWhitespace(code)
+        }
+        return openAfter(code)
+      }
+      if (code === buffer.charCodeAt(bufferIndex++)) {
+        effects.consume(code)
+        return openSequence
+      }
+      return nok(code)
+    }
+
+    /**
+     * In whitespace after open sequence.
+     *
+     * ```markdown
+     * > | ---␠
+     *        ^
+     *   | title: "Venus"
+     *   | ---
+     * ```
+     *
+     * @type {State}
+     */
+    function openSequenceWhitespace(code) {
+      if (markdownSpace(code)) {
+        effects.consume(code)
+        return openSequenceWhitespace
+      }
+      effects.exit('whitespace')
+      return openAfter(code)
+    }
+
+    /**
+     * After open sequence.
+     *
+     * ```markdown
+     * > | ---
+     *        ^
+     *   | title: "Venus"
+     *   | ---
+     * ```
+     *
+     * @type {State}
+     */
+    function openAfter(code) {
+      if (markdownLineEnding(code)) {
+        effects.exit(fenceType)
+        effects.enter('lineEnding')
+        effects.consume(code)
+        effects.exit('lineEnding')
+        // Get ready for closing fence.
+        buffer = syntax_fence(matter, 'close')
+        bufferIndex = 0
+        return effects.attempt(closingFenceConstruct, after, contentStart)
+      }
+
+      // EOF is not okay.
+      return nok(code)
+    }
+
+    /**
+     * Start of content chunk.
+     *
+     * ```markdown
+     *   | ---
+     * > | title: "Venus"
+     *     ^
+     *   | ---
+     * ```
+     *
+     * @type {State}
+     */
+    function contentStart(code) {
+      if (code === null || markdownLineEnding(code)) {
+        return contentEnd(code)
+      }
+      effects.enter(valueType)
+      return contentInside(code)
+    }
+
+    /**
+     * In content chunk.
+     *
+     * ```markdown
+     *   | ---
+     * > | title: "Venus"
+     *     ^
+     *   | ---
+     * ```
+     *
+     * @type {State}
+     */
+    function contentInside(code) {
+      if (code === null || markdownLineEnding(code)) {
+        effects.exit(valueType)
+        return contentEnd(code)
+      }
+      effects.consume(code)
+      return contentInside
+    }
+
+    /**
+     * End of content chunk.
+     *
+     * ```markdown
+     *   | ---
+     * > | title: "Venus"
+     *                   ^
+     *   | ---
+     * ```
+     *
+     * @type {State}
+     */
+    function contentEnd(code) {
+      // Require a closing fence.
+      if (code === null) {
+        return nok(code)
+      }
+
+      // Can only be an eol.
+      effects.enter('lineEnding')
+      effects.consume(code)
+      effects.exit('lineEnding')
+      return effects.attempt(closingFenceConstruct, after, contentStart)
+    }
+
+    /**
+     * After frontmatter.
+     *
+     * ```markdown
+     *   | ---
+     *   | title: "Venus"
+     * > | ---
+     *        ^
+     * ```
+     *
+     * @type {State}
+     */
+    function after(code) {
+      // `code` must be eol/eof.
+      effects.exit(frontmatterType)
+      return ok(code)
+    }
+  }
+
+  /** @type {Tokenizer} */
+  function tokenizeClosingFence(effects, ok, nok) {
+    let bufferIndex = 0
+    return closeStart
+
+    /**
+     * Start of close sequence.
+     *
+     * ```markdown
+     *   | ---
+     *   | title: "Venus"
+     * > | ---
+     *     ^
+     * ```
+     *
+     * @type {State}
+     */
+    function closeStart(code) {
+      if (code === buffer.charCodeAt(bufferIndex)) {
+        effects.enter(fenceType)
+        effects.enter(sequenceType)
+        return closeSequence(code)
+      }
+      return nok(code)
+    }
+
+    /**
+     * In close sequence.
+     *
+     * ```markdown
+     *   | ---
+     *   | title: "Venus"
+     * > | ---
+     *     ^
+     * ```
+     *
+     * @type {State}
+     */
+    function closeSequence(code) {
+      if (bufferIndex === buffer.length) {
+        effects.exit(sequenceType)
+        if (markdownSpace(code)) {
+          effects.enter('whitespace')
+          return closeSequenceWhitespace(code)
+        }
+        return closeAfter(code)
+      }
+      if (code === buffer.charCodeAt(bufferIndex++)) {
+        effects.consume(code)
+        return closeSequence
+      }
+      return nok(code)
+    }
+
+    /**
+     * In whitespace after close sequence.
+     *
+     * ```markdown
+     * > | ---
+     *   | title: "Venus"
+     *   | ---␠
+     *        ^
+     * ```
+     *
+     * @type {State}
+     */
+    function closeSequenceWhitespace(code) {
+      if (markdownSpace(code)) {
+        effects.consume(code)
+        return closeSequenceWhitespace
+      }
+      effects.exit('whitespace')
+      return closeAfter(code)
+    }
+
+    /**
+     * After close sequence.
+     *
+     * ```markdown
+     *   | ---
+     *   | title: "Venus"
+     * > | ---
+     *        ^
+     * ```
+     *
+     * @type {State}
+     */
+    function closeAfter(code) {
+      if (code === null || markdownLineEnding(code)) {
+        effects.exit(fenceType)
+        return ok(code)
+      }
+      return nok(code)
+    }
+  }
+}
+
+/**
+ * @param {Matter} matter
+ * @param {'close' | 'open'} prop
+ * @returns {string}
+ */
+function syntax_fence(matter, prop) {
+  return matter.marker
+    ? syntax_pick(matter.marker, prop).repeat(3)
+    : // @ts-expect-error: They’re mutually exclusive.
+      syntax_pick(matter.fence, prop)
+}
+
+/**
+ * @param {Info | string} schema
+ * @param {'close' | 'open'} prop
+ * @returns {string}
+ */
+function syntax_pick(schema, prop) {
+  return typeof schema === 'string' ? schema : schema[prop]
+}
+
+;// CONCATENATED MODULE: ./node_modules/remark-frontmatter/lib/index.js
+/// <reference types="remark-parse" />
+/// <reference types="remark-stringify" />
+
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('micromark-extension-frontmatter').Options} Options
+ * @typedef {import('unified').Processor<Root>} Processor
+ */
+
+
+
+
+/** @type {Options} */
+const remark_frontmatter_lib_emptyOptions = 'yaml'
+
+/**
+ * Add support for frontmatter.
+ *
+ * ###### Notes
+ *
+ * Doesn’t parse the data inside them: create your own plugin to do that.
+ *
+ * @param {Options | null | undefined} [options='yaml']
+ *   Configuration (default: `'yaml'`).
+ * @returns {undefined}
+ *   Nothing.
+ */
+function remarkFrontmatter(options) {
+  // @ts-expect-error: TS is wrong about `this`.
+  // eslint-disable-next-line unicorn/no-this-assignment
+  const self = /** @type {Processor} */ (this)
+  const settings = options || remark_frontmatter_lib_emptyOptions
+  const data = self.data()
+
+  const micromarkExtensions =
+    data.micromarkExtensions || (data.micromarkExtensions = [])
+  const fromMarkdownExtensions =
+    data.fromMarkdownExtensions || (data.fromMarkdownExtensions = [])
+  const toMarkdownExtensions =
+    data.toMarkdownExtensions || (data.toMarkdownExtensions = [])
+
+  micromarkExtensions.push(frontmatter(settings))
+  fromMarkdownExtensions.push(frontmatterFromMarkdown(settings))
+  toMarkdownExtensions.push(frontmatterToMarkdown(settings))
+}
+
 ;// CONCATENATED MODULE: ./node_modules/@ungap/structured-clone/esm/types.js
 const VOID       = -1;
 const PRIMITIVE  = 0;
@@ -49231,7 +50169,7 @@ function extract_identifiers(param, nodes = []) {
  * @returns {undefined}
  *   Nothing.
  */
-function create(from, to) {
+function estree_util_create_create(from, to) {
   /** @type {Array<keyof Node>} */
   // @ts-expect-error: `start`, `end`, `comments` are custom Acorn fields.
   const fields = ['start', 'end', 'loc', 'range', 'comments']
@@ -49356,7 +50294,7 @@ function specifiersToDeclarations(specifiers, init) {
       id: importNamespaceSpecifier.local,
       init
     }
-    create(importNamespaceSpecifier, declarator)
+    estree_util_create_create(importNamespaceSpecifier, declarator)
     declarations.push(declarator)
   }
 
@@ -49390,7 +50328,7 @@ function specifiersToDeclarations(specifiers, init) {
           key,
           value
         }
-        create(specifier, property)
+        estree_util_create_create(specifier, property)
         return property
       })
     },
@@ -49675,13 +50613,13 @@ function recmaDocument(options) {
                 imported: specifier.local,
                 local: {type: 'Identifier', name: 'MDXLayout'}
               }
-              create(specifier.local, importSpecifier)
+              estree_util_create_create(specifier.local, importSpecifier)
               specifiers.push(importSpecifier)
             }
 
             /** @type {Literal} */
             const from = {type: 'Literal', value: source.value}
-            create(source, from)
+            estree_util_create_create(source, from)
 
             /** @type {ImportDeclaration} */
             const declaration = {
@@ -49689,7 +50627,7 @@ function recmaDocument(options) {
               specifiers,
               source: from
             }
-            create(specifier, declaration)
+            estree_util_create_create(specifier, declaration)
             handleEsm(declaration)
 
             return false
@@ -49837,7 +50775,7 @@ function recmaDocument(options) {
 
             /** @type {SimpleLiteral} */
             const replacement = {type: 'Literal', value}
-            create(node.source, replacement)
+            estree_util_create_create(node.source, replacement)
             node.source = replacement
             return
           }
@@ -49869,7 +50807,7 @@ function recmaDocument(options) {
             usesImportMetaUrlVariable = true
             /** @type {Identifier} */
             const replacement = {type: 'Identifier', name: '_importMetaUrl'}
-            create(node, replacement)
+            estree_util_create_create(node, replacement)
             this.replace(replacement)
           }
         }
@@ -49964,7 +50902,7 @@ function recmaDocument(options) {
           // ```
           /** @type {ImportExpression} */
           const argument = {type: 'ImportExpression', source: node.source}
-          create(node, argument)
+          estree_util_create_create(node, argument)
           init = {type: 'AwaitExpression', argument}
 
           if (
@@ -59102,6 +60040,7 @@ var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from
 
 
 
+
 __webpack_require__(7973);
 
 
@@ -59118,16 +60057,16 @@ var utils = {
     calloutIcons: {},
 };
 var makeUseMDXComponents = function (more) {
-    var components = index_assign(index_assign({}, components_namespaceObject), more);
+    var components = index_assign(index_assign(index_assign({}, more), components_namespaceObject), { Variable: (variable_default()) });
     return function () { return components; };
 };
 var reactProcessor = function (opts) {
     if (opts === void 0) { opts = {}; }
-    return core_createProcessor(index_assign({ remarkPlugins: [callouts] }, opts));
+    return core_createProcessor(index_assign({ remarkPlugins: [remarkFrontmatter, callouts] }, opts));
 };
 var index_compile = function (text, opts) {
     if (opts === void 0) { opts = {}; }
-    return String(compileSync(text, index_assign({ outputFormat: 'function-body', providerImportSource: '#', remarkPlugins: [callouts] }, opts))).replace(/await import\(_resolveDynamicMdxSpecifier\('react'\)\)/, 'arguments[0].imports.React');
+    return String(compileSync(text, index_assign({ outputFormat: 'function-body', providerImportSource: '#', remarkPlugins: [remarkFrontmatter, callouts] }, opts))).replace(/await import\(_resolveDynamicMdxSpecifier\('react'\)\)/, 'arguments[0].imports.React');
 };
 var index_run = function (code_1) {
     var args_1 = [];
@@ -59164,7 +60103,7 @@ var index_html = function (text, opts) {
 };
 var mdast = function (text, opts) {
     if (opts === void 0) { opts = {}; }
-    var processor = remark().use(remarkMdx);
+    var processor = remark().use(remarkMdx).use(remarkFrontmatter);
     try {
         var tree = processor.parse(text);
         return processor.runSync(tree);