Refactor routing in App component to enhance navigation and improve error handling by integrating dynamic routes and updating the NotFound route.

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

@@ -0,0 +1,139 @@
+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;
+}
+//# sourceMappingURL=codes.d.ts.map

node_modules/micromark-util-symbol/lib/codes.d.ts.map

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

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: 65_279,
+  // Unicode Specials block.
+  replacementCharacter: 65_533 // `<60>`
+})

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

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

node_modules/micromark-util-symbol/lib/constants.d.ts.map

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

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} */ ({
+  attentionSideAfter: 2, // Symbol to mark an attention sequence as after content: `a*`
+  attentionSideBefore: 1, // Symbol to mark an attention sequence as before 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 `<![`.
+  characterGroupPunctuation: 2, // Symbol used to indicate a character is punctuation
+  characterGroupWhitespace: 1, // Symbol used to indicate a character is whitespace
+  characterReferenceDecimalSizeMax: 7, // `&#9999999;`.
+  characterReferenceHexadecimalSizeMax: 6, // `&#xff9999;`.
+  characterReferenceNamedSizeMax: 31, // `&CounterClockwiseContourIntegral;`.
+  codeFencedSequenceSizeMin: 3, // At least 3 ticks or tildes are needed.
+  contentTypeContent: 'content',
+  contentTypeDocument: 'document',
+  contentTypeFlow: 'flow',
+  contentTypeString: 'string',
+  contentTypeText: 'text',
+  hardBreakPrefixSizeMin: 2, // At least 2 trailing spaces are needed.
+  htmlBasic: 6, // Symbol for `<div`
+  htmlCdata: 5, // Symbol for `<![CDATA[]]>`
+  htmlComment: 2, // Symbol for `<!---->`
+  htmlComplete: 7, // Symbol for `<x>`
+  htmlDeclaration: 4, // Symbol for `<!doctype>`
+  htmlInstruction: 3, // Symbol for `<?php?>`
+  htmlRawSizeMax: 8, // Length of `textarea`.
+  htmlRaw: 1, // Symbol for `<script>`
+  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: 10_000 // V8 (and potentially others) have problems injecting giant arrays into other arrays, hence we operate in chunks.
+})

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

@@ -0,0 +1,5 @@
+export { codes } from "./codes.js";
+export { constants } from "./constants.js";
+export { types } from "./types.js";
+export { values } from "./values.js";
+//# sourceMappingURL=default.d.ts.map

node_modules/micromark-util-symbol/lib/default.d.ts.map

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

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-util-symbol/lib/types.d.ts

@@ -0,0 +1,106 @@
+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";
+}
+//# sourceMappingURL=types.d.ts.map

node_modules/micromark-util-symbol/lib/types.d.ts.map

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

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 ordered list:
+  //
+  // ```markdown
+  // 1. a
+  //    b
+  // ```
+  //
+  // Includes `listItemPrefix`, flow, and optionally  `listItemIndent` on further
+  // lines.
+  listOrdered: 'listOrdered',
+
+  // Whole unordered list:
+  //
+  // ```markdown
+  // - 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-util-symbol/lib/values.d.ts

@@ -0,0 +1,102 @@
+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: "<22>";
+}
+//# sourceMappingURL=values.d.ts.map

node_modules/micromark-util-symbol/lib/values.d.ts.map

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

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>'
+})