完成世界书、骰子、apiconfig页面处理

frontend/node_modules/mdast-util-to-markdown/lib/handle/blockquote.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @import {Blockquote, Parents} from 'mdast'
+ * @import {Info, Map, State} from 'mdast-util-to-markdown'
+ */
+/**
+ * @param {Blockquote} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function blockquote(node: Blockquote, _: Parents | undefined, state: State, info: Info): string;
+import type { Blockquote } from 'mdast';
+import type { Parents } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+import type { Info } from 'mdast-util-to-markdown';
+//# sourceMappingURL=blockquote.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/handle/blockquote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockquote.d.ts","sourceRoot":"","sources":["blockquote.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,iCANW,UAAU,KACV,OAAO,GAAG,SAAS,SACnB,KAAK,QACL,IAAI,GACF,MAAM,CAalB;gCAtBqC,OAAO;6BAAP,OAAO;2BACV,wBAAwB;0BAAxB,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/handle/break.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {Break} _
+ * @param {Parents | undefined} _1
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function hardBreak(_: Break, _1: Parents | undefined, state: State, info: Info): string;
+import type { Break } from 'mdast';
+import type { Parents } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+import type { Info } from 'mdast-util-to-markdown';
+//# sourceMappingURL=break.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/handle/code.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {Code} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function code(node: Code, _: Parents | undefined, state: State, info: Info): string;
+import type { Code } from 'mdast';
+import type { Parents } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+import type { Info } from 'mdast-util-to-markdown';
+//# sourceMappingURL=code.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/handle/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["definition.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,iCANW,UAAU,KACV,OAAO,GAAG,SAAS,SACnB,KAAK,QACL,IAAI,GACF,MAAM,CA+DlB;gCAzEqC,OAAO;6BAAP,OAAO;2BADf,wBAAwB;0BAAxB,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/handle/definition.js

@@ -0,0 +1,76 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Definition, Parents} from 'mdast'
+ */
+
+import {checkQuote} from '../util/check-quote.js'
+
+/**
+ * @param {Definition} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function definition(node, _, state, info) {
+  const quote = checkQuote(state)
+  const suffix = quote === '"' ? 'Quote' : 'Apostrophe'
+  const exit = state.enter('definition')
+  let subexit = state.enter('label')
+  const tracker = state.createTracker(info)
+  let value = tracker.move('[')
+  value += tracker.move(
+    state.safe(state.associationId(node), {
+      before: value,
+      after: ']',
+      ...tracker.current()
+    })
+  )
+  value += tracker.move(']: ')
+
+  subexit()
+
+  if (
+    // If there’s no url, or…
+    !node.url ||
+    // If there are control characters or whitespace.
+    /[\0- \u007F]/.test(node.url)
+  ) {
+    subexit = state.enter('destinationLiteral')
+    value += tracker.move('<')
+    value += tracker.move(
+      state.safe(node.url, {before: value, after: '>', ...tracker.current()})
+    )
+    value += tracker.move('>')
+  } else {
+    // No whitespace, raw is prettier.
+    subexit = state.enter('destinationRaw')
+    value += tracker.move(
+      state.safe(node.url, {
+        before: value,
+        after: node.title ? ' ' : '\n',
+        ...tracker.current()
+      })
+    )
+  }
+
+  subexit()
+
+  if (node.title) {
+    subexit = state.enter(`title${suffix}`)
+    value += tracker.move(' ' + quote)
+    value += tracker.move(
+      state.safe(node.title, {
+        before: value,
+        after: quote,
+        ...tracker.current()
+      })
+    )
+    value += tracker.move(quote)
+    subexit()
+  }
+
+  exit()
+
+  return value
+}

frontend/node_modules/mdast-util-to-markdown/lib/handle/emphasis.js

@@ -0,0 +1,69 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Emphasis, Parents} from 'mdast'
+ */
+
+import {checkEmphasis} from '../util/check-emphasis.js'
+import {encodeCharacterReference} from '../util/encode-character-reference.js'
+import {encodeInfo} from '../util/encode-info.js'
+
+emphasis.peek = emphasisPeek
+
+/**
+ * @param {Emphasis} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function emphasis(node, _, state, info) {
+  const marker = checkEmphasis(state)
+  const exit = state.enter('emphasis')
+  const tracker = state.createTracker(info)
+  const before = tracker.move(marker)
+
+  let between = tracker.move(
+    state.containerPhrasing(node, {
+      after: marker,
+      before,
+      ...tracker.current()
+    })
+  )
+  const betweenHead = between.charCodeAt(0)
+  const open = encodeInfo(
+    info.before.charCodeAt(info.before.length - 1),
+    betweenHead,
+    marker
+  )
+
+  if (open.inside) {
+    between = encodeCharacterReference(betweenHead) + between.slice(1)
+  }
+
+  const betweenTail = between.charCodeAt(between.length - 1)
+  const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker)
+
+  if (close.inside) {
+    between = between.slice(0, -1) + encodeCharacterReference(betweenTail)
+  }
+
+  const after = tracker.move(marker)
+
+  exit()
+
+  state.attentionEncodeSurroundingInfo = {
+    after: close.outside,
+    before: open.outside
+  }
+  return before + between + after
+}
+
+/**
+ * @param {Emphasis} _
+ * @param {Parents | undefined} _1
+ * @param {State} state
+ * @returns {string}
+ */
+function emphasisPeek(_, _1, state) {
+  return state.options.emphasis || '*'
+}

