@e-llm-studio/citation 0.0.140-beta.6 → 0.0.141

package/dist/cjs/node_modules/micromark-extension-gfm-footnote/lib/syntax.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.js","sources":["../../../../../node_modules/micromark-extension-gfm-footnote/lib/syntax.js"],"sourcesContent":["/**\n * @import {Event, Exiter, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { blankLine } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nconst indent = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\n// To do: micromark should support a `_hiddenGfmFootnoteSupport`, which only\n// affects label start (image).\n// That will let us drop `tokenizePotentialGfmFootnote*`.\n// It currently has a `_hiddenFootnoteSupport`, which affects that and more.\n// That can be removed when `micromark-extension-footnote` is archived.\n\n/**\n * Create an extension for `micromark` to enable GFM footnote syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to\n *   enable GFM footnote syntax.\n */\nexport function gfmFootnote() {\n  /** @type {Extension} */\n  return {\n    document: {\n      [91]: {\n        name: 'gfmFootnoteDefinition',\n        tokenize: tokenizeDefinitionStart,\n        continuation: {\n          tokenize: tokenizeDefinitionContinuation\n        },\n        exit: gfmFootnoteDefinitionEnd\n      }\n    },\n    text: {\n      [91]: {\n        name: 'gfmFootnoteCall',\n        tokenize: tokenizeGfmFootnoteCall\n      },\n      [93]: {\n        name: 'gfmPotentialFootnoteCall',\n        add: 'after',\n        tokenize: tokenizePotentialGfmFootnoteCall,\n        resolveTo: resolveToPotentialGfmFootnoteCall\n      }\n    }\n  };\n}\n\n// To do: remove after micromark update.\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePotentialGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {Token} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    const token = self.events[index][1];\n    if (token.type === \"labelImage\") {\n      labelStart = token;\n      break;\n    }\n\n    // Exit if we’ve walked far enough.\n    if (token.type === 'gfmFootnoteCall' || token.type === \"labelLink\" || token.type === \"label\" || token.type === \"image\" || token.type === \"link\") {\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * @type {State}\n   */\n  function start(code) {\n    if (!labelStart || !labelStart._balanced) {\n      return nok(code);\n    }\n    const id = normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    }));\n    if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {\n      return nok(code);\n    }\n    effects.enter('gfmFootnoteCallLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallLabelMarker');\n    return ok(code);\n  }\n}\n\n// To do: remove after micromark update.\n/** @type {Resolver} */\nfunction resolveToPotentialGfmFootnoteCall(events, context) {\n  let index = events.length;\n  /** @type {Token | undefined} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    if (events[index][1].type === \"labelImage\" && events[index][0] === 'enter') {\n      labelStart = events[index][1];\n      break;\n    }\n  }\n  // Change the `labelImageMarker` to a `data`.\n  events[index + 1][1].type = \"data\";\n  events[index + 3][1].type = 'gfmFootnoteCallLabelMarker';\n\n  // The whole (without `!`):\n  /** @type {Token} */\n  const call = {\n    type: 'gfmFootnoteCall',\n    start: Object.assign({}, events[index + 3][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  };\n  // The `^` marker\n  /** @type {Token} */\n  const marker = {\n    type: 'gfmFootnoteCallMarker',\n    start: Object.assign({}, events[index + 3][1].end),\n    end: Object.assign({}, events[index + 3][1].end)\n  };\n  // Increment the end 1 character.\n  marker.end.column++;\n  marker.end.offset++;\n  marker.end._bufferIndex++;\n  /** @type {Token} */\n  const string = {\n    type: 'gfmFootnoteCallString',\n    start: Object.assign({}, marker.end),\n    end: Object.assign({}, events[events.length - 1][1].start)\n  };\n  /** @type {Token} */\n  const chunk = {\n    type: \"chunkString\",\n    contentType: 'string',\n    start: Object.assign({}, string.start),\n    end: Object.assign({}, string.end)\n  };\n\n  /** @type {Array<Event>} */\n  const replacement = [\n  // Take the `labelImageMarker` (now `data`, the `!`)\n  events[index + 1], events[index + 2], ['enter', call, context],\n  // The `[`\n  events[index + 3], events[index + 4],\n  // The `^`.\n  ['enter', marker, context], ['exit', marker, context],\n  // Everything in between.\n  ['enter', string, context], ['enter', chunk, context], ['exit', chunk, context], ['exit', string, context],\n  // The ending (`]`, properly parsed and labelled).\n  events[events.length - 2], events[events.length - 1], ['exit', call, context]];\n  events.splice(index, events.length - index + 1, ...replacement);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  let size = 0;\n  /** @type {boolean} */\n  let data;\n\n  // Note: the implementation of `markdown-rs` is different, because it houses\n  // core *and* extensions in one project.\n  // Therefore, it can include footnote logic inside `label-end`.\n  // We can’t do that, but luckily, we can parse footnotes in a simpler way than\n  // needed for labels.\n  return start;\n\n  /**\n   * Start of footnote label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteCall');\n    effects.enter('gfmFootnoteCallLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallLabelMarker');\n    return callStart;\n  }\n\n  /**\n   * After `[`, at `^`.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callStart(code) {\n    if (code !== 94) return nok(code);\n    effects.enter('gfmFootnoteCallMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallMarker');\n    effects.enter('gfmFootnoteCallString');\n    effects.enter('chunkString').contentType = 'string';\n    return callData;\n  }\n\n  /**\n   * In label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callData(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const token = effects.exit('gfmFootnoteCallString');\n      if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {\n        return nok(code);\n      }\n      effects.enter('gfmFootnoteCallLabelMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteCallLabelMarker');\n      effects.exit('gfmFootnoteCall');\n      return ok;\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? callEscape : callData;\n  }\n\n  /**\n   * On character after escape.\n   *\n   * ```markdown\n   * > | a [^b\\c] d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return callData;\n    }\n    return callData(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionStart(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {string} */\n  let identifier;\n  let size = 0;\n  /** @type {boolean | undefined} */\n  let data;\n  return start;\n\n  /**\n   * Start of GFM footnote definition.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteDefinition')._container = true;\n    effects.enter('gfmFootnoteDefinitionLabel');\n    effects.enter('gfmFootnoteDefinitionLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteDefinitionLabelMarker');\n    return labelAtMarker;\n  }\n\n  /**\n   * In label, at caret.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAtMarker(code) {\n    if (code === 94) {\n      effects.enter('gfmFootnoteDefinitionMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteDefinitionMarker');\n      effects.enter('gfmFootnoteDefinitionLabelString');\n      effects.enter('chunkString').contentType = 'string';\n      return labelInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label.\n   *\n   * > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote\n   * > definition labels.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const token = effects.exit('gfmFootnoteDefinitionLabelString');\n      identifier = normalizeIdentifier(self.sliceSerialize(token));\n      effects.enter('gfmFootnoteDefinitionLabelMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteDefinitionLabelMarker');\n      effects.exit('gfmFootnoteDefinitionLabel');\n      return labelAfter;\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets:\n   * > <https://github.com/github/cmark-gfm/issues/240>\n   *\n   * ```markdown\n   * > | [^a\\*b]: c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return labelInside;\n    }\n    return labelInside(code);\n  }\n\n  /**\n   * After definition label.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    if (code === 58) {\n      effects.enter('definitionMarker');\n      effects.consume(code);\n      effects.exit('definitionMarker');\n      if (!defined.includes(identifier)) {\n        defined.push(identifier);\n      }\n\n      // Any whitespace after the marker is eaten, forming indented code\n      // is not possible.\n      // No space is also fine, just like a block quote marker.\n      return factorySpace(effects, whitespaceAfter, 'gfmFootnoteDefinitionWhitespace');\n    }\n    return nok(code);\n  }\n\n  /**\n   * After definition prefix.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function whitespaceAfter(code) {\n    // `markdown-rs` has a wrapping token for the prefix that is closed here.\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionContinuation(effects, ok, nok) {\n  /// Start of footnote definition continuation.\n  ///\n  /// ```markdown\n  ///   | [^a]: b\n  /// > |     c\n  ///     ^\n  /// ```\n  //\n  // Either a blank line, which is okay, or an indented thing.\n  return effects.check(blankLine, ok, effects.attempt(indent, ok, nok));\n}\n\n/** @type {Exiter} */\nfunction gfmFootnoteDefinitionEnd(effects) {\n  effects.exit('gfmFootnoteDefinition');\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, 'gfmFootnoteDefinitionIndent', 4 + 1);\n\n  /**\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === 'gfmFootnoteDefinitionIndent' && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok(code) : nok(code);\n  }\n}"],"names":["indent","tokenize","effects","ok","nok","self","this","factorySpace","code","tail","events","length","type","sliceSerialize","partial","tokenizePotentialGfmFootnoteCall","index","defined","parser","gfmFootnotes","labelStart","token","_balanced","id","normalizeIdentifier","start","end","now","codePointAt","includes","slice","enter","consume","exit","resolveToPotentialGfmFootnoteCall","context","call","Object","assign","marker","column","offset","_bufferIndex","string","chunk","contentType","replacement","splice","tokenizeGfmFootnoteCall","data","size","callStart","callData","markdownLineEndingOrSpace","callEscape","tokenizeDefinitionStart","identifier","_container","labelAtMarker","labelInside","labelAfter","labelEscape","push","whitespaceAfter","tokenizeDefinitionContinuation","check","blankLine","attempt","gfmFootnoteDefinitionEnd","document","name","continuation","text","add","resolveTo"],"mappings":"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"}

package/dist/cjs/node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-util-chunked/index.js"),t=require("../../micromark-util-classify-character/index.js"),r=require("../../micromark-util-resolve-all/index.js");exports.gfmStrikethrough=function(n){let s=(n||{}).singleTilde;const i={name:"strikethrough",tokenize:function(e,r,n){const i=this.previous,o=this.events;let u=0;return function(t){if(126===i&&"characterEscape"!==o[o.length-1][1].type)return n(t);return e.enter("strikethroughSequenceTemporary"),c(t)};function c(o){const l=t.classifyCharacter(i);if(126===o)return u>1?n(o):(e.consume(o),u++,c);if(u<2&&!s)return n(o);const a=e.exit("strikethroughSequenceTemporary"),h=t.classifyCharacter(o);return a._open=!h||2===h&&Boolean(l),a._close=!l||2===l&&Boolean(h),r(o)}},resolveAll:function(t,n){let s=-1;for(;++s<t.length;)if("enter"===t[s][0]&&"strikethroughSequenceTemporary"===t[s][1].type&&t[s][1]._close){let i=s;for(;i--;)if("exit"===t[i][0]&&"strikethroughSequenceTemporary"===t[i][1].type&&t[i][1]._open&&t[s][1].end.offset-t[s][1].start.offset===t[i][1].end.offset-t[i][1].start.offset){t[s][1].type="strikethroughSequence",t[i][1].type="strikethroughSequence";const o={type:"strikethrough",start:Object.assign({},t[i][1].start),end:Object.assign({},t[s][1].end)},u={type:"strikethroughText",start:Object.assign({},t[i][1].end),end:Object.assign({},t[s][1].start)},c=[["enter",o,n],["enter",t[i][1],n],["exit",t[i][1],n],["enter",u,n]],l=n.parser.constructs.insideSpan.null;l&&e.splice(c,c.length,0,r.resolveAll(l,t.slice(i+1,s),n)),e.splice(c,c.length,0,[["exit",u,n],["enter",t[s][1],n],["exit",t[s][1],n],["exit",o,n]]),e.splice(t,i-1,s-i+3,c),s=i+c.length-2;break}}s=-1;for(;++s<t.length;)"strikethroughSequenceTemporary"===t[s][1].type&&(t[s][1].type="data");return t}};return null==s&&(s=!0),{text:{126:i},insideSpan:{null:[i]},attentionMarkers:{null:[126]}}};
-//# sourceMappingURL=syntax.js.map