frontend/node_modules/mdast-util-to-markdown/lib/handle/heading.js

@@ -0,0 +1,75 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Heading, Parents} from 'mdast'
+ */
+
+import {encodeCharacterReference} from '../util/encode-character-reference.js'
+import {formatHeadingAsSetext} from '../util/format-heading-as-setext.js'
+
+/**
+ * @param {Heading} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function heading(node, _, state, info) {
+  const rank = Math.max(Math.min(6, node.depth || 1), 1)
+  const tracker = state.createTracker(info)
+
+  if (formatHeadingAsSetext(node, state)) {
+    const exit = state.enter('headingSetext')
+    const subexit = state.enter('phrasing')
+    const value = state.containerPhrasing(node, {
+      ...tracker.current(),
+      before: '\n',
+      after: '\n'
+    })
+    subexit()
+    exit()
+
+    return (
+      value +
+      '\n' +
+      (rank === 1 ? '=' : '-').repeat(
+        // The whole size…
+        value.length -
+          // Minus the position of the character after the last EOL (or
+          // 0 if there is none)…
+          (Math.max(value.lastIndexOf('\r'), value.lastIndexOf('\n')) + 1)
+      )
+    )
+  }
+
+  const sequence = '#'.repeat(rank)
+  const exit = state.enter('headingAtx')
+  const subexit = state.enter('phrasing')
+
+  // Note: for proper tracking, we should reset the output positions when there
+  // is no content returned, because then the space is not output.
+  // Practically, in that case, there is no content, so it doesn’t matter that
+  // we’ve tracked one too many characters.
+  tracker.move(sequence + ' ')
+
+  let value = state.containerPhrasing(node, {
+    before: '# ',
+    after: '\n',
+    ...tracker.current()
+  })
+
+  if (/^[\t ]/.test(value)) {
+    // To do: what effect has the character reference on tracking?
+    value = encodeCharacterReference(value.charCodeAt(0)) + value.slice(1)
+  }
+
+  value = value ? sequence + ' ' + value : sequence
+
+  if (state.options.closeAtx) {
+    value += ' ' + sequence
+  }
+
+  subexit()
+  exit()
+
+  return value
+}

frontend/node_modules/mdast-util-to-markdown/lib/handle/html.js

@@ -0,0 +1,20 @@
+/**
+ * @import {Html} from 'mdast'
+ */
+
+html.peek = htmlPeek
+
+/**
+ * @param {Html} node
+ * @returns {string}
+ */
+export function html(node) {
+  return node.value || ''
+}
+
+/**
+ * @returns {string}
+ */
+function htmlPeek() {
+  return '<'
+}

frontend/node_modules/mdast-util-to-markdown/lib/handle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;2BAAyB,iBAAiB;0BAClB,YAAY;qBACjB,WAAW;2BACL,iBAAiB;yBACnB,eAAe;wBAChB,cAAc;qBACjB,WAAW;sBACV,YAAY;+BACH,sBAAsB;2BAC1B,kBAAkB;qBACxB,WAAW;8BACF,qBAAqB;qBAC9B,WAAW;yBACP,gBAAgB;0BACf,gBAAgB;qBACrB,WAAW;uBACT,aAAa;qBACf,WAAW;8BACF,qBAAqB"}

frontend/node_modules/mdast-util-to-markdown/lib/handle/link-reference.js

@@ -0,0 +1,63 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {LinkReference, Parents} from 'mdast'
+ */
+
+linkReference.peek = linkReferencePeek
+
+/**
+ * @param {LinkReference} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function linkReference(node, _, state, info) {
+  const type = node.referenceType
+  const exit = state.enter('linkReference')
+  let subexit = state.enter('label')
+  const tracker = state.createTracker(info)
+  let value = tracker.move('[')
+  const text = state.containerPhrasing(node, {
+    before: value,
+    after: ']',
+    ...tracker.current()
+  })
+  value += tracker.move(text + '][')
+
+  subexit()
+  // Hide the fact that we’re in phrasing, because escapes don’t work.
+  const stack = state.stack
+  state.stack = []
+  subexit = state.enter('reference')
+  // Note: for proper tracking, we should reset the output positions when we end
+  // up making a `shortcut` reference, because then there is no brace output.
+  // Practically, in that case, there is no content, so it doesn’t matter that
+  // we’ve tracked one too many characters.
+  const reference = state.safe(state.associationId(node), {
+    before: value,
+    after: ']',
+    ...tracker.current()
+  })
+  subexit()
+  state.stack = stack
+  exit()
+
+  if (type === 'full' || !text || text !== reference) {
+    value += tracker.move(reference + ']')
+  } else if (type === 'shortcut') {
+    // Remove the unwanted `[`.
+    value = value.slice(0, -1)
+  } else {
+    value += tracker.move(']')
+  }
+
+  return value
+}
+
+/**
+ * @returns {string}
+ */
+function linkReferencePeek() {
+  return '['
+}

frontend/node_modules/mdast-util-to-markdown/lib/handle/link.js

@@ -0,0 +1,114 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Link, Parents} from 'mdast'
+ * @import {Exit} from '../types.js'
+ */
+
+import {checkQuote} from '../util/check-quote.js'
+import {formatLinkAsAutolink} from '../util/format-link-as-autolink.js'
+
+link.peek = linkPeek
+
+/**
+ * @param {Link} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function link(node, _, state, info) {
+  const quote = checkQuote(state)
+  const suffix = quote === '"' ? 'Quote' : 'Apostrophe'
+  const tracker = state.createTracker(info)
+  /** @type {Exit} */
+  let exit
+  /** @type {Exit} */
+  let subexit
+
+  if (formatLinkAsAutolink(node, state)) {
+    // Hide the fact that we’re in phrasing, because escapes don’t work.
+    const stack = state.stack
+    state.stack = []
+    exit = state.enter('autolink')
+    let value = tracker.move('<')
+    value += tracker.move(
+      state.containerPhrasing(node, {
+        before: value,
+        after: '>',
+        ...tracker.current()
+      })
+    )
+    value += tracker.move('>')
+    exit()
+    state.stack = stack
+    return value
+  }
+
+  exit = state.enter('link')
+  subexit = state.enter('label')
+  let value = tracker.move('[')
+  value += tracker.move(
+    state.containerPhrasing(node, {
+      before: value,
+      after: '](',
+      ...tracker.current()
+    })
+  )
+  value += tracker.move('](')
+  subexit()
+
+  if (
+    // If there’s no url but there is a title…
+    (!node.url && node.title) ||
+    // If there are control characters or whitespace.
+    /[\0- \u007F]/.test(node.url)
+  ) {
+    subexit = state.enter('destinationLiteral')
+    value += tracker.move('<')
+    value += tracker.move(
+      state.safe(node.url, {before: value, after: '>', ...tracker.current()})
+    )
+    value += tracker.move('>')
+  } else {
+    // No whitespace, raw is prettier.
+    subexit = state.enter('destinationRaw')
+    value += tracker.move(
+      state.safe(node.url, {
+        before: value,
+        after: node.title ? ' ' : ')',
+        ...tracker.current()
+      })
+    )
+  }
+
+  subexit()
+
+  if (node.title) {
+    subexit = state.enter(`title${suffix}`)
+    value += tracker.move(' ' + quote)
+    value += tracker.move(
+      state.safe(node.title, {
+        before: value,
+        after: quote,
+        ...tracker.current()
+      })
+    )
+    value += tracker.move(quote)
+    subexit()
+  }
+
+  value += tracker.move(')')
+
+  exit()
+  return value
+}
+
+/**
+ * @param {Link} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @returns {string}
+ */
+function linkPeek(node, _, state) {
+  return formatLinkAsAutolink(node, state) ? '<' : '['
+}