package/dist/cjs/node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.js","sources":["../../../../../node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js"],"sourcesContent":["/**\n * @import {Options} from 'micromark-extension-gfm-strikethrough'\n * @import {Event, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create an extension for `micromark` to enable GFM strikethrough syntax.\n *\n * @param {Options | null | undefined} [options={}]\n *   Configuration.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions`, to\n *   enable GFM strikethrough syntax.\n */\nexport function gfmStrikethrough(options) {\n  const options_ = options || {};\n  let single = options_.singleTilde;\n  const tokenizer = {\n    name: 'strikethrough',\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  };\n  if (single === null || single === undefined) {\n    single = true;\n  }\n  return {\n    text: {\n      [126]: tokenizer\n    },\n    insideSpan: {\n      null: [tokenizer]\n    },\n    attentionMarkers: {\n      null: [126]\n    }\n  };\n\n  /**\n   * Take events and resolve strikethrough.\n   *\n   * @type {Resolver}\n   */\n  function resolveAllStrikethrough(events, context) {\n    let index = -1;\n\n    // Walk through all events.\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && events[index][1]._close) {\n        let open = index;\n\n        // Now walk back to find an opener.\n        while (open--) {\n          // Find a token that can open the closer.\n          if (events[open][0] === 'exit' && events[open][1].type === 'strikethroughSequenceTemporary' && events[open][1]._open &&\n          // If the sizes are the same:\n          events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {\n            events[index][1].type = 'strikethroughSequence';\n            events[open][1].type = 'strikethroughSequence';\n\n            /** @type {Token} */\n            const strikethrough = {\n              type: 'strikethrough',\n              start: Object.assign({}, events[open][1].start),\n              end: Object.assign({}, events[index][1].end)\n            };\n\n            /** @type {Token} */\n            const text = {\n              type: 'strikethroughText',\n              start: Object.assign({}, events[open][1].end),\n              end: Object.assign({}, events[index][1].start)\n            };\n\n            // Opening.\n            /** @type {Array<Event>} */\n            const nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]];\n            const insideSpan = context.parser.constructs.insideSpan.null;\n            if (insideSpan) {\n              // Between.\n              splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));\n            }\n\n            // Closing.\n            splice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]);\n            splice(events, open - 1, index - open + 3, nextEvents);\n            index = open + nextEvents.length - 2;\n            break;\n          }\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = \"data\";\n      }\n    }\n    return events;\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeStrikethrough(effects, ok, nok) {\n    const previous = this.previous;\n    const events = this.events;\n    let size = 0;\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      if (previous === 126 && events[events.length - 1][1].type !== \"characterEscape\") {\n        return nok(code);\n      }\n      effects.enter('strikethroughSequenceTemporary');\n      return more(code);\n    }\n\n    /** @type {State} */\n    function more(code) {\n      const before = classifyCharacter(previous);\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code);\n        effects.consume(code);\n        size++;\n        return more;\n      }\n      if (size < 2 && !single) return nok(code);\n      const token = effects.exit('strikethroughSequenceTemporary');\n      const after = classifyCharacter(code);\n      token._open = !after || after === 2 && Boolean(before);\n      token._close = !before || before === 2 && Boolean(after);\n      return ok(code);\n    }\n  }\n}"],"names":["options","single","singleTilde","tokenizer","name","tokenize","effects","ok","nok","previous","this","events","size","code","length","type","enter","more","before","classifyCharacter","consume","token","exit","after","_open","Boolean","_close","resolveAll","context","index","open","end","offset","start","strikethrough","Object","assign","text","nextEvents","insideSpan","parser","constructs","null","splice","slice","attentionMarkers"],"mappings":"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"}

package/dist/cjs/node_modules/micromark-extension-gfm-table/lib/edit-map.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});exports.EditMap=class{constructor(){this.map=[]}add(t,s,e){!function(t,s,e,p){let h=0;if(0===e&&0===p.length)return;for(;h<t.map.length;){if(t.map[h][0]===s)return t.map[h][1]+=e,void t.map[h][2].push(...p);h+=1}t.map.push([s,e,p])}(this,t,s,e)}consume(t){if(this.map.sort(function(t,s){return t[0]-s[0]}),0===this.map.length)return;let s=this.map.length;const e=[];for(;s>0;)s-=1,e.push(t.slice(this.map[s][0]+this.map[s][1]),this.map[s][2]),t.length=this.map[s][0];e.push(t.slice()),t.length=0;let p=e.pop();for(;p;){for(const s of p)t.push(s);p=e.pop()}this.map.length=0}};
-//# sourceMappingURL=edit-map.js.map

package/dist/cjs/node_modules/micromark-extension-gfm-table/lib/edit-map.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"edit-map.js","sources":["../../../../../node_modules/micromark-extension-gfm-table/lib/edit-map.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\n// Port of `edit_map.rs` from `markdown-rs`.\n// This should move to `markdown-js` later.\n\n// Deal with several changes in events, batching them together.\n//\n// Preferably, changes should be kept to a minimum.\n// Sometimes, it’s needed to change the list of events, because parsing can be\n// messy, and it helps to expose a cleaner interface of events to the compiler\n// and other users.\n// It can also help to merge many adjacent similar events.\n// And, in other cases, it’s needed to parse subcontent: pass some events\n// through another tokenizer and inject the result.\n\n/**\n * @typedef {[number, number, Array<Event>]} Change\n * @typedef {[number, number, number]} Jump\n */\n\n/**\n * Tracks a bunch of edits.\n */\nexport class EditMap {\n  /**\n   * Create a new edit map.\n   */\n  constructor() {\n    /**\n     * Record of changes.\n     *\n     * @type {Array<Change>}\n     */\n    this.map = [];\n  }\n\n  /**\n   * Create an edit: a remove and/or add at a certain place.\n   *\n   * @param {number} index\n   * @param {number} remove\n   * @param {Array<Event>} add\n   * @returns {undefined}\n   */\n  add(index, remove, add) {\n    addImplementation(this, index, remove, add);\n  }\n\n  // To do: add this when moving to `micromark`.\n  // /**\n  //  * Create an edit: but insert `add` before existing additions.\n  //  *\n  //  * @param {number} index\n  //  * @param {number} remove\n  //  * @param {Array<Event>} add\n  //  * @returns {undefined}\n  //  */\n  // addBefore(index, remove, add) {\n  //   addImplementation(this, index, remove, add, true)\n  // }\n\n  /**\n   * Done, change the events.\n   *\n   * @param {Array<Event>} events\n   * @returns {undefined}\n   */\n  consume(events) {\n    this.map.sort(function (a, b) {\n      return a[0] - b[0];\n    });\n\n    /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n    if (this.map.length === 0) {\n      return;\n    }\n\n    // To do: if links are added in events, like they are in `markdown-rs`,\n    // this is needed.\n    // // Calculate jumps: where items in the current list move to.\n    // /** @type {Array<Jump>} */\n    // const jumps = []\n    // let index = 0\n    // let addAcc = 0\n    // let removeAcc = 0\n    // while (index < this.map.length) {\n    //   const [at, remove, add] = this.map[index]\n    //   removeAcc += remove\n    //   addAcc += add.length\n    //   jumps.push([at, removeAcc, addAcc])\n    //   index += 1\n    // }\n    //\n    // . shiftLinks(events, jumps)\n\n    let index = this.map.length;\n    /** @type {Array<Array<Event>>} */\n    const vecs = [];\n    while (index > 0) {\n      index -= 1;\n      vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);\n\n      // Truncate rest.\n      events.length = this.map[index][0];\n    }\n    vecs.push(events.slice());\n    events.length = 0;\n    let slice = vecs.pop();\n    while (slice) {\n      for (const element of slice) {\n        events.push(element);\n      }\n      slice = vecs.pop();\n    }\n\n    // Truncate everything.\n    this.map.length = 0;\n  }\n}\n\n/**\n * Create an edit.\n *\n * @param {EditMap} editMap\n * @param {number} at\n * @param {number} remove\n * @param {Array<Event>} add\n * @returns {undefined}\n */\nfunction addImplementation(editMap, at, remove, add) {\n  let index = 0;\n\n  /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n  if (remove === 0 && add.length === 0) {\n    return;\n  }\n  while (index < editMap.map.length) {\n    if (editMap.map[index][0] === at) {\n      editMap.map[index][1] += remove;\n\n      // To do: before not used by tables, use when moving to micromark.\n      // if (before) {\n      //   add.push(...editMap.map[index][2])\n      //   editMap.map[index][2] = add\n      // } else {\n      editMap.map[index][2].push(...add);\n      // }\n\n      return;\n    }\n    index += 1;\n  }\n  editMap.map.push([at, remove, add]);\n}\n\n// /**\n//  * Shift `previous` and `next` links according to `jumps`.\n//  *\n//  * This fixes links in case there are events removed or added between them.\n//  *\n//  * @param {Array<Event>} events\n//  * @param {Array<Jump>} jumps\n//  */\n// function shiftLinks(events, jumps) {\n//   let jumpIndex = 0\n//   let index = 0\n//   let add = 0\n//   let rm = 0\n\n//   while (index < events.length) {\n//     const rmCurr = rm\n\n//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {\n//       add = jumps[jumpIndex][2]\n//       rm = jumps[jumpIndex][1]\n//       jumpIndex += 1\n//     }\n\n//     // Ignore items that will be removed.\n//     if (rm > rmCurr) {\n//       index += rm - rmCurr\n//     } else {\n//       // ?\n//       // if let Some(link) = &events[index].link {\n//       //     if let Some(next) = link.next {\n//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);\n//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {\n//       //             add = jumps[jumpIndex].2;\n//       //             rm = jumps[jumpIndex].1;\n//       //             jumpIndex += 1;\n//       //         }\n//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);\n//       //         index = next;\n//       //         continue;\n//       //     }\n//       // }\n//       index += 1\n//     }\n//   }\n// }"],"names":["constructor","this","map","add","index","remove","editMap","at","length","push","addImplementation","consume","events","sort","a","b","vecs","slice","pop","element"],"mappings":"oFAyBO,MAIL,WAAAA,GAMEC,KAAKC,IAAM,EACZ,CAUD,GAAAC,CAAIC,EAAOC,EAAQF,IAqFrB,SAA2BG,EAASC,EAAIF,EAAQF,GAC9C,IAAIC,EAAQ,EAGZ,GAAe,IAAXC,GAA+B,IAAfF,EAAIK,OACtB,OAEF,KAAOJ,EAAQE,EAAQJ,IAAIM,QAAQ,CACjC,GAAIF,EAAQJ,IAAIE,GAAO,KAAOG,EAW5B,OAVAD,EAAQJ,IAAIE,GAAO,IAAMC,OAOzBC,EAAQJ,IAAIE,GAAO,GAAGK,QAAQN,GAKhCC,GAAS,CACV,CACDE,EAAQJ,IAAIO,KAAK,CAACF,EAAIF,EAAQF,GAChC,CA5GIO,CAAkBT,KAAMG,EAAOC,EAAQF,EACxC,CAqBD,OAAAQ,CAAQC,GAMN,GALAX,KAAKC,IAAIW,KAAK,SAAUC,EAAGC,GACzB,OAAOD,EAAE,GAAKC,EAAE,EACtB,GAG4B,IAApBd,KAAKC,IAAIM,OACX,OAqBF,IAAIJ,EAAQH,KAAKC,IAAIM,OAErB,MAAMQ,EAAO,GACb,KAAOZ,EAAQ,GACbA,GAAS,EACTY,EAAKP,KAAKG,EAAOK,MAAMhB,KAAKC,IAAIE,GAAO,GAAKH,KAAKC,IAAIE,GAAO,IAAKH,KAAKC,IAAIE,GAAO,IAGjFQ,EAAOJ,OAASP,KAAKC,IAAIE,GAAO,GAElCY,EAAKP,KAAKG,EAAOK,SACjBL,EAAOJ,OAAS,EAChB,IAAIS,EAAQD,EAAKE,MACjB,KAAOD,GAAO,CACZ,IAAK,MAAME,KAAWF,EACpBL,EAAOH,KAAKU,GAEdF,EAAQD,EAAKE,KACd,CAGDjB,KAAKC,IAAIM,OAAS,CACnB"}

package/dist/cjs/node_modules/micromark-extension-gfm-table/lib/infer.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.gfmTableAlign=function(e,t){let l=!1;const r=[];for(;t<e.length;){const n=e[t];if(l){if("enter"===n[0])"tableContent"===n[1].type&&r.push("tableDelimiterMarker"===e[t+1][1].type?"left":"none");else if("tableContent"===n[1].type){if("tableDelimiterMarker"===e[t-1][1].type){const e=r.length-1;r[e]="left"===r[e]?"center":"right"}}else if("tableDelimiterRow"===n[1].type)break}else"enter"===n[0]&&"tableDelimiterRow"===n[1].type&&(l=!0);t+=1}return r};
-//# sourceMappingURL=infer.js.map

package/dist/cjs/node_modules/micromark-extension-gfm-table/lib/infer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"infer.js","sources":["../../../../../node_modules/micromark-extension-gfm-table/lib/infer.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\n/**\n * @typedef {'center' | 'left' | 'none' | 'right'} Align\n */\n\n/**\n * Figure out the alignment of a GFM table.\n *\n * @param {Readonly<Array<Event>>} events\n *   List of events.\n * @param {number} index\n *   Table enter event.\n * @returns {Array<Align>}\n *   List of aligns.\n */\nexport function gfmTableAlign(events, index) {\n  let inDelimiterRow = false;\n  /** @type {Array<Align>} */\n  const align = [];\n  while (index < events.length) {\n    const event = events[index];\n    if (inDelimiterRow) {\n      if (event[0] === 'enter') {\n        // Start of alignment value: set a new column.\n        // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n        if (event[1].type === 'tableContent') {\n          align.push(events[index + 1][1].type === 'tableDelimiterMarker' ? 'left' : 'none');\n        }\n      }\n      // Exits:\n      // End of alignment value: change the column.\n      // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n      else if (event[1].type === 'tableContent') {\n        if (events[index - 1][1].type === 'tableDelimiterMarker') {\n          const alignIndex = align.length - 1;\n          align[alignIndex] = align[alignIndex] === 'left' ? 'center' : 'right';\n        }\n      }\n      // Done!\n      else if (event[1].type === 'tableDelimiterRow') {\n        break;\n      }\n    } else if (event[0] === 'enter' && event[1].type === 'tableDelimiterRow') {\n      inDelimiterRow = true;\n    }\n    index += 1;\n  }\n  return align;\n}"],"names":["events","index","inDelimiterRow","align","length","event","type","push","alignIndex"],"mappings":"0FAkBO,SAAuBA,EAAQC,GACpC,IAAIC,GAAiB,EAErB,MAAMC,EAAQ,GACd,KAAOF,EAAQD,EAAOI,QAAQ,CAC5B,MAAMC,EAAQL,EAAOC,GACrB,GAAIC,GACF,GAAiB,UAAbG,EAAM,GAGc,iBAAlBA,EAAM,GAAGC,MACXH,EAAMI,KAAmC,yBAA9BP,EAAOC,EAAQ,GAAG,GAAGK,KAAkC,OAAS,aAM1E,GAAsB,iBAAlBD,EAAM,GAAGC,MAChB,GAAkC,yBAA9BN,EAAOC,EAAQ,GAAG,GAAGK,KAAiC,CACxD,MAAME,EAAaL,EAAMC,OAAS,EAClCD,EAAMK,GAAoC,SAAtBL,EAAMK,GAAyB,SAAW,OAC/D,OAGE,GAAsB,sBAAlBH,EAAM,GAAGC,KAChB,UAEoB,UAAbD,EAAM,IAAoC,sBAAlBA,EAAM,GAAGC,OAC1CJ,GAAiB,GAEnBD,GAAS,CACV,CACD,OAAOE,CACT"}