frontend/node_modules/mdast-util-to-markdown/lib/handle/list-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-item.d.ts","sourceRoot":"","sources":["list-item.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,+BANW,QAAQ,UACR,OAAO,GAAG,SAAS,SACnB,KAAK,QACL,IAAI,GACF,MAAM,CAgDlB;8BA3DmC,OAAO;6BAAP,OAAO;2BADR,wBAAwB;0BAAxB,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/handle/list.js

@@ -0,0 +1,100 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {List, Parents} from 'mdast'
+ */
+
+import {checkBullet} from '../util/check-bullet.js'
+import {checkBulletOther} from '../util/check-bullet-other.js'
+import {checkBulletOrdered} from '../util/check-bullet-ordered.js'
+import {checkRule} from '../util/check-rule.js'
+
+/**
+ * @param {List} node
+ * @param {Parents | undefined} parent
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function list(node, parent, state, info) {
+  const exit = state.enter('list')
+  const bulletCurrent = state.bulletCurrent
+  /** @type {string} */
+  let bullet = node.ordered ? checkBulletOrdered(state) : checkBullet(state)
+  /** @type {string} */
+  const bulletOther = node.ordered
+    ? bullet === '.'
+      ? ')'
+      : '.'
+    : checkBulletOther(state)
+  let useDifferentMarker =
+    parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false
+
+  if (!node.ordered) {
+    const firstListItem = node.children ? node.children[0] : undefined
+
+    // If there’s an empty first list item directly in two list items,
+    // we have to use a different bullet:
+    //
+    // ```markdown
+    // * - *
+    // ```
+    //
+    // …because otherwise it would become one big thematic break.
+    if (
+      // Bullet could be used as a thematic break marker:
+      (bullet === '*' || bullet === '-') &&
+      // Empty first list item:
+      firstListItem &&
+      (!firstListItem.children || !firstListItem.children[0]) &&
+      // Directly in two other list items:
+      state.stack[state.stack.length - 1] === 'list' &&
+      state.stack[state.stack.length - 2] === 'listItem' &&
+      state.stack[state.stack.length - 3] === 'list' &&
+      state.stack[state.stack.length - 4] === 'listItem' &&
+      // That are each the first child.
+      state.indexStack[state.indexStack.length - 1] === 0 &&
+      state.indexStack[state.indexStack.length - 2] === 0 &&
+      state.indexStack[state.indexStack.length - 3] === 0
+    ) {
+      useDifferentMarker = true
+    }
+
+    // If there’s a thematic break at the start of the first list item,
+    // we have to use a different bullet:
+    //
+    // ```markdown
+    // * ---
+    // ```
+    //
+    // …because otherwise it would become one big thematic break.
+    if (checkRule(state) === bullet && firstListItem) {
+      let index = -1
+
+      while (++index < node.children.length) {
+        const item = node.children[index]
+
+        if (
+          item &&
+          item.type === 'listItem' &&
+          item.children &&
+          item.children[0] &&
+          item.children[0].type === 'thematicBreak'
+        ) {
+          useDifferentMarker = true
+          break
+        }
+      }
+    }
+  }
+
+  if (useDifferentMarker) {
+    bullet = bulletOther
+  }
+
+  state.bulletCurrent = bullet
+  const value = state.containerFlow(node, info)
+  state.bulletLastUsed = bullet
+  state.bulletCurrent = bulletCurrent
+  exit()
+  return value
+}

frontend/node_modules/mdast-util-to-markdown/lib/handle/paragraph.js

@@ -0,0 +1,20 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Paragraph, Parents} from 'mdast'
+ */
+
+/**
+ * @param {Paragraph} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function paragraph(node, _, state, info) {
+  const exit = state.enter('paragraph')
+  const subexit = state.enter('phrasing')
+  const value = state.containerPhrasing(node, info)
+  subexit()
+  exit()
+  return value
+}

frontend/node_modules/mdast-util-to-markdown/lib/handle/strong.js

@@ -0,0 +1,69 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Strong} from 'mdast'
+ */
+
+import {checkStrong} from '../util/check-strong.js'
+import {encodeCharacterReference} from '../util/encode-character-reference.js'
+import {encodeInfo} from '../util/encode-info.js'
+
+strong.peek = strongPeek
+
+/**
+ * @param {Strong} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function strong(node, _, state, info) {
+  const marker = checkStrong(state)
+  const exit = state.enter('strong')
+  const tracker = state.createTracker(info)
+  const before = tracker.move(marker + marker)
+
+  let between = tracker.move(
+    state.containerPhrasing(node, {
+      after: marker,
+      before,
+      ...tracker.current()
+    })
+  )
+  const betweenHead = between.charCodeAt(0)
+  const open = encodeInfo(
+    info.before.charCodeAt(info.before.length - 1),
+    betweenHead,
+    marker
+  )
+
+  if (open.inside) {
+    between = encodeCharacterReference(betweenHead) + between.slice(1)
+  }
+
+  const betweenTail = between.charCodeAt(between.length - 1)
+  const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker)
+
+  if (close.inside) {
+    between = between.slice(0, -1) + encodeCharacterReference(betweenTail)
+  }
+
+  const after = tracker.move(marker + marker)
+
+  exit()
+
+  state.attentionEncodeSurroundingInfo = {
+    after: close.outside,
+    before: open.outside
+  }
+  return before + between + after
+}
+
+/**
+ * @param {Strong} _
+ * @param {Parents | undefined} _1
+ * @param {State} state
+ * @returns {string}
+ */
+function strongPeek(_, _1, state) {
+  return state.options.strong || '*'
+}

frontend/node_modules/mdast-util-to-markdown/lib/handle/text.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Text} from 'mdast'
+ */
+/**
+ * @param {Text} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
+ * @returns {string}
+ */
+export function text(node: Text, _: Parents | undefined, state: State, info: Info): string;
+import type { Text } from 'mdast';
+import type { Parents } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+import type { Info } from 'mdast-util-to-markdown';
+//# sourceMappingURL=text.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast syntax tree into markdown.
+ *
+ * @param {Nodes} tree
+ *   Tree to serialize.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {string}
+ *   Serialized markdown representing `tree`.
+ */
+export function toMarkdown(tree: Nodes, options?: Options | null | undefined): string;
+import type { Nodes } from 'mdast';
+import type { Options } from 'mdast-util-to-markdown';
+//# sourceMappingURL=index.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAmBA;;;;;;;;;GASG;AACH,iCAPW,KAAK,YAEL,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,MAAM,CAoElB;2BA5FuB,OAAO;6BAD0B,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/join.d.ts

@@ -0,0 +1,4 @@
+/** @type {Array<Join>} */
+export const join: Array<Join>;
+import type { Join } from 'mdast-util-to-markdown';
+//# sourceMappingURL=join.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/join.js