package/dist/cjs/node_modules/micromark-extension-gfm-table/lib/syntax.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),t=require("../../micromark-util-character/index.js"),n=require("./edit-map.js"),r=require("./infer.js");function i(n,r,i){const a=this;let l,o=0,c=0;return function(e){let t=a.events.length-1;for(;t>-1;){const e=a.events[t][1].type;if("lineEnding"!==e&&"linePrefix"!==e)break;t--}const n=t>-1?a.events[t][1].type:null,r="tableHead"===n||"tableRow"===n?k:s;if(r===k&&a.parser.lazy[a.now().line])return i(e);return r(e)};function s(e){return n.enter("tableHead"),n.enter("tableRow"),function(e){if(124===e)return d(e);return l=!0,c+=1,d(e)}(e)}function d(r){return null===r?i(r):t.markdownLineEnding(r)?c>1?(c=0,a.interrupt=!0,n.exit("tableRow"),n.enter("lineEnding"),n.consume(r),n.exit("lineEnding"),p):i(r):t.markdownSpace(r)?e.factorySpace(n,d,"whitespace")(r):(c+=1,l&&(l=!1,o+=1),124===r?(n.enter("tableCellDivider"),n.consume(r),n.exit("tableCellDivider"),l=!0,d):(n.enter("data"),u(r)))}function u(e){return null===e||124===e||t.markdownLineEndingOrSpace(e)?(n.exit("data"),d(e)):(n.consume(e),92===e?b:u)}function b(e){return 92===e||124===e?(n.consume(e),u):u(e)}function p(r){return a.interrupt=!1,a.parser.lazy[a.now().line]?i(r):(n.enter("tableDelimiterRow"),l=!1,t.markdownSpace(r)?e.factorySpace(n,m,"linePrefix",a.parser.constructs.disable.null.includes("codeIndented")?void 0:4)(r):m(r))}function m(e){return 45===e||58===e?y(e):124===e?(l=!0,n.enter("tableCellDivider"),n.consume(e),n.exit("tableCellDivider"),f):D(e)}function f(r){return t.markdownSpace(r)?e.factorySpace(n,y,"whitespace")(r):y(r)}function y(e){return 58===e?(c+=1,l=!0,n.enter("tableDelimiterMarker"),n.consume(e),n.exit("tableDelimiterMarker"),v):45===e?(c+=1,v(e)):null===e||t.markdownLineEnding(e)?x(e):D(e)}function v(e){return 45===e?(n.enter("tableDelimiterFiller"),w(e)):D(e)}function w(e){return 45===e?(n.consume(e),w):58===e?(l=!0,n.exit("tableDelimiterFiller"),n.enter("tableDelimiterMarker"),n.consume(e),n.exit("tableDelimiterMarker"),g):(n.exit("tableDelimiterFiller"),g(e))}function g(r){return t.markdownSpace(r)?e.factorySpace(n,x,"whitespace")(r):x(r)}function x(e){return 124===e?m(e):(null===e||t.markdownLineEnding(e))&&l&&o===c?(n.exit("tableDelimiterRow"),n.exit("tableHead"),r(e)):D(e)}function D(e){return i(e)}function k(e){return n.enter("tableRow"),j(e)}function j(i){return 124===i?(n.enter("tableCellDivider"),n.consume(i),n.exit("tableCellDivider"),j):null===i||t.markdownLineEnding(i)?(n.exit("tableRow"),r(i)):t.markdownSpace(i)?e.factorySpace(n,j,"whitespace")(i):(n.enter("data"),O(i))}function O(e){return null===e||124===e||t.markdownLineEndingOrSpace(e)?(n.exit("data"),j(e)):(n.consume(e),92===e?h:O)}function h(e){return 92===e||124===e?(n.consume(e),O):O(e)}}function a(e,t){let i,a,c,s=-1,d=!0,u=0,b=[0,0,0,0],p=[0,0,0,0],m=!1,f=0;const y=new n.EditMap;for(;++s<e.length;){const n=e[s],r=n[1];"enter"===n[0]?"tableHead"===r.type?(m=!1,0!==f&&(o(y,t,f,i,a),a=void 0,f=0),i={type:"table",start:Object.assign({},r.start),end:Object.assign({},r.end)},y.add(s,0,[["enter",i,t]])):"tableRow"===r.type||"tableDelimiterRow"===r.type?(d=!0,c=void 0,b=[0,0,0,0],p=[0,s+1,0,0],m&&(m=!1,a={type:"tableBody",start:Object.assign({},r.start),end:Object.assign({},r.end)},y.add(s,0,[["enter",a,t]])),u="tableDelimiterRow"===r.type?2:a?3:1):!u||"data"!==r.type&&"tableDelimiterMarker"!==r.type&&"tableDelimiterFiller"!==r.type?"tableCellDivider"===r.type&&(d?d=!1:(0!==b[1]&&(p[0]=p[1],c=l(y,t,b,u,void 0,c)),b=p,p=[b[1],s,0,0])):(d=!1,0===p[2]&&(0!==b[1]&&(p[0]=p[1],c=l(y,t,b,u,void 0,c),b=[0,0,0,0]),p[2]=s)):"tableHead"===r.type?(m=!0,f=s):"tableRow"===r.type||"tableDelimiterRow"===r.type?(f=s,0!==b[1]?(p[0]=p[1],c=l(y,t,b,u,s,c)):0!==p[1]&&(c=l(y,t,p,u,s,c)),u=0):!u||"data"!==r.type&&"tableDelimiterMarker"!==r.type&&"tableDelimiterFiller"!==r.type||(p[3]=s)}for(0!==f&&o(y,t,f,i,a),y.consume(t.events),s=-1;++s<t.events.length;){const e=t.events[s];"enter"===e[0]&&"table"===e[1].type&&(e[1]._align=r.gfmTableAlign(t.events,s))}return e}function l(e,t,n,r,i,a){const l=1===r?"tableHeader":2===r?"tableDelimiter":"tableData";0!==n[0]&&(a.end=Object.assign({},c(t.events,n[0])),e.add(n[0],0,[["exit",a,t]]));const o=c(t.events,n[1]);if(a={type:l,start:Object.assign({},o),end:Object.assign({},o)},e.add(n[1],0,[["enter",a,t]]),0!==n[2]){const i=c(t.events,n[2]),a=c(t.events,n[3]),l={type:"tableContent",start:Object.assign({},i),end:Object.assign({},a)};if(e.add(n[2],0,[["enter",l,t]]),2!==r){const r=t.events[n[2]],i=t.events[n[3]];if(r[1].end=Object.assign({},i[1].end),r[1].type="chunkText",r[1].contentType="text",n[3]>n[2]+1){const t=n[2]+1,r=n[3]-n[2]-1;e.add(t,r,[])}}e.add(n[3]+1,0,[["exit",l,t]])}return void 0!==i&&(a.end=Object.assign({},c(t.events,i)),e.add(i,0,[["exit",a,t]]),a=void 0),a}function o(e,t,n,r,i){const a=[],l=c(t.events,n);i&&(i.end=Object.assign({},l),a.push(["exit",i,t])),r.end=Object.assign({},l),a.push(["exit",r,t]),e.add(n+1,0,a)}function c(e,t){const n=e[t],r="enter"===n[0]?"start":"end";return n[1][r]}exports.gfmTable=function(){return{flow:{null:{name:"table",tokenize:i,resolveAll:a}}}};
-//# sourceMappingURL=syntax.js.map