@@ -0,0 +1,39 @@
+/**
+ * @import {Join} from 'mdast-util-to-markdown'
+ */
+
+import {formatCodeAsIndented} from './util/format-code-as-indented.js'
+import {formatHeadingAsSetext} from './util/format-heading-as-setext.js'
+
+/** @type {Array<Join>} */
+export const join = [joinDefaults]
+
+/** @type {Join} */
+function joinDefaults(left, right, parent, state) {
+  // Indented code after list or another indented code.
+  if (
+    right.type === 'code' &&
+    formatCodeAsIndented(right, state) &&
+    (left.type === 'list' ||
+      (left.type === right.type && formatCodeAsIndented(left, state)))
+  ) {
+    return false
+  }
+
+  // Join children of a list or an item.
+  // In which case, `parent` has a `spread` field.
+  if ('spread' in parent && typeof parent.spread === 'boolean') {
+    if (
+      left.type === 'paragraph' &&
+      // Two paragraphs.
+      (left.type === right.type ||
+        right.type === 'definition' ||
+        // Paragraph followed by a setext heading.
+        (right.type === 'heading' && formatHeadingAsSetext(right, state)))
+    ) {
+      return
+    }
+
+    return parent.spread ? 1 : 0
+  }
+}

frontend/node_modules/mdast-util-to-markdown/lib/unsafe.d.ts

@@ -0,0 +1,4 @@
+/** @type {Array<Unsafe>} */
+export const unsafe: Array<Unsafe>;
+import type { Unsafe } from 'mdast-util-to-markdown';
+//# sourceMappingURL=unsafe.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js

@@ -0,0 +1,21 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * @param {State} state
+ * @returns {Exclude<Options['bulletOrdered'], null | undefined>}
+ */
+export function checkBulletOrdered(state) {
+  const marker = state.options.bulletOrdered || '.'
+
+  if (marker !== '.' && marker !== ')') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        marker +
+        '` for `options.bulletOrdered`, expected `.` or `)`'
+    )
+  }
+
+  return marker
+}

frontend/node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-bullet-other.d.ts","sourceRoot":"","sources":["check-bullet-other.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,wCAHW,KAAK,GACH,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC,CA6BxD;2BApCgC,wBAAwB;6BAAxB,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js

@@ -0,0 +1,38 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+import {checkBullet} from './check-bullet.js'
+
+/**
+ * @param {State} state
+ * @returns {Exclude<Options['bullet'], null | undefined>}
+ */
+export function checkBulletOther(state) {
+  const bullet = checkBullet(state)
+  const bulletOther = state.options.bulletOther
+
+  if (!bulletOther) {
+    return bullet === '*' ? '-' : '*'
+  }
+
+  if (bulletOther !== '*' && bulletOther !== '+' && bulletOther !== '-') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        bulletOther +
+        '` for `options.bulletOther`, expected `*`, `+`, or `-`'
+    )
+  }
+
+  if (bulletOther === bullet) {
+    throw new Error(
+      'Expected `bullet` (`' +
+        bullet +
+        '`) and `bulletOther` (`' +
+        bulletOther +
+        '`) to be different'
+    )
+  }
+
+  return bulletOther
+}

frontend/node_modules/mdast-util-to-markdown/lib/util/check-bullet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-bullet.d.ts","sourceRoot":"","sources":["check-bullet.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,mCAHW,KAAK,GACH,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC,CAcxD;2BAnBgC,wBAAwB;6BAAxB,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/util/check-bullet.js

@@ -0,0 +1,21 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * @param {State} state
+ * @returns {Exclude<Options['bullet'], null | undefined>}
+ */
+export function checkBullet(state) {
+  const marker = state.options.bullet || '*'
+
+  if (marker !== '*' && marker !== '+' && marker !== '-') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        marker +
+        '` for `options.bullet`, expected `*`, `+`, or `-`'
+    )
+  }
+
+  return marker
+}

frontend/node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-list-item-indent.d.ts","sourceRoot":"","sources":["check-list-item-indent.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,2CAHW,KAAK,GACH,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC,CAchE;2BAnBgC,wBAAwB;6BAAxB,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/util/check-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-quote.d.ts","sourceRoot":"","sources":["check-quote.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,kCAHW,KAAK,GACH,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC,CAcvD;2BAnBgC,wBAAwB;6BAAxB,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+/**
+ * @param {State} state
+ * @returns {Exclude<Options['ruleRepetition'], null | undefined>}
+ */
+export function checkRuleRepetition(state: State): Exclude<Options["ruleRepetition"], null | undefined>;
+import type { State } from 'mdast-util-to-markdown';
+import type { Options } from 'mdast-util-to-markdown';
+//# sourceMappingURL=check-rule-repetition.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js

@@ -0,0 +1,21 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * @param {State} state
+ * @returns {Exclude<Options['ruleRepetition'], null | undefined>}
+ */
+export function checkRuleRepetition(state) {
+  const repetition = state.options.ruleRepetition || 3
+
+  if (repetition < 3) {
+    throw new Error(
+      'Cannot serialize rules with repetition `' +
+        repetition +
+        '` for `options.ruleRepetition`, expected `3` or more'
+    )
+  }
+
+  return repetition
+}

frontend/node_modules/mdast-util-to-markdown/lib/util/check-rule.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+/**
+ * @param {State} state
+ * @returns {Exclude<Options['rule'], null | undefined>}
+ */
+export function checkRule(state: State): Exclude<Options["rule"], null | undefined>;
+import type { State } from 'mdast-util-to-markdown';
+import type { Options } from 'mdast-util-to-markdown';
+//# sourceMappingURL=check-rule.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/util/check-strong.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-strong.d.ts","sourceRoot":"","sources":["check-strong.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,mCAHW,KAAK,GACH,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC,CAcxD;2BAnBgC,wBAAwB;6BAAxB,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/util/check-strong.js

@@ -0,0 +1,21 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * @param {State} state
+ * @returns {Exclude<Options['strong'], null | undefined>}
+ */
+export function checkStrong(state) {
+  const marker = state.options.strong || '*'
+
+  if (marker !== '*' && marker !== '_') {
+    throw new Error(
+      'Cannot serialize strong with `' +
+        marker +
+        '` for `options.strong`, expected `*`, or `_`'
+    )
+  }
+
+  return marker
+}

frontend/node_modules/mdast-util-to-markdown/lib/util/container-flow.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {FlowChildren, FlowParents, TrackFields} from '../types.js'
+ */
+/**
+ * @param {FlowParents} parent
+ *   Parent of flow nodes.
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {TrackFields} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined by (blank) lines.
+ */
+export function containerFlow(parent: FlowParents, state: State, info: TrackFields): string;
+import type { FlowParents } from '../types.js';
+import type { State } from 'mdast-util-to-markdown';
+import type { TrackFields } from '../types.js';
+//# sourceMappingURL=container-flow.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/util/container-flow.js

@@ -0,0 +1,84 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {FlowChildren, FlowParents, TrackFields} from '../types.js'
+ */
+
+/**
+ * @param {FlowParents} parent
+ *   Parent of flow nodes.
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {TrackFields} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined by (blank) lines.
+ */
+export function containerFlow(parent, state, info) {
+  const indexStack = state.indexStack
+  const children = parent.children || []
+  const tracker = state.createTracker(info)
+  /** @type {Array<string>} */
+  const results = []
+  let index = -1
+
+  indexStack.push(-1)
+
+  while (++index < children.length) {
+    const child = children[index]
+
+    indexStack[indexStack.length - 1] = index
+
+    results.push(
+      tracker.move(
+        state.handle(child, parent, state, {
+          before: '\n',
+          after: '\n',
+          ...tracker.current()
+        })
+      )
+    )
+
+    if (child.type !== 'list') {
+      state.bulletLastUsed = undefined
+    }
+
+    if (index < children.length - 1) {
+      results.push(
+        tracker.move(between(child, children[index + 1], parent, state))
+      )
+    }
+  }
+
+  indexStack.pop()
+
+  return results.join('')
+}
+
+/**
+ * @param {FlowChildren} left
+ * @param {FlowChildren} right
+ * @param {FlowParents} parent
+ * @param {State} state
+ * @returns {string}
+ */
+function between(left, right, parent, state) {
+  let index = state.join.length
+
+  while (index--) {
+    const result = state.join[index](left, right, parent, state)
+
+    if (result === true || result === 1) {
+      break
+    }
+
+    if (typeof result === 'number') {
+      return '\n'.repeat(1 + result)
+    }
+
+    if (result === false) {
+      return '\n\n<!---->\n\n'
+    }
+  }
+
+  return '\n\n'
+}