package/dist/cjs/node_modules/micromark-extension-gfm-table/lib/syntax.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.js","sources":["../../../../../node_modules/micromark-extension-gfm-table/lib/syntax.js"],"sourcesContent":["/**\n * @import {Event, Extension, Point, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\n/**\n * @typedef {[number, number, number, number]} Range\n *   Cell info.\n *\n * @typedef {0 | 1 | 2 | 3} RowKind\n *   Where we are: `1` for head row, `2` for delimiter row, `3` for body row.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { EditMap } from './edit-map.js';\nimport { gfmTableAlign } from './infer.js';\n\n/**\n * Create an HTML extension for `micromark` to support GitHub tables syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   table syntax.\n */\nexport function gfmTable() {\n  return {\n    flow: {\n      null: {\n        name: 'table',\n        tokenize: tokenizeTable,\n        resolveAll: resolveTable\n      }\n    }\n  };\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTable(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  let sizeB = 0;\n  /** @type {boolean | undefined} */\n  let seen;\n  return start;\n\n  /**\n   * Start of a GFM table.\n   *\n   * If there is a valid table row or table head before, then we try to parse\n   * another row.\n   * Otherwise, we try to parse a head.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length - 1;\n    while (index > -1) {\n      const type = self.events[index][1].type;\n      if (type === \"lineEnding\" ||\n      // Note: markdown-rs uses `whitespace` instead of `linePrefix`\n      type === \"linePrefix\") index--;else break;\n    }\n    const tail = index > -1 ? self.events[index][1].type : null;\n    const next = tail === 'tableHead' || tail === 'tableRow' ? bodyRowStart : headRowBefore;\n\n    // Don’t allow lazy body rows.\n    if (next === bodyRowStart && self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    return next(code);\n  }\n\n  /**\n   * Before table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBefore(code) {\n    effects.enter('tableHead');\n    effects.enter('tableRow');\n    return headRowStart(code);\n  }\n\n  /**\n   * Before table head row, after whitespace.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowStart(code) {\n    if (code === 124) {\n      return headRowBreak(code);\n    }\n\n    // To do: micromark-js should let us parse our own whitespace in extensions,\n    // like `markdown-rs`:\n    //\n    // ```js\n    // // 4+ spaces.\n    // if (markdownSpace(code)) {\n    //   return nok(code)\n    // }\n    // ```\n\n    seen = true;\n    // Count the first character, that isn’t a pipe, double.\n    sizeB += 1;\n    return headRowBreak(code);\n  }\n\n  /**\n   * At break in table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *       ^\n   *         ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBreak(code) {\n    if (code === null) {\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      // If anything other than one pipe (ignoring whitespace) was used, it’s fine.\n      if (sizeB > 1) {\n        sizeB = 0;\n        // To do: check if this works.\n        // Feel free to interrupt:\n        self.interrupt = true;\n        effects.exit('tableRow');\n        effects.enter(\"lineEnding\");\n        effects.consume(code);\n        effects.exit(\"lineEnding\");\n        return headDelimiterStart;\n      }\n\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code);\n    }\n    if (markdownSpace(code)) {\n      // To do: check if this is fine.\n      // effects.attempt(State::Next(StateName::GfmTableHeadRowBreak), State::Nok)\n      // State::Retry(space_or_tab(tokenizer))\n      return factorySpace(effects, headRowBreak, \"whitespace\")(code);\n    }\n    sizeB += 1;\n    if (seen) {\n      seen = false;\n      // Header cell count.\n      size += 1;\n    }\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      // Whether a delimiter was seen.\n      seen = true;\n      return headRowBreak;\n    }\n\n    // Anything else is cell data.\n    effects.enter(\"data\");\n    return headRowData(code);\n  }\n\n  /**\n   * In table head row data.\n   *\n   * ```markdown\n   * > | | a |\n   *       ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"data\");\n      return headRowBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? headRowEscape : headRowData;\n  }\n\n  /**\n   * In table head row escape.\n   *\n   * ```markdown\n   * > | | a\\-b |\n   *         ^\n   *   | | ---- |\n   *   | | c    |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return headRowData;\n    }\n    return headRowData(code);\n  }\n\n  /**\n   * Before delimiter row.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterStart(code) {\n    // Reset `interrupt`.\n    self.interrupt = false;\n\n    // Note: in `markdown-rs`, we need to handle piercing here too.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    effects.enter('tableDelimiterRow');\n    // Track if we’ve seen a `:` or `|`.\n    seen = false;\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return headDelimiterBefore(code);\n  }\n\n  /**\n   * Before delimiter row, after optional whitespace.\n   *\n   * Reused when a `|` is found later, to parse another cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterBefore(code) {\n    if (code === 45 || code === 58) {\n      return headDelimiterValueBefore(code);\n    }\n    if (code === 124) {\n      seen = true;\n      // If we start with a pipe, we open a cell marker.\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return headDelimiterCellBefore;\n    }\n\n    // More whitespace / empty row not allowed at start.\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * After `|`, before delimiter cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellBefore(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterValueBefore, \"whitespace\")(code);\n    }\n    return headDelimiterValueBefore(code);\n  }\n\n  /**\n   * Before delimiter cell value.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterValueBefore(code) {\n    // Align: left.\n    if (code === 58) {\n      sizeB += 1;\n      seen = true;\n      effects.enter('tableDelimiterMarker');\n      effects.consume(code);\n      effects.exit('tableDelimiterMarker');\n      return headDelimiterLeftAlignmentAfter;\n    }\n\n    // Align: none.\n    if (code === 45) {\n      sizeB += 1;\n      // To do: seems weird that this *isn’t* left aligned, but that state is used?\n      return headDelimiterLeftAlignmentAfter(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return headDelimiterCellAfter(code);\n    }\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * After delimiter cell left alignment marker.\n   *\n   * ```markdown\n   *   | | a  |\n   * > | | :- |\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterLeftAlignmentAfter(code) {\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller');\n      return headDelimiterFiller(code);\n    }\n\n    // Anything else is not ok after the left-align colon.\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * In delimiter cell filler.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterFiller(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return headDelimiterFiller;\n    }\n\n    // Align is `center` if it was `left`, `right` otherwise.\n    if (code === 58) {\n      seen = true;\n      effects.exit('tableDelimiterFiller');\n      effects.enter('tableDelimiterMarker');\n      effects.consume(code);\n      effects.exit('tableDelimiterMarker');\n      return headDelimiterRightAlignmentAfter;\n    }\n    effects.exit('tableDelimiterFiller');\n    return headDelimiterRightAlignmentAfter(code);\n  }\n\n  /**\n   * After delimiter cell right alignment marker.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterRightAlignmentAfter(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterCellAfter, \"whitespace\")(code);\n    }\n    return headDelimiterCellAfter(code);\n  }\n\n  /**\n   * After delimiter cell.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellAfter(code) {\n    if (code === 124) {\n      return headDelimiterBefore(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      // Exit when:\n      // * there was no `:` or `|` at all (it’s a thematic break or setext\n      //   underline instead)\n      // * the header cell count is not the delimiter cell count\n      if (!seen || size !== sizeB) {\n        return headDelimiterNok(code);\n      }\n\n      // Note: in markdown-rs`, a reset is needed here.\n      effects.exit('tableDelimiterRow');\n      effects.exit('tableHead');\n      // To do: in `markdown-rs`, resolvers need to be registered manually.\n      // effects.register_resolver(ResolveName::GfmTable)\n      return ok(code);\n    }\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * In delimiter row, at a disallowed byte.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | x |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterNok(code) {\n    // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n    return nok(code);\n  }\n\n  /**\n   * Before table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowStart(code) {\n    // Note: in `markdown-rs` we need to manually take care of a prefix,\n    // but in `micromark-js` that is done for us, so if we’re here, we’re\n    // never at whitespace.\n    effects.enter('tableRow');\n    return bodyRowBreak(code);\n  }\n\n  /**\n   * At break in table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   *       ^\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowBreak(code) {\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return bodyRowBreak;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('tableRow');\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, bodyRowBreak, \"whitespace\")(code);\n    }\n\n    // Anything else is cell content.\n    effects.enter(\"data\");\n    return bodyRowData(code);\n  }\n\n  /**\n   * In table body row data.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"data\");\n      return bodyRowBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? bodyRowEscape : bodyRowData;\n  }\n\n  /**\n   * In table body row escape.\n   *\n   * ```markdown\n   *   | | a    |\n   *   | | ---- |\n   * > | | b\\-c |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return bodyRowData;\n    }\n    return bodyRowData(code);\n  }\n}\n\n/** @type {Resolver} */\n\nfunction resolveTable(events, context) {\n  let index = -1;\n  let inFirstCellAwaitingPipe = true;\n  /** @type {RowKind} */\n  let rowKind = 0;\n  /** @type {Range} */\n  let lastCell = [0, 0, 0, 0];\n  /** @type {Range} */\n  let cell = [0, 0, 0, 0];\n  let afterHeadAwaitingFirstBodyRow = false;\n  let lastTableEnd = 0;\n  /** @type {Token | undefined} */\n  let currentTable;\n  /** @type {Token | undefined} */\n  let currentBody;\n  /** @type {Token | undefined} */\n  let currentCell;\n  const map = new EditMap();\n  while (++index < events.length) {\n    const event = events[index];\n    const token = event[1];\n    if (event[0] === 'enter') {\n      // Start of head.\n      if (token.type === 'tableHead') {\n        afterHeadAwaitingFirstBodyRow = false;\n\n        // Inject previous (body end and) table end.\n        if (lastTableEnd !== 0) {\n          flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);\n          currentBody = undefined;\n          lastTableEnd = 0;\n        }\n\n        // Inject table start.\n        currentTable = {\n          type: 'table',\n          start: Object.assign({}, token.start),\n          // Note: correct end is set later.\n          end: Object.assign({}, token.end)\n        };\n        map.add(index, 0, [['enter', currentTable, context]]);\n      } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') {\n        inFirstCellAwaitingPipe = true;\n        currentCell = undefined;\n        lastCell = [0, 0, 0, 0];\n        cell = [0, index + 1, 0, 0];\n\n        // Inject table body start.\n        if (afterHeadAwaitingFirstBodyRow) {\n          afterHeadAwaitingFirstBodyRow = false;\n          currentBody = {\n            type: 'tableBody',\n            start: Object.assign({}, token.start),\n            // Note: correct end is set later.\n            end: Object.assign({}, token.end)\n          };\n          map.add(index, 0, [['enter', currentBody, context]]);\n        }\n        rowKind = token.type === 'tableDelimiterRow' ? 2 : currentBody ? 3 : 1;\n      }\n      // Cell data.\n      else if (rowKind && (token.type === \"data\" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) {\n        inFirstCellAwaitingPipe = false;\n\n        // First value in cell.\n        if (cell[2] === 0) {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1];\n            currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell);\n            lastCell = [0, 0, 0, 0];\n          }\n          cell[2] = index;\n        }\n      } else if (token.type === 'tableCellDivider') {\n        if (inFirstCellAwaitingPipe) {\n          inFirstCellAwaitingPipe = false;\n        } else {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1];\n            currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell);\n          }\n          lastCell = cell;\n          cell = [lastCell[1], index, 0, 0];\n        }\n      }\n    }\n    // Exit events.\n    else if (token.type === 'tableHead') {\n      afterHeadAwaitingFirstBodyRow = true;\n      lastTableEnd = index;\n    } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') {\n      lastTableEnd = index;\n      if (lastCell[1] !== 0) {\n        cell[0] = cell[1];\n        currentCell = flushCell(map, context, lastCell, rowKind, index, currentCell);\n      } else if (cell[1] !== 0) {\n        currentCell = flushCell(map, context, cell, rowKind, index, currentCell);\n      }\n      rowKind = 0;\n    } else if (rowKind && (token.type === \"data\" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) {\n      cell[3] = index;\n    }\n  }\n  if (lastTableEnd !== 0) {\n    flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);\n  }\n  map.consume(context.events);\n\n  // To do: move this into `html`, when events are exposed there.\n  // That’s what `markdown-rs` does.\n  // That needs updates to `mdast-util-gfm-table`.\n  index = -1;\n  while (++index < context.events.length) {\n    const event = context.events[index];\n    if (event[0] === 'enter' && event[1].type === 'table') {\n      event[1]._align = gfmTableAlign(context.events, index);\n    }\n  }\n  return events;\n}\n\n/**\n * Generate a cell.\n *\n * @param {EditMap} map\n * @param {Readonly<TokenizeContext>} context\n * @param {Readonly<Range>} range\n * @param {RowKind} rowKind\n * @param {number | undefined} rowEnd\n * @param {Token | undefined} previousCell\n * @returns {Token | undefined}\n */\n// eslint-disable-next-line max-params\nfunction flushCell(map, context, range, rowKind, rowEnd, previousCell) {\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCell' : 'tableCell'\n  const groupName = rowKind === 1 ? 'tableHeader' : rowKind === 2 ? 'tableDelimiter' : 'tableData';\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCellValue' : 'tableCellText'\n  const valueName = 'tableContent';\n\n  // Insert an exit for the previous cell, if there is one.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //          ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[0] !== 0) {\n    previousCell.end = Object.assign({}, getPoint(context.events, range[0]));\n    map.add(range[0], 0, [['exit', previousCell, context]]);\n  }\n\n  // Insert enter of this cell.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //           ^-- enter\n  //           ^^^^-- this cell\n  // ```\n  const now = getPoint(context.events, range[1]);\n  previousCell = {\n    type: groupName,\n    start: Object.assign({}, now),\n    // Note: correct end is set later.\n    end: Object.assign({}, now)\n  };\n  map.add(range[1], 0, [['enter', previousCell, context]]);\n\n  // Insert text start at first data start and end at last data end, and\n  // remove events between.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //            ^-- enter\n  //             ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[2] !== 0) {\n    const relatedStart = getPoint(context.events, range[2]);\n    const relatedEnd = getPoint(context.events, range[3]);\n    /** @type {Token} */\n    const valueToken = {\n      type: valueName,\n      start: Object.assign({}, relatedStart),\n      end: Object.assign({}, relatedEnd)\n    };\n    map.add(range[2], 0, [['enter', valueToken, context]]);\n    if (rowKind !== 2) {\n      // Fix positional info on remaining events\n      const start = context.events[range[2]];\n      const end = context.events[range[3]];\n      start[1].end = Object.assign({}, end[1].end);\n      start[1].type = \"chunkText\";\n      start[1].contentType = \"text\";\n\n      // Remove if needed.\n      if (range[3] > range[2] + 1) {\n        const a = range[2] + 1;\n        const b = range[3] - range[2] - 1;\n        map.add(a, b, []);\n      }\n    }\n    map.add(range[3] + 1, 0, [['exit', valueToken, context]]);\n  }\n\n  // Insert an exit for the last cell, if at the row end.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //                    ^-- exit\n  //               ^^^^^^-- this cell (the last one contains two “between” parts)\n  // ```\n  if (rowEnd !== undefined) {\n    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd));\n    map.add(rowEnd, 0, [['exit', previousCell, context]]);\n    previousCell = undefined;\n  }\n  return previousCell;\n}\n\n/**\n * Generate table end (and table body end).\n *\n * @param {Readonly<EditMap>} map\n * @param {Readonly<TokenizeContext>} context\n * @param {number} index\n * @param {Token} table\n * @param {Token | undefined} tableBody\n */\n// eslint-disable-next-line max-params\nfunction flushTableEnd(map, context, index, table, tableBody) {\n  /** @type {Array<Event>} */\n  const exits = [];\n  const related = getPoint(context.events, index);\n  if (tableBody) {\n    tableBody.end = Object.assign({}, related);\n    exits.push(['exit', tableBody, context]);\n  }\n  table.end = Object.assign({}, related);\n  exits.push(['exit', table, context]);\n  map.add(index + 1, 0, exits);\n}\n\n/**\n * @param {Readonly<Array<Event>>} events\n * @param {number} index\n * @returns {Readonly<Point>}\n */\nfunction getPoint(events, index) {\n  const event = events[index];\n  const side = event[0] === 'enter' ? 'start' : 'end';\n  return event[1][side];\n}"],"names":["tokenizeTable","effects","ok","nok","self","this","seen","size","sizeB","code","index","events","length","type","tail","next","bodyRowStart","headRowBefore","parser","lazy","now","line","enter","headRowBreak","headRowStart","markdownLineEnding","interrupt","exit","consume","headDelimiterStart","markdownSpace","factorySpace","headRowData","markdownLineEndingOrSpace","headRowEscape","headDelimiterBefore","constructs","disable","null","includes","undefined","headDelimiterValueBefore","headDelimiterCellBefore","headDelimiterNok","headDelimiterLeftAlignmentAfter","headDelimiterCellAfter","headDelimiterFiller","headDelimiterRightAlignmentAfter","bodyRowBreak","bodyRowData","bodyRowEscape","resolveTable","context","currentTable","currentBody","currentCell","inFirstCellAwaitingPipe","rowKind","lastCell","cell","afterHeadAwaitingFirstBodyRow","lastTableEnd","map","EditMap","event","token","flushTableEnd","start","Object","assign","end","add","flushCell","_align","gfmTableAlign","range","rowEnd","previousCell","groupName","getPoint","relatedStart","relatedEnd","valueToken","contentType","a","b","table","tableBody","exits","related","push","side","flow","name","tokenize","resolveAll"],"mappings":"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"}

package/dist/cjs/node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),t=require("../../micromark-util-character/index.js");const n={name:"tasklistCheck",tokenize:function(e,n,i){const c=this;return function(t){if(null!==c.previous||!c._gfmTasklistFirstContentOfListItem)return i(t);return e.enter("taskListCheck"),e.enter("taskListCheckMarker"),e.consume(t),e.exit("taskListCheckMarker"),s};function s(n){return t.markdownLineEndingOrSpace(n)?(e.enter("taskListCheckValueUnchecked"),e.consume(n),e.exit("taskListCheckValueUnchecked"),k):88===n||120===n?(e.enter("taskListCheckValueChecked"),e.consume(n),e.exit("taskListCheckValueChecked"),k):i(n)}function k(t){return 93===t?(e.enter("taskListCheckMarker"),e.consume(t),e.exit("taskListCheckMarker"),e.exit("taskListCheck"),a):i(t)}function a(c){return t.markdownLineEnding(c)?n(c):t.markdownSpace(c)?e.check({tokenize:r},n,i)(c):i(c)}}};function r(t,n,r){return e.factorySpace(t,function(e){return null===e?r(e):n(e)},"whitespace")}exports.gfmTaskListItem=function(){return{text:{91:n}}};
-//# sourceMappingURL=syntax.js.map

package/dist/cjs/node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.js","sources":["../../../../../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js"],"sourcesContent":["/**\n * @import {Extension, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nconst tasklistCheck = {\n  name: 'tasklistCheck',\n  tokenize: tokenizeTasklistCheck\n};\n\n/**\n * Create an HTML extension for `micromark` to support GFM task list items\n * syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `htmlExtensions` to\n *   support GFM task list items when serializing to HTML.\n */\nexport function gfmTaskListItem() {\n  return {\n    text: {\n      [91]: tasklistCheck\n    }\n  };\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  const self = this;\n  return open;\n\n  /**\n   * At start of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (\n    // Exit if there’s stuff before.\n    self.previous !== null ||\n    // Exit if not in the first content that is the first child of a list\n    // item.\n    !self._gfmTasklistFirstContentOfListItem) {\n      return nok(code);\n    }\n    effects.enter('taskListCheck');\n    effects.enter('taskListCheckMarker');\n    effects.consume(code);\n    effects.exit('taskListCheckMarker');\n    return inside;\n  }\n\n  /**\n   * In task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // Currently we match how GH works in files.\n    // To match how GH works in comments, use `markdownSpace` (`[\\t ]`) instead\n    // of `markdownLineEndingOrSpace` (`[\\t\\n\\r ]`).\n    if (markdownLineEndingOrSpace(code)) {\n      effects.enter('taskListCheckValueUnchecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueUnchecked');\n      return close;\n    }\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueChecked');\n      return close;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At close of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function close(code) {\n    if (code === 93) {\n      effects.enter('taskListCheckMarker');\n      effects.consume(code);\n      effects.exit('taskListCheckMarker');\n      effects.exit('taskListCheck');\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   */\n  function after(code) {\n    // EOL in paragraph means there must be something else after it.\n    if (markdownLineEnding(code)) {\n      return ok(code);\n    }\n\n    // Space or tab?\n    // Check what comes after.\n    if (markdownSpace(code)) {\n      return effects.check({\n        tokenize: spaceThenNonSpace\n      }, ok, nok)(code);\n    }\n\n    // EOF, or non-whitespace, both wrong.\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction spaceThenNonSpace(effects, ok, nok) {\n  return factorySpace(effects, after, \"whitespace\");\n\n  /**\n   * After whitespace, after task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // EOF means there was nothing, so bad.\n    // EOL means there’s content after it, so good.\n    // Impossible to have more spaces.\n    // Anything else is good.\n    return code === null ? nok(code) : ok(code);\n  }\n}"],"names":["tasklistCheck","name","tokenize","effects","ok","nok","self","this","code","previous","_gfmTasklistFirstContentOfListItem","enter","consume","exit","inside","markdownLineEndingOrSpace","close","after","markdownLineEnding","markdownSpace","check","spaceThenNonSpace","factorySpace","text"],"mappings":"iLAMA,MAAMA,EAAgB,CACpBC,KAAM,gBACNC,SAuBF,SAA+BC,EAASC,EAAIC,GAC1C,MAAMC,EAAOC,KACb,OAYA,SAAcC,GACZ,GAEkB,OAAlBF,EAAKG,WAGJH,EAAKI,mCACJ,OAAOL,EAAIG,GAMb,OAJAL,EAAQQ,MAAM,iBACdR,EAAQQ,MAAM,uBACdR,EAAQS,QAAQJ,GAChBL,EAAQU,KAAK,uBACNC,CACR,EAYD,SAASA,EAAON,GAId,OAAIO,EAAAA,0BAA0BP,IAC5BL,EAAQQ,MAAM,+BACdR,EAAQS,QAAQJ,GAChBL,EAAQU,KAAK,+BACNG,GAEI,KAATR,GAAwB,MAATA,GACjBL,EAAQQ,MAAM,6BACdR,EAAQS,QAAQJ,GAChBL,EAAQU,KAAK,6BACNG,GAEFX,EAAIG,EACZ,CAYD,SAASQ,EAAMR,GACb,OAAa,KAATA,GACFL,EAAQQ,MAAM,uBACdR,EAAQS,QAAQJ,GAChBL,EAAQU,KAAK,uBACbV,EAAQU,KAAK,iBACNI,GAEFZ,EAAIG,EACZ,CAKD,SAASS,EAAMT,GAEb,OAAIU,EAAAA,mBAAmBV,GACdJ,EAAGI,GAKRW,EAAAA,cAAcX,GACTL,EAAQiB,MAAM,CACnBlB,SAAUmB,GACTjB,EAAIC,EAFAF,CAEKK,GAIPH,EAAIG,EACZ,CACH,GAMA,SAASa,EAAkBlB,EAASC,EAAIC,GACtC,OAAOiB,eAAanB,EAYpB,SAAeK,GAKb,OAAgB,OAATA,EAAgBH,EAAIG,GAAQJ,EAAGI,EACvC,EAlBmC,aAmBtC,yBA1IO,WACL,MAAO,CACLe,KAAM,CACJ,GAAMvB,GAGZ"}

package/dist/cjs/node_modules/micromark-factory-space/index.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../micromark-util-character/index.js");exports.factorySpace=function(r,t,n,c){const u=c?c-1:Number.POSITIVE_INFINITY;let o=0;return function(c){if(e.markdownSpace(c))return r.enter(n),a(c);return t(c)};function a(c){return e.markdownSpace(c)&&o++<u?(r.consume(c),a):(r.exit(n),t(c))}};
-//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/micromark-factory-space/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/micromark-factory-space/index.js"],"sourcesContent":["/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}"],"names":["effects","ok","type","max","limit","Number","POSITIVE_INFINITY","size","code","markdownSpace","enter","prefix","consume","exit"],"mappings":"+IAwCO,SAAsBA,EAASC,EAAIC,EAAMC,GAC9C,MAAMC,EAAQD,EAAMA,EAAM,EAAIE,OAAOC,kBACrC,IAAIC,EAAO,EACX,OAGA,SAAeC,GACb,GAAIC,EAAAA,cAAcD,GAEhB,OADAR,EAAQU,MAAMR,GACPS,EAAOH,GAEhB,OAAOP,EAAGO,EACX,EAGD,SAASG,EAAOH,GACd,OAAIC,EAAaA,cAACD,IAASD,IAASH,GAClCJ,EAAQY,QAAQJ,GACTG,IAETX,EAAQa,KAAKX,GACND,EAAGO,GACX,CACH"}

package/dist/cjs/node_modules/micromark-util-character/index.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const n=o(/[A-Za-z]/),e=o(/[\dA-Za-z]/);const t=o(/\p{P}|\p{S}/u),r=o(/\s/);function o(n){return function(e){return null!==e&&e>-1&&n.test(String.fromCharCode(e))}}exports.asciiAlpha=n,exports.asciiAlphanumeric=e,exports.asciiControl=function(n){return null!==n&&(n<32||127===n)},exports.markdownLineEnding=function(n){return null!==n&&n<-2},exports.markdownLineEndingOrSpace=function(n){return null!==n&&(n<0||32===n)},exports.markdownSpace=function(n){return-2===n||-1===n||32===n},exports.unicodePunctuation=t,exports.unicodeWhitespace=r;
-//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/micromark-util-character/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/micromark-util-character/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}"],"names":["asciiAlpha","regexCheck","asciiAlphanumeric","unicodePunctuation","unicodeWhitespace","regex","code","test","String","fromCharCode"],"mappings":"oEAqBY,MAACA,EAAaC,EAAW,YAcxBC,EAAoBD,EAAW,cAoKhC,MAACE,EAAqBF,EAAW,gBAsBhCG,EAAoBH,EAAW,MAU5C,SAASA,EAAWI,GAClB,OAUA,SAAeC,GACb,OAAgB,OAATA,GAAiBA,GAAQ,GAAKD,EAAME,KAAKC,OAAOC,aAAaH,GACrE,CACH,uEA9KO,SAAsBA,GAC3B,OAGW,OAATA,IAAkBA,EAAO,IAAe,MAATA,EAEnC,6BAiEO,SAA4BA,GACjC,OAAgB,OAATA,GAAiBA,GAAQ,CAClC,oCAWO,SAAmCA,GACxC,OAAgB,OAATA,IAAkBA,EAAO,GAAc,KAATA,EACvC,wBAiBO,SAAuBA,GAC5B,OAAiB,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,CACvC"}

package/dist/cjs/node_modules/micromark-util-chunked/index.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.splice=function(e,s,t,l){const i=e.length;let c,n=0;if(s=s<0?-s>i?0:i+s:s>i?i:s,t=t>0?t:0,l.length<1e4)c=Array.from(l),c.unshift(s,t),e.splice(...c);else for(t&&e.splice(s,t);n<l.length;)c=l.slice(n,n+1e4),c.unshift(s,0),e.splice(...c),n+=1e4,s+=1e4};
-//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/micromark-util-chunked/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/micromark-util-chunked/index.js"],"sourcesContent":["/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length;\n  let chunkStart = 0;\n  /** @type {Array<unknown>} */\n  let parameters;\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n  remove = remove > 0 ? remove : 0;\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove);\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}"],"names":["list","start","remove","items","end","length","parameters","chunkStart","Array","from","unshift","splice","slice"],"mappings":"mFAsBO,SAAgBA,EAAMC,EAAOC,EAAQC,GAC1C,MAAMC,EAAMJ,EAAKK,OACjB,IAEIC,EAFAC,EAAa,EAajB,GAPEN,EADEA,EAAQ,GACDA,EAAQG,EAAM,EAAIA,EAAMH,EAEzBA,EAAQG,EAAMA,EAAMH,EAE9BC,EAASA,EAAS,EAAIA,EAAS,EAG3BC,EAAME,OAAS,IACjBC,EAAaE,MAAMC,KAAKN,GACxBG,EAAWI,QAAQT,EAAOC,GAE1BF,EAAKW,UAAUL,QAMf,IAHIJ,GAAQF,EAAKW,OAAOV,EAAOC,GAGxBK,EAAaJ,EAAME,QACxBC,EAAaH,EAAMS,MAAML,EAAYA,EAAa,KAClDD,EAAWI,QAAQT,EAAO,GAE1BD,EAAKW,UAAUL,GACfC,GAAc,IACdN,GAAS,GAGf"}

package/dist/cjs/node_modules/micromark-util-classify-character/index.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../micromark-util-character/index.js");exports.classifyCharacter=function(r){return null===r||e.markdownLineEndingOrSpace(r)||e.unicodeWhitespace(r)?1:e.unicodePunctuation(r)?2:void 0};
-//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/micromark-util-classify-character/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/micromark-util-classify-character/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}"],"names":["code","markdownLineEndingOrSpace","unicodeWhitespace","unicodePunctuation"],"mappings":"oJAmBO,SAA2BA,GAChC,OAAa,OAATA,GAAiBC,EAAyBA,0BAACD,IAASE,EAAAA,kBAAkBF,GACjE,EAELG,EAAAA,mBAAmBH,GACd,OADT,CAGF"}

package/dist/cjs/node_modules/micromark-util-combine-extensions/index.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../micromark-util-chunked/index.js");const t={}.hasOwnProperty;function n(e,n){let o;for(o in n){const i=(t.call(e,o)?e[o]:void 0)||(e[o]={}),s=n[o];let c;if(s)for(c in s){t.call(i,c)||(i[c]=[]);const e=s[c];r(i[c],Array.isArray(e)?e:e?[e]:[])}}}function r(t,n){let r=-1;const o=[];for(;++r<n.length;)("after"===n[r].add?t:o).push(n[r]);e.splice(t,0,0,o)}exports.combineExtensions=function(e){const t={};let r=-1;for(;++r<e.length;)n(t,e[r]);return t};
-//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/micromark-util-combine-extensions/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/micromark-util-combine-extensions/index.js"],"sourcesContent":["/**\n * @import {\n *   Extension,\n *   Handles,\n *   HtmlExtension,\n *   NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n *   List of constructs to merge into.\n * @param {Array<unknown>} list\n *   List of constructs to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {ReadonlyArray<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   Single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n"],"names":["hasOwnProperty","syntaxExtension","all","extension","hook","left","call","undefined","right","code","value","constructs","Array","isArray","existing","list","index","before","length","add","push","splice","extensions"],"mappings":"wHAWA,MAAMA,EAAiB,CAAE,EAACA,eAgC1B,SAASC,EAAgBC,EAAKC,GAE5B,IAAIC,EAEJ,IAAKA,KAAQD,EAAW,CACtB,MAEME,GAFQL,EAAeM,KAAKJ,EAAKE,GAAQF,EAAIE,QAAQG,KAEpCL,EAAIE,GAAQ,CAAA,GAE7BI,EAAQL,EAAUC,GAExB,IAAIK,EAEJ,GAAID,EACF,IAAKC,KAAQD,EAAO,CACbR,EAAeM,KAAKD,EAAMI,KAAOJ,EAAKI,GAAQ,IACnD,MAAMC,EAAQF,EAAMC,GACpBE,EAEEN,EAAKI,GACLG,MAAMC,QAAQH,GAASA,EAAQA,EAAQ,CAACA,GAAS,GAEpD,CAEJ,CACH,CAaA,SAASC,EAAWG,EAAUC,GAC5B,IAAIC,GAAS,EAEb,MAAMC,EAAS,GAEf,OAASD,EAAQD,EAAKG,SAEE,UAApBH,EAAKC,GAAOG,IAAkBL,EAAWG,GAAQG,KAAKL,EAAKC,IAG/DK,EAAAA,OAAOP,EAAU,EAAG,EAAGG,EACzB,2BAvEO,SAA2BK,GAEhC,MAAMpB,EAAM,CAAE,EACd,IAAIc,GAAS,EAEb,OAASA,EAAQM,EAAWJ,QAC1BjB,EAAgBC,EAAKoB,EAAWN,IAGlC,OAAOd,CACT"}

package/dist/cjs/node_modules/micromark-util-normalize-identifier/index.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.normalizeIdentifier=function(e){return e.replace(/[\t\n\r ]+/g," ").replace(/^ | $/g,"").toLowerCase().toUpperCase()};
-//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/micromark-util-normalize-identifier/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/micromark-util-normalize-identifier/index.js"],"sourcesContent":["/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return value\n  // Collapse markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, \" \")\n  // Trim.\n  .replace(/^ | $/g, '')\n  // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no method is uppercase.\n  .toLowerCase().toUpperCase();\n}"],"names":["value","replace","toLowerCase","toUpperCase"],"mappings":"gGAmBO,SAA6BA,GAClC,OAAOA,EAENC,QAAQ,cAAe,KAEvBA,QAAQ,SAAU,IAOlBC,cAAcC,aACjB"}

package/dist/cjs/node_modules/micromark-util-resolve-all/index.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.resolveAll=function(e,t,l){const s=[];let o=-1;for(;++o<e.length;){const r=e[o].resolveAll;r&&!s.includes(r)&&(t=r(t,l),s.push(r))}return t};
-//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/micromark-util-resolve-all/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/micromark-util-resolve-all/index.js"],"sourcesContent":["/**\n * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n"],"names":["constructs","events","context","called","index","length","resolve","resolveAll","includes","push"],"mappings":"uFAgBO,SAAoBA,EAAYC,EAAQC,GAE7C,MAAMC,EAAS,GACf,IAAIC,GAAS,EAEb,OAASA,EAAQJ,EAAWK,QAAQ,CAClC,MAAMC,EAAUN,EAAWI,GAAOG,WAE9BD,IAAYH,EAAOK,SAASF,KAC9BL,EAASK,EAAQL,EAAQC,GACzBC,EAAOM,KAAKH,GAEf,CAED,OAAOL,CACT"}

package/dist/cjs/node_modules/object-assign/index.js

@@ -1,8 +0,0 @@
-"use strict";
-/*
-object-assign
-(c) Sindre Sorhus
-@license MIT
-*/
-var r,e;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){if(e)return r;e=1;var t=Object.getOwnPropertySymbols,n=Object.prototype.hasOwnProperty,o=Object.prototype.propertyIsEnumerable;return r=function(){try{if(!Object.assign)return!1;var r=new String("abc");if(r[5]="de","5"===Object.getOwnPropertyNames(r)[0])return!1;for(var e={},t=0;t<10;t++)e["_"+String.fromCharCode(t)]=t;if("0123456789"!==Object.getOwnPropertyNames(e).map(function(r){return e[r]}).join(""))return!1;var n={};return"abcdefghijklmnopqrst".split("").forEach(function(r){n[r]=r}),"abcdefghijklmnopqrst"===Object.keys(Object.assign({},n)).join("")}catch(r){return!1}}()?Object.assign:function(r,e){for(var c,i,a=function(r){if(null==r)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(r)}(r),u=1;u<arguments.length;u++){for(var f in c=Object(arguments[u]))n.call(c,f)&&(a[f]=c[f]);if(t){i=t(c);for(var s=0;s<i.length;s++)o.call(c,i[s])&&(a[i[s]]=c[i[s]])}}return a}};
-//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/object-assign/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/object-assign/index.js"],"sourcesContent":["/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n"],"names":["getOwnPropertySymbols","Object","hasOwnProperty","prototype","propIsEnumerable","propertyIsEnumerable","objectAssign","assign","test1","String","getOwnPropertyNames","test2","i","fromCharCode","map","n","join","test3","split","forEach","letter","keys","err","shouldUseNative","target","source","from","symbols","to","val","TypeError","toObject","s","arguments","length","key","call"],"mappings":";;;;;;8GAQA,IAAIA,EAAwBC,OAAOD,sBAC/BE,EAAiBD,OAAOE,UAAUD,eAClCE,EAAmBH,OAAOE,UAAUE,4BAsDxCC,EA5CA,WACC,IACC,IAAKL,OAAOM,OACX,OAAO,EAMR,IAAIC,EAAQ,IAAIC,OAAO,OAEvB,GADAD,EAAM,GAAK,KACkC,MAAzCP,OAAOS,oBAAoBF,GAAO,GACrC,OAAO,EAKR,IADA,IAAIG,EAAQ,CAAA,EACHC,EAAI,EAAGA,EAAI,GAAIA,IACvBD,EAAM,IAAMF,OAAOI,aAAaD,IAAMA,EAKvC,GAAwB,eAHXX,OAAOS,oBAAoBC,GAAOG,IAAI,SAAUC,GAC5D,OAAOJ,EAAMI,EAChB,GACaC,KAAK,IACf,OAAO,EAIR,IAAIC,EAAQ,CAAA,EAIZ,MAHA,uBAAuBC,MAAM,IAAIC,QAAQ,SAAUC,GAClDH,EAAMG,GAAUA,CACnB,GAEI,yBADEnB,OAAOoB,KAAKpB,OAAOM,OAAO,CAAE,EAAEU,IAAQD,KAAK,GAM/C,CAAC,MAAOM,GAER,OAAO,CACT,CACA,CAEiBC,GAAoBtB,OAAOM,OAAS,SAAUiB,EAAQC,GAKtE,IAJA,IAAIC,EAEAC,EADAC,EAtDL,SAAkBC,GACjB,GAAIA,QACH,MAAM,IAAIC,UAAU,yDAGrB,OAAO7B,OAAO4B,EACf,CAgDUE,CAASP,GAGTQ,EAAI,EAAGA,EAAIC,UAAUC,OAAQF,IAAK,CAG1C,IAAK,IAAIG,KAFTT,EAAOzB,OAAOgC,UAAUD,IAGnB9B,EAAekC,KAAKV,EAAMS,KAC7BP,EAAGO,GAAOT,EAAKS,IAIjB,GAAInC,EAAuB,CAC1B2B,EAAU3B,EAAsB0B,GAChC,IAAK,IAAId,EAAI,EAAGA,EAAIe,EAAQO,OAAQtB,IAC/BR,EAAiBgC,KAAKV,EAAMC,EAAQf,MACvCgB,EAAGD,EAAQf,IAAMc,EAAKC,EAAQf,IAGnC,CACA,CAEC,OAAOgB"}

package/dist/cjs/node_modules/prop-types/checkPropTypes.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,r,n=require("./lib/ReactPropTypesSecret.js"),t=require("./lib/has.js");exports.__require=function(){if(r)return e;r=1;var o=function(){};if("production"!==process.env.NODE_ENV){var a=n.__require(),i={},s=t.__require();o=function(e){var r="Warning: "+e;"undefined"!=typeof console&&console.error(r);try{throw new Error(r)}catch(e){}}}function c(e,r,n,t,c){if("production"!==process.env.NODE_ENV)for(var u in e)if(s(e,u)){var f;try{if("function"!=typeof e[u]){var p=Error((t||"React class")+": "+n+" type `"+u+"` is invalid; it must be a function, usually from the `prop-types` package, but received `"+typeof e[u]+"`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");throw p.name="Invariant Violation",p}f=e[u](r,u,t,n,null,a)}catch(e){f=e}if(!f||f instanceof Error||o((t||"React class")+": type specification of "+n+" `"+u+"` is invalid; the type checker function must return `null` or an `Error` but returned a "+typeof f+". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."),f instanceof Error&&!(f.message in i)){i[f.message]=!0;var l=c?c():"";o("Failed "+n+" type: "+f.message+(null!=l?l:""))}}}return c.resetWarningCache=function(){"production"!==process.env.NODE_ENV&&(i={})},e=c};
-//# sourceMappingURL=checkPropTypes.js.map

package/dist/cjs/node_modules/prop-types/checkPropTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"checkPropTypes.js","sources":["../../../../node_modules/prop-types/checkPropTypes.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n  var loggedTypeFailures = {};\n  var has = require('./lib/has');\n\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) { /**/ }\n  };\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n  if (process.env.NODE_ENV !== 'production') {\n    for (var typeSpecName in typeSpecs) {\n      if (has(typeSpecs, typeSpecName)) {\n        var error;\n        // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          if (typeof typeSpecs[typeSpecName] !== 'function') {\n            var err = Error(\n              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +\n              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +\n              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'\n            );\n            err.name = 'Invariant Violation';\n            throw err;\n          }\n          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n        } catch (ex) {\n          error = ex;\n        }\n        if (error && !(error instanceof Error)) {\n          printWarning(\n            (componentName || 'React class') + ': type specification of ' +\n            location + ' `' + typeSpecName + '` is invalid; the type checker ' +\n            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +\n            'You may have forgotten to pass an argument to the type checker ' +\n            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +\n            'shape all require an argument).'\n          );\n        }\n        if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error.message] = true;\n\n          var stack = getStack ? getStack() : '';\n\n          printWarning(\n            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')\n          );\n        }\n      }\n    }\n  }\n}\n\n/**\n * Resets warning cache when testing.\n *\n * @private\n */\ncheckPropTypes.resetWarningCache = function() {\n  if (process.env.NODE_ENV !== 'production') {\n    loggedTypeFailures = {};\n  }\n}\n\nmodule.exports = checkPropTypes;\n"],"names":["printWarning","process","env","NODE_ENV","ReactPropTypesSecret","require$$0","loggedTypeFailures","has","require$$1","text","message","console","error","Error","x","checkPropTypes","typeSpecs","values","location","componentName","getStack","typeSpecName","err","name","ex","stack","resetWarningCache","checkPropTypes_1"],"mappings":"gMASA,IAAIA,EAAe,aAEnB,GAA6B,eAAzBC,QAAQC,IAAIC,SAA2B,CACzC,IAAIC,EAA4DC,EAAAA,YAC5DC,EAAqB,CAAA,EACrBC,EAA0BC,EAAAA,YAE9BR,EAAe,SAASS,GACtB,IAAIC,EAAU,YAAcD,EACL,oBAAZE,SACTA,QAAQC,MAAMF,GAEhB,IAIE,MAAM,IAAIG,MAAMH,GAChB,MAAOI,GAAG,EAEhB,CAaA,SAASC,EAAeC,EAAWC,EAAQC,EAAUC,EAAeC,GAClE,GAA6B,eAAzBnB,QAAQC,IAAIC,SACd,IAAK,IAAIkB,KAAgBL,EACvB,GAAIT,EAAIS,EAAWK,GAAe,CAChC,IAAIT,EAIJ,IAGE,GAAuC,mBAA5BI,EAAUK,GAA8B,CACjD,IAAIC,EAAMT,OACPM,GAAiB,eAAiB,KAAOD,EAAW,UAAYG,EAAjE,oGACwFL,EAAUK,GADlG,mGAKF,MADAC,EAAIC,KAAO,sBACLD,CAClB,CACUV,EAAQI,EAAUK,GAAcJ,EAAQI,EAAcF,EAAeD,EAAU,KAAMd,EACtF,CAAC,MAAOoB,GACPZ,EAAQY,CAClB,CAWQ,IAVIZ,GAAWA,aAAiBC,OAC9Bb,GACGmB,GAAiB,eAAiB,2BACnCD,EAAW,KAAOG,EADlB,kGAEqET,EAFrE,kKAQAA,aAAiBC,SAAWD,EAAMF,WAAWJ,GAAqB,CAGpEA,EAAmBM,EAAMF,UAAW,EAEpC,IAAIe,EAAQL,EAAWA,IAAa,GAEpCpB,EACE,UAAYkB,EAAW,UAAYN,EAAMF,SAAoB,MAATe,EAAgBA,EAAQ,IAExF,CACA,CAGA,QAOAV,EAAeW,kBAAoB,WACJ,eAAzBzB,QAAQC,IAAIC,WACdG,EAAqB,CAAA,EAEzB,EAEAqB,EAAiBZ"}

package/dist/cjs/node_modules/prop-types/factoryWithThrowingShims.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,r,t=require("./lib/ReactPropTypesSecret.js");exports.__require=function(){if(r)return e;r=1;var n=t.__require();function o(){}function a(){}return a.resetWarningCache=o,e=function(){function e(e,r,t,o,a,i){if(i!==n){var p=new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");throw p.name="Invariant Violation",p}}function r(){return e}e.isRequired=e;var t={array:e,bigint:e,bool:e,func:e,number:e,object:e,string:e,symbol:e,any:e,arrayOf:r,element:e,elementType:e,instanceOf:r,node:e,objectOf:r,oneOf:r,oneOfType:r,shape:r,exact:r,checkPropTypes:a,resetWarningCache:o};return t.PropTypes=t,t}};
-//# sourceMappingURL=factoryWithThrowingShims.js.map

package/dist/cjs/node_modules/prop-types/factoryWithThrowingShims.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"factoryWithThrowingShims.js","sources":["../../../../node_modules/prop-types/factoryWithThrowingShims.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n"],"names":["ReactPropTypesSecret","require$$0","emptyFunction","emptyFunctionWithReset","resetWarningCache","factoryWithThrowingShims","shim","props","propName","componentName","location","propFullName","secret","err","Error","name","getShim","isRequired","ReactPropTypes","array","bigint","bool","func","number","object","string","symbol","any","arrayOf","element","elementType","instanceOf","node","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes"],"mappings":"sKASA,IAAIA,EAA4DC,EAAAA,YAEhE,SAASC,IAAgB,CACzB,SAASC,IAAyB,QAClCA,EAAuBC,kBAAoBF,EAE3CG,EAAiB,WACf,SAASC,EAAKC,EAAOC,EAAUC,EAAeC,EAAUC,EAAcC,GACpE,GAAIA,IAAWZ,EAAf,CAIA,IAAIa,EAAM,IAAIC,MACZ,mLAKF,MADAD,EAAIE,KAAO,sBACLF,CAPV,EAUE,SAASG,IACP,OAAOV,CAEX,CAJEA,EAAKW,WAAaX,EAMlB,IAAIY,EAAiB,CACnBC,MAAOb,EACPc,OAAQd,EACRe,KAAMf,EACNgB,KAAMhB,EACNiB,OAAQjB,EACRkB,OAAQlB,EACRmB,OAAQnB,EACRoB,OAAQpB,EAERqB,IAAKrB,EACLsB,QAASZ,EACTa,QAASvB,EACTwB,YAAaxB,EACbyB,WAAYf,EACZgB,KAAM1B,EACN2B,SAAUjB,EACVkB,MAAOlB,EACPmB,UAAWnB,EACXoB,MAAOpB,EACPqB,MAAOrB,EAEPsB,eAAgBnC,EAChBC,kBAAmBF,GAKrB,OAFAgB,EAAeqB,UAAYrB,EAEpBA"}

package/dist/cjs/node_modules/prop-types/factoryWithTypeCheckers.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,n,r=require("./node_modules/react-is/index.js"),t=require("../object-assign/index.js"),o=require("./lib/ReactPropTypesSecret.js"),i=require("./lib/has.js"),a=require("./checkPropTypes.js");exports.__require=function(){if(n)return e;n=1;var u=r.__require(),c=t.__require(),f=o.__require(),p=i.__require(),s=a.__require(),l=function(){};function d(){return null}return"production"!==process.env.NODE_ENV&&(l=function(e){var n="Warning: "+e;"undefined"!=typeof console&&console.error(n);try{throw new Error(n)}catch(e){}}),e=function(e,n){var r="function"==typeof Symbol&&Symbol.iterator;var t="<<anonymous>>",o={array:v("array"),bigint:v("bigint"),bool:v("boolean"),func:v("function"),number:v("number"),object:v("object"),string:v("string"),symbol:v("symbol"),any:y(d),arrayOf:function(e){return y(function(n,r,t,o,i){if("function"!=typeof e)return new a("Property `"+i+"` of component `"+t+"` has invalid PropType notation inside arrayOf.");var u=n[r];if(!Array.isArray(u))return new a("Invalid "+o+" `"+i+"` of type `"+g(u)+"` supplied to `"+t+"`, expected an array.");for(var c=0;c<u.length;c++){var p=e(u,c,t,o,i+"["+c+"]",f);if(p instanceof Error)return p}return null})},element:y(function(n,r,t,o,i){var u=n[r];return e(u)?null:new a("Invalid "+o+" `"+i+"` of type `"+g(u)+"` supplied to `"+t+"`, expected a single ReactElement.")}),elementType:y(function(e,n,r,t,o){var i=e[n];return u.isValidElementType(i)?null:new a("Invalid "+t+" `"+o+"` of type `"+g(i)+"` supplied to `"+r+"`, expected a single ReactElement type.")}),instanceOf:function(e){return y(function(n,r,o,i,u){if(!(n[r]instanceof e)){var c=e.name||t;return new a("Invalid "+i+" `"+u+"` of type `"+(((f=n[r]).constructor&&f.constructor.name?f.constructor.name:t)+"` supplied to `")+o+"`, expected instance of `"+c+"`.")}var f;return null})},node:y(function(e,n,r,t,o){return m(e[n])?null:new a("Invalid "+t+" `"+o+"` supplied to `"+r+"`, expected a ReactNode.")}),objectOf:function(e){return y(function(n,r,t,o,i){if("function"!=typeof e)return new a("Property `"+i+"` of component `"+t+"` has invalid PropType notation inside objectOf.");var u=n[r],c=g(u);if("object"!==c)return new a("Invalid "+o+" `"+i+"` of type `"+c+"` supplied to `"+t+"`, expected an object.");for(var s in u)if(p(u,s)){var l=e(u,s,t,o,i+"."+s,f);if(l instanceof Error)return l}return null})},oneOf:function(e){if(!Array.isArray(e))return"production"!==process.env.NODE_ENV&&l(arguments.length>1?"Invalid arguments supplied to oneOf, expected an array, got "+arguments.length+" arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).":"Invalid argument supplied to oneOf, expected an array."),d;return y(function(n,r,t,o,u){for(var c=n[r],f=0;f<e.length;f++)if(i(c,e[f]))return null;var p=JSON.stringify(e,function(e,n){return"symbol"===h(n)?String(n):n});return new a("Invalid "+o+" `"+u+"` of value `"+String(c)+"` supplied to `"+t+"`, expected one of "+p+".")})},oneOfType:function(e){if(!Array.isArray(e))return"production"!==process.env.NODE_ENV&&l("Invalid argument supplied to oneOfType, expected an instance of array."),d;for(var n=0;n<e.length;n++){var r=e[n];if("function"!=typeof r)return l("Invalid argument supplied to oneOfType. Expected an array of check functions, but received "+x(r)+" at index "+n+"."),d}return y(function(n,r,t,o,i){for(var u=[],c=0;c<e.length;c++){var s=(0,e[c])(n,r,t,o,i,f);if(null==s)return null;s.data&&p(s.data,"expectedType")&&u.push(s.data.expectedType)}return new a("Invalid "+o+" `"+i+"` supplied to `"+t+"`"+(u.length>0?", expected one of type ["+u.join(", ")+"]":"")+".")})},shape:function(e){return y(function(n,r,t,o,i){var u=n[r],c=g(u);if("object"!==c)return new a("Invalid "+o+" `"+i+"` of type `"+c+"` supplied to `"+t+"`, expected `object`.");for(var p in e){var s=e[p];if("function"!=typeof s)return b(t,o,i,p,h(s));var l=s(u,p,t,o,i+"."+p,f);if(l)return l}return null})},exact:function(e){return y(function(n,r,t,o,i){var u=n[r],s=g(u);if("object"!==s)return new a("Invalid "+o+" `"+i+"` of type `"+s+"` supplied to `"+t+"`, expected `object`.");var l=c({},n[r],e);for(var d in l){var y=e[d];if(p(e,d)&&"function"!=typeof y)return b(t,o,i,d,h(y));if(!y)return new a("Invalid "+o+" `"+i+"` key `"+d+"` supplied to `"+t+"`.\nBad object: "+JSON.stringify(n[r],null,"  ")+"\nValid keys: "+JSON.stringify(Object.keys(e),null,"  "));var v=y(u,d,t,o,i+"."+d,f);if(v)return v}return null})}};function i(e,n){return e===n?0!==e||1/e==1/n:e!=e&&n!=n}function a(e,n){this.message=e,this.data=n&&"object"==typeof n?n:{},this.stack=""}function y(e){if("production"!==process.env.NODE_ENV)var r={},o=0;function i(i,u,c,p,s,d,y){if(p=p||t,d=d||c,y!==f){if(n){var v=new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types");throw v.name="Invariant Violation",v}if("production"!==process.env.NODE_ENV&&"undefined"!=typeof console){var b=p+":"+c;!r[b]&&o<3&&(l("You are manually calling a React.PropTypes validation function for the `"+d+"` prop on `"+p+"`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."),r[b]=!0,o++)}}return null==u[c]?i?null===u[c]?new a("The "+s+" `"+d+"` is marked as required in `"+p+"`, but its value is `null`."):new a("The "+s+" `"+d+"` is marked as required in `"+p+"`, but its value is `undefined`."):null:e(u,c,p,s,d)}var u=i.bind(null,!1);return u.isRequired=i.bind(null,!0),u}function v(e){return y(function(n,r,t,o,i,u){var c=n[r];return g(c)!==e?new a("Invalid "+o+" `"+i+"` of type `"+h(c)+"` supplied to `"+t+"`, expected `"+e+"`.",{expectedType:e}):null})}function b(e,n,r,t,o){return new a((e||"React class")+": "+n+" type `"+r+"."+t+"` is invalid; it must be a function, usually from the `prop-types` package, but received `"+o+"`.")}function m(n){switch(typeof n){case"number":case"string":case"undefined":return!0;case"boolean":return!n;case"object":if(Array.isArray(n))return n.every(m);if(null===n||e(n))return!0;var t=function(e){var n=e&&(r&&e[r]||e["@@iterator"]);if("function"==typeof n)return n}(n);if(!t)return!1;var o,i=t.call(n);if(t!==n.entries){for(;!(o=i.next()).done;)if(!m(o.value))return!1}else for(;!(o=i.next()).done;){var a=o.value;if(a&&!m(a[1]))return!1}return!0;default:return!1}}function g(e){var n=typeof e;return Array.isArray(e)?"array":e instanceof RegExp?"object":function(e,n){return"symbol"===e||!!n&&("Symbol"===n["@@toStringTag"]||"function"==typeof Symbol&&n instanceof Symbol)}(n,e)?"symbol":n}function h(e){if(null==e)return""+e;var n=g(e);if("object"===n){if(e instanceof Date)return"date";if(e instanceof RegExp)return"regexp"}return n}function x(e){var n=h(e);switch(n){case"array":case"object":return"an "+n;case"boolean":case"date":case"regexp":return"a "+n;default:return n}}return a.prototype=Error.prototype,o.checkPropTypes=s,o.resetWarningCache=s.resetWarningCache,o.PropTypes=o,o}};
-//# sourceMappingURL=factoryWithTypeCheckers.js.map

package/dist/cjs/node_modules/prop-types/factoryWithTypeCheckers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"factoryWithTypeCheckers.js","sources":["../../../../node_modules/prop-types/factoryWithTypeCheckers.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactIs = require('react-is');\nvar assign = require('object-assign');\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\nvar has = require('./lib/has');\nvar checkPropTypes = require('./checkPropTypes');\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  };\n}\n\nfunction emptyFunctionThatReturnsNull() {\n  return null;\n}\n\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\n  /* global Symbol */\n  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n  /**\n   * Returns the iterator method function contained on the iterable object.\n   *\n   * Be sure to invoke the function with the iterable as context:\n   *\n   *     var iteratorFn = getIteratorFn(myIterable);\n   *     if (iteratorFn) {\n   *       var iterator = iteratorFn.call(myIterable);\n   *       ...\n   *     }\n   *\n   * @param {?object} maybeIterable\n   * @return {?function}\n   */\n  function getIteratorFn(maybeIterable) {\n    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  /**\n   * Collection of methods that allow declaration and validation of props that are\n   * supplied to React components. Example usage:\n   *\n   *   var Props = require('ReactPropTypes');\n   *   var MyArticle = React.createClass({\n   *     propTypes: {\n   *       // An optional string prop named \"description\".\n   *       description: Props.string,\n   *\n   *       // A required enum prop named \"category\".\n   *       category: Props.oneOf(['News','Photos']).isRequired,\n   *\n   *       // A prop named \"dialog\" that requires an instance of Dialog.\n   *       dialog: Props.instanceOf(Dialog).isRequired\n   *     },\n   *     render: function() { ... }\n   *   });\n   *\n   * A more formal specification of how these methods are used:\n   *\n   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n   *   decl := ReactPropTypes.{type}(.isRequired)?\n   *\n   * Each and every declaration produces a function with the same signature. This\n   * allows the creation of custom validation functions. For example:\n   *\n   *  var MyLink = React.createClass({\n   *    propTypes: {\n   *      // An optional string or URI prop named \"href\".\n   *      href: function(props, propName, componentName) {\n   *        var propValue = props[propName];\n   *        if (propValue != null && typeof propValue !== 'string' &&\n   *            !(propValue instanceof URI)) {\n   *          return new Error(\n   *            'Expected a string or an URI for ' + propName + ' in ' +\n   *            componentName\n   *          );\n   *        }\n   *      }\n   *    },\n   *    render: function() {...}\n   *  });\n   *\n   * @internal\n   */\n\n  var ANONYMOUS = '<<anonymous>>';\n\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\n  var ReactPropTypes = {\n    array: createPrimitiveTypeChecker('array'),\n    bigint: createPrimitiveTypeChecker('bigint'),\n    bool: createPrimitiveTypeChecker('boolean'),\n    func: createPrimitiveTypeChecker('function'),\n    number: createPrimitiveTypeChecker('number'),\n    object: createPrimitiveTypeChecker('object'),\n    string: createPrimitiveTypeChecker('string'),\n    symbol: createPrimitiveTypeChecker('symbol'),\n\n    any: createAnyTypeChecker(),\n    arrayOf: createArrayOfTypeChecker,\n    element: createElementTypeChecker(),\n    elementType: createElementTypeTypeChecker(),\n    instanceOf: createInstanceTypeChecker,\n    node: createNodeChecker(),\n    objectOf: createObjectOfTypeChecker,\n    oneOf: createEnumTypeChecker,\n    oneOfType: createUnionTypeChecker,\n    shape: createShapeTypeChecker,\n    exact: createStrictShapeTypeChecker,\n  };\n\n  /**\n   * inlined Object.is polyfill to avoid requiring consumers ship their own\n   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n   */\n  /*eslint-disable no-self-compare*/\n  function is(x, y) {\n    // SameValue algorithm\n    if (x === y) {\n      // Steps 1-5, 7-10\n      // Steps 6.b-6.e: +0 != -0\n      return x !== 0 || 1 / x === 1 / y;\n    } else {\n      // Step 6.a: NaN == NaN\n      return x !== x && y !== y;\n    }\n  }\n  /*eslint-enable no-self-compare*/\n\n  /**\n   * We use an Error-like object for backward compatibility as people may call\n   * PropTypes directly and inspect their output. However, we don't use real\n   * Errors anymore. We don't inspect their stack anyway, and creating them\n   * is prohibitively expensive if they are created too often, such as what\n   * happens in oneOfType() for any type before the one that matched.\n   */\n  function PropTypeError(message, data) {\n    this.message = message;\n    this.data = data && typeof data === 'object' ? data: {};\n    this.stack = '';\n  }\n  // Make `instanceof Error` still work for returned errors.\n  PropTypeError.prototype = Error.prototype;\n\n  function createChainableTypeChecker(validate) {\n    if (process.env.NODE_ENV !== 'production') {\n      var manualPropTypeCallCache = {};\n      var manualPropTypeWarningCount = 0;\n    }\n    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\n      componentName = componentName || ANONYMOUS;\n      propFullName = propFullName || propName;\n\n      if (secret !== ReactPropTypesSecret) {\n        if (throwOnDirectAccess) {\n          // New behavior only for users of `prop-types` package\n          var err = new Error(\n            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n            'Use `PropTypes.checkPropTypes()` to call them. ' +\n            'Read more at http://fb.me/use-check-prop-types'\n          );\n          err.name = 'Invariant Violation';\n          throw err;\n        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {\n          // Old behavior for people using React.PropTypes\n          var cacheKey = componentName + ':' + propName;\n          if (\n            !manualPropTypeCallCache[cacheKey] &&\n            // Avoid spamming the console because they are often not actionable except for lib authors\n            manualPropTypeWarningCount < 3\n          ) {\n            printWarning(\n              'You are manually calling a React.PropTypes validation ' +\n              'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +\n              'and will throw in the standalone `prop-types` package. ' +\n              'You may be seeing this warning due to a third-party PropTypes ' +\n              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'\n            );\n            manualPropTypeCallCache[cacheKey] = true;\n            manualPropTypeWarningCount++;\n          }\n        }\n      }\n      if (props[propName] == null) {\n        if (isRequired) {\n          if (props[propName] === null) {\n            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\n          }\n          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\n        }\n        return null;\n      } else {\n        return validate(props, propName, componentName, location, propFullName);\n      }\n    }\n\n    var chainedCheckType = checkType.bind(null, false);\n    chainedCheckType.isRequired = checkType.bind(null, true);\n\n    return chainedCheckType;\n  }\n\n  function createPrimitiveTypeChecker(expectedType) {\n    function validate(props, propName, componentName, location, propFullName, secret) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== expectedType) {\n        // `propValue` being instance of, say, date/regexp, pass the 'object'\n        // check, but we can offer a more precise error message here rather than\n        // 'of type `object`'.\n        var preciseType = getPreciseType(propValue);\n\n        return new PropTypeError(\n          'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),\n          {expectedType: expectedType}\n        );\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createAnyTypeChecker() {\n    return createChainableTypeChecker(emptyFunctionThatReturnsNull);\n  }\n\n  function createArrayOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\n      }\n      var propValue = props[propName];\n      if (!Array.isArray(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\n      }\n      for (var i = 0; i < propValue.length; i++) {\n        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\n        if (error instanceof Error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createElementTypeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      if (!isValidElement(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createElementTypeTypeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      if (!ReactIs.isValidElementType(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createInstanceTypeChecker(expectedClass) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!(props[propName] instanceof expectedClass)) {\n        var expectedClassName = expectedClass.name || ANONYMOUS;\n        var actualClassName = getClassName(props[propName]);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createEnumTypeChecker(expectedValues) {\n    if (!Array.isArray(expectedValues)) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (arguments.length > 1) {\n          printWarning(\n            'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +\n            'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'\n          );\n        } else {\n          printWarning('Invalid argument supplied to oneOf, expected an array.');\n        }\n      }\n      return emptyFunctionThatReturnsNull;\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      for (var i = 0; i < expectedValues.length; i++) {\n        if (is(propValue, expectedValues[i])) {\n          return null;\n        }\n      }\n\n      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {\n        var type = getPreciseType(value);\n        if (type === 'symbol') {\n          return String(value);\n        }\n        return value;\n      });\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createObjectOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\n      }\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\n      }\n      for (var key in propValue) {\n        if (has(propValue, key)) {\n          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n          if (error instanceof Error) {\n            return error;\n          }\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createUnionTypeChecker(arrayOfTypeCheckers) {\n    if (!Array.isArray(arrayOfTypeCheckers)) {\n      process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;\n      return emptyFunctionThatReturnsNull;\n    }\n\n    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n      var checker = arrayOfTypeCheckers[i];\n      if (typeof checker !== 'function') {\n        printWarning(\n          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +\n          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'\n        );\n        return emptyFunctionThatReturnsNull;\n      }\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      var expectedTypes = [];\n      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n        var checker = arrayOfTypeCheckers[i];\n        var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);\n        if (checkerResult == null) {\n          return null;\n        }\n        if (checkerResult.data && has(checkerResult.data, 'expectedType')) {\n          expectedTypes.push(checkerResult.data.expectedType);\n        }\n      }\n      var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createNodeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!isNode(props[propName])) {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function invalidValidatorError(componentName, location, propFullName, key, type) {\n    return new PropTypeError(\n      (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +\n      'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'\n    );\n  }\n\n  function createShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      for (var key in shapeTypes) {\n        var checker = shapeTypes[key];\n        if (typeof checker !== 'function') {\n          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createStrictShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      // We need to check all keys in case some are required but missing from props.\n      var allKeys = assign({}, props[propName], shapeTypes);\n      for (var key in allKeys) {\n        var checker = shapeTypes[key];\n        if (has(shapeTypes, key) && typeof checker !== 'function') {\n          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));\n        }\n        if (!checker) {\n          return new PropTypeError(\n            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +\n            '\\nBad object: ' + JSON.stringify(props[propName], null, '  ') +\n            '\\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  ')\n          );\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n\n    return createChainableTypeChecker(validate);\n  }\n\n  function isNode(propValue) {\n    switch (typeof propValue) {\n      case 'number':\n      case 'string':\n      case 'undefined':\n        return true;\n      case 'boolean':\n        return !propValue;\n      case 'object':\n        if (Array.isArray(propValue)) {\n          return propValue.every(isNode);\n        }\n        if (propValue === null || isValidElement(propValue)) {\n          return true;\n        }\n\n        var iteratorFn = getIteratorFn(propValue);\n        if (iteratorFn) {\n          var iterator = iteratorFn.call(propValue);\n          var step;\n          if (iteratorFn !== propValue.entries) {\n            while (!(step = iterator.next()).done) {\n              if (!isNode(step.value)) {\n                return false;\n              }\n            }\n          } else {\n            // Iterator will provide entry [k,v] tuples rather than values.\n            while (!(step = iterator.next()).done) {\n              var entry = step.value;\n              if (entry) {\n                if (!isNode(entry[1])) {\n                  return false;\n                }\n              }\n            }\n          }\n        } else {\n          return false;\n        }\n\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  function isSymbol(propType, propValue) {\n    // Native Symbol.\n    if (propType === 'symbol') {\n      return true;\n    }\n\n    // falsy value can't be a Symbol\n    if (!propValue) {\n      return false;\n    }\n\n    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n    if (propValue['@@toStringTag'] === 'Symbol') {\n      return true;\n    }\n\n    // Fallback for non-spec compliant Symbols which are polyfilled.\n    if (typeof Symbol === 'function' && propValue instanceof Symbol) {\n      return true;\n    }\n\n    return false;\n  }\n\n  // Equivalent of `typeof` but with special handling for array and regexp.\n  function getPropType(propValue) {\n    var propType = typeof propValue;\n    if (Array.isArray(propValue)) {\n      return 'array';\n    }\n    if (propValue instanceof RegExp) {\n      // Old webkits (at least until Android 4.0) return 'function' rather than\n      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n      // passes PropTypes.object.\n      return 'object';\n    }\n    if (isSymbol(propType, propValue)) {\n      return 'symbol';\n    }\n    return propType;\n  }\n\n  // This handles more types than `getPropType`. Only used for error messages.\n  // See `createPrimitiveTypeChecker`.\n  function getPreciseType(propValue) {\n    if (typeof propValue === 'undefined' || propValue === null) {\n      return '' + propValue;\n    }\n    var propType = getPropType(propValue);\n    if (propType === 'object') {\n      if (propValue instanceof Date) {\n        return 'date';\n      } else if (propValue instanceof RegExp) {\n        return 'regexp';\n      }\n    }\n    return propType;\n  }\n\n  // Returns a string that is postfixed to a warning about an invalid type.\n  // For example, \"undefined\" or \"of type array\"\n  function getPostfixForTypeWarning(value) {\n    var type = getPreciseType(value);\n    switch (type) {\n      case 'array':\n      case 'object':\n        return 'an ' + type;\n      case 'boolean':\n      case 'date':\n      case 'regexp':\n        return 'a ' + type;\n      default:\n        return type;\n    }\n  }\n\n  // Returns class name of the object, if any.\n  function getClassName(propValue) {\n    if (!propValue.constructor || !propValue.constructor.name) {\n      return ANONYMOUS;\n    }\n    return propValue.constructor.name;\n  }\n\n  ReactPropTypes.checkPropTypes = checkPropTypes;\n  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n"],"names":["ReactIs","require$$0","assign","require$$1","ReactPropTypesSecret","require$$2","has","require$$3","checkPropTypes","require$$4","printWarning","emptyFunctionThatReturnsNull","process","env","NODE_ENV","text","message","console","error","Error","x","factoryWithTypeCheckers","isValidElement","throwOnDirectAccess","ITERATOR_SYMBOL","Symbol","iterator","ANONYMOUS","ReactPropTypes","array","createPrimitiveTypeChecker","bigint","bool","func","number","object","string","symbol","any","createChainableTypeChecker","arrayOf","typeChecker","props","propName","componentName","location","propFullName","PropTypeError","propValue","Array","isArray","getPropType","i","length","element","elementType","isValidElementType","instanceOf","expectedClass","expectedClassName","name","constructor","node","isNode","objectOf","propType","key","oneOf","expectedValues","arguments","is","valuesString","JSON","stringify","value","getPreciseType","String","oneOfType","arrayOfTypeCheckers","checker","getPostfixForTypeWarning","expectedTypes","checkerResult","data","push","expectedType","join","shape","shapeTypes","invalidValidatorError","exact","allKeys","Object","keys","y","this","stack","validate","manualPropTypeCallCache","manualPropTypeWarningCount","checkType","isRequired","secret","err","cacheKey","chainedCheckType","bind","type","every","iteratorFn","maybeIterable","getIteratorFn","step","call","entries","next","done","entry","RegExp","isSymbol","Date","prototype","resetWarningCache","PropTypes"],"mappings":"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"}

package/dist/cjs/node_modules/prop-types/index.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,r=require("../../_virtual/index5.js"),i=require("./node_modules/react-is/index.js"),t=require("./factoryWithTypeCheckers.js"),u=require("./factoryWithThrowingShims.js");exports.__require=function(){if(e)return r.__module.exports;if(e=1,"production"!==process.env.NODE_ENV){var o=i.__require();r.__module.exports=t.__require()(o.isElement,true)}else r.__module.exports=u.__require()();return r.__module.exports};
-//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/prop-types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../node_modules/prop-types/index.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n"],"names":["process","env","NODE_ENV","ReactIs","require$$0","propTypesModule","__module","exports","require$$1","__require","isElement","require$$2"],"mappings":"+SAOA,OAA6B,eAAzBA,QAAQC,IAAIC,SAA2B,CACzC,IAAIC,EAAUC,EAAAA,YAKdC,EAAAC,SAAAC,QAAqDC,EAAAC,WAAAD,CAACL,EAAQO,UADpC,KAE5B,MAGEL,WAAAE,QAAiBI,EAAAF,WAAAE"}

package/dist/cjs/node_modules/prop-types/lib/ReactPropTypesSecret.js

@@ -1,2 +0,0 @@
-"use strict";var e,_;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){return _?e:(_=1,e="SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED")};
-//# sourceMappingURL=ReactPropTypesSecret.js.map

package/dist/cjs/node_modules/prop-types/lib/ReactPropTypesSecret.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReactPropTypesSecret.js","sources":["../../../../../node_modules/prop-types/lib/ReactPropTypesSecret.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n"],"names":["ReactPropTypesSecret_1"],"mappings":"yHAWAA,EAF2B"}

package/dist/cjs/node_modules/prop-types/lib/has.js

@@ -1,2 +0,0 @@
-"use strict";var e,r;Object.defineProperty(exports,"__esModule",{value:!0}),exports.__require=function(){return r?e:(r=1,e=Function.call.bind(Object.prototype.hasOwnProperty))};
-//# sourceMappingURL=has.js.map

package/dist/cjs/node_modules/prop-types/lib/has.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"has.js","sources":["../../../../../node_modules/prop-types/lib/has.js"],"sourcesContent":["module.exports = Function.call.bind(Object.prototype.hasOwnProperty);\n"],"names":["has","Function","call","bind","Object","prototype","hasOwnProperty"],"mappings":"yHAAAA,EAAiBC,SAASC,KAAKC,KAAKC,OAAOC,UAAUC"}