frontend/node_modules/mdast-util-to-markdown/lib/util/emphasis-strong-marker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @this {State}
+ * @returns {'*' | '_'}
+ */
+export function emphasisStrongMarker(this: State): "*" | "_";
+import type { State } from '../types.js';
+//# sourceMappingURL=emphasis-strong-marker.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Encode a code point as a character reference.
+ *
+ * @param {number} code
+ *   Code point to encode.
+ * @returns {string}
+ *   Encoded character reference.
+ */
+export function encodeCharacterReference(code: number): string;
+//# sourceMappingURL=encode-character-reference.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js

@@ -0,0 +1,11 @@
+/**
+ * Encode a code point as a character reference.
+ *
+ * @param {number} code
+ *   Code point to encode.
+ * @returns {string}
+ *   Encoded character reference.
+ */
+export function encodeCharacterReference(code) {
+  return '&#x' + code.toString(16).toUpperCase() + ';'
+}

frontend/node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Code} from 'mdast'
+ */
+/**
+ * @param {Code} node
+ * @param {State} state
+ * @returns {boolean}
+ */
+export function formatCodeAsIndented(node: Code, state: State): boolean;
+import type { Code } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+//# sourceMappingURL=format-code-as-indented.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-heading-as-setext.d.ts","sourceRoot":"","sources":["format-heading-as-setext.js"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,4CAJW,OAAO,SACP,KAAK,GACH,OAAO,CAsBnB;6BA/ByB,OAAO;2BADT,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js

@@ -0,0 +1,34 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Heading} from 'mdast'
+ */
+
+import {EXIT, visit} from 'unist-util-visit'
+import {toString} from 'mdast-util-to-string'
+
+/**
+ * @param {Heading} node
+ * @param {State} state
+ * @returns {boolean}
+ */
+export function formatHeadingAsSetext(node, state) {
+  let literalWithBreak = false
+
+  // Look for literals with a line break.
+  // Note that this also
+  visit(node, function (node) {
+    if (
+      ('value' in node && /\r?\n|\r/.test(node.value)) ||
+      node.type === 'break'
+    ) {
+      literalWithBreak = true
+      return EXIT
+    }
+  })
+
+  return Boolean(
+    (!node.depth || node.depth < 3) &&
+      toString(node) &&
+      (state.options.setext || literalWithBreak)
+  )
+}

frontend/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-link-as-autolink.d.ts","sourceRoot":"","sources":["format-link-as-autolink.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,2CAJW,IAAI,SACJ,KAAK,GACH,OAAO,CAuBnB;0BA/BsB,OAAO;2BADN,wBAAwB"}

frontend/node_modules/mdast-util-to-markdown/lib/util/indent-lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indent-lines.d.ts","sourceRoot":"","sources":["indent-lines.js"],"names":[],"mappings":""}

frontend/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'
+ */
+/**
+ * @param {Array<ConstructName>} stack
+ * @param {Unsafe} pattern
+ * @returns {boolean}
+ */
+export function patternInScope(stack: Array<ConstructName>, pattern: Unsafe): boolean;
+import type { ConstructName } from 'mdast-util-to-markdown';
+import type { Unsafe } from 'mdast-util-to-markdown';
+//# sourceMappingURL=pattern-in-scope.d.ts.map

frontend/node_modules/mdast-util-to-markdown/lib/util/track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track.d.ts","sourceRoot":"","sources":["track.js"],"names":[],"mappings":""}