.config/coc/extensions/node_modules/coc-markdownlint/lib/index.js

   1 var __create = Object.create;
   2 var __defProp = Object.defineProperty;
   3 var __getProtoOf = Object.getPrototypeOf;
   4 var __hasOwnProp = Object.prototype.hasOwnProperty;
   5 var __getOwnPropNames = Object.getOwnPropertyNames;
   6 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   7 var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
   8 var __commonJS = (callback, module2) => () => {
   9   if (!module2) {
  10     module2 = {exports: {}};
  11     callback(module2.exports, module2);
  12   }
  13   return module2.exports;
  14 };
  15 var __export = (target, all) => {
  16   for (var name in all)
  17     __defProp(target, name, {get: all[name], enumerable: true});
  18 };
  19 var __exportStar = (target, module2, desc) => {
  20   if (module2 && typeof module2 === "object" || typeof module2 === "function") {
  21     for (let key of __getOwnPropNames(module2))
  22       if (!__hasOwnProp.call(target, key) && key !== "default")
  23         __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
  24   }
  25   return target;
  26 };
  27 var __toModule = (module2) => {
  28   if (module2 && module2.__esModule)
  29     return module2;
  30   return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", {value: module2, enumerable: true})), module2);
  31 };
  32
  33 // node_modules/deep-extend/lib/deep-extend.js
  34 var require_deep_extend = __commonJS((exports2, module2) => {
  35   /*!
  36    * @description Recursive object extending
  37    * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
  38    * @license MIT
  39    *
  40    * The MIT License (MIT)
  41    *
  42    * Copyright (c) 2013-2018 Viacheslav Lotsmanov
  43    *
  44    * Permission is hereby granted, free of charge, to any person obtaining a copy of
  45    * this software and associated documentation files (the "Software"), to deal in
  46    * the Software without restriction, including without limitation the rights to
  47    * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  48    * the Software, and to permit persons to whom the Software is furnished to do so,
  49    * subject to the following conditions:
  50    *
  51    * The above copyright notice and this permission notice shall be included in all
  52    * copies or substantial portions of the Software.
  53    *
  54    * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  55    * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  56    * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  57    * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  58    * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  59    * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  60    */
  61   "use strict";
  62   function isSpecificValue(val) {
  63     return val instanceof Buffer || val instanceof Date || val instanceof RegExp ? true : false;
  64   }
  65   function cloneSpecificValue(val) {
  66     if (val instanceof Buffer) {
  67       var x = Buffer.alloc ? Buffer.alloc(val.length) : new Buffer(val.length);
  68       val.copy(x);
  69       return x;
  70     } else if (val instanceof Date) {
  71       return new Date(val.getTime());
  72     } else if (val instanceof RegExp) {
  73       return new RegExp(val);
  74     } else {
  75       throw new Error("Unexpected situation");
  76     }
  77   }
  78   function deepCloneArray(arr) {
  79     var clone = [];
  80     arr.forEach(function(item, index) {
  81       if (typeof item === "object" && item !== null) {
  82         if (Array.isArray(item)) {
  83           clone[index] = deepCloneArray(item);
  84         } else if (isSpecificValue(item)) {
  85           clone[index] = cloneSpecificValue(item);
  86         } else {
  87           clone[index] = deepExtend({}, item);
  88         }
  89       } else {
  90         clone[index] = item;
  91       }
  92     });
  93     return clone;
  94   }
  95   function safeGetProperty(object, property) {
  96     return property === "__proto__" ? void 0 : object[property];
  97   }
  98   var deepExtend = module2.exports = function() {
  99     if (arguments.length < 1 || typeof arguments[0] !== "object") {
 100       return false;
 101     }
 102     if (arguments.length < 2) {
 103       return arguments[0];
 104     }
 105     var target = arguments[0];
 106     var args = Array.prototype.slice.call(arguments, 1);
 107     var val, src, clone;
 108     args.forEach(function(obj) {
 109       if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
 110         return;
 111       }
 112       Object.keys(obj).forEach(function(key) {
 113         src = safeGetProperty(target, key);
 114         val = safeGetProperty(obj, key);
 115         if (val === target) {
 116           return;
 117         } else if (typeof val !== "object" || val === null) {
 118           target[key] = val;
 119           return;
 120         } else if (Array.isArray(val)) {
 121           target[key] = deepCloneArray(val);
 122           return;
 123         } else if (isSpecificValue(val)) {
 124           target[key] = cloneSpecificValue(val);
 125           return;
 126         } else if (typeof src !== "object" || src === null || Array.isArray(src)) {
 127           target[key] = deepExtend({}, val);
 128           return;
 129         } else {
 130           target[key] = deepExtend(src, val);
 131           return;
 132         }
 133       });
 134     });
 135     return target;
 136   };
 137 });
 138
 139 // node_modules/js-yaml/lib/js-yaml/common.js
 140 var require_common = __commonJS((exports2, module2) => {
 141   "use strict";
 142   function isNothing(subject) {
 143     return typeof subject === "undefined" || subject === null;
 144   }
 145   function isObject(subject) {
 146     return typeof subject === "object" && subject !== null;
 147   }
 148   function toArray(sequence) {
 149     if (Array.isArray(sequence))
 150       return sequence;
 151     else if (isNothing(sequence))
 152       return [];
 153     return [sequence];
 154   }
 155   function extend2(target, source) {
 156     var index, length, key, sourceKeys;
 157     if (source) {
 158       sourceKeys = Object.keys(source);
 159       for (index = 0, length = sourceKeys.length; index < length; index += 1) {
 160         key = sourceKeys[index];
 161         target[key] = source[key];
 162       }
 163     }
 164     return target;
 165   }
 166   function repeat(string, count) {
 167     var result = "", cycle;
 168     for (cycle = 0; cycle < count; cycle += 1) {
 169       result += string;
 170     }
 171     return result;
 172   }
 173   function isNegativeZero(number) {
 174     return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
 175   }
 176   module2.exports.isNothing = isNothing;
 177   module2.exports.isObject = isObject;
 178   module2.exports.toArray = toArray;
 179   module2.exports.repeat = repeat;
 180   module2.exports.isNegativeZero = isNegativeZero;
 181   module2.exports.extend = extend2;
 182 });
 183
 184 // node_modules/js-yaml/lib/js-yaml/exception.js
 185 var require_exception = __commonJS((exports2, module2) => {
 186   "use strict";
 187   function YAMLException(reason, mark) {
 188     Error.call(this);
 189     this.name = "YAMLException";
 190     this.reason = reason;
 191     this.mark = mark;
 192     this.message = (this.reason || "(unknown reason)") + (this.mark ? " " + this.mark.toString() : "");
 193     if (Error.captureStackTrace) {
 194       Error.captureStackTrace(this, this.constructor);
 195     } else {
 196       this.stack = new Error().stack || "";
 197     }
 198   }
 199   YAMLException.prototype = Object.create(Error.prototype);
 200   YAMLException.prototype.constructor = YAMLException;
 201   YAMLException.prototype.toString = function toString(compact) {
 202     var result = this.name + ": ";
 203     result += this.reason || "(unknown reason)";
 204     if (!compact && this.mark) {
 205       result += " " + this.mark.toString();
 206     }
 207     return result;
 208   };
 209   module2.exports = YAMLException;
 210 });
 211
 212 // node_modules/js-yaml/lib/js-yaml/mark.js
 213 var require_mark = __commonJS((exports2, module2) => {
 214   "use strict";
 215   var common = require_common();
 216   function Mark(name, buffer, position, line, column) {
 217     this.name = name;
 218     this.buffer = buffer;
 219     this.position = position;
 220     this.line = line;
 221     this.column = column;
 222   }
 223   Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
 224     var head, start, tail, end, snippet;
 225     if (!this.buffer)
 226       return null;
 227     indent = indent || 4;
 228     maxLength = maxLength || 75;
 229     head = "";
 230     start = this.position;
 231     while (start > 0 && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(start - 1)) === -1) {
 232       start -= 1;
 233       if (this.position - start > maxLength / 2 - 1) {
 234         head = " ... ";
 235         start += 5;
 236         break;
 237       }
 238     }
 239     tail = "";
 240     end = this.position;
 241     while (end < this.buffer.length && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(end)) === -1) {
 242       end += 1;
 243       if (end - this.position > maxLength / 2 - 1) {
 244         tail = " ... ";
 245         end -= 5;
 246         break;
 247       }
 248     }
 249     snippet = this.buffer.slice(start, end);
 250     return common.repeat(" ", indent) + head + snippet + tail + "\n" + common.repeat(" ", indent + this.position - start + head.length) + "^";
 251   };
 252   Mark.prototype.toString = function toString(compact) {
 253     var snippet, where = "";
 254     if (this.name) {
 255       where += 'in "' + this.name + '" ';
 256     }
 257     where += "at line " + (this.line + 1) + ", column " + (this.column + 1);
 258     if (!compact) {
 259       snippet = this.getSnippet();
 260       if (snippet) {
 261         where += ":\n" + snippet;
 262       }
 263     }
 264     return where;
 265   };
 266   module2.exports = Mark;
 267 });
 268
 269 // node_modules/js-yaml/lib/js-yaml/type.js
 270 var require_type = __commonJS((exports2, module2) => {
 271   "use strict";
 272   var YAMLException = require_exception();
 273   var TYPE_CONSTRUCTOR_OPTIONS = [
 274     "kind",
 275     "resolve",
 276     "construct",
 277     "instanceOf",
 278     "predicate",
 279     "represent",
 280     "defaultStyle",
 281     "styleAliases"
 282   ];
 283   var YAML_NODE_KINDS = [
 284     "scalar",
 285     "sequence",
 286     "mapping"
 287   ];
 288   function compileStyleAliases(map) {
 289     var result = {};
 290     if (map !== null) {
 291       Object.keys(map).forEach(function(style) {
 292         map[style].forEach(function(alias) {
 293           result[String(alias)] = style;
 294         });
 295       });
 296     }
 297     return result;
 298   }
 299   function Type(tag, options) {
 300     options = options || {};
 301     Object.keys(options).forEach(function(name) {
 302       if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
 303         throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
 304       }
 305     });
 306     this.tag = tag;
 307     this.kind = options["kind"] || null;
 308     this.resolve = options["resolve"] || function() {
 309       return true;
 310     };
 311     this.construct = options["construct"] || function(data) {
 312       return data;
 313     };
 314     this.instanceOf = options["instanceOf"] || null;
 315     this.predicate = options["predicate"] || null;
 316     this.represent = options["represent"] || null;
 317     this.defaultStyle = options["defaultStyle"] || null;
 318     this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
 319     if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
 320       throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
 321     }
 322   }
 323   module2.exports = Type;
 324 });
 325
 326 // node_modules/js-yaml/lib/js-yaml/schema.js
 327 var require_schema = __commonJS((exports2, module2) => {
 328   "use strict";
 329   var common = require_common();
 330   var YAMLException = require_exception();
 331   var Type = require_type();
 332   function compileList(schema, name, result) {
 333     var exclude = [];
 334     schema.include.forEach(function(includedSchema) {
 335       result = compileList(includedSchema, name, result);
 336     });
 337     schema[name].forEach(function(currentType) {
 338       result.forEach(function(previousType, previousIndex) {
 339         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
 340           exclude.push(previousIndex);
 341         }
 342       });
 343       result.push(currentType);
 344     });
 345     return result.filter(function(type, index) {
 346       return exclude.indexOf(index) === -1;
 347     });
 348   }
 349   function compileMap() {
 350     var result = {
 351       scalar: {},
 352       sequence: {},
 353       mapping: {},
 354       fallback: {}
 355     }, index, length;
 356     function collectType(type) {
 357       result[type.kind][type.tag] = result["fallback"][type.tag] = type;
 358     }
 359     for (index = 0, length = arguments.length; index < length; index += 1) {
 360       arguments[index].forEach(collectType);
 361     }
 362     return result;
 363   }
 364   function Schema(definition) {
 365     this.include = definition.include || [];
 366     this.implicit = definition.implicit || [];
 367     this.explicit = definition.explicit || [];
 368     this.implicit.forEach(function(type) {
 369       if (type.loadKind && type.loadKind !== "scalar") {
 370         throw new YAMLException("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
 371       }
 372     });
 373     this.compiledImplicit = compileList(this, "implicit", []);
 374     this.compiledExplicit = compileList(this, "explicit", []);
 375     this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
 376   }
 377   Schema.DEFAULT = null;
 378   Schema.create = function createSchema() {
 379     var schemas, types;
 380     switch (arguments.length) {
 381       case 1:
 382         schemas = Schema.DEFAULT;
 383         types = arguments[0];
 384         break;
 385       case 2:
 386         schemas = arguments[0];
 387         types = arguments[1];
 388         break;
 389       default:
 390         throw new YAMLException("Wrong number of arguments for Schema.create function");
 391     }
 392     schemas = common.toArray(schemas);
 393     types = common.toArray(types);
 394     if (!schemas.every(function(schema) {
 395       return schema instanceof Schema;
 396     })) {
 397       throw new YAMLException("Specified list of super schemas (or a single Schema object) contains a non-Schema object.");
 398     }
 399     if (!types.every(function(type) {
 400       return type instanceof Type;
 401     })) {
 402       throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
 403     }
 404     return new Schema({
 405       include: schemas,
 406       explicit: types
 407     });
 408   };
 409   module2.exports = Schema;
 410 });
 411
 412 // node_modules/js-yaml/lib/js-yaml/type/str.js
 413 var require_str = __commonJS((exports2, module2) => {
 414   "use strict";
 415   var Type = require_type();
 416   module2.exports = new Type("tag:yaml.org,2002:str", {
 417     kind: "scalar",
 418     construct: function(data) {
 419       return data !== null ? data : "";
 420     }
 421   });
 422 });
 423
 424 // node_modules/js-yaml/lib/js-yaml/type/seq.js
 425 var require_seq = __commonJS((exports2, module2) => {
 426   "use strict";
 427   var Type = require_type();
 428   module2.exports = new Type("tag:yaml.org,2002:seq", {
 429     kind: "sequence",
 430     construct: function(data) {
 431       return data !== null ? data : [];
 432     }
 433   });
 434 });
 435
 436 // node_modules/js-yaml/lib/js-yaml/type/map.js
 437 var require_map = __commonJS((exports2, module2) => {
 438   "use strict";
 439   var Type = require_type();
 440   module2.exports = new Type("tag:yaml.org,2002:map", {
 441     kind: "mapping",
 442     construct: function(data) {
 443       return data !== null ? data : {};
 444     }
 445   });
 446 });
 447
 448 // node_modules/js-yaml/lib/js-yaml/schema/failsafe.js
 449 var require_failsafe = __commonJS((exports2, module2) => {
 450   "use strict";
 451   var Schema = require_schema();
 452   module2.exports = new Schema({
 453     explicit: [
 454       require_str(),
 455       require_seq(),
 456       require_map()
 457     ]
 458   });
 459 });
 460
 461 // node_modules/js-yaml/lib/js-yaml/type/null.js
 462 var require_null = __commonJS((exports2, module2) => {
 463   "use strict";
 464   var Type = require_type();
 465   function resolveYamlNull(data) {
 466     if (data === null)
 467       return true;
 468     var max = data.length;
 469     return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
 470   }
 471   function constructYamlNull() {
 472     return null;
 473   }
 474   function isNull(object) {
 475     return object === null;
 476   }
 477   module2.exports = new Type("tag:yaml.org,2002:null", {
 478     kind: "scalar",
 479     resolve: resolveYamlNull,
 480     construct: constructYamlNull,
 481     predicate: isNull,
 482     represent: {
 483       canonical: function() {
 484         return "~";
 485       },
 486       lowercase: function() {
 487         return "null";
 488       },
 489       uppercase: function() {
 490         return "NULL";
 491       },
 492       camelcase: function() {
 493         return "Null";
 494       }
 495     },
 496     defaultStyle: "lowercase"
 497   });
 498 });
 499
 500 // node_modules/js-yaml/lib/js-yaml/type/bool.js
 501 var require_bool = __commonJS((exports2, module2) => {
 502   "use strict";
 503   var Type = require_type();
 504   function resolveYamlBoolean(data) {
 505     if (data === null)
 506       return false;
 507     var max = data.length;
 508     return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
 509   }
 510   function constructYamlBoolean(data) {
 511     return data === "true" || data === "True" || data === "TRUE";
 512   }
 513   function isBoolean(object) {
 514     return Object.prototype.toString.call(object) === "[object Boolean]";
 515   }
 516   module2.exports = new Type("tag:yaml.org,2002:bool", {
 517     kind: "scalar",
 518     resolve: resolveYamlBoolean,
 519     construct: constructYamlBoolean,
 520     predicate: isBoolean,
 521     represent: {
 522       lowercase: function(object) {
 523         return object ? "true" : "false";
 524       },
 525       uppercase: function(object) {
 526         return object ? "TRUE" : "FALSE";
 527       },
 528       camelcase: function(object) {
 529         return object ? "True" : "False";
 530       }
 531     },
 532     defaultStyle: "lowercase"
 533   });
 534 });
 535
 536 // node_modules/js-yaml/lib/js-yaml/type/int.js
 537 var require_int = __commonJS((exports2, module2) => {
 538   "use strict";
 539   var common = require_common();
 540   var Type = require_type();
 541   function isHexCode(c) {
 542     return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
 543   }
 544   function isOctCode(c) {
 545     return 48 <= c && c <= 55;
 546   }
 547   function isDecCode(c) {
 548     return 48 <= c && c <= 57;
 549   }
 550   function resolveYamlInteger(data) {
 551     if (data === null)
 552       return false;
 553     var max = data.length, index = 0, hasDigits = false, ch;
 554     if (!max)
 555       return false;
 556     ch = data[index];
 557     if (ch === "-" || ch === "+") {
 558       ch = data[++index];
 559     }
 560     if (ch === "0") {
 561       if (index + 1 === max)
 562         return true;
 563       ch = data[++index];
 564       if (ch === "b") {
 565         index++;
 566         for (; index < max; index++) {
 567           ch = data[index];
 568           if (ch === "_")
 569             continue;
 570           if (ch !== "0" && ch !== "1")
 571             return false;
 572           hasDigits = true;
 573         }
 574         return hasDigits && ch !== "_";
 575       }
 576       if (ch === "x") {
 577         index++;
 578         for (; index < max; index++) {
 579           ch = data[index];
 580           if (ch === "_")
 581             continue;
 582           if (!isHexCode(data.charCodeAt(index)))
 583             return false;
 584           hasDigits = true;
 585         }
 586         return hasDigits && ch !== "_";
 587       }
 588       for (; index < max; index++) {
 589         ch = data[index];
 590         if (ch === "_")
 591           continue;
 592         if (!isOctCode(data.charCodeAt(index)))
 593           return false;
 594         hasDigits = true;
 595       }
 596       return hasDigits && ch !== "_";
 597     }
 598     if (ch === "_")
 599       return false;
 600     for (; index < max; index++) {
 601       ch = data[index];
 602       if (ch === "_")
 603         continue;
 604       if (ch === ":")
 605         break;
 606       if (!isDecCode(data.charCodeAt(index))) {
 607         return false;
 608       }
 609       hasDigits = true;
 610     }
 611     if (!hasDigits || ch === "_")
 612       return false;
 613     if (ch !== ":")
 614       return true;
 615     return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
 616   }
 617   function constructYamlInteger(data) {
 618     var value = data, sign = 1, ch, base, digits = [];
 619     if (value.indexOf("_") !== -1) {
 620       value = value.replace(/_/g, "");
 621     }
 622     ch = value[0];
 623     if (ch === "-" || ch === "+") {
 624       if (ch === "-")
 625         sign = -1;
 626       value = value.slice(1);
 627       ch = value[0];
 628     }
 629     if (value === "0")
 630       return 0;
 631     if (ch === "0") {
 632       if (value[1] === "b")
 633         return sign * parseInt(value.slice(2), 2);
 634       if (value[1] === "x")
 635         return sign * parseInt(value, 16);
 636       return sign * parseInt(value, 8);
 637     }
 638     if (value.indexOf(":") !== -1) {
 639       value.split(":").forEach(function(v) {
 640         digits.unshift(parseInt(v, 10));
 641       });
 642       value = 0;
 643       base = 1;
 644       digits.forEach(function(d) {
 645         value += d * base;
 646         base *= 60;
 647       });
 648       return sign * value;
 649     }
 650     return sign * parseInt(value, 10);
 651   }
 652   function isInteger(object) {
 653     return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object));
 654   }
 655   module2.exports = new Type("tag:yaml.org,2002:int", {
 656     kind: "scalar",
 657     resolve: resolveYamlInteger,
 658     construct: constructYamlInteger,
 659     predicate: isInteger,
 660     represent: {
 661       binary: function(obj) {
 662         return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
 663       },
 664       octal: function(obj) {
 665         return obj >= 0 ? "0" + obj.toString(8) : "-0" + obj.toString(8).slice(1);
 666       },
 667       decimal: function(obj) {
 668         return obj.toString(10);
 669       },
 670       hexadecimal: function(obj) {
 671         return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
 672       }
 673     },
 674     defaultStyle: "decimal",
 675     styleAliases: {
 676       binary: [2, "bin"],
 677       octal: [8, "oct"],
 678       decimal: [10, "dec"],
 679       hexadecimal: [16, "hex"]
 680     }
 681   });
 682 });
 683
 684 // node_modules/js-yaml/lib/js-yaml/type/float.js
 685 var require_float = __commonJS((exports2, module2) => {
 686   "use strict";
 687   var common = require_common();
 688   var Type = require_type();
 689   var YAML_FLOAT_PATTERN = new RegExp("^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
 690   function resolveYamlFloat(data) {
 691     if (data === null)
 692       return false;
 693     if (!YAML_FLOAT_PATTERN.test(data) || data[data.length - 1] === "_") {
 694       return false;
 695     }
 696     return true;
 697   }
 698   function constructYamlFloat(data) {
 699     var value, sign, base, digits;
 700     value = data.replace(/_/g, "").toLowerCase();
 701     sign = value[0] === "-" ? -1 : 1;
 702     digits = [];
 703     if ("+-".indexOf(value[0]) >= 0) {
 704       value = value.slice(1);
 705     }
 706     if (value === ".inf") {
 707       return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
 708     } else if (value === ".nan") {
 709       return NaN;
 710     } else if (value.indexOf(":") >= 0) {
 711       value.split(":").forEach(function(v) {
 712         digits.unshift(parseFloat(v, 10));
 713       });
 714       value = 0;
 715       base = 1;
 716       digits.forEach(function(d) {
 717         value += d * base;
 718         base *= 60;
 719       });
 720       return sign * value;
 721     }
 722     return sign * parseFloat(value, 10);
 723   }
 724   var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
 725   function representYamlFloat(object, style) {
 726     var res;
 727     if (isNaN(object)) {
 728       switch (style) {
 729         case "lowercase":
 730           return ".nan";
 731         case "uppercase":
 732           return ".NAN";
 733         case "camelcase":
 734           return ".NaN";
 735       }
 736     } else if (Number.POSITIVE_INFINITY === object) {
 737       switch (style) {
 738         case "lowercase":
 739           return ".inf";
 740         case "uppercase":
 741           return ".INF";
 742         case "camelcase":
 743           return ".Inf";
 744       }
 745     } else if (Number.NEGATIVE_INFINITY === object) {
 746       switch (style) {
 747         case "lowercase":
 748           return "-.inf";
 749         case "uppercase":
 750           return "-.INF";
 751         case "camelcase":
 752           return "-.Inf";
 753       }
 754     } else if (common.isNegativeZero(object)) {
 755       return "-0.0";
 756     }
 757     res = object.toString(10);
 758     return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
 759   }
 760   function isFloat(object) {
 761     return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
 762   }
 763   module2.exports = new Type("tag:yaml.org,2002:float", {
 764     kind: "scalar",
 765     resolve: resolveYamlFloat,
 766     construct: constructYamlFloat,
 767     predicate: isFloat,
 768     represent: representYamlFloat,
 769     defaultStyle: "lowercase"
 770   });
 771 });
 772
 773 // node_modules/js-yaml/lib/js-yaml/schema/json.js
 774 var require_json = __commonJS((exports2, module2) => {
 775   "use strict";
 776   var Schema = require_schema();
 777   module2.exports = new Schema({
 778     include: [
 779       require_failsafe()
 780     ],
 781     implicit: [
 782       require_null(),
 783       require_bool(),
 784       require_int(),
 785       require_float()
 786     ]
 787   });
 788 });
 789
 790 // node_modules/js-yaml/lib/js-yaml/schema/core.js
 791 var require_core = __commonJS((exports2, module2) => {
 792   "use strict";
 793   var Schema = require_schema();
 794   module2.exports = new Schema({
 795     include: [
 796       require_json()
 797     ]
 798   });
 799 });
 800
 801 // node_modules/js-yaml/lib/js-yaml/type/timestamp.js
 802 var require_timestamp = __commonJS((exports2, module2) => {
 803   "use strict";
 804   var Type = require_type();
 805   var YAML_DATE_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
 806   var YAML_TIMESTAMP_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
 807   function resolveYamlTimestamp(data) {
 808     if (data === null)
 809       return false;
 810     if (YAML_DATE_REGEXP.exec(data) !== null)
 811       return true;
 812     if (YAML_TIMESTAMP_REGEXP.exec(data) !== null)
 813       return true;
 814     return false;
 815   }
 816   function constructYamlTimestamp(data) {
 817     var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
 818     match = YAML_DATE_REGEXP.exec(data);
 819     if (match === null)
 820       match = YAML_TIMESTAMP_REGEXP.exec(data);
 821     if (match === null)
 822       throw new Error("Date resolve error");
 823     year = +match[1];
 824     month = +match[2] - 1;
 825     day = +match[3];
 826     if (!match[4]) {
 827       return new Date(Date.UTC(year, month, day));
 828     }
 829     hour = +match[4];
 830     minute = +match[5];
 831     second = +match[6];
 832     if (match[7]) {
 833       fraction = match[7].slice(0, 3);
 834       while (fraction.length < 3) {
 835         fraction += "0";
 836       }
 837       fraction = +fraction;
 838     }
 839     if (match[9]) {
 840       tz_hour = +match[10];
 841       tz_minute = +(match[11] || 0);
 842       delta = (tz_hour * 60 + tz_minute) * 6e4;
 843       if (match[9] === "-")
 844         delta = -delta;
 845     }
 846     date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
 847     if (delta)
 848       date.setTime(date.getTime() - delta);
 849     return date;
 850   }
 851   function representYamlTimestamp(object) {
 852     return object.toISOString();
 853   }
 854   module2.exports = new Type("tag:yaml.org,2002:timestamp", {
 855     kind: "scalar",
 856     resolve: resolveYamlTimestamp,
 857     construct: constructYamlTimestamp,
 858     instanceOf: Date,
 859     represent: representYamlTimestamp
 860   });
 861 });
 862
 863 // node_modules/js-yaml/lib/js-yaml/type/merge.js
 864 var require_merge = __commonJS((exports2, module2) => {
 865   "use strict";
 866   var Type = require_type();
 867   function resolveYamlMerge(data) {
 868     return data === "<<" || data === null;
 869   }
 870   module2.exports = new Type("tag:yaml.org,2002:merge", {
 871     kind: "scalar",
 872     resolve: resolveYamlMerge
 873   });
 874 });
 875
 876 // node_modules/js-yaml/lib/js-yaml/type/binary.js
 877 var require_binary = __commonJS((exports2, module2) => {
 878   "use strict";
 879   var NodeBuffer;
 880   try {
 881     _require = require;
 882     NodeBuffer = _require("buffer").Buffer;
 883   } catch (__) {
 884   }
 885   var _require;
 886   var Type = require_type();
 887   var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
 888   function resolveYamlBinary(data) {
 889     if (data === null)
 890       return false;
 891     var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
 892     for (idx = 0; idx < max; idx++) {
 893       code = map.indexOf(data.charAt(idx));
 894       if (code > 64)
 895         continue;
 896       if (code < 0)
 897         return false;
 898       bitlen += 6;
 899     }
 900     return bitlen % 8 === 0;
 901   }
 902   function constructYamlBinary(data) {
 903     var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map = BASE64_MAP, bits = 0, result = [];
 904     for (idx = 0; idx < max; idx++) {
 905       if (idx % 4 === 0 && idx) {
 906         result.push(bits >> 16 & 255);
 907         result.push(bits >> 8 & 255);
 908         result.push(bits & 255);
 909       }
 910       bits = bits << 6 | map.indexOf(input.charAt(idx));
 911     }
 912     tailbits = max % 4 * 6;
 913     if (tailbits === 0) {
 914       result.push(bits >> 16 & 255);
 915       result.push(bits >> 8 & 255);
 916       result.push(bits & 255);
 917     } else if (tailbits === 18) {
 918       result.push(bits >> 10 & 255);
 919       result.push(bits >> 2 & 255);
 920     } else if (tailbits === 12) {
 921       result.push(bits >> 4 & 255);
 922     }
 923     if (NodeBuffer) {
 924       return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
 925     }
 926     return result;
 927   }
 928   function representYamlBinary(object) {
 929     var result = "", bits = 0, idx, tail, max = object.length, map = BASE64_MAP;
 930     for (idx = 0; idx < max; idx++) {
 931       if (idx % 3 === 0 && idx) {
 932         result += map[bits >> 18 & 63];
 933         result += map[bits >> 12 & 63];
 934         result += map[bits >> 6 & 63];
 935         result += map[bits & 63];
 936       }
 937       bits = (bits << 8) + object[idx];
 938     }
 939     tail = max % 3;
 940     if (tail === 0) {
 941       result += map[bits >> 18 & 63];
 942       result += map[bits >> 12 & 63];
 943       result += map[bits >> 6 & 63];
 944       result += map[bits & 63];
 945     } else if (tail === 2) {
 946       result += map[bits >> 10 & 63];
 947       result += map[bits >> 4 & 63];
 948       result += map[bits << 2 & 63];
 949       result += map[64];
 950     } else if (tail === 1) {
 951       result += map[bits >> 2 & 63];
 952       result += map[bits << 4 & 63];
 953       result += map[64];
 954       result += map[64];
 955     }
 956     return result;
 957   }
 958   function isBinary(object) {
 959     return NodeBuffer && NodeBuffer.isBuffer(object);
 960   }
 961   module2.exports = new Type("tag:yaml.org,2002:binary", {
 962     kind: "scalar",
 963     resolve: resolveYamlBinary,
 964     construct: constructYamlBinary,
 965     predicate: isBinary,
 966     represent: representYamlBinary
 967   });
 968 });
 969
 970 // node_modules/js-yaml/lib/js-yaml/type/omap.js
 971 var require_omap = __commonJS((exports2, module2) => {
 972   "use strict";
 973   var Type = require_type();
 974   var _hasOwnProperty = Object.prototype.hasOwnProperty;
 975   var _toString = Object.prototype.toString;
 976   function resolveYamlOmap(data) {
 977     if (data === null)
 978       return true;
 979     var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data;
 980     for (index = 0, length = object.length; index < length; index += 1) {
 981       pair = object[index];
 982       pairHasKey = false;
 983       if (_toString.call(pair) !== "[object Object]")
 984         return false;
 985       for (pairKey in pair) {
 986         if (_hasOwnProperty.call(pair, pairKey)) {
 987           if (!pairHasKey)
 988             pairHasKey = true;
 989           else
 990             return false;
 991         }
 992       }
 993       if (!pairHasKey)
 994         return false;
 995       if (objectKeys.indexOf(pairKey) === -1)
 996         objectKeys.push(pairKey);
 997       else
 998         return false;
 999     }
1000     return true;
1001   }
1002   function constructYamlOmap(data) {
1003     return data !== null ? data : [];
1004   }
1005   module2.exports = new Type("tag:yaml.org,2002:omap", {
1006     kind: "sequence",
1007     resolve: resolveYamlOmap,
1008     construct: constructYamlOmap
1009   });
1010 });
1011
1012 // node_modules/js-yaml/lib/js-yaml/type/pairs.js
1013 var require_pairs = __commonJS((exports2, module2) => {
1014   "use strict";
1015   var Type = require_type();
1016   var _toString = Object.prototype.toString;
1017   function resolveYamlPairs(data) {
1018     if (data === null)
1019       return true;
1020     var index, length, pair, keys, result, object = data;
1021     result = new Array(object.length);
1022     for (index = 0, length = object.length; index < length; index += 1) {
1023       pair = object[index];
1024       if (_toString.call(pair) !== "[object Object]")
1025         return false;
1026       keys = Object.keys(pair);
1027       if (keys.length !== 1)
1028         return false;
1029       result[index] = [keys[0], pair[keys[0]]];
1030     }
1031     return true;
1032   }
1033   function constructYamlPairs(data) {
1034     if (data === null)
1035       return [];
1036     var index, length, pair, keys, result, object = data;
1037     result = new Array(object.length);
1038     for (index = 0, length = object.length; index < length; index += 1) {
1039       pair = object[index];
1040       keys = Object.keys(pair);
1041       result[index] = [keys[0], pair[keys[0]]];
1042     }
1043     return result;
1044   }
1045   module2.exports = new Type("tag:yaml.org,2002:pairs", {
1046     kind: "sequence",
1047     resolve: resolveYamlPairs,
1048     construct: constructYamlPairs
1049   });
1050 });
1051
1052 // node_modules/js-yaml/lib/js-yaml/type/set.js
1053 var require_set = __commonJS((exports2, module2) => {
1054   "use strict";
1055   var Type = require_type();
1056   var _hasOwnProperty = Object.prototype.hasOwnProperty;
1057   function resolveYamlSet(data) {
1058     if (data === null)
1059       return true;
1060     var key, object = data;
1061     for (key in object) {
1062       if (_hasOwnProperty.call(object, key)) {
1063         if (object[key] !== null)
1064           return false;
1065       }
1066     }
1067     return true;
1068   }
1069   function constructYamlSet(data) {
1070     return data !== null ? data : {};
1071   }
1072   module2.exports = new Type("tag:yaml.org,2002:set", {
1073     kind: "mapping",
1074     resolve: resolveYamlSet,
1075     construct: constructYamlSet
1076   });
1077 });
1078
1079 // node_modules/js-yaml/lib/js-yaml/schema/default_safe.js
1080 var require_default_safe = __commonJS((exports2, module2) => {
1081   "use strict";
1082   var Schema = require_schema();
1083   module2.exports = new Schema({
1084     include: [
1085       require_core()
1086     ],
1087     implicit: [
1088       require_timestamp(),
1089       require_merge()
1090     ],
1091     explicit: [
1092       require_binary(),
1093       require_omap(),
1094       require_pairs(),
1095       require_set()
1096     ]
1097   });
1098 });
1099
1100 // node_modules/js-yaml/lib/js-yaml/type/js/undefined.js
1101 var require_undefined = __commonJS((exports2, module2) => {
1102   "use strict";
1103   var Type = require_type();
1104   function resolveJavascriptUndefined() {
1105     return true;
1106   }
1107   function constructJavascriptUndefined() {
1108     return void 0;
1109   }
1110   function representJavascriptUndefined() {
1111     return "";
1112   }
1113   function isUndefined(object) {
1114     return typeof object === "undefined";
1115   }
1116   module2.exports = new Type("tag:yaml.org,2002:js/undefined", {
1117     kind: "scalar",
1118     resolve: resolveJavascriptUndefined,
1119     construct: constructJavascriptUndefined,
1120     predicate: isUndefined,
1121     represent: representJavascriptUndefined
1122   });
1123 });
1124
1125 // node_modules/js-yaml/lib/js-yaml/type/js/regexp.js
1126 var require_regexp = __commonJS((exports2, module2) => {
1127   "use strict";
1128   var Type = require_type();
1129   function resolveJavascriptRegExp(data) {
1130     if (data === null)
1131       return false;
1132     if (data.length === 0)
1133       return false;
1134     var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = "";
1135     if (regexp[0] === "/") {
1136       if (tail)
1137         modifiers = tail[1];
1138       if (modifiers.length > 3)
1139         return false;
1140       if (regexp[regexp.length - modifiers.length - 1] !== "/")
1141         return false;
1142     }
1143     return true;
1144   }
1145   function constructJavascriptRegExp(data) {
1146     var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = "";
1147     if (regexp[0] === "/") {
1148       if (tail)
1149         modifiers = tail[1];
1150       regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
1151     }
1152     return new RegExp(regexp, modifiers);
1153   }
1154   function representJavascriptRegExp(object) {
1155     var result = "/" + object.source + "/";
1156     if (object.global)
1157       result += "g";
1158     if (object.multiline)
1159       result += "m";
1160     if (object.ignoreCase)
1161       result += "i";
1162     return result;
1163   }
1164   function isRegExp(object) {
1165     return Object.prototype.toString.call(object) === "[object RegExp]";
1166   }
1167   module2.exports = new Type("tag:yaml.org,2002:js/regexp", {
1168     kind: "scalar",
1169     resolve: resolveJavascriptRegExp,
1170     construct: constructJavascriptRegExp,
1171     predicate: isRegExp,
1172     represent: representJavascriptRegExp
1173   });
1174 });
1175
1176 // node_modules/js-yaml/lib/js-yaml/type/js/function.js
1177 var require_function = __commonJS((exports2, module2) => {
1178   "use strict";
1179   var esprima;
1180   try {
1181     _require = require;
1182     esprima = _require("esprima");
1183   } catch (_) {
1184     if (typeof window !== "undefined")
1185       esprima = window.esprima;
1186   }
1187   var _require;
1188   var Type = require_type();
1189   function resolveJavascriptFunction(data) {
1190     if (data === null)
1191       return false;
1192     try {
1193       var source = "(" + data + ")", ast = esprima.parse(source, {range: true});
1194       if (ast.type !== "Program" || ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement" || ast.body[0].expression.type !== "ArrowFunctionExpression" && ast.body[0].expression.type !== "FunctionExpression") {
1195         return false;
1196       }
1197       return true;
1198     } catch (err) {
1199       return false;
1200     }
1201   }
1202   function constructJavascriptFunction(data) {
1203     var source = "(" + data + ")", ast = esprima.parse(source, {range: true}), params = [], body;
1204     if (ast.type !== "Program" || ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement" || ast.body[0].expression.type !== "ArrowFunctionExpression" && ast.body[0].expression.type !== "FunctionExpression") {
1205       throw new Error("Failed to resolve function");
1206     }
1207     ast.body[0].expression.params.forEach(function(param) {
1208       params.push(param.name);
1209     });
1210     body = ast.body[0].expression.body.range;
1211     if (ast.body[0].expression.body.type === "BlockStatement") {
1212       return new Function(params, source.slice(body[0] + 1, body[1] - 1));
1213     }
1214     return new Function(params, "return " + source.slice(body[0], body[1]));
1215   }
1216   function representJavascriptFunction(object) {
1217     return object.toString();
1218   }
1219   function isFunction(object) {
1220     return Object.prototype.toString.call(object) === "[object Function]";
1221   }
1222   module2.exports = new Type("tag:yaml.org,2002:js/function", {
1223     kind: "scalar",
1224     resolve: resolveJavascriptFunction,
1225     construct: constructJavascriptFunction,
1226     predicate: isFunction,
1227     represent: representJavascriptFunction
1228   });
1229 });
1230
1231 // node_modules/js-yaml/lib/js-yaml/schema/default_full.js
1232 var require_default_full = __commonJS((exports2, module2) => {
1233   "use strict";
1234   var Schema = require_schema();
1235   module2.exports = Schema.DEFAULT = new Schema({
1236     include: [
1237       require_default_safe()
1238     ],
1239     explicit: [
1240       require_undefined(),
1241       require_regexp(),
1242       require_function()
1243     ]
1244   });
1245 });
1246
1247 // node_modules/js-yaml/lib/js-yaml/loader.js
1248 var require_loader = __commonJS((exports2, module2) => {
1249   "use strict";
1250   var common = require_common();
1251   var YAMLException = require_exception();
1252   var Mark = require_mark();
1253   var DEFAULT_SAFE_SCHEMA = require_default_safe();
1254   var DEFAULT_FULL_SCHEMA = require_default_full();
1255   var _hasOwnProperty = Object.prototype.hasOwnProperty;
1256   var CONTEXT_FLOW_IN = 1;
1257   var CONTEXT_FLOW_OUT = 2;
1258   var CONTEXT_BLOCK_IN = 3;
1259   var CONTEXT_BLOCK_OUT = 4;
1260   var CHOMPING_CLIP = 1;
1261   var CHOMPING_STRIP = 2;
1262   var CHOMPING_KEEP = 3;
1263   var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
1264   var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
1265   var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
1266   var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
1267   var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
1268   function _class(obj) {
1269     return Object.prototype.toString.call(obj);
1270   }
1271   function is_EOL(c) {
1272     return c === 10 || c === 13;
1273   }
1274   function is_WHITE_SPACE(c) {
1275     return c === 9 || c === 32;
1276   }
1277   function is_WS_OR_EOL(c) {
1278     return c === 9 || c === 32 || c === 10 || c === 13;
1279   }
1280   function is_FLOW_INDICATOR(c) {
1281     return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
1282   }
1283   function fromHexCode(c) {
1284     var lc;
1285     if (48 <= c && c <= 57) {
1286       return c - 48;
1287     }
1288     lc = c | 32;
1289     if (97 <= lc && lc <= 102) {
1290       return lc - 97 + 10;
1291     }
1292     return -1;
1293   }
1294   function escapedHexLen(c) {
1295     if (c === 120) {
1296       return 2;
1297     }
1298     if (c === 117) {
1299       return 4;
1300     }
1301     if (c === 85) {
1302       return 8;
1303     }
1304     return 0;
1305   }
1306   function fromDecimalCode(c) {
1307     if (48 <= c && c <= 57) {
1308       return c - 48;
1309     }
1310     return -1;
1311   }
1312   function simpleEscapeSequence(c) {
1313     return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? "        " : c === 9 ? " " : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\e" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "\x85" : c === 95 ? "\xA0" : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
1314   }
1315   function charFromCodepoint(c) {
1316     if (c <= 65535) {
1317       return String.fromCharCode(c);
1318     }
1319     return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
1320   }
1321   var simpleEscapeCheck = new Array(256);
1322   var simpleEscapeMap = new Array(256);
1323   for (var i = 0; i < 256; i++) {
1324     simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
1325     simpleEscapeMap[i] = simpleEscapeSequence(i);
1326   }
1327   function State(input, options) {
1328     this.input = input;
1329     this.filename = options["filename"] || null;
1330     this.schema = options["schema"] || DEFAULT_FULL_SCHEMA;
1331     this.onWarning = options["onWarning"] || null;
1332     this.legacy = options["legacy"] || false;
1333     this.json = options["json"] || false;
1334     this.listener = options["listener"] || null;
1335     this.implicitTypes = this.schema.compiledImplicit;
1336     this.typeMap = this.schema.compiledTypeMap;
1337     this.length = input.length;
1338     this.position = 0;
1339     this.line = 0;
1340     this.lineStart = 0;
1341     this.lineIndent = 0;
1342     this.documents = [];
1343   }
1344   function generateError(state, message) {
1345     return new YAMLException(message, new Mark(state.filename, state.input, state.position, state.line, state.position - state.lineStart));
1346   }
1347   function throwError(state, message) {
1348     throw generateError(state, message);
1349   }
1350   function throwWarning(state, message) {
1351     if (state.onWarning) {
1352       state.onWarning.call(null, generateError(state, message));
1353     }
1354   }
1355   var directiveHandlers = {
1356     YAML: function handleYamlDirective(state, name, args) {
1357       var match, major, minor;
1358       if (state.version !== null) {
1359         throwError(state, "duplication of %YAML directive");
1360       }
1361       if (args.length !== 1) {
1362         throwError(state, "YAML directive accepts exactly one argument");
1363       }
1364       match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
1365       if (match === null) {
1366         throwError(state, "ill-formed argument of the YAML directive");
1367       }
1368       major = parseInt(match[1], 10);
1369       minor = parseInt(match[2], 10);
1370       if (major !== 1) {
1371         throwError(state, "unacceptable YAML version of the document");
1372       }
1373       state.version = args[0];
1374       state.checkLineBreaks = minor < 2;
1375       if (minor !== 1 && minor !== 2) {
1376         throwWarning(state, "unsupported YAML version of the document");
1377       }
1378     },
1379     TAG: function handleTagDirective(state, name, args) {
1380       var handle, prefix;
1381       if (args.length !== 2) {
1382         throwError(state, "TAG directive accepts exactly two arguments");
1383       }
1384       handle = args[0];
1385       prefix = args[1];
1386       if (!PATTERN_TAG_HANDLE.test(handle)) {
1387         throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
1388       }
1389       if (_hasOwnProperty.call(state.tagMap, handle)) {
1390         throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
1391       }
1392       if (!PATTERN_TAG_URI.test(prefix)) {
1393         throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
1394       }
1395       state.tagMap[handle] = prefix;
1396     }
1397   };
1398   function captureSegment(state, start, end, checkJson) {
1399     var _position, _length, _character, _result;
1400     if (start < end) {
1401       _result = state.input.slice(start, end);
1402       if (checkJson) {
1403         for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
1404           _character = _result.charCodeAt(_position);
1405           if (!(_character === 9 || 32 <= _character && _character <= 1114111)) {
1406             throwError(state, "expected valid JSON character");
1407           }
1408         }
1409       } else if (PATTERN_NON_PRINTABLE.test(_result)) {
1410         throwError(state, "the stream contains non-printable characters");
1411       }
1412       state.result += _result;
1413     }
1414   }
1415   function mergeMappings(state, destination, source, overridableKeys) {
1416     var sourceKeys, key, index, quantity;
1417     if (!common.isObject(source)) {
1418       throwError(state, "cannot merge mappings; the provided source object is unacceptable");
1419     }
1420     sourceKeys = Object.keys(source);
1421     for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
1422       key = sourceKeys[index];
1423       if (!_hasOwnProperty.call(destination, key)) {
1424         destination[key] = source[key];
1425         overridableKeys[key] = true;
1426       }
1427     }
1428   }
1429   function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
1430     var index, quantity;
1431     if (Array.isArray(keyNode)) {
1432       keyNode = Array.prototype.slice.call(keyNode);
1433       for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
1434         if (Array.isArray(keyNode[index])) {
1435           throwError(state, "nested arrays are not supported inside keys");
1436         }
1437         if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") {
1438           keyNode[index] = "[object Object]";
1439         }
1440       }
1441     }
1442     if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") {
1443       keyNode = "[object Object]";
1444     }
1445     keyNode = String(keyNode);
1446     if (_result === null) {
1447       _result = {};
1448     }
1449     if (keyTag === "tag:yaml.org,2002:merge") {
1450       if (Array.isArray(valueNode)) {
1451         for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
1452           mergeMappings(state, _result, valueNode[index], overridableKeys);
1453         }
1454       } else {
1455         mergeMappings(state, _result, valueNode, overridableKeys);
1456       }
1457     } else {
1458       if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
1459         state.line = startLine || state.line;
1460         state.position = startPos || state.position;
1461         throwError(state, "duplicated mapping key");
1462       }
1463       _result[keyNode] = valueNode;
1464       delete overridableKeys[keyNode];
1465     }
1466     return _result;
1467   }
1468   function readLineBreak(state) {
1469     var ch;
1470     ch = state.input.charCodeAt(state.position);
1471     if (ch === 10) {
1472       state.position++;
1473     } else if (ch === 13) {
1474       state.position++;
1475       if (state.input.charCodeAt(state.position) === 10) {
1476         state.position++;
1477       }
1478     } else {
1479       throwError(state, "a line break is expected");
1480     }
1481     state.line += 1;
1482     state.lineStart = state.position;
1483   }
1484   function skipSeparationSpace(state, allowComments, checkIndent) {
1485     var lineBreaks = 0, ch = state.input.charCodeAt(state.position);
1486     while (ch !== 0) {
1487       while (is_WHITE_SPACE(ch)) {
1488         ch = state.input.charCodeAt(++state.position);
1489       }
1490       if (allowComments && ch === 35) {
1491         do {
1492           ch = state.input.charCodeAt(++state.position);
1493         } while (ch !== 10 && ch !== 13 && ch !== 0);
1494       }
1495       if (is_EOL(ch)) {
1496         readLineBreak(state);
1497         ch = state.input.charCodeAt(state.position);
1498         lineBreaks++;
1499         state.lineIndent = 0;
1500         while (ch === 32) {
1501           state.lineIndent++;
1502           ch = state.input.charCodeAt(++state.position);
1503         }
1504       } else {
1505         break;
1506       }
1507     }
1508     if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
1509       throwWarning(state, "deficient indentation");
1510     }
1511     return lineBreaks;
1512   }
1513   function testDocumentSeparator(state) {
1514     var _position = state.position, ch;
1515     ch = state.input.charCodeAt(_position);
1516     if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
1517       _position += 3;
1518       ch = state.input.charCodeAt(_position);
1519       if (ch === 0 || is_WS_OR_EOL(ch)) {
1520         return true;
1521       }
1522     }
1523     return false;
1524   }
1525   function writeFoldedLines(state, count) {
1526     if (count === 1) {
1527       state.result += " ";
1528     } else if (count > 1) {
1529       state.result += common.repeat("\n", count - 1);
1530     }
1531   }
1532   function readPlainScalar(state, nodeIndent, withinFlowCollection) {
1533     var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch;
1534     ch = state.input.charCodeAt(state.position);
1535     if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) {
1536       return false;
1537     }
1538     if (ch === 63 || ch === 45) {
1539       following = state.input.charCodeAt(state.position + 1);
1540       if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
1541         return false;
1542       }
1543     }
1544     state.kind = "scalar";
1545     state.result = "";
1546     captureStart = captureEnd = state.position;
1547     hasPendingContent = false;
1548     while (ch !== 0) {
1549       if (ch === 58) {
1550         following = state.input.charCodeAt(state.position + 1);
1551         if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
1552           break;
1553         }
1554       } else if (ch === 35) {
1555         preceding = state.input.charCodeAt(state.position - 1);
1556         if (is_WS_OR_EOL(preceding)) {
1557           break;
1558         }
1559       } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) {
1560         break;
1561       } else if (is_EOL(ch)) {
1562         _line = state.line;
1563         _lineStart = state.lineStart;
1564         _lineIndent = state.lineIndent;
1565         skipSeparationSpace(state, false, -1);
1566         if (state.lineIndent >= nodeIndent) {
1567           hasPendingContent = true;
1568           ch = state.input.charCodeAt(state.position);
1569           continue;
1570         } else {
1571           state.position = captureEnd;
1572           state.line = _line;
1573           state.lineStart = _lineStart;
1574           state.lineIndent = _lineIndent;
1575           break;
1576         }
1577       }
1578       if (hasPendingContent) {
1579         captureSegment(state, captureStart, captureEnd, false);
1580         writeFoldedLines(state, state.line - _line);
1581         captureStart = captureEnd = state.position;
1582         hasPendingContent = false;
1583       }
1584       if (!is_WHITE_SPACE(ch)) {
1585         captureEnd = state.position + 1;
1586       }
1587       ch = state.input.charCodeAt(++state.position);
1588     }
1589     captureSegment(state, captureStart, captureEnd, false);
1590     if (state.result) {
1591       return true;
1592     }
1593     state.kind = _kind;
1594     state.result = _result;
1595     return false;
1596   }
1597   function readSingleQuotedScalar(state, nodeIndent) {
1598     var ch, captureStart, captureEnd;
1599     ch = state.input.charCodeAt(state.position);
1600     if (ch !== 39) {
1601       return false;
1602     }
1603     state.kind = "scalar";
1604     state.result = "";
1605     state.position++;
1606     captureStart = captureEnd = state.position;
1607     while ((ch = state.input.charCodeAt(state.position)) !== 0) {
1608       if (ch === 39) {
1609         captureSegment(state, captureStart, state.position, true);
1610         ch = state.input.charCodeAt(++state.position);
1611         if (ch === 39) {
1612           captureStart = state.position;
1613           state.position++;
1614           captureEnd = state.position;
1615         } else {
1616           return true;
1617         }
1618       } else if (is_EOL(ch)) {
1619         captureSegment(state, captureStart, captureEnd, true);
1620         writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
1621         captureStart = captureEnd = state.position;
1622       } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
1623         throwError(state, "unexpected end of the document within a single quoted scalar");
1624       } else {
1625         state.position++;
1626         captureEnd = state.position;
1627       }
1628     }
1629     throwError(state, "unexpected end of the stream within a single quoted scalar");
1630   }
1631   function readDoubleQuotedScalar(state, nodeIndent) {
1632     var captureStart, captureEnd, hexLength, hexResult, tmp, ch;
1633     ch = state.input.charCodeAt(state.position);
1634     if (ch !== 34) {
1635       return false;
1636     }
1637     state.kind = "scalar";
1638     state.result = "";
1639     state.position++;
1640     captureStart = captureEnd = state.position;
1641     while ((ch = state.input.charCodeAt(state.position)) !== 0) {
1642       if (ch === 34) {
1643         captureSegment(state, captureStart, state.position, true);
1644         state.position++;
1645         return true;
1646       } else if (ch === 92) {
1647         captureSegment(state, captureStart, state.position, true);
1648         ch = state.input.charCodeAt(++state.position);
1649         if (is_EOL(ch)) {
1650           skipSeparationSpace(state, false, nodeIndent);
1651         } else if (ch < 256 && simpleEscapeCheck[ch]) {
1652           state.result += simpleEscapeMap[ch];
1653           state.position++;
1654         } else if ((tmp = escapedHexLen(ch)) > 0) {
1655           hexLength = tmp;
1656           hexResult = 0;
1657           for (; hexLength > 0; hexLength--) {
1658             ch = state.input.charCodeAt(++state.position);
1659             if ((tmp = fromHexCode(ch)) >= 0) {
1660               hexResult = (hexResult << 4) + tmp;
1661             } else {
1662               throwError(state, "expected hexadecimal character");
1663             }
1664           }
1665           state.result += charFromCodepoint(hexResult);
1666           state.position++;
1667         } else {
1668           throwError(state, "unknown escape sequence");
1669         }
1670         captureStart = captureEnd = state.position;
1671       } else if (is_EOL(ch)) {
1672         captureSegment(state, captureStart, captureEnd, true);
1673         writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
1674         captureStart = captureEnd = state.position;
1675       } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
1676         throwError(state, "unexpected end of the document within a double quoted scalar");
1677       } else {
1678         state.position++;
1679         captureEnd = state.position;
1680       }
1681     }
1682     throwError(state, "unexpected end of the stream within a double quoted scalar");
1683   }
1684   function readFlowCollection(state, nodeIndent) {
1685     var readNext = true, _line, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = {}, keyNode, keyTag, valueNode, ch;
1686     ch = state.input.charCodeAt(state.position);
1687     if (ch === 91) {
1688       terminator = 93;
1689       isMapping = false;
1690       _result = [];
1691     } else if (ch === 123) {
1692       terminator = 125;
1693       isMapping = true;
1694       _result = {};
1695     } else {
1696       return false;
1697     }
1698     if (state.anchor !== null) {
1699       state.anchorMap[state.anchor] = _result;
1700     }
1701     ch = state.input.charCodeAt(++state.position);
1702     while (ch !== 0) {
1703       skipSeparationSpace(state, true, nodeIndent);
1704       ch = state.input.charCodeAt(state.position);
1705       if (ch === terminator) {
1706         state.position++;
1707         state.tag = _tag;
1708         state.anchor = _anchor;
1709         state.kind = isMapping ? "mapping" : "sequence";
1710         state.result = _result;
1711         return true;
1712       } else if (!readNext) {
1713         throwError(state, "missed comma between flow collection entries");
1714       }
1715       keyTag = keyNode = valueNode = null;
1716       isPair = isExplicitPair = false;
1717       if (ch === 63) {
1718         following = state.input.charCodeAt(state.position + 1);
1719         if (is_WS_OR_EOL(following)) {
1720           isPair = isExplicitPair = true;
1721           state.position++;
1722           skipSeparationSpace(state, true, nodeIndent);
1723         }
1724       }
1725       _line = state.line;
1726       composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
1727       keyTag = state.tag;
1728       keyNode = state.result;
1729       skipSeparationSpace(state, true, nodeIndent);
1730       ch = state.input.charCodeAt(state.position);
1731       if ((isExplicitPair || state.line === _line) && ch === 58) {
1732         isPair = true;
1733         ch = state.input.charCodeAt(++state.position);
1734         skipSeparationSpace(state, true, nodeIndent);
1735         composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
1736         valueNode = state.result;
1737       }
1738       if (isMapping) {
1739         storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
1740       } else if (isPair) {
1741         _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
1742       } else {
1743         _result.push(keyNode);
1744       }
1745       skipSeparationSpace(state, true, nodeIndent);
1746       ch = state.input.charCodeAt(state.position);
1747       if (ch === 44) {
1748         readNext = true;
1749         ch = state.input.charCodeAt(++state.position);
1750       } else {
1751         readNext = false;
1752       }
1753     }
1754     throwError(state, "unexpected end of the stream within a flow collection");
1755   }
1756   function readBlockScalar(state, nodeIndent) {
1757     var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch;
1758     ch = state.input.charCodeAt(state.position);
1759     if (ch === 124) {
1760       folding = false;
1761     } else if (ch === 62) {
1762       folding = true;
1763     } else {
1764       return false;
1765     }
1766     state.kind = "scalar";
1767     state.result = "";
1768     while (ch !== 0) {
1769       ch = state.input.charCodeAt(++state.position);
1770       if (ch === 43 || ch === 45) {
1771         if (CHOMPING_CLIP === chomping) {
1772           chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
1773         } else {
1774           throwError(state, "repeat of a chomping mode identifier");
1775         }
1776       } else if ((tmp = fromDecimalCode(ch)) >= 0) {
1777         if (tmp === 0) {
1778           throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
1779         } else if (!detectedIndent) {
1780           textIndent = nodeIndent + tmp - 1;
1781           detectedIndent = true;
1782         } else {
1783           throwError(state, "repeat of an indentation width identifier");
1784         }
1785       } else {
1786         break;
1787       }
1788     }
1789     if (is_WHITE_SPACE(ch)) {
1790       do {
1791         ch = state.input.charCodeAt(++state.position);
1792       } while (is_WHITE_SPACE(ch));
1793       if (ch === 35) {
1794         do {
1795           ch = state.input.charCodeAt(++state.position);
1796         } while (!is_EOL(ch) && ch !== 0);
1797       }
1798     }
1799     while (ch !== 0) {
1800       readLineBreak(state);
1801       state.lineIndent = 0;
1802       ch = state.input.charCodeAt(state.position);
1803       while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
1804         state.lineIndent++;
1805         ch = state.input.charCodeAt(++state.position);
1806       }
1807       if (!detectedIndent && state.lineIndent > textIndent) {
1808         textIndent = state.lineIndent;
1809       }
1810       if (is_EOL(ch)) {
1811         emptyLines++;
1812         continue;
1813       }
1814       if (state.lineIndent < textIndent) {
1815         if (chomping === CHOMPING_KEEP) {
1816           state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
1817         } else if (chomping === CHOMPING_CLIP) {
1818           if (didReadContent) {
1819             state.result += "\n";
1820           }
1821         }
1822         break;
1823       }
1824       if (folding) {
1825         if (is_WHITE_SPACE(ch)) {
1826           atMoreIndented = true;
1827           state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
1828         } else if (atMoreIndented) {
1829           atMoreIndented = false;
1830           state.result += common.repeat("\n", emptyLines + 1);
1831         } else if (emptyLines === 0) {
1832           if (didReadContent) {
1833             state.result += " ";
1834           }
1835         } else {
1836           state.result += common.repeat("\n", emptyLines);
1837         }
1838       } else {
1839         state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
1840       }
1841       didReadContent = true;
1842       detectedIndent = true;
1843       emptyLines = 0;
1844       captureStart = state.position;
1845       while (!is_EOL(ch) && ch !== 0) {
1846         ch = state.input.charCodeAt(++state.position);
1847       }
1848       captureSegment(state, captureStart, state.position, false);
1849     }
1850     return true;
1851   }
1852   function readBlockSequence(state, nodeIndent) {
1853     var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch;
1854     if (state.anchor !== null) {
1855       state.anchorMap[state.anchor] = _result;
1856     }
1857     ch = state.input.charCodeAt(state.position);
1858     while (ch !== 0) {
1859       if (ch !== 45) {
1860         break;
1861       }
1862       following = state.input.charCodeAt(state.position + 1);
1863       if (!is_WS_OR_EOL(following)) {
1864         break;
1865       }
1866       detected = true;
1867       state.position++;
1868       if (skipSeparationSpace(state, true, -1)) {
1869         if (state.lineIndent <= nodeIndent) {
1870           _result.push(null);
1871           ch = state.input.charCodeAt(state.position);
1872           continue;
1873         }
1874       }
1875       _line = state.line;
1876       composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
1877       _result.push(state.result);
1878       skipSeparationSpace(state, true, -1);
1879       ch = state.input.charCodeAt(state.position);
1880       if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
1881         throwError(state, "bad indentation of a sequence entry");
1882       } else if (state.lineIndent < nodeIndent) {
1883         break;
1884       }
1885     }
1886     if (detected) {
1887       state.tag = _tag;
1888       state.anchor = _anchor;
1889       state.kind = "sequence";
1890       state.result = _result;
1891       return true;
1892     }
1893     return false;
1894   }
1895   function readBlockMapping(state, nodeIndent, flowIndent) {
1896     var following, allowCompact, _line, _pos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = {}, keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
1897     if (state.anchor !== null) {
1898       state.anchorMap[state.anchor] = _result;
1899     }
1900     ch = state.input.charCodeAt(state.position);
1901     while (ch !== 0) {
1902       following = state.input.charCodeAt(state.position + 1);
1903       _line = state.line;
1904       _pos = state.position;
1905       if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) {
1906         if (ch === 63) {
1907           if (atExplicitKey) {
1908             storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
1909             keyTag = keyNode = valueNode = null;
1910           }
1911           detected = true;
1912           atExplicitKey = true;
1913           allowCompact = true;
1914         } else if (atExplicitKey) {
1915           atExplicitKey = false;
1916           allowCompact = true;
1917         } else {
1918           throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
1919         }
1920         state.position += 1;
1921         ch = following;
1922       } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
1923         if (state.line === _line) {
1924           ch = state.input.charCodeAt(state.position);
1925           while (is_WHITE_SPACE(ch)) {
1926             ch = state.input.charCodeAt(++state.position);
1927           }
1928           if (ch === 58) {
1929             ch = state.input.charCodeAt(++state.position);
1930             if (!is_WS_OR_EOL(ch)) {
1931               throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
1932             }
1933             if (atExplicitKey) {
1934               storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
1935               keyTag = keyNode = valueNode = null;
1936             }
1937             detected = true;
1938             atExplicitKey = false;
1939             allowCompact = false;
1940             keyTag = state.tag;
1941             keyNode = state.result;
1942           } else if (detected) {
1943             throwError(state, "can not read an implicit mapping pair; a colon is missed");
1944           } else {
1945             state.tag = _tag;
1946             state.anchor = _anchor;
1947             return true;
1948           }
1949         } else if (detected) {
1950           throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
1951         } else {
1952           state.tag = _tag;
1953           state.anchor = _anchor;
1954           return true;
1955         }
1956       } else {
1957         break;
1958       }
1959       if (state.line === _line || state.lineIndent > nodeIndent) {
1960         if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
1961           if (atExplicitKey) {
1962             keyNode = state.result;
1963           } else {
1964             valueNode = state.result;
1965           }
1966         }
1967         if (!atExplicitKey) {
1968           storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
1969           keyTag = keyNode = valueNode = null;
1970         }
1971         skipSeparationSpace(state, true, -1);
1972         ch = state.input.charCodeAt(state.position);
1973       }
1974       if (state.lineIndent > nodeIndent && ch !== 0) {
1975         throwError(state, "bad indentation of a mapping entry");
1976       } else if (state.lineIndent < nodeIndent) {
1977         break;
1978       }
1979     }
1980     if (atExplicitKey) {
1981       storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
1982     }
1983     if (detected) {
1984       state.tag = _tag;
1985       state.anchor = _anchor;
1986       state.kind = "mapping";
1987       state.result = _result;
1988     }
1989     return detected;
1990   }
1991   function readTagProperty(state) {
1992     var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch;
1993     ch = state.input.charCodeAt(state.position);
1994     if (ch !== 33)
1995       return false;
1996     if (state.tag !== null) {
1997       throwError(state, "duplication of a tag property");
1998     }
1999     ch = state.input.charCodeAt(++state.position);
2000     if (ch === 60) {
2001       isVerbatim = true;
2002       ch = state.input.charCodeAt(++state.position);
2003     } else if (ch === 33) {
2004       isNamed = true;
2005       tagHandle = "!!";
2006       ch = state.input.charCodeAt(++state.position);
2007     } else {
2008       tagHandle = "!";
2009     }
2010     _position = state.position;
2011     if (isVerbatim) {
2012       do {
2013         ch = state.input.charCodeAt(++state.position);
2014       } while (ch !== 0 && ch !== 62);
2015       if (state.position < state.length) {
2016         tagName = state.input.slice(_position, state.position);
2017         ch = state.input.charCodeAt(++state.position);
2018       } else {
2019         throwError(state, "unexpected end of the stream within a verbatim tag");
2020       }
2021     } else {
2022       while (ch !== 0 && !is_WS_OR_EOL(ch)) {
2023         if (ch === 33) {
2024           if (!isNamed) {
2025             tagHandle = state.input.slice(_position - 1, state.position + 1);
2026             if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
2027               throwError(state, "named tag handle cannot contain such characters");
2028             }
2029             isNamed = true;
2030             _position = state.position + 1;
2031           } else {
2032             throwError(state, "tag suffix cannot contain exclamation marks");
2033           }
2034         }
2035         ch = state.input.charCodeAt(++state.position);
2036       }
2037       tagName = state.input.slice(_position, state.position);
2038       if (PATTERN_FLOW_INDICATORS.test(tagName)) {
2039         throwError(state, "tag suffix cannot contain flow indicator characters");
2040       }
2041     }
2042     if (tagName && !PATTERN_TAG_URI.test(tagName)) {
2043       throwError(state, "tag name cannot contain such characters: " + tagName);
2044     }
2045     if (isVerbatim) {
2046       state.tag = tagName;
2047     } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
2048       state.tag = state.tagMap[tagHandle] + tagName;
2049     } else if (tagHandle === "!") {
2050       state.tag = "!" + tagName;
2051     } else if (tagHandle === "!!") {
2052       state.tag = "tag:yaml.org,2002:" + tagName;
2053     } else {
2054       throwError(state, 'undeclared tag handle "' + tagHandle + '"');
2055     }
2056     return true;
2057   }
2058   function readAnchorProperty(state) {
2059     var _position, ch;
2060     ch = state.input.charCodeAt(state.position);
2061     if (ch !== 38)
2062       return false;
2063     if (state.anchor !== null) {
2064       throwError(state, "duplication of an anchor property");
2065     }
2066     ch = state.input.charCodeAt(++state.position);
2067     _position = state.position;
2068     while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
2069       ch = state.input.charCodeAt(++state.position);
2070     }
2071     if (state.position === _position) {
2072       throwError(state, "name of an anchor node must contain at least one character");
2073     }
2074     state.anchor = state.input.slice(_position, state.position);
2075     return true;
2076   }
2077   function readAlias(state) {
2078     var _position, alias, ch;
2079     ch = state.input.charCodeAt(state.position);
2080     if (ch !== 42)
2081       return false;
2082     ch = state.input.charCodeAt(++state.position);
2083     _position = state.position;
2084     while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
2085       ch = state.input.charCodeAt(++state.position);
2086     }
2087     if (state.position === _position) {
2088       throwError(state, "name of an alias node must contain at least one character");
2089     }
2090     alias = state.input.slice(_position, state.position);
2091     if (!_hasOwnProperty.call(state.anchorMap, alias)) {
2092       throwError(state, 'unidentified alias "' + alias + '"');
2093     }
2094     state.result = state.anchorMap[alias];
2095     skipSeparationSpace(state, true, -1);
2096     return true;
2097   }
2098   function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
2099     var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, type, flowIndent, blockIndent;
2100     if (state.listener !== null) {
2101       state.listener("open", state);
2102     }
2103     state.tag = null;
2104     state.anchor = null;
2105     state.kind = null;
2106     state.result = null;
2107     allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
2108     if (allowToSeek) {
2109       if (skipSeparationSpace(state, true, -1)) {
2110         atNewLine = true;
2111         if (state.lineIndent > parentIndent) {
2112           indentStatus = 1;
2113         } else if (state.lineIndent === parentIndent) {
2114           indentStatus = 0;
2115         } else if (state.lineIndent < parentIndent) {
2116           indentStatus = -1;
2117         }
2118       }
2119     }
2120     if (indentStatus === 1) {
2121       while (readTagProperty(state) || readAnchorProperty(state)) {
2122         if (skipSeparationSpace(state, true, -1)) {
2123           atNewLine = true;
2124           allowBlockCollections = allowBlockStyles;
2125           if (state.lineIndent > parentIndent) {
2126             indentStatus = 1;
2127           } else if (state.lineIndent === parentIndent) {
2128             indentStatus = 0;
2129           } else if (state.lineIndent < parentIndent) {
2130             indentStatus = -1;
2131           }
2132         } else {
2133           allowBlockCollections = false;
2134         }
2135       }
2136     }
2137     if (allowBlockCollections) {
2138       allowBlockCollections = atNewLine || allowCompact;
2139     }
2140     if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
2141       if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
2142         flowIndent = parentIndent;
2143       } else {
2144         flowIndent = parentIndent + 1;
2145       }
2146       blockIndent = state.position - state.lineStart;
2147       if (indentStatus === 1) {
2148         if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) {
2149           hasContent = true;
2150         } else {
2151           if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) {
2152             hasContent = true;
2153           } else if (readAlias(state)) {
2154             hasContent = true;
2155             if (state.tag !== null || state.anchor !== null) {
2156               throwError(state, "alias node should not have any properties");
2157             }
2158           } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
2159             hasContent = true;
2160             if (state.tag === null) {
2161               state.tag = "?";
2162             }
2163           }
2164           if (state.anchor !== null) {
2165             state.anchorMap[state.anchor] = state.result;
2166           }
2167         }
2168       } else if (indentStatus === 0) {
2169         hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
2170       }
2171     }
2172     if (state.tag !== null && state.tag !== "!") {
2173       if (state.tag === "?") {
2174         if (state.result !== null && state.kind !== "scalar") {
2175           throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
2176         }
2177         for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
2178           type = state.implicitTypes[typeIndex];
2179           if (type.resolve(state.result)) {
2180             state.result = type.construct(state.result);
2181             state.tag = type.tag;
2182             if (state.anchor !== null) {
2183               state.anchorMap[state.anchor] = state.result;
2184             }
2185             break;
2186           }
2187         }
2188       } else if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) {
2189         type = state.typeMap[state.kind || "fallback"][state.tag];
2190         if (state.result !== null && type.kind !== state.kind) {
2191           throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
2192         }
2193         if (!type.resolve(state.result)) {
2194           throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
2195         } else {
2196           state.result = type.construct(state.result);
2197           if (state.anchor !== null) {
2198             state.anchorMap[state.anchor] = state.result;
2199           }
2200         }
2201       } else {
2202         throwError(state, "unknown tag !<" + state.tag + ">");
2203       }
2204     }
2205     if (state.listener !== null) {
2206       state.listener("close", state);
2207     }
2208     return state.tag !== null || state.anchor !== null || hasContent;
2209   }
2210   function readDocument(state) {
2211     var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch;
2212     state.version = null;
2213     state.checkLineBreaks = state.legacy;
2214     state.tagMap = {};
2215     state.anchorMap = {};
2216     while ((ch = state.input.charCodeAt(state.position)) !== 0) {
2217       skipSeparationSpace(state, true, -1);
2218       ch = state.input.charCodeAt(state.position);
2219       if (state.lineIndent > 0 || ch !== 37) {
2220         break;
2221       }
2222       hasDirectives = true;
2223       ch = state.input.charCodeAt(++state.position);
2224       _position = state.position;
2225       while (ch !== 0 && !is_WS_OR_EOL(ch)) {
2226         ch = state.input.charCodeAt(++state.position);
2227       }
2228       directiveName = state.input.slice(_position, state.position);
2229       directiveArgs = [];
2230       if (directiveName.length < 1) {
2231         throwError(state, "directive name must not be less than one character in length");
2232       }
2233       while (ch !== 0) {
2234         while (is_WHITE_SPACE(ch)) {
2235           ch = state.input.charCodeAt(++state.position);
2236         }
2237         if (ch === 35) {
2238           do {
2239             ch = state.input.charCodeAt(++state.position);
2240           } while (ch !== 0 && !is_EOL(ch));
2241           break;
2242         }
2243         if (is_EOL(ch))
2244           break;
2245         _position = state.position;
2246         while (ch !== 0 && !is_WS_OR_EOL(ch)) {
2247           ch = state.input.charCodeAt(++state.position);
2248         }
2249         directiveArgs.push(state.input.slice(_position, state.position));
2250       }
2251       if (ch !== 0)
2252         readLineBreak(state);
2253       if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
2254         directiveHandlers[directiveName](state, directiveName, directiveArgs);
2255       } else {
2256         throwWarning(state, 'unknown document directive "' + directiveName + '"');
2257       }
2258     }
2259     skipSeparationSpace(state, true, -1);
2260     if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
2261       state.position += 3;
2262       skipSeparationSpace(state, true, -1);
2263     } else if (hasDirectives) {
2264       throwError(state, "directives end mark is expected");
2265     }
2266     composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
2267     skipSeparationSpace(state, true, -1);
2268     if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
2269       throwWarning(state, "non-ASCII line breaks are interpreted as content");
2270     }
2271     state.documents.push(state.result);
2272     if (state.position === state.lineStart && testDocumentSeparator(state)) {
2273       if (state.input.charCodeAt(state.position) === 46) {
2274         state.position += 3;
2275         skipSeparationSpace(state, true, -1);
2276       }
2277       return;
2278     }
2279     if (state.position < state.length - 1) {
2280       throwError(state, "end of the stream or a document separator is expected");
2281     } else {
2282       return;
2283     }
2284   }
2285   function loadDocuments(input, options) {
2286     input = String(input);
2287     options = options || {};
2288     if (input.length !== 0) {
2289       if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) {
2290         input += "\n";
2291       }
2292       if (input.charCodeAt(0) === 65279) {
2293         input = input.slice(1);
2294       }
2295     }
2296     var state = new State(input, options);
2297     var nullpos = input.indexOf("\0");
2298     if (nullpos !== -1) {
2299       state.position = nullpos;
2300       throwError(state, "null byte is not allowed in input");
2301     }
2302     state.input += "\0";
2303     while (state.input.charCodeAt(state.position) === 32) {
2304       state.lineIndent += 1;
2305       state.position += 1;
2306     }
2307     while (state.position < state.length - 1) {
2308       readDocument(state);
2309     }
2310     return state.documents;
2311   }
2312   function loadAll(input, iterator, options) {
2313     if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
2314       options = iterator;
2315       iterator = null;
2316     }
2317     var documents = loadDocuments(input, options);
2318     if (typeof iterator !== "function") {
2319       return documents;
2320     }
2321     for (var index = 0, length = documents.length; index < length; index += 1) {
2322       iterator(documents[index]);
2323     }
2324   }
2325   function load(input, options) {
2326     var documents = loadDocuments(input, options);
2327     if (documents.length === 0) {
2328       return void 0;
2329     } else if (documents.length === 1) {
2330       return documents[0];
2331     }
2332     throw new YAMLException("expected a single document in the stream, but found more");
2333   }
2334   function safeLoadAll(input, iterator, options) {
2335     if (typeof iterator === "object" && iterator !== null && typeof options === "undefined") {
2336       options = iterator;
2337       iterator = null;
2338     }
2339     return loadAll(input, iterator, common.extend({schema: DEFAULT_SAFE_SCHEMA}, options));
2340   }
2341   function safeLoad(input, options) {
2342     return load(input, common.extend({schema: DEFAULT_SAFE_SCHEMA}, options));
2343   }
2344   module2.exports.loadAll = loadAll;
2345   module2.exports.load = load;
2346   module2.exports.safeLoadAll = safeLoadAll;
2347   module2.exports.safeLoad = safeLoad;
2348 });
2349
2350 // node_modules/js-yaml/lib/js-yaml/dumper.js
2351 var require_dumper = __commonJS((exports2, module2) => {
2352   "use strict";
2353   var common = require_common();
2354   var YAMLException = require_exception();
2355   var DEFAULT_FULL_SCHEMA = require_default_full();
2356   var DEFAULT_SAFE_SCHEMA = require_default_safe();
2357   var _toString = Object.prototype.toString;
2358   var _hasOwnProperty = Object.prototype.hasOwnProperty;
2359   var CHAR_TAB = 9;
2360   var CHAR_LINE_FEED = 10;
2361   var CHAR_CARRIAGE_RETURN = 13;
2362   var CHAR_SPACE = 32;
2363   var CHAR_EXCLAMATION = 33;
2364   var CHAR_DOUBLE_QUOTE = 34;
2365   var CHAR_SHARP = 35;
2366   var CHAR_PERCENT = 37;
2367   var CHAR_AMPERSAND = 38;
2368   var CHAR_SINGLE_QUOTE = 39;
2369   var CHAR_ASTERISK = 42;
2370   var CHAR_COMMA = 44;
2371   var CHAR_MINUS = 45;
2372   var CHAR_COLON = 58;
2373   var CHAR_EQUALS = 61;
2374   var CHAR_GREATER_THAN = 62;
2375   var CHAR_QUESTION = 63;
2376   var CHAR_COMMERCIAL_AT = 64;
2377   var CHAR_LEFT_SQUARE_BRACKET = 91;
2378   var CHAR_RIGHT_SQUARE_BRACKET = 93;
2379   var CHAR_GRAVE_ACCENT = 96;
2380   var CHAR_LEFT_CURLY_BRACKET = 123;
2381   var CHAR_VERTICAL_LINE = 124;
2382   var CHAR_RIGHT_CURLY_BRACKET = 125;
2383   var ESCAPE_SEQUENCES = {};
2384   ESCAPE_SEQUENCES[0] = "\\0";
2385   ESCAPE_SEQUENCES[7] = "\\a";
2386   ESCAPE_SEQUENCES[8] = "\\b";
2387   ESCAPE_SEQUENCES[9] = "\\t";
2388   ESCAPE_SEQUENCES[10] = "\\n";
2389   ESCAPE_SEQUENCES[11] = "\\v";
2390   ESCAPE_SEQUENCES[12] = "\\f";
2391   ESCAPE_SEQUENCES[13] = "\\r";
2392   ESCAPE_SEQUENCES[27] = "\\e";
2393   ESCAPE_SEQUENCES[34] = '\\"';
2394   ESCAPE_SEQUENCES[92] = "\\\\";
2395   ESCAPE_SEQUENCES[133] = "\\N";
2396   ESCAPE_SEQUENCES[160] = "\\_";
2397   ESCAPE_SEQUENCES[8232] = "\\L";
2398   ESCAPE_SEQUENCES[8233] = "\\P";
2399   var DEPRECATED_BOOLEANS_SYNTAX = [
2400     "y",
2401     "Y",
2402     "yes",
2403     "Yes",
2404     "YES",
2405     "on",
2406     "On",
2407     "ON",
2408     "n",
2409     "N",
2410     "no",
2411     "No",
2412     "NO",
2413     "off",
2414     "Off",
2415     "OFF"
2416   ];
2417   function compileStyleMap(schema, map) {
2418     var result, keys, index, length, tag, style, type;
2419     if (map === null)
2420       return {};
2421     result = {};
2422     keys = Object.keys(map);
2423     for (index = 0, length = keys.length; index < length; index += 1) {
2424       tag = keys[index];
2425       style = String(map[tag]);
2426       if (tag.slice(0, 2) === "!!") {
2427         tag = "tag:yaml.org,2002:" + tag.slice(2);
2428       }
2429       type = schema.compiledTypeMap["fallback"][tag];
2430       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
2431         style = type.styleAliases[style];
2432       }
2433       result[tag] = style;
2434     }
2435     return result;
2436   }
2437   function encodeHex(character) {
2438     var string, handle, length;
2439     string = character.toString(16).toUpperCase();
2440     if (character <= 255) {
2441       handle = "x";
2442       length = 2;
2443     } else if (character <= 65535) {
2444       handle = "u";
2445       length = 4;
2446     } else if (character <= 4294967295) {
2447       handle = "U";
2448       length = 8;
2449     } else {
2450       throw new YAMLException("code point within a string may not be greater than 0xFFFFFFFF");
2451     }
2452     return "\\" + handle + common.repeat("0", length - string.length) + string;
2453   }
2454   function State(options) {
2455     this.schema = options["schema"] || DEFAULT_FULL_SCHEMA;
2456     this.indent = Math.max(1, options["indent"] || 2);
2457     this.noArrayIndent = options["noArrayIndent"] || false;
2458     this.skipInvalid = options["skipInvalid"] || false;
2459     this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"];
2460     this.styleMap = compileStyleMap(this.schema, options["styles"] || null);
2461     this.sortKeys = options["sortKeys"] || false;
2462     this.lineWidth = options["lineWidth"] || 80;
2463     this.noRefs = options["noRefs"] || false;
2464     this.noCompatMode = options["noCompatMode"] || false;
2465     this.condenseFlow = options["condenseFlow"] || false;
2466     this.implicitTypes = this.schema.compiledImplicit;
2467     this.explicitTypes = this.schema.compiledExplicit;
2468     this.tag = null;
2469     this.result = "";
2470     this.duplicates = [];
2471     this.usedDuplicates = null;
2472   }
2473   function indentString(string, spaces) {
2474     var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string.length;
2475     while (position < length) {
2476       next = string.indexOf("\n", position);
2477       if (next === -1) {
2478         line = string.slice(position);
2479         position = length;
2480       } else {
2481         line = string.slice(position, next + 1);
2482         position = next + 1;
2483       }
2484       if (line.length && line !== "\n")
2485         result += ind;
2486       result += line;
2487     }
2488     return result;
2489   }
2490   function generateNextLine(state, level) {
2491     return "\n" + common.repeat(" ", state.indent * level);
2492   }
2493   function testImplicitResolving(state, str) {
2494     var index, length, type;
2495     for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
2496       type = state.implicitTypes[index];
2497       if (type.resolve(str)) {
2498         return true;
2499       }
2500     }
2501     return false;
2502   }
2503   function isWhitespace(c) {
2504     return c === CHAR_SPACE || c === CHAR_TAB;
2505   }
2506   function isPrintable(c) {
2507     return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== 65279 || 65536 <= c && c <= 1114111;
2508   }
2509   function isNsChar(c) {
2510     return isPrintable(c) && !isWhitespace(c) && c !== 65279 && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
2511   }
2512   function isPlainSafe(c, prev) {
2513     return isPrintable(c) && c !== 65279 && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_COLON && (c !== CHAR_SHARP || prev && isNsChar(prev));
2514   }
2515   function isPlainSafeFirst(c) {
2516     return isPrintable(c) && c !== 65279 && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
2517   }
2518   function needIndentIndicator(string) {
2519     var leadingSpaceRe = /^\n* /;
2520     return leadingSpaceRe.test(string);
2521   }
2522   var STYLE_PLAIN = 1;
2523   var STYLE_SINGLE = 2;
2524   var STYLE_LITERAL = 3;
2525   var STYLE_FOLDED = 4;
2526   var STYLE_DOUBLE = 5;
2527   function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
2528     var i;
2529     var char, prev_char;
2530     var hasLineBreak = false;
2531     var hasFoldableLine = false;
2532     var shouldTrackWidth = lineWidth !== -1;
2533     var previousLineBreak = -1;
2534     var plain = isPlainSafeFirst(string.charCodeAt(0)) && !isWhitespace(string.charCodeAt(string.length - 1));
2535     if (singleLineOnly) {
2536       for (i = 0; i < string.length; i++) {
2537         char = string.charCodeAt(i);
2538         if (!isPrintable(char)) {
2539           return STYLE_DOUBLE;
2540         }
2541         prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
2542         plain = plain && isPlainSafe(char, prev_char);
2543       }
2544     } else {
2545       for (i = 0; i < string.length; i++) {
2546         char = string.charCodeAt(i);
2547         if (char === CHAR_LINE_FEED) {
2548           hasLineBreak = true;
2549           if (shouldTrackWidth) {
2550             hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
2551             previousLineBreak = i;
2552           }
2553         } else if (!isPrintable(char)) {
2554           return STYLE_DOUBLE;
2555         }
2556         prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
2557         plain = plain && isPlainSafe(char, prev_char);
2558       }
2559       hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ");
2560     }
2561     if (!hasLineBreak && !hasFoldableLine) {
2562       return plain && !testAmbiguousType(string) ? STYLE_PLAIN : STYLE_SINGLE;
2563     }
2564     if (indentPerLevel > 9 && needIndentIndicator(string)) {
2565       return STYLE_DOUBLE;
2566     }
2567     return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
2568   }
2569   function writeScalar(state, string, level, iskey) {
2570     state.dump = function() {
2571       if (string.length === 0) {
2572         return "''";
2573       }
2574       if (!state.noCompatMode && DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
2575         return "'" + string + "'";
2576       }
2577       var indent = state.indent * Math.max(1, level);
2578       var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
2579       var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
2580       function testAmbiguity(string2) {
2581         return testImplicitResolving(state, string2);
2582       }
2583       switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
2584         case STYLE_PLAIN:
2585           return string;
2586         case STYLE_SINGLE:
2587           return "'" + string.replace(/'/g, "''") + "'";
2588         case STYLE_LITERAL:
2589           return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
2590         case STYLE_FOLDED:
2591           return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
2592         case STYLE_DOUBLE:
2593           return '"' + escapeString(string, lineWidth) + '"';
2594         default:
2595           throw new YAMLException("impossible error: invalid scalar style");
2596       }
2597     }();
2598   }
2599   function blockHeader(string, indentPerLevel) {
2600     var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
2601     var clip = string[string.length - 1] === "\n";
2602     var keep = clip && (string[string.length - 2] === "\n" || string === "\n");
2603     var chomp = keep ? "+" : clip ? "" : "-";
2604     return indentIndicator + chomp + "\n";
2605   }
2606   function dropEndingNewline(string) {
2607     return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
2608   }
2609   function foldString(string, width) {
2610     var lineRe = /(\n+)([^\n]*)/g;
2611     var result = function() {
2612       var nextLF = string.indexOf("\n");
2613       nextLF = nextLF !== -1 ? nextLF : string.length;
2614       lineRe.lastIndex = nextLF;
2615       return foldLine(string.slice(0, nextLF), width);
2616     }();
2617     var prevMoreIndented = string[0] === "\n" || string[0] === " ";
2618     var moreIndented;
2619     var match;
2620     while (match = lineRe.exec(string)) {
2621       var prefix = match[1], line = match[2];
2622       moreIndented = line[0] === " ";
2623       result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
2624       prevMoreIndented = moreIndented;
2625     }
2626     return result;
2627   }
2628   function foldLine(line, width) {
2629     if (line === "" || line[0] === " ")
2630       return line;
2631     var breakRe = / [^ ]/g;
2632     var match;
2633     var start = 0, end, curr = 0, next = 0;
2634     var result = "";
2635     while (match = breakRe.exec(line)) {
2636       next = match.index;
2637       if (next - start > width) {
2638         end = curr > start ? curr : next;
2639         result += "\n" + line.slice(start, end);
2640         start = end + 1;
2641       }
2642       curr = next;
2643     }
2644     result += "\n";
2645     if (line.length - start > width && curr > start) {
2646       result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
2647     } else {
2648       result += line.slice(start);
2649     }
2650     return result.slice(1);
2651   }
2652   function escapeString(string) {
2653     var result = "";
2654     var char, nextChar;
2655     var escapeSeq;
2656     for (var i = 0; i < string.length; i++) {
2657       char = string.charCodeAt(i);
2658       if (char >= 55296 && char <= 56319) {
2659         nextChar = string.charCodeAt(i + 1);
2660         if (nextChar >= 56320 && nextChar <= 57343) {
2661           result += encodeHex((char - 55296) * 1024 + nextChar - 56320 + 65536);
2662           i++;
2663           continue;
2664         }
2665       }
2666       escapeSeq = ESCAPE_SEQUENCES[char];
2667       result += !escapeSeq && isPrintable(char) ? string[i] : escapeSeq || encodeHex(char);
2668     }
2669     return result;
2670   }
2671   function writeFlowSequence(state, level, object) {
2672     var _result = "", _tag = state.tag, index, length;
2673     for (index = 0, length = object.length; index < length; index += 1) {
2674       if (writeNode(state, level, object[index], false, false)) {
2675         if (index !== 0)
2676           _result += "," + (!state.condenseFlow ? " " : "");
2677         _result += state.dump;
2678       }
2679     }
2680     state.tag = _tag;
2681     state.dump = "[" + _result + "]";
2682   }
2683   function writeBlockSequence(state, level, object, compact) {
2684     var _result = "", _tag = state.tag, index, length;
2685     for (index = 0, length = object.length; index < length; index += 1) {
2686       if (writeNode(state, level + 1, object[index], true, true)) {
2687         if (!compact || index !== 0) {
2688           _result += generateNextLine(state, level);
2689         }
2690         if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
2691           _result += "-";
2692         } else {
2693           _result += "- ";
2694         }
2695         _result += state.dump;
2696       }
2697     }
2698     state.tag = _tag;
2699     state.dump = _result || "[]";
2700   }
2701   function writeFlowMapping(state, level, object) {
2702     var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, pairBuffer;
2703     for (index = 0, length = objectKeyList.length; index < length; index += 1) {
2704       pairBuffer = "";
2705       if (index !== 0)
2706         pairBuffer += ", ";
2707       if (state.condenseFlow)
2708         pairBuffer += '"';
2709       objectKey = objectKeyList[index];
2710       objectValue = object[objectKey];
2711       if (!writeNode(state, level, objectKey, false, false)) {
2712         continue;
2713       }
2714       if (state.dump.length > 1024)
2715         pairBuffer += "? ";
2716       pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
2717       if (!writeNode(state, level, objectValue, false, false)) {
2718         continue;
2719       }
2720       pairBuffer += state.dump;
2721       _result += pairBuffer;
2722     }
2723     state.tag = _tag;
2724     state.dump = "{" + _result + "}";
2725   }
2726   function writeBlockMapping(state, level, object, compact) {
2727     var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
2728     if (state.sortKeys === true) {
2729       objectKeyList.sort();
2730     } else if (typeof state.sortKeys === "function") {
2731       objectKeyList.sort(state.sortKeys);
2732     } else if (state.sortKeys) {
2733       throw new YAMLException("sortKeys must be a boolean or a function");
2734     }
2735     for (index = 0, length = objectKeyList.length; index < length; index += 1) {
2736       pairBuffer = "";
2737       if (!compact || index !== 0) {
2738         pairBuffer += generateNextLine(state, level);
2739       }
2740       objectKey = objectKeyList[index];
2741       objectValue = object[objectKey];
2742       if (!writeNode(state, level + 1, objectKey, true, true, true)) {
2743         continue;
2744       }
2745       explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
2746       if (explicitPair) {
2747         if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
2748           pairBuffer += "?";
2749         } else {
2750           pairBuffer += "? ";
2751         }
2752       }
2753       pairBuffer += state.dump;
2754       if (explicitPair) {
2755         pairBuffer += generateNextLine(state, level);
2756       }
2757       if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
2758         continue;
2759       }
2760       if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
2761         pairBuffer += ":";
2762       } else {
2763         pairBuffer += ": ";
2764       }
2765       pairBuffer += state.dump;
2766       _result += pairBuffer;
2767     }
2768     state.tag = _tag;
2769     state.dump = _result || "{}";
2770   }
2771   function detectType(state, object, explicit) {
2772     var _result, typeList, index, length, type, style;
2773     typeList = explicit ? state.explicitTypes : state.implicitTypes;
2774     for (index = 0, length = typeList.length; index < length; index += 1) {
2775       type = typeList[index];
2776       if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
2777         state.tag = explicit ? type.tag : "?";
2778         if (type.represent) {
2779           style = state.styleMap[type.tag] || type.defaultStyle;
2780           if (_toString.call(type.represent) === "[object Function]") {
2781             _result = type.represent(object, style);
2782           } else if (_hasOwnProperty.call(type.represent, style)) {
2783             _result = type.represent[style](object, style);
2784           } else {
2785             throw new YAMLException("!<" + type.tag + '> tag resolver accepts not "' + style + '" style');
2786           }
2787           state.dump = _result;
2788         }
2789         return true;
2790       }
2791     }
2792     return false;
2793   }
2794   function writeNode(state, level, object, block, compact, iskey) {
2795     state.tag = null;
2796     state.dump = object;
2797     if (!detectType(state, object, false)) {
2798       detectType(state, object, true);
2799     }
2800     var type = _toString.call(state.dump);
2801     if (block) {
2802       block = state.flowLevel < 0 || state.flowLevel > level;
2803     }
2804     var objectOrArray = type === "[object Object]" || type === "[object Array]", duplicateIndex, duplicate;
2805     if (objectOrArray) {
2806       duplicateIndex = state.duplicates.indexOf(object);
2807       duplicate = duplicateIndex !== -1;
2808     }
2809     if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
2810       compact = false;
2811     }
2812     if (duplicate && state.usedDuplicates[duplicateIndex]) {
2813       state.dump = "*ref_" + duplicateIndex;
2814     } else {
2815       if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
2816         state.usedDuplicates[duplicateIndex] = true;
2817       }
2818       if (type === "[object Object]") {
2819         if (block && Object.keys(state.dump).length !== 0) {
2820           writeBlockMapping(state, level, state.dump, compact);
2821           if (duplicate) {
2822             state.dump = "&ref_" + duplicateIndex + state.dump;
2823           }
2824         } else {
2825           writeFlowMapping(state, level, state.dump);
2826           if (duplicate) {
2827             state.dump = "&ref_" + duplicateIndex + " " + state.dump;
2828           }
2829         }
2830       } else if (type === "[object Array]") {
2831         var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level;
2832         if (block && state.dump.length !== 0) {
2833           writeBlockSequence(state, arrayLevel, state.dump, compact);
2834           if (duplicate) {
2835             state.dump = "&ref_" + duplicateIndex + state.dump;
2836           }
2837         } else {
2838           writeFlowSequence(state, arrayLevel, state.dump);
2839           if (duplicate) {
2840             state.dump = "&ref_" + duplicateIndex + " " + state.dump;
2841           }
2842         }
2843       } else if (type === "[object String]") {
2844         if (state.tag !== "?") {
2845           writeScalar(state, state.dump, level, iskey);
2846         }
2847       } else {
2848         if (state.skipInvalid)
2849           return false;
2850         throw new YAMLException("unacceptable kind of an object to dump " + type);
2851       }
2852       if (state.tag !== null && state.tag !== "?") {
2853         state.dump = "!<" + state.tag + "> " + state.dump;
2854       }
2855     }
2856     return true;
2857   }
2858   function getDuplicateReferences(object, state) {
2859     var objects = [], duplicatesIndexes = [], index, length;
2860     inspectNode(object, objects, duplicatesIndexes);
2861     for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
2862       state.duplicates.push(objects[duplicatesIndexes[index]]);
2863     }
2864     state.usedDuplicates = new Array(length);
2865   }
2866   function inspectNode(object, objects, duplicatesIndexes) {
2867     var objectKeyList, index, length;
2868     if (object !== null && typeof object === "object") {
2869       index = objects.indexOf(object);
2870       if (index !== -1) {
2871         if (duplicatesIndexes.indexOf(index) === -1) {
2872           duplicatesIndexes.push(index);
2873         }
2874       } else {
2875         objects.push(object);
2876         if (Array.isArray(object)) {
2877           for (index = 0, length = object.length; index < length; index += 1) {
2878             inspectNode(object[index], objects, duplicatesIndexes);
2879           }
2880         } else {
2881           objectKeyList = Object.keys(object);
2882           for (index = 0, length = objectKeyList.length; index < length; index += 1) {
2883             inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
2884           }
2885         }
2886       }
2887     }
2888   }
2889   function dump(input, options) {
2890     options = options || {};
2891     var state = new State(options);
2892     if (!state.noRefs)
2893       getDuplicateReferences(input, state);
2894     if (writeNode(state, 0, input, true, true))
2895       return state.dump + "\n";
2896     return "";
2897   }
2898   function safeDump(input, options) {
2899     return dump(input, common.extend({schema: DEFAULT_SAFE_SCHEMA}, options));
2900   }
2901   module2.exports.dump = dump;
2902   module2.exports.safeDump = safeDump;
2903 });
2904
2905 // node_modules/js-yaml/lib/js-yaml.js
2906 var require_js_yaml = __commonJS((exports2, module2) => {
2907   "use strict";
2908   var loader = require_loader();
2909   var dumper = require_dumper();
2910   function deprecated(name) {
2911     return function() {
2912       throw new Error("Function " + name + " is deprecated and cannot be used.");
2913     };
2914   }
2915   module2.exports.Type = require_type();
2916   module2.exports.Schema = require_schema();
2917   module2.exports.FAILSAFE_SCHEMA = require_failsafe();
2918   module2.exports.JSON_SCHEMA = require_json();
2919   module2.exports.CORE_SCHEMA = require_core();
2920   module2.exports.DEFAULT_SAFE_SCHEMA = require_default_safe();
2921   module2.exports.DEFAULT_FULL_SCHEMA = require_default_full();
2922   module2.exports.load = loader.load;
2923   module2.exports.loadAll = loader.loadAll;
2924   module2.exports.safeLoad = loader.safeLoad;
2925   module2.exports.safeLoadAll = loader.safeLoadAll;
2926   module2.exports.dump = dumper.dump;
2927   module2.exports.safeDump = dumper.safeDump;
2928   module2.exports.YAMLException = require_exception();
2929   module2.exports.MINIMAL_SCHEMA = require_failsafe();
2930   module2.exports.SAFE_SCHEMA = require_default_safe();
2931   module2.exports.DEFAULT_SCHEMA = require_default_full();
2932   module2.exports.scan = deprecated("scan");
2933   module2.exports.parse = deprecated("parse");
2934   module2.exports.compose = deprecated("compose");
2935   module2.exports.addConstructor = deprecated("addConstructor");
2936 });
2937
2938 // node_modules/js-yaml/index.js
2939 var require_js_yaml2 = __commonJS((exports2, module2) => {
2940   "use strict";
2941   var yaml = require_js_yaml();
2942   module2.exports = yaml;
2943 });
2944
2945 // node_modules/entities/lib/maps/entities.json
2946 var require_entities = __commonJS((exports2, module2) => {
2947   module2.exports = {Aacute: "\xC1", aacute: "\xE1", Abreve: "\u0102", abreve: "\u0103", ac: "\u223E", acd: "\u223F", acE: "\u223E\u0333", Acirc: "\xC2", acirc: "\xE2", acute: "\xB4", Acy: "\u0410", acy: "\u0430", AElig: "\xC6", aelig: "\xE6", af: "\u2061", Afr: "\u{1D504}", afr: "\u{1D51E}", Agrave: "\xC0", agrave: "\xE0", alefsym: "\u2135", aleph: "\u2135", Alpha: "\u0391", alpha: "\u03B1", Amacr: "\u0100", amacr: "\u0101", amalg: "\u2A3F", amp: "&", AMP: "&", andand: "\u2A55", And: "\u2A53", and: "\u2227", andd: "\u2A5C", andslope: "\u2A58", andv: "\u2A5A", ang: "\u2220", ange: "\u29A4", angle: "\u2220", angmsdaa: "\u29A8", angmsdab: "\u29A9", angmsdac: "\u29AA", angmsdad: "\u29AB", angmsdae: "\u29AC", angmsdaf: "\u29AD", angmsdag: "\u29AE", angmsdah: "\u29AF", angmsd: "\u2221", angrt: "\u221F", angrtvb: "\u22BE", angrtvbd: "\u299D", angsph: "\u2222", angst: "\xC5", angzarr: "\u237C", Aogon: "\u0104", aogon: "\u0105", Aopf: "\u{1D538}", aopf: "\u{1D552}", apacir: "\u2A6F", ap: "\u2248", apE: "\u2A70", ape: "\u224A", apid: "\u224B", apos: "'", ApplyFunction: "\u2061", approx: "\u2248", approxeq: "\u224A", Aring: "\xC5", aring: "\xE5", Ascr: "\u{1D49C}", ascr: "\u{1D4B6}", Assign: "\u2254", ast: "*", asymp: "\u2248", asympeq: "\u224D", Atilde: "\xC3", atilde: "\xE3", Auml: "\xC4", auml: "\xE4", awconint: "\u2233", awint: "\u2A11", backcong: "\u224C", backepsilon: "\u03F6", backprime: "\u2035", backsim: "\u223D", backsimeq: "\u22CD", Backslash: "\u2216", Barv: "\u2AE7", barvee: "\u22BD", barwed: "\u2305", Barwed: "\u2306", barwedge: "\u2305", bbrk: "\u23B5", bbrktbrk: "\u23B6", bcong: "\u224C", Bcy: "\u0411", bcy: "\u0431", bdquo: "\u201E", becaus: "\u2235", because: "\u2235", Because: "\u2235", bemptyv: "\u29B0", bepsi: "\u03F6", bernou: "\u212C", Bernoullis: "\u212C", Beta: "\u0392", beta: "\u03B2", beth: "\u2136", between: "\u226C", Bfr: "\u{1D505}", bfr: "\u{1D51F}", bigcap: "\u22C2", bigcirc: "\u25EF", bigcup: "\u22C3", bigodot: "\u2A00", bigoplus: "\u2A01", bigotimes: "\u2A02", bigsqcup: "\u2A06", bigstar: "\u2605", bigtriangledown: "\u25BD", bigtriangleup: "\u25B3", biguplus: "\u2A04", bigvee: "\u22C1", bigwedge: "\u22C0", bkarow: "\u290D", blacklozenge: "\u29EB", blacksquare: "\u25AA", blacktriangle: "\u25B4", blacktriangledown: "\u25BE", blacktriangleleft: "\u25C2", blacktriangleright: "\u25B8", blank: "\u2423", blk12: "\u2592", blk14: "\u2591", blk34: "\u2593", block: "\u2588", bne: "=\u20E5", bnequiv: "\u2261\u20E5", bNot: "\u2AED", bnot: "\u2310", Bopf: "\u{1D539}", bopf: "\u{1D553}", bot: "\u22A5", bottom: "\u22A5", bowtie: "\u22C8", boxbox: "\u29C9", boxdl: "\u2510", boxdL: "\u2555", boxDl: "\u2556", boxDL: "\u2557", boxdr: "\u250C", boxdR: "\u2552", boxDr: "\u2553", boxDR: "\u2554", boxh: "\u2500", boxH: "\u2550", boxhd: "\u252C", boxHd: "\u2564", boxhD: "\u2565", boxHD: "\u2566", boxhu: "\u2534", boxHu: "\u2567", boxhU: "\u2568", boxHU: "\u2569", boxminus: "\u229F", boxplus: "\u229E", boxtimes: "\u22A0", boxul: "\u2518", boxuL: "\u255B", boxUl: "\u255C", boxUL: "\u255D", boxur: "\u2514", boxuR: "\u2558", boxUr: "\u2559", boxUR: "\u255A", boxv: "\u2502", boxV: "\u2551", boxvh: "\u253C", boxvH: "\u256A", boxVh: "\u256B", boxVH: "\u256C", boxvl: "\u2524", boxvL: "\u2561", boxVl: "\u2562", boxVL: "\u2563", boxvr: "\u251C", boxvR: "\u255E", boxVr: "\u255F", boxVR: "\u2560", bprime: "\u2035", breve: "\u02D8", Breve: "\u02D8", brvbar: "\xA6", bscr: "\u{1D4B7}", Bscr: "\u212C", bsemi: "\u204F", bsim: "\u223D", bsime: "\u22CD", bsolb: "\u29C5", bsol: "\\", bsolhsub: "\u27C8", bull: "\u2022", bullet: "\u2022", bump: "\u224E", bumpE: "\u2AAE", bumpe: "\u224F", Bumpeq: "\u224E", bumpeq: "\u224F", Cacute: "\u0106", cacute: "\u0107", capand: "\u2A44", capbrcup: "\u2A49", capcap: "\u2A4B", cap: "\u2229", Cap: "\u22D2", capcup: "\u2A47", capdot: "\u2A40", CapitalDifferentialD: "\u2145", caps: "\u2229\uFE00", caret: "\u2041", caron: "\u02C7", Cayleys: "\u212D", ccaps: "\u2A4D", Ccaron: "\u010C", ccaron: "\u010D", Ccedil: "\xC7", ccedil: "\xE7", Ccirc: "\u0108", ccirc: "\u0109", Cconint: "\u2230", ccups: "\u2A4C", ccupssm: "\u2A50", Cdot: "\u010A", cdot: "\u010B", cedil: "\xB8", Cedilla: "\xB8", cemptyv: "\u29B2", cent: "\xA2", centerdot: "\xB7", CenterDot: "\xB7", cfr: "\u{1D520}", Cfr: "\u212D", CHcy: "\u0427", chcy: "\u0447", check: "\u2713", checkmark: "\u2713", Chi: "\u03A7", chi: "\u03C7", circ: "\u02C6", circeq: "\u2257", circlearrowleft: "\u21BA", circlearrowright: "\u21BB", circledast: "\u229B", circledcirc: "\u229A", circleddash: "\u229D", CircleDot: "\u2299", circledR: "\xAE", circledS: "\u24C8", CircleMinus: "\u2296", CirclePlus: "\u2295", CircleTimes: "\u2297", cir: "\u25CB", cirE: "\u29C3", cire: "\u2257", cirfnint: "\u2A10", cirmid: "\u2AEF", cirscir: "\u29C2", ClockwiseContourIntegral: "\u2232", CloseCurlyDoubleQuote: "\u201D", CloseCurlyQuote: "\u2019", clubs: "\u2663", clubsuit: "\u2663", colon: ":", Colon: "\u2237", Colone: "\u2A74", colone: "\u2254", coloneq: "\u2254", comma: ",", commat: "@", comp: "\u2201", compfn: "\u2218", complement: "\u2201", complexes: "\u2102", cong: "\u2245", congdot: "\u2A6D", Congruent: "\u2261", conint: "\u222E", Conint: "\u222F", ContourIntegral: "\u222E", copf: "\u{1D554}", Copf: "\u2102", coprod: "\u2210", Coproduct: "\u2210", copy: "\xA9", COPY: "\xA9", copysr: "\u2117", CounterClockwiseContourIntegral: "\u2233", crarr: "\u21B5", cross: "\u2717", Cross: "\u2A2F", Cscr: "\u{1D49E}", cscr: "\u{1D4B8}", csub: "\u2ACF", csube: "\u2AD1", csup: "\u2AD0", csupe: "\u2AD2", ctdot: "\u22EF", cudarrl: "\u2938", cudarrr: "\u2935", cuepr: "\u22DE", cuesc: "\u22DF", cularr: "\u21B6", cularrp: "\u293D", cupbrcap: "\u2A48", cupcap: "\u2A46", CupCap: "\u224D", cup: "\u222A", Cup: "\u22D3", cupcup: "\u2A4A", cupdot: "\u228D", cupor: "\u2A45", cups: "\u222A\uFE00", curarr: "\u21B7", curarrm: "\u293C", curlyeqprec: "\u22DE", curlyeqsucc: "\u22DF", curlyvee: "\u22CE", curlywedge: "\u22CF", curren: "\xA4", curvearrowleft: "\u21B6", curvearrowright: "\u21B7", cuvee: "\u22CE", cuwed: "\u22CF", cwconint: "\u2232", cwint: "\u2231", cylcty: "\u232D", dagger: "\u2020", Dagger: "\u2021", daleth: "\u2138", darr: "\u2193", Darr: "\u21A1", dArr: "\u21D3", dash: "\u2010", Dashv: "\u2AE4", dashv: "\u22A3", dbkarow: "\u290F", dblac: "\u02DD", Dcaron: "\u010E", dcaron: "\u010F", Dcy: "\u0414", dcy: "\u0434", ddagger: "\u2021", ddarr: "\u21CA", DD: "\u2145", dd: "\u2146", DDotrahd: "\u2911", ddotseq: "\u2A77", deg: "\xB0", Del: "\u2207", Delta: "\u0394", delta: "\u03B4", demptyv: "\u29B1", dfisht: "\u297F", Dfr: "\u{1D507}", dfr: "\u{1D521}", dHar: "\u2965", dharl: "\u21C3", dharr: "\u21C2", DiacriticalAcute: "\xB4", DiacriticalDot: "\u02D9", DiacriticalDoubleAcute: "\u02DD", DiacriticalGrave: "`", DiacriticalTilde: "\u02DC", diam: "\u22C4", diamond: "\u22C4", Diamond: "\u22C4", diamondsuit: "\u2666", diams: "\u2666", die: "\xA8", DifferentialD: "\u2146", digamma: "\u03DD", disin: "\u22F2", div: "\xF7", divide: "\xF7", divideontimes: "\u22C7", divonx: "\u22C7", DJcy: "\u0402", djcy: "\u0452", dlcorn: "\u231E", dlcrop: "\u230D", dollar: "$", Dopf: "\u{1D53B}", dopf: "\u{1D555}", Dot: "\xA8", dot: "\u02D9", DotDot: "\u20DC", doteq: "\u2250", doteqdot: "\u2251", DotEqual: "\u2250", dotminus: "\u2238", dotplus: "\u2214", dotsquare: "\u22A1", doublebarwedge: "\u2306", DoubleContourIntegral: "\u222F", DoubleDot: "\xA8", DoubleDownArrow: "\u21D3", DoubleLeftArrow: "\u21D0", DoubleLeftRightArrow: "\u21D4", DoubleLeftTee: "\u2AE4", DoubleLongLeftArrow: "\u27F8", DoubleLongLeftRightArrow: "\u27FA", DoubleLongRightArrow: "\u27F9", DoubleRightArrow: "\u21D2", DoubleRightTee: "\u22A8", DoubleUpArrow: "\u21D1", DoubleUpDownArrow: "\u21D5", DoubleVerticalBar: "\u2225", DownArrowBar: "\u2913", downarrow: "\u2193", DownArrow: "\u2193", Downarrow: "\u21D3", DownArrowUpArrow: "\u21F5", DownBreve: "\u0311", downdownarrows: "\u21CA", downharpoonleft: "\u21C3", downharpoonright: "\u21C2", DownLeftRightVector: "\u2950", DownLeftTeeVector: "\u295E", DownLeftVectorBar: "\u2956", DownLeftVector: "\u21BD", DownRightTeeVector: "\u295F", DownRightVectorBar: "\u2957", DownRightVector: "\u21C1", DownTeeArrow: "\u21A7", DownTee: "\u22A4", drbkarow: "\u2910", drcorn: "\u231F", drcrop: "\u230C", Dscr: "\u{1D49F}", dscr: "\u{1D4B9}", DScy: "\u0405", dscy: "\u0455", dsol: "\u29F6", Dstrok: "\u0110", dstrok: "\u0111", dtdot: "\u22F1", dtri: "\u25BF", dtrif: "\u25BE", duarr: "\u21F5", duhar: "\u296F", dwangle: "\u29A6", DZcy: "\u040F", dzcy: "\u045F", dzigrarr: "\u27FF", Eacute: "\xC9", eacute: "\xE9", easter: "\u2A6E", Ecaron: "\u011A", ecaron: "\u011B", Ecirc: "\xCA", ecirc: "\xEA", ecir: "\u2256", ecolon: "\u2255", Ecy: "\u042D", ecy: "\u044D", eDDot: "\u2A77", Edot: "\u0116", edot: "\u0117", eDot: "\u2251", ee: "\u2147", efDot: "\u2252", Efr: "\u{1D508}", efr: "\u{1D522}", eg: "\u2A9A", Egrave: "\xC8", egrave: "\xE8", egs: "\u2A96", egsdot: "\u2A98", el: "\u2A99", Element: "\u2208", elinters: "\u23E7", ell: "\u2113", els: "\u2A95", elsdot: "\u2A97", Emacr: "\u0112", emacr: "\u0113", empty: "\u2205", emptyset: "\u2205", EmptySmallSquare: "\u25FB", emptyv: "\u2205", EmptyVerySmallSquare: "\u25AB", emsp13: "\u2004", emsp14: "\u2005", emsp: "\u2003", ENG: "\u014A", eng: "\u014B", ensp: "\u2002", Eogon: "\u0118", eogon: "\u0119", Eopf: "\u{1D53C}", eopf: "\u{1D556}", epar: "\u22D5", eparsl: "\u29E3", eplus: "\u2A71", epsi: "\u03B5", Epsilon: "\u0395", epsilon: "\u03B5", epsiv: "\u03F5", eqcirc: "\u2256", eqcolon: "\u2255", eqsim: "\u2242", eqslantgtr: "\u2A96", eqslantless: "\u2A95", Equal: "\u2A75", equals: "=", EqualTilde: "\u2242", equest: "\u225F", Equilibrium: "\u21CC", equiv: "\u2261", equivDD: "\u2A78", eqvparsl: "\u29E5", erarr: "\u2971", erDot: "\u2253", escr: "\u212F", Escr: "\u2130", esdot: "\u2250", Esim: "\u2A73", esim: "\u2242", Eta: "\u0397", eta: "\u03B7", ETH: "\xD0", eth: "\xF0", Euml: "\xCB", euml: "\xEB", euro: "\u20AC", excl: "!", exist: "\u2203", Exists: "\u2203", expectation: "\u2130", exponentiale: "\u2147", ExponentialE: "\u2147", fallingdotseq: "\u2252", Fcy: "\u0424", fcy: "\u0444", female: "\u2640", ffilig: "\uFB03", fflig: "\uFB00", ffllig: "\uFB04", Ffr: "\u{1D509}", ffr: "\u{1D523}", filig: "\uFB01", FilledSmallSquare: "\u25FC", FilledVerySmallSquare: "\u25AA", fjlig: "fj", flat: "\u266D", fllig: "\uFB02", fltns: "\u25B1", fnof: "\u0192", Fopf: "\u{1D53D}", fopf: "\u{1D557}", forall: "\u2200", ForAll: "\u2200", fork: "\u22D4", forkv: "\u2AD9", Fouriertrf: "\u2131", fpartint: "\u2A0D", frac12: "\xBD", frac13: "\u2153", frac14: "\xBC", frac15: "\u2155", frac16: "\u2159", frac18: "\u215B", frac23: "\u2154", frac25: "\u2156", frac34: "\xBE", frac35: "\u2157", frac38: "\u215C", frac45: "\u2158", frac56: "\u215A", frac58: "\u215D", frac78: "\u215E", frasl: "\u2044", frown: "\u2322", fscr: "\u{1D4BB}", Fscr: "\u2131", gacute: "\u01F5", Gamma: "\u0393", gamma: "\u03B3", Gammad: "\u03DC", gammad: "\u03DD", gap: "\u2A86", Gbreve: "\u011E", gbreve: "\u011F", Gcedil: "\u0122", Gcirc: "\u011C", gcirc: "\u011D", Gcy: "\u0413", gcy: "\u0433", Gdot: "\u0120", gdot: "\u0121", ge: "\u2265", gE: "\u2267", gEl: "\u2A8C", gel: "\u22DB", geq: "\u2265", geqq: "\u2267", geqslant: "\u2A7E", gescc: "\u2AA9", ges: "\u2A7E", gesdot: "\u2A80", gesdoto: "\u2A82", gesdotol: "\u2A84", gesl: "\u22DB\uFE00", gesles: "\u2A94", Gfr: "\u{1D50A}", gfr: "\u{1D524}", gg: "\u226B", Gg: "\u22D9", ggg: "\u22D9", gimel: "\u2137", GJcy: "\u0403", gjcy: "\u0453", gla: "\u2AA5", gl: "\u2277", glE: "\u2A92", glj: "\u2AA4", gnap: "\u2A8A", gnapprox: "\u2A8A", gne: "\u2A88", gnE: "\u2269", gneq: "\u2A88", gneqq: "\u2269", gnsim: "\u22E7", Gopf: "\u{1D53E}", gopf: "\u{1D558}", grave: "`", GreaterEqual: "\u2265", GreaterEqualLess: "\u22DB", GreaterFullEqual: "\u2267", GreaterGreater: "\u2AA2", GreaterLess: "\u2277", GreaterSlantEqual: "\u2A7E", GreaterTilde: "\u2273", Gscr: "\u{1D4A2}", gscr: "\u210A", gsim: "\u2273", gsime: "\u2A8E", gsiml: "\u2A90", gtcc: "\u2AA7", gtcir: "\u2A7A", gt: ">", GT: ">", Gt: "\u226B", gtdot: "\u22D7", gtlPar: "\u2995", gtquest: "\u2A7C", gtrapprox: "\u2A86", gtrarr: "\u2978", gtrdot: "\u22D7", gtreqless: "\u22DB", gtreqqless: "\u2A8C", gtrless: "\u2277", gtrsim: "\u2273", gvertneqq: "\u2269\uFE00", gvnE: "\u2269\uFE00", Hacek: "\u02C7", hairsp: "\u200A", half: "\xBD", hamilt: "\u210B", HARDcy: "\u042A", hardcy: "\u044A", harrcir: "\u2948", harr: "\u2194", hArr: "\u21D4", harrw: "\u21AD", Hat: "^", hbar: "\u210F", Hcirc: "\u0124", hcirc: "\u0125", hearts: "\u2665", heartsuit: "\u2665", hellip: "\u2026", hercon: "\u22B9", hfr: "\u{1D525}", Hfr: "\u210C", HilbertSpace: "\u210B", hksearow: "\u2925", hkswarow: "\u2926", hoarr: "\u21FF", homtht: "\u223B", hookleftarrow: "\u21A9", hookrightarrow: "\u21AA", hopf: "\u{1D559}", Hopf: "\u210D", horbar: "\u2015", HorizontalLine: "\u2500", hscr: "\u{1D4BD}", Hscr: "\u210B", hslash: "\u210F", Hstrok: "\u0126", hstrok: "\u0127", HumpDownHump: "\u224E", HumpEqual: "\u224F", hybull: "\u2043", hyphen: "\u2010", Iacute: "\xCD", iacute: "\xED", ic: "\u2063", Icirc: "\xCE", icirc: "\xEE", Icy: "\u0418", icy: "\u0438", Idot: "\u0130", IEcy: "\u0415", iecy: "\u0435", iexcl: "\xA1", iff: "\u21D4", ifr: "\u{1D526}", Ifr: "\u2111", Igrave: "\xCC", igrave: "\xEC", ii: "\u2148", iiiint: "\u2A0C", iiint: "\u222D", iinfin: "\u29DC", iiota: "\u2129", IJlig: "\u0132", ijlig: "\u0133", Imacr: "\u012A", imacr: "\u012B", image: "\u2111", ImaginaryI: "\u2148", imagline: "\u2110", imagpart: "\u2111", imath: "\u0131", Im: "\u2111", imof: "\u22B7", imped: "\u01B5", Implies: "\u21D2", incare: "\u2105", in: "\u2208", infin: "\u221E", infintie: "\u29DD", inodot: "\u0131", intcal: "\u22BA", int: "\u222B", Int: "\u222C", integers: "\u2124", Integral: "\u222B", intercal: "\u22BA", Intersection: "\u22C2", intlarhk: "\u2A17", intprod: "\u2A3C", InvisibleComma: "\u2063", InvisibleTimes: "\u2062", IOcy: "\u0401", iocy: "\u0451", Iogon: "\u012E", iogon: "\u012F", Iopf: "\u{1D540}", iopf: "\u{1D55A}", Iota: "\u0399", iota: "\u03B9", iprod: "\u2A3C", iquest: "\xBF", iscr: "\u{1D4BE}", Iscr: "\u2110", isin: "\u2208", isindot: "\u22F5", isinE: "\u22F9", isins: "\u22F4", isinsv: "\u22F3", isinv: "\u2208", it: "\u2062", Itilde: "\u0128", itilde: "\u0129", Iukcy: "\u0406", iukcy: "\u0456", Iuml: "\xCF", iuml: "\xEF", Jcirc: "\u0134", jcirc: "\u0135", Jcy: "\u0419", jcy: "\u0439", Jfr: "\u{1D50D}", jfr: "\u{1D527}", jmath: "\u0237", Jopf: "\u{1D541}", jopf: "\u{1D55B}", Jscr: "\u{1D4A5}", jscr: "\u{1D4BF}", Jsercy: "\u0408", jsercy: "\u0458", Jukcy: "\u0404", jukcy: "\u0454", Kappa: "\u039A", kappa: "\u03BA", kappav: "\u03F0", Kcedil: "\u0136", kcedil: "\u0137", Kcy: "\u041A", kcy: "\u043A", Kfr: "\u{1D50E}", kfr: "\u{1D528}", kgreen: "\u0138", KHcy: "\u0425", khcy: "\u0445", KJcy: "\u040C", kjcy: "\u045C", Kopf: "\u{1D542}", kopf: "\u{1D55C}", Kscr: "\u{1D4A6}", kscr: "\u{1D4C0}", lAarr: "\u21DA", Lacute: "\u0139", lacute: "\u013A", laemptyv: "\u29B4", lagran: "\u2112", Lambda: "\u039B", lambda: "\u03BB", lang: "\u27E8", Lang: "\u27EA", langd: "\u2991", langle: "\u27E8", lap: "\u2A85", Laplacetrf: "\u2112", laquo: "\xAB", larrb: "\u21E4", larrbfs: "\u291F", larr: "\u2190", Larr: "\u219E", lArr: "\u21D0", larrfs: "\u291D", larrhk: "\u21A9", larrlp: "\u21AB", larrpl: "\u2939", larrsim: "\u2973", larrtl: "\u21A2", latail: "\u2919", lAtail: "\u291B", lat: "\u2AAB", late: "\u2AAD", lates: "\u2AAD\uFE00", lbarr: "\u290C", lBarr: "\u290E", lbbrk: "\u2772", lbrace: "{", lbrack: "[", lbrke: "\u298B", lbrksld: "\u298F", lbrkslu: "\u298D", Lcaron: "\u013D", lcaron: "\u013E", Lcedil: "\u013B", lcedil: "\u013C", lceil: "\u2308", lcub: "{", Lcy: "\u041B", lcy: "\u043B", ldca: "\u2936", ldquo: "\u201C", ldquor: "\u201E", ldrdhar: "\u2967", ldrushar: "\u294B", ldsh: "\u21B2", le: "\u2264", lE: "\u2266", LeftAngleBracket: "\u27E8", LeftArrowBar: "\u21E4", leftarrow: "\u2190", LeftArrow: "\u2190", Leftarrow: "\u21D0", LeftArrowRightArrow: "\u21C6", leftarrowtail: "\u21A2", LeftCeiling: "\u2308", LeftDoubleBracket: "\u27E6", LeftDownTeeVector: "\u2961", LeftDownVectorBar: "\u2959", LeftDownVector: "\u21C3", LeftFloor: "\u230A", leftharpoondown: "\u21BD", leftharpoonup: "\u21BC", leftleftarrows: "\u21C7", leftrightarrow: "\u2194", LeftRightArrow: "\u2194", Leftrightarrow: "\u21D4", leftrightarrows: "\u21C6", leftrightharpoons: "\u21CB", leftrightsquigarrow: "\u21AD", LeftRightVector: "\u294E", LeftTeeArrow: "\u21A4", LeftTee: "\u22A3", LeftTeeVector: "\u295A", leftthreetimes: "\u22CB", LeftTriangleBar: "\u29CF", LeftTriangle: "\u22B2", LeftTriangleEqual: "\u22B4", LeftUpDownVector: "\u2951", LeftUpTeeVector: "\u2960", LeftUpVectorBar: "\u2958", LeftUpVector: "\u21BF", LeftVectorBar: "\u2952", LeftVector: "\u21BC", lEg: "\u2A8B", leg: "\u22DA", leq: "\u2264", leqq: "\u2266", leqslant: "\u2A7D", lescc: "\u2AA8", les: "\u2A7D", lesdot: "\u2A7F", lesdoto: "\u2A81", lesdotor: "\u2A83", lesg: "\u22DA\uFE00", lesges: "\u2A93", lessapprox: "\u2A85", lessdot: "\u22D6", lesseqgtr: "\u22DA", lesseqqgtr: "\u2A8B", LessEqualGreater: "\u22DA", LessFullEqual: "\u2266", LessGreater: "\u2276", lessgtr: "\u2276", LessLess: "\u2AA1", lesssim: "\u2272", LessSlantEqual: "\u2A7D", LessTilde: "\u2272", lfisht: "\u297C", lfloor: "\u230A", Lfr: "\u{1D50F}", lfr: "\u{1D529}", lg: "\u2276", lgE: "\u2A91", lHar: "\u2962", lhard: "\u21BD", lharu: "\u21BC", lharul: "\u296A", lhblk: "\u2584", LJcy: "\u0409", ljcy: "\u0459", llarr: "\u21C7", ll: "\u226A", Ll: "\u22D8", llcorner: "\u231E", Lleftarrow: "\u21DA", llhard: "\u296B", lltri: "\u25FA", Lmidot: "\u013F", lmidot: "\u0140", lmoustache: "\u23B0", lmoust: "\u23B0", lnap: "\u2A89", lnapprox: "\u2A89", lne: "\u2A87", lnE: "\u2268", lneq: "\u2A87", lneqq: "\u2268", lnsim: "\u22E6", loang: "\u27EC", loarr: "\u21FD", lobrk: "\u27E6", longleftarrow: "\u27F5", LongLeftArrow: "\u27F5", Longleftarrow: "\u27F8", longleftrightarrow: "\u27F7", LongLeftRightArrow: "\u27F7", Longleftrightarrow: "\u27FA", longmapsto: "\u27FC", longrightarrow: "\u27F6", LongRightArrow: "\u27F6", Longrightarrow: "\u27F9", looparrowleft: "\u21AB", looparrowright: "\u21AC", lopar: "\u2985", Lopf: "\u{1D543}", lopf: "\u{1D55D}", loplus: "\u2A2D", lotimes: "\u2A34", lowast: "\u2217", lowbar: "_", LowerLeftArrow: "\u2199", LowerRightArrow: "\u2198", loz: "\u25CA", lozenge: "\u25CA", lozf: "\u29EB", lpar: "(", lparlt: "\u2993", lrarr: "\u21C6", lrcorner: "\u231F", lrhar: "\u21CB", lrhard: "\u296D", lrm: "\u200E", lrtri: "\u22BF", lsaquo: "\u2039", lscr: "\u{1D4C1}", Lscr: "\u2112", lsh: "\u21B0", Lsh: "\u21B0", lsim: "\u2272", lsime: "\u2A8D", lsimg: "\u2A8F", lsqb: "[", lsquo: "\u2018", lsquor: "\u201A", Lstrok: "\u0141", lstrok: "\u0142", ltcc: "\u2AA6", ltcir: "\u2A79", lt: "<", LT: "<", Lt: "\u226A", ltdot: "\u22D6", lthree: "\u22CB", ltimes: "\u22C9", ltlarr: "\u2976", ltquest: "\u2A7B", ltri: "\u25C3", ltrie: "\u22B4", ltrif: "\u25C2", ltrPar: "\u2996", lurdshar: "\u294A", luruhar: "\u2966", lvertneqq: "\u2268\uFE00", lvnE: "\u2268\uFE00", macr: "\xAF", male: "\u2642", malt: "\u2720", maltese: "\u2720", Map: "\u2905", map: "\u21A6", mapsto: "\u21A6", mapstodown: "\u21A7", mapstoleft: "\u21A4", mapstoup: "\u21A5", marker: "\u25AE", mcomma: "\u2A29", Mcy: "\u041C", mcy: "\u043C", mdash: "\u2014", mDDot: "\u223A", measuredangle: "\u2221", MediumSpace: "\u205F", Mellintrf: "\u2133", Mfr: "\u{1D510}", mfr: "\u{1D52A}", mho: "\u2127", micro: "\xB5", midast: "*", midcir: "\u2AF0", mid: "\u2223", middot: "\xB7", minusb: "\u229F", minus: "\u2212", minusd: "\u2238", minusdu: "\u2A2A", MinusPlus: "\u2213", mlcp: "\u2ADB", mldr: "\u2026", mnplus: "\u2213", models: "\u22A7", Mopf: "\u{1D544}", mopf: "\u{1D55E}", mp: "\u2213", mscr: "\u{1D4C2}", Mscr: "\u2133", mstpos: "\u223E", Mu: "\u039C", mu: "\u03BC", multimap: "\u22B8", mumap: "\u22B8", nabla: "\u2207", Nacute: "\u0143", nacute: "\u0144", nang: "\u2220\u20D2", nap: "\u2249", napE: "\u2A70\u0338", napid: "\u224B\u0338", napos: "\u0149", napprox: "\u2249", natural: "\u266E", naturals: "\u2115", natur: "\u266E", nbsp: "\xA0", nbump: "\u224E\u0338", nbumpe: "\u224F\u0338", ncap: "\u2A43", Ncaron: "\u0147", ncaron: "\u0148", Ncedil: "\u0145", ncedil: "\u0146", ncong: "\u2247", ncongdot: "\u2A6D\u0338", ncup: "\u2A42", Ncy: "\u041D", ncy: "\u043D", ndash: "\u2013", nearhk: "\u2924", nearr: "\u2197", neArr: "\u21D7", nearrow: "\u2197", ne: "\u2260", nedot: "\u2250\u0338", NegativeMediumSpace: "\u200B", NegativeThickSpace: "\u200B", NegativeThinSpace: "\u200B", NegativeVeryThinSpace: "\u200B", nequiv: "\u2262", nesear: "\u2928", nesim: "\u2242\u0338", NestedGreaterGreater: "\u226B", NestedLessLess: "\u226A", NewLine: "\n", nexist: "\u2204", nexists: "\u2204", Nfr: "\u{1D511}", nfr: "\u{1D52B}", ngE: "\u2267\u0338", nge: "\u2271", ngeq: "\u2271", ngeqq: "\u2267\u0338", ngeqslant: "\u2A7E\u0338", nges: "\u2A7E\u0338", nGg: "\u22D9\u0338", ngsim: "\u2275", nGt: "\u226B\u20D2", ngt: "\u226F", ngtr: "\u226F", nGtv: "\u226B\u0338", nharr: "\u21AE", nhArr: "\u21CE", nhpar: "\u2AF2", ni: "\u220B", nis: "\u22FC", nisd: "\u22FA", niv: "\u220B", NJcy: "\u040A", njcy: "\u045A", nlarr: "\u219A", nlArr: "\u21CD", nldr: "\u2025", nlE: "\u2266\u0338", nle: "\u2270", nleftarrow: "\u219A", nLeftarrow: "\u21CD", nleftrightarrow: "\u21AE", nLeftrightarrow: "\u21CE", nleq: "\u2270", nleqq: "\u2266\u0338", nleqslant: "\u2A7D\u0338", nles: "\u2A7D\u0338", nless: "\u226E", nLl: "\u22D8\u0338", nlsim: "\u2274", nLt: "\u226A\u20D2", nlt: "\u226E", nltri: "\u22EA", nltrie: "\u22EC", nLtv: "\u226A\u0338", nmid: "\u2224", NoBreak: "\u2060", NonBreakingSpace: "\xA0", nopf: "\u{1D55F}", Nopf: "\u2115", Not: "\u2AEC", not: "\xAC", NotCongruent: "\u2262", NotCupCap: "\u226D", NotDoubleVerticalBar: "\u2226", NotElement: "\u2209", NotEqual: "\u2260", NotEqualTilde: "\u2242\u0338", NotExists: "\u2204", NotGreater: "\u226F", NotGreaterEqual: "\u2271", NotGreaterFullEqual: "\u2267\u0338", NotGreaterGreater: "\u226B\u0338", NotGreaterLess: "\u2279", NotGreaterSlantEqual: "\u2A7E\u0338", NotGreaterTilde: "\u2275", NotHumpDownHump: "\u224E\u0338", NotHumpEqual: "\u224F\u0338", notin: "\u2209", notindot: "\u22F5\u0338", notinE: "\u22F9\u0338", notinva: "\u2209", notinvb: "\u22F7", notinvc: "\u22F6", NotLeftTriangleBar: "\u29CF\u0338", NotLeftTriangle: "\u22EA", NotLeftTriangleEqual: "\u22EC", NotLess: "\u226E", NotLessEqual: "\u2270", NotLessGreater: "\u2278", NotLessLess: "\u226A\u0338", NotLessSlantEqual: "\u2A7D\u0338", NotLessTilde: "\u2274", NotNestedGreaterGreater: "\u2AA2\u0338", NotNestedLessLess: "\u2AA1\u0338", notni: "\u220C", notniva: "\u220C", notnivb: "\u22FE", notnivc: "\u22FD", NotPrecedes: "\u2280", NotPrecedesEqual: "\u2AAF\u0338", NotPrecedesSlantEqual: "\u22E0", NotReverseElement: "\u220C", NotRightTriangleBar: "\u29D0\u0338", NotRightTriangle: "\u22EB", NotRightTriangleEqual: "\u22ED", NotSquareSubset: "\u228F\u0338", NotSquareSubsetEqual: "\u22E2", NotSquareSuperset: "\u2290\u0338", NotSquareSupersetEqual: "\u22E3", NotSubset: "\u2282\u20D2", NotSubsetEqual: "\u2288", NotSucceeds: "\u2281", NotSucceedsEqual: "\u2AB0\u0338", NotSucceedsSlantEqual: "\u22E1", NotSucceedsTilde: "\u227F\u0338", NotSuperset: "\u2283\u20D2", NotSupersetEqual: "\u2289", NotTilde: "\u2241", NotTildeEqual: "\u2244", NotTildeFullEqual: "\u2247", NotTildeTilde: "\u2249", NotVerticalBar: "\u2224", nparallel: "\u2226", npar: "\u2226", nparsl: "\u2AFD\u20E5", npart: "\u2202\u0338", npolint: "\u2A14", npr: "\u2280", nprcue: "\u22E0", nprec: "\u2280", npreceq: "\u2AAF\u0338", npre: "\u2AAF\u0338", nrarrc: "\u2933\u0338", nrarr: "\u219B", nrArr: "\u21CF", nrarrw: "\u219D\u0338", nrightarrow: "\u219B", nRightarrow: "\u21CF", nrtri: "\u22EB", nrtrie: "\u22ED", nsc: "\u2281", nsccue: "\u22E1", nsce: "\u2AB0\u0338", Nscr: "\u{1D4A9}", nscr: "\u{1D4C3}", nshortmid: "\u2224", nshortparallel: "\u2226", nsim: "\u2241", nsime: "\u2244", nsimeq: "\u2244", nsmid: "\u2224", nspar: "\u2226", nsqsube: "\u22E2", nsqsupe: "\u22E3", nsub: "\u2284", nsubE: "\u2AC5\u0338", nsube: "\u2288", nsubset: "\u2282\u20D2", nsubseteq: "\u2288", nsubseteqq: "\u2AC5\u0338", nsucc: "\u2281", nsucceq: "\u2AB0\u0338", nsup: "\u2285", nsupE: "\u2AC6\u0338", nsupe: "\u2289", nsupset: "\u2283\u20D2", nsupseteq: "\u2289", nsupseteqq: "\u2AC6\u0338", ntgl: "\u2279", Ntilde: "\xD1", ntilde: "\xF1", ntlg: "\u2278", ntriangleleft: "\u22EA", ntrianglelefteq: "\u22EC", ntriangleright: "\u22EB", ntrianglerighteq: "\u22ED", Nu: "\u039D", nu: "\u03BD", num: "#", numero: "\u2116", numsp: "\u2007", nvap: "\u224D\u20D2", nvdash: "\u22AC", nvDash: "\u22AD", nVdash: "\u22AE", nVDash: "\u22AF", nvge: "\u2265\u20D2", nvgt: ">\u20D2", nvHarr: "\u2904", nvinfin: "\u29DE", nvlArr: "\u2902", nvle: "\u2264\u20D2", nvlt: "<\u20D2", nvltrie: "\u22B4\u20D2", nvrArr: "\u2903", nvrtrie: "\u22B5\u20D2", nvsim: "\u223C\u20D2", nwarhk: "\u2923", nwarr: "\u2196", nwArr: "\u21D6", nwarrow: "\u2196", nwnear: "\u2927", Oacute: "\xD3", oacute: "\xF3", oast: "\u229B", Ocirc: "\xD4", ocirc: "\xF4", ocir: "\u229A", Ocy: "\u041E", ocy: "\u043E", odash: "\u229D", Odblac: "\u0150", odblac: "\u0151", odiv: "\u2A38", odot: "\u2299", odsold: "\u29BC", OElig: "\u0152", oelig: "\u0153", ofcir: "\u29BF", Ofr: "\u{1D512}", ofr: "\u{1D52C}", ogon: "\u02DB", Ograve: "\xD2", ograve: "\xF2", ogt: "\u29C1", ohbar: "\u29B5", ohm: "\u03A9", oint: "\u222E", olarr: "\u21BA", olcir: "\u29BE", olcross: "\u29BB", oline: "\u203E", olt: "\u29C0", Omacr: "\u014C", omacr: "\u014D", Omega: "\u03A9", omega: "\u03C9", Omicron: "\u039F", omicron: "\u03BF", omid: "\u29B6", ominus: "\u2296", Oopf: "\u{1D546}", oopf: "\u{1D560}", opar: "\u29B7", OpenCurlyDoubleQuote: "\u201C", OpenCurlyQuote: "\u2018", operp: "\u29B9", oplus: "\u2295", orarr: "\u21BB", Or: "\u2A54", or: "\u2228", ord: "\u2A5D", order: "\u2134", orderof: "\u2134", ordf: "\xAA", ordm: "\xBA", origof: "\u22B6", oror: "\u2A56", orslope: "\u2A57", orv: "\u2A5B", oS: "\u24C8", Oscr: "\u{1D4AA}", oscr: "\u2134", Oslash: "\xD8", oslash: "\xF8", osol: "\u2298", Otilde: "\xD5", otilde: "\xF5", otimesas: "\u2A36", Otimes: "\u2A37", otimes: "\u2297", Ouml: "\xD6", ouml: "\xF6", ovbar: "\u233D", OverBar: "\u203E", OverBrace: "\u23DE", OverBracket: "\u23B4", OverParenthesis: "\u23DC", para: "\xB6", parallel: "\u2225", par: "\u2225", parsim: "\u2AF3", parsl: "\u2AFD", part: "\u2202", PartialD: "\u2202", Pcy: "\u041F", pcy: "\u043F", percnt: "%", period: ".", permil: "\u2030", perp: "\u22A5", pertenk: "\u2031", Pfr: "\u{1D513}", pfr: "\u{1D52D}", Phi: "\u03A6", phi: "\u03C6", phiv: "\u03D5", phmmat: "\u2133", phone: "\u260E", Pi: "\u03A0", pi: "\u03C0", pitchfork: "\u22D4", piv: "\u03D6", planck: "\u210F", planckh: "\u210E", plankv: "\u210F", plusacir: "\u2A23", plusb: "\u229E", pluscir: "\u2A22", plus: "+", plusdo: "\u2214", plusdu: "\u2A25", pluse: "\u2A72", PlusMinus: "\xB1", plusmn: "\xB1", plussim: "\u2A26", plustwo: "\u2A27", pm: "\xB1", Poincareplane: "\u210C", pointint: "\u2A15", popf: "\u{1D561}", Popf: "\u2119", pound: "\xA3", prap: "\u2AB7", Pr: "\u2ABB", pr: "\u227A", prcue: "\u227C", precapprox: "\u2AB7", prec: "\u227A", preccurlyeq: "\u227C", Precedes: "\u227A", PrecedesEqual: "\u2AAF", PrecedesSlantEqual: "\u227C", PrecedesTilde: "\u227E", preceq: "\u2AAF", precnapprox: "\u2AB9", precneqq: "\u2AB5", precnsim: "\u22E8", pre: "\u2AAF", prE: "\u2AB3", precsim: "\u227E", prime: "\u2032", Prime: "\u2033", primes: "\u2119", prnap: "\u2AB9", prnE: "\u2AB5", prnsim: "\u22E8", prod: "\u220F", Product: "\u220F", profalar: "\u232E", profline: "\u2312", profsurf: "\u2313", prop: "\u221D", Proportional: "\u221D", Proportion: "\u2237", propto: "\u221D", prsim: "\u227E", prurel: "\u22B0", Pscr: "\u{1D4AB}", pscr: "\u{1D4C5}", Psi: "\u03A8", psi: "\u03C8", puncsp: "\u2008", Qfr: "\u{1D514}", qfr: "\u{1D52E}", qint: "\u2A0C", qopf: "\u{1D562}", Qopf: "\u211A", qprime: "\u2057", Qscr: "\u{1D4AC}", qscr: "\u{1D4C6}", quaternions: "\u210D", quatint: "\u2A16", quest: "?", questeq: "\u225F", quot: '"', QUOT: '"', rAarr: "\u21DB", race: "\u223D\u0331", Racute: "\u0154", racute: "\u0155", radic: "\u221A", raemptyv: "\u29B3", rang: "\u27E9", Rang: "\u27EB", rangd: "\u2992", range: "\u29A5", rangle: "\u27E9", raquo: "\xBB", rarrap: "\u2975", rarrb: "\u21E5", rarrbfs: "\u2920", rarrc: "\u2933", rarr: "\u2192", Rarr: "\u21A0", rArr: "\u21D2", rarrfs: "\u291E", rarrhk: "\u21AA", rarrlp: "\u21AC", rarrpl: "\u2945", rarrsim: "\u2974", Rarrtl: "\u2916", rarrtl: "\u21A3", rarrw: "\u219D", ratail: "\u291A", rAtail: "\u291C", ratio: "\u2236", rationals: "\u211A", rbarr: "\u290D", rBarr: "\u290F", RBarr: "\u2910", rbbrk: "\u2773", rbrace: "}", rbrack: "]", rbrke: "\u298C", rbrksld: "\u298E", rbrkslu: "\u2990", Rcaron: "\u0158", rcaron: "\u0159", Rcedil: "\u0156", rcedil: "\u0157", rceil: "\u2309", rcub: "}", Rcy: "\u0420", rcy: "\u0440", rdca: "\u2937", rdldhar: "\u2969", rdquo: "\u201D", rdquor: "\u201D", rdsh: "\u21B3", real: "\u211C", realine: "\u211B", realpart: "\u211C", reals: "\u211D", Re: "\u211C", rect: "\u25AD", reg: "\xAE", REG: "\xAE", ReverseElement: "\u220B", ReverseEquilibrium: "\u21CB", ReverseUpEquilibrium: "\u296F", rfisht: "\u297D", rfloor: "\u230B", rfr: "\u{1D52F}", Rfr: "\u211C", rHar: "\u2964", rhard: "\u21C1", rharu: "\u21C0", rharul: "\u296C", Rho: "\u03A1", rho: "\u03C1", rhov: "\u03F1", RightAngleBracket: "\u27E9", RightArrowBar: "\u21E5", rightarrow: "\u2192", RightArrow: "\u2192", Rightarrow: "\u21D2", RightArrowLeftArrow: "\u21C4", rightarrowtail: "\u21A3", RightCeiling: "\u2309", RightDoubleBracket: "\u27E7", RightDownTeeVector: "\u295D", RightDownVectorBar: "\u2955", RightDownVector: "\u21C2", RightFloor: "\u230B", rightharpoondown: "\u21C1", rightharpoonup: "\u21C0", rightleftarrows: "\u21C4", rightleftharpoons: "\u21CC", rightrightarrows: "\u21C9", rightsquigarrow: "\u219D", RightTeeArrow: "\u21A6", RightTee: "\u22A2", RightTeeVector: "\u295B", rightthreetimes: "\u22CC", RightTriangleBar: "\u29D0", RightTriangle: "\u22B3", RightTriangleEqual: "\u22B5", RightUpDownVector: "\u294F", RightUpTeeVector: "\u295C", RightUpVectorBar: "\u2954", RightUpVector: "\u21BE", RightVectorBar: "\u2953", RightVector: "\u21C0", ring: "\u02DA", risingdotseq: "\u2253", rlarr: "\u21C4", rlhar: "\u21CC", rlm: "\u200F", rmoustache: "\u23B1", rmoust: "\u23B1", rnmid: "\u2AEE", roang: "\u27ED", roarr: "\u21FE", robrk: "\u27E7", ropar: "\u2986", ropf: "\u{1D563}", Ropf: "\u211D", roplus: "\u2A2E", rotimes: "\u2A35", RoundImplies: "\u2970", rpar: ")", rpargt: "\u2994", rppolint: "\u2A12", rrarr: "\u21C9", Rrightarrow: "\u21DB", rsaquo: "\u203A", rscr: "\u{1D4C7}", Rscr: "\u211B", rsh: "\u21B1", Rsh: "\u21B1", rsqb: "]", rsquo: "\u2019", rsquor: "\u2019", rthree: "\u22CC", rtimes: "\u22CA", rtri: "\u25B9", rtrie: "\u22B5", rtrif: "\u25B8", rtriltri: "\u29CE", RuleDelayed: "\u29F4", ruluhar: "\u2968", rx: "\u211E", Sacute: "\u015A", sacute: "\u015B", sbquo: "\u201A", scap: "\u2AB8", Scaron: "\u0160", scaron: "\u0161", Sc: "\u2ABC", sc: "\u227B", sccue: "\u227D", sce: "\u2AB0", scE: "\u2AB4", Scedil: "\u015E", scedil: "\u015F", Scirc: "\u015C", scirc: "\u015D", scnap: "\u2ABA", scnE: "\u2AB6", scnsim: "\u22E9", scpolint: "\u2A13", scsim: "\u227F", Scy: "\u0421", scy: "\u0441", sdotb: "\u22A1", sdot: "\u22C5", sdote: "\u2A66", searhk: "\u2925", searr: "\u2198", seArr: "\u21D8", searrow: "\u2198", sect: "\xA7", semi: ";", seswar: "\u2929", setminus: "\u2216", setmn: "\u2216", sext: "\u2736", Sfr: "\u{1D516}", sfr: "\u{1D530}", sfrown: "\u2322", sharp: "\u266F", SHCHcy: "\u0429", shchcy: "\u0449", SHcy: "\u0428", shcy: "\u0448", ShortDownArrow: "\u2193", ShortLeftArrow: "\u2190", shortmid: "\u2223", shortparallel: "\u2225", ShortRightArrow: "\u2192", ShortUpArrow: "\u2191", shy: "\xAD", Sigma: "\u03A3", sigma: "\u03C3", sigmaf: "\u03C2", sigmav: "\u03C2", sim: "\u223C", simdot: "\u2A6A", sime: "\u2243", simeq: "\u2243", simg: "\u2A9E", simgE: "\u2AA0", siml: "\u2A9D", simlE: "\u2A9F", simne: "\u2246", simplus: "\u2A24", simrarr: "\u2972", slarr: "\u2190", SmallCircle: "\u2218", smallsetminus: "\u2216", smashp: "\u2A33", smeparsl: "\u29E4", smid: "\u2223", smile: "\u2323", smt: "\u2AAA", smte: "\u2AAC", smtes: "\u2AAC\uFE00", SOFTcy: "\u042C", softcy: "\u044C", solbar: "\u233F", solb: "\u29C4", sol: "/", Sopf: "\u{1D54A}", sopf: "\u{1D564}", spades: "\u2660", spadesuit: "\u2660", spar: "\u2225", sqcap: "\u2293", sqcaps: "\u2293\uFE00", sqcup: "\u2294", sqcups: "\u2294\uFE00", Sqrt: "\u221A", sqsub: "\u228F", sqsube: "\u2291", sqsubset: "\u228F", sqsubseteq: "\u2291", sqsup: "\u2290", sqsupe: "\u2292", sqsupset: "\u2290", sqsupseteq: "\u2292", square: "\u25A1", Square: "\u25A1", SquareIntersection: "\u2293", SquareSubset: "\u228F", SquareSubsetEqual: "\u2291", SquareSuperset: "\u2290", SquareSupersetEqual: "\u2292", SquareUnion: "\u2294", squarf: "\u25AA", squ: "\u25A1", squf: "\u25AA", srarr: "\u2192", Sscr: "\u{1D4AE}", sscr: "\u{1D4C8}", ssetmn: "\u2216", ssmile: "\u2323", sstarf: "\u22C6", Star: "\u22C6", star: "\u2606", starf: "\u2605", straightepsilon: "\u03F5", straightphi: "\u03D5", strns: "\xAF", sub: "\u2282", Sub: "\u22D0", subdot: "\u2ABD", subE: "\u2AC5", sube: "\u2286", subedot: "\u2AC3", submult: "\u2AC1", subnE: "\u2ACB", subne: "\u228A", subplus: "\u2ABF", subrarr: "\u2979", subset: "\u2282", Subset: "\u22D0", subseteq: "\u2286", subseteqq: "\u2AC5", SubsetEqual: "\u2286", subsetneq: "\u228A", subsetneqq: "\u2ACB", subsim: "\u2AC7", subsub: "\u2AD5", subsup: "\u2AD3", succapprox: "\u2AB8", succ: "\u227B", succcurlyeq: "\u227D", Succeeds: "\u227B", SucceedsEqual: "\u2AB0", SucceedsSlantEqual: "\u227D", SucceedsTilde: "\u227F", succeq: "\u2AB0", succnapprox: "\u2ABA", succneqq: "\u2AB6", succnsim: "\u22E9", succsim: "\u227F", SuchThat: "\u220B", sum: "\u2211", Sum: "\u2211", sung: "\u266A", sup1: "\xB9", sup2: "\xB2", sup3: "\xB3", sup: "\u2283", Sup: "\u22D1", supdot: "\u2ABE", supdsub: "\u2AD8", supE: "\u2AC6", supe: "\u2287", supedot: "\u2AC4", Superset: "\u2283", SupersetEqual: "\u2287", suphsol: "\u27C9", suphsub: "\u2AD7", suplarr: "\u297B", supmult: "\u2AC2", supnE: "\u2ACC", supne: "\u228B", supplus: "\u2AC0", supset: "\u2283", Supset: "\u22D1", supseteq: "\u2287", supseteqq: "\u2AC6", supsetneq: "\u228B", supsetneqq: "\u2ACC", supsim: "\u2AC8", supsub: "\u2AD4", supsup: "\u2AD6", swarhk: "\u2926", swarr: "\u2199", swArr: "\u21D9", swarrow: "\u2199", swnwar: "\u292A", szlig: "\xDF", Tab: "     ", target: "\u2316", Tau: "\u03A4", tau: "\u03C4", tbrk: "\u23B4", Tcaron: "\u0164", tcaron: "\u0165", Tcedil: "\u0162", tcedil: "\u0163", Tcy: "\u0422", tcy: "\u0442", tdot: "\u20DB", telrec: "\u2315", Tfr: "\u{1D517}", tfr: "\u{1D531}", there4: "\u2234", therefore: "\u2234", Therefore: "\u2234", Theta: "\u0398", theta: "\u03B8", thetasym: "\u03D1", thetav: "\u03D1", thickapprox: "\u2248", thicksim: "\u223C", ThickSpace: "\u205F\u200A", ThinSpace: "\u2009", thinsp: "\u2009", thkap: "\u2248", thksim: "\u223C", THORN: "\xDE", thorn: "\xFE", tilde: "\u02DC", Tilde: "\u223C", TildeEqual: "\u2243", TildeFullEqual: "\u2245", TildeTilde: "\u2248", timesbar: "\u2A31", timesb: "\u22A0", times: "\xD7", timesd: "\u2A30", tint: "\u222D", toea: "\u2928", topbot: "\u2336", topcir: "\u2AF1", top: "\u22A4", Topf: "\u{1D54B}", topf: "\u{1D565}", topfork: "\u2ADA", tosa: "\u2929", tprime: "\u2034", trade: "\u2122", TRADE: "\u2122", triangle: "\u25B5", triangledown: "\u25BF", triangleleft: "\u25C3", trianglelefteq: "\u22B4", triangleq: "\u225C", triangleright: "\u25B9", trianglerighteq: "\u22B5", tridot: "\u25EC", trie: "\u225C", triminus: "\u2A3A", TripleDot: "\u20DB", triplus: "\u2A39", trisb: "\u29CD", tritime: "\u2A3B", trpezium: "\u23E2", Tscr: "\u{1D4AF}", tscr: "\u{1D4C9}", TScy: "\u0426", tscy: "\u0446", TSHcy: "\u040B", tshcy: "\u045B", Tstrok: "\u0166", tstrok: "\u0167", twixt: "\u226C", twoheadleftarrow: "\u219E", twoheadrightarrow: "\u21A0", Uacute: "\xDA", uacute: "\xFA", uarr: "\u2191", Uarr: "\u219F", uArr: "\u21D1", Uarrocir: "\u2949", Ubrcy: "\u040E", ubrcy: "\u045E", Ubreve: "\u016C", ubreve: "\u016D", Ucirc: "\xDB", ucirc: "\xFB", Ucy: "\u0423", ucy: "\u0443", udarr: "\u21C5", Udblac: "\u0170", udblac: "\u0171", udhar: "\u296E", ufisht: "\u297E", Ufr: "\u{1D518}", ufr: "\u{1D532}", Ugrave: "\xD9", ugrave: "\xF9", uHar: "\u2963", uharl: "\u21BF", uharr: "\u21BE", uhblk: "\u2580", ulcorn: "\u231C", ulcorner: "\u231C", ulcrop: "\u230F", ultri: "\u25F8", Umacr: "\u016A", umacr: "\u016B", uml: "\xA8", UnderBar: "_", UnderBrace: "\u23DF", UnderBracket: "\u23B5", UnderParenthesis: "\u23DD", Union: "\u22C3", UnionPlus: "\u228E", Uogon: "\u0172", uogon: "\u0173", Uopf: "\u{1D54C}", uopf: "\u{1D566}", UpArrowBar: "\u2912", uparrow: "\u2191", UpArrow: "\u2191", Uparrow: "\u21D1", UpArrowDownArrow: "\u21C5", updownarrow: "\u2195", UpDownArrow: "\u2195", Updownarrow: "\u21D5", UpEquilibrium: "\u296E", upharpoonleft: "\u21BF", upharpoonright: "\u21BE", uplus: "\u228E", UpperLeftArrow: "\u2196", UpperRightArrow: "\u2197", upsi: "\u03C5", Upsi: "\u03D2", upsih: "\u03D2", Upsilon: "\u03A5", upsilon: "\u03C5", UpTeeArrow: "\u21A5", UpTee: "\u22A5", upuparrows: "\u21C8", urcorn: "\u231D", urcorner: "\u231D", urcrop: "\u230E", Uring: "\u016E", uring: "\u016F", urtri: "\u25F9", Uscr: "\u{1D4B0}", uscr: "\u{1D4CA}", utdot: "\u22F0", Utilde: "\u0168", utilde: "\u0169", utri: "\u25B5", utrif: "\u25B4", uuarr: "\u21C8", Uuml: "\xDC", uuml: "\xFC", uwangle: "\u29A7", vangrt: "\u299C", varepsilon: "\u03F5", varkappa: "\u03F0", varnothing: "\u2205", varphi: "\u03D5", varpi: "\u03D6", varpropto: "\u221D", varr: "\u2195", vArr: "\u21D5", varrho: "\u03F1", varsigma: "\u03C2", varsubsetneq: "\u228A\uFE00", varsubsetneqq: "\u2ACB\uFE00", varsupsetneq: "\u228B\uFE00", varsupsetneqq: "\u2ACC\uFE00", vartheta: "\u03D1", vartriangleleft: "\u22B2", vartriangleright: "\u22B3", vBar: "\u2AE8", Vbar: "\u2AEB", vBarv: "\u2AE9", Vcy: "\u0412", vcy: "\u0432", vdash: "\u22A2", vDash: "\u22A8", Vdash: "\u22A9", VDash: "\u22AB", Vdashl: "\u2AE6", veebar: "\u22BB", vee: "\u2228", Vee: "\u22C1", veeeq: "\u225A", vellip: "\u22EE", verbar: "|", Verbar: "\u2016", vert: "|", Vert: "\u2016", VerticalBar: "\u2223", VerticalLine: "|", VerticalSeparator: "\u2758", VerticalTilde: "\u2240", VeryThinSpace: "\u200A", Vfr: "\u{1D519}", vfr: "\u{1D533}", vltri: "\u22B2", vnsub: "\u2282\u20D2", vnsup: "\u2283\u20D2", Vopf: "\u{1D54D}", vopf: "\u{1D567}", vprop: "\u221D", vrtri: "\u22B3", Vscr: "\u{1D4B1}", vscr: "\u{1D4CB}", vsubnE: "\u2ACB\uFE00", vsubne: "\u228A\uFE00", vsupnE: "\u2ACC\uFE00", vsupne: "\u228B\uFE00", Vvdash: "\u22AA", vzigzag: "\u299A", Wcirc: "\u0174", wcirc: "\u0175", wedbar: "\u2A5F", wedge: "\u2227", Wedge: "\u22C0", wedgeq: "\u2259", weierp: "\u2118", Wfr: "\u{1D51A}", wfr: "\u{1D534}", Wopf: "\u{1D54E}", wopf: "\u{1D568}", wp: "\u2118", wr: "\u2240", wreath: "\u2240", Wscr: "\u{1D4B2}", wscr: "\u{1D4CC}", xcap: "\u22C2", xcirc: "\u25EF", xcup: "\u22C3", xdtri: "\u25BD", Xfr: "\u{1D51B}", xfr: "\u{1D535}", xharr: "\u27F7", xhArr: "\u27FA", Xi: "\u039E", xi: "\u03BE", xlarr: "\u27F5", xlArr: "\u27F8", xmap: "\u27FC", xnis: "\u22FB", xodot: "\u2A00", Xopf: "\u{1D54F}", xopf: "\u{1D569}", xoplus: "\u2A01", xotime: "\u2A02", xrarr: "\u27F6", xrArr: "\u27F9", Xscr: "\u{1D4B3}", xscr: "\u{1D4CD}", xsqcup: "\u2A06", xuplus: "\u2A04", xutri: "\u25B3", xvee: "\u22C1", xwedge: "\u22C0", Yacute: "\xDD", yacute: "\xFD", YAcy: "\u042F", yacy: "\u044F", Ycirc: "\u0176", ycirc: "\u0177", Ycy: "\u042B", ycy: "\u044B", yen: "\xA5", Yfr: "\u{1D51C}", yfr: "\u{1D536}", YIcy: "\u0407", yicy: "\u0457", Yopf: "\u{1D550}", yopf: "\u{1D56A}", Yscr: "\u{1D4B4}", yscr: "\u{1D4CE}", YUcy: "\u042E", yucy: "\u044E", yuml: "\xFF", Yuml: "\u0178", Zacute: "\u0179", zacute: "\u017A", Zcaron: "\u017D", zcaron: "\u017E", Zcy: "\u0417", zcy: "\u0437", Zdot: "\u017B", zdot: "\u017C", zeetrf: "\u2128", ZeroWidthSpace: "\u200B", Zeta: "\u0396", zeta: "\u03B6", zfr: "\u{1D537}", Zfr: "\u2128", ZHcy: "\u0416", zhcy: "\u0436", zigrarr: "\u21DD", zopf: "\u{1D56B}", Zopf: "\u2124", Zscr: "\u{1D4B5}", zscr: "\u{1D4CF}", zwj: "\u200D", zwnj: "\u200C"};
2948 });
2949
2950 // node_modules/markdown-it/lib/common/entities.js
2951 var require_entities2 = __commonJS((exports2, module2) => {
2952   "use strict";
2953   module2.exports = require_entities();
2954 });
2955
2956 // node_modules/uc.micro/categories/P/regex.js
2957 var require_regex = __commonJS((exports2, module2) => {
2958   module2.exports = /[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4E\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/;
2959 });
2960
2961 // node_modules/mdurl/encode.js
2962 var require_encode = __commonJS((exports2, module2) => {
2963   "use strict";
2964   var encodeCache = {};
2965   function getEncodeCache(exclude) {
2966     var i, ch, cache = encodeCache[exclude];
2967     if (cache) {
2968       return cache;
2969     }
2970     cache = encodeCache[exclude] = [];
2971     for (i = 0; i < 128; i++) {
2972       ch = String.fromCharCode(i);
2973       if (/^[0-9a-z]$/i.test(ch)) {
2974         cache.push(ch);
2975       } else {
2976         cache.push("%" + ("0" + i.toString(16).toUpperCase()).slice(-2));
2977       }
2978     }
2979     for (i = 0; i < exclude.length; i++) {
2980       cache[exclude.charCodeAt(i)] = exclude[i];
2981     }
2982     return cache;
2983   }
2984   function encode(string, exclude, keepEscaped) {
2985     var i, l, code, nextCode, cache, result = "";
2986     if (typeof exclude !== "string") {
2987       keepEscaped = exclude;
2988       exclude = encode.defaultChars;
2989     }
2990     if (typeof keepEscaped === "undefined") {
2991       keepEscaped = true;
2992     }
2993     cache = getEncodeCache(exclude);
2994     for (i = 0, l = string.length; i < l; i++) {
2995       code = string.charCodeAt(i);
2996       if (keepEscaped && code === 37 && i + 2 < l) {
2997         if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
2998           result += string.slice(i, i + 3);
2999           i += 2;
3000           continue;
3001         }
3002       }
3003       if (code < 128) {
3004         result += cache[code];
3005         continue;
3006       }
3007       if (code >= 55296 && code <= 57343) {
3008         if (code >= 55296 && code <= 56319 && i + 1 < l) {
3009           nextCode = string.charCodeAt(i + 1);
3010           if (nextCode >= 56320 && nextCode <= 57343) {
3011             result += encodeURIComponent(string[i] + string[i + 1]);
3012             i++;
3013             continue;
3014           }
3015         }
3016         result += "%EF%BF%BD";
3017         continue;
3018       }
3019       result += encodeURIComponent(string[i]);
3020     }
3021     return result;
3022   }
3023   encode.defaultChars = ";/?:@&=+$,-_.!~*'()#";
3024   encode.componentChars = "-_.!~*'()";
3025   module2.exports = encode;
3026 });
3027
3028 // node_modules/mdurl/decode.js
3029 var require_decode = __commonJS((exports2, module2) => {
3030   "use strict";
3031   var decodeCache = {};
3032   function getDecodeCache(exclude) {
3033     var i, ch, cache = decodeCache[exclude];
3034     if (cache) {
3035       return cache;
3036     }
3037     cache = decodeCache[exclude] = [];
3038     for (i = 0; i < 128; i++) {
3039       ch = String.fromCharCode(i);
3040       cache.push(ch);
3041     }
3042     for (i = 0; i < exclude.length; i++) {
3043       ch = exclude.charCodeAt(i);
3044       cache[ch] = "%" + ("0" + ch.toString(16).toUpperCase()).slice(-2);
3045     }
3046     return cache;
3047   }
3048   function decode(string, exclude) {
3049     var cache;
3050     if (typeof exclude !== "string") {
3051       exclude = decode.defaultChars;
3052     }
3053     cache = getDecodeCache(exclude);
3054     return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {
3055       var i, l, b1, b2, b3, b4, chr, result = "";
3056       for (i = 0, l = seq.length; i < l; i += 3) {
3057         b1 = parseInt(seq.slice(i + 1, i + 3), 16);
3058         if (b1 < 128) {
3059           result += cache[b1];
3060           continue;
3061         }
3062         if ((b1 & 224) === 192 && i + 3 < l) {
3063           b2 = parseInt(seq.slice(i + 4, i + 6), 16);
3064           if ((b2 & 192) === 128) {
3065             chr = b1 << 6 & 1984 | b2 & 63;
3066             if (chr < 128) {
3067               result += "\uFFFD\uFFFD";
3068             } else {
3069               result += String.fromCharCode(chr);
3070             }
3071             i += 3;
3072             continue;
3073           }
3074         }
3075         if ((b1 & 240) === 224 && i + 6 < l) {
3076           b2 = parseInt(seq.slice(i + 4, i + 6), 16);
3077           b3 = parseInt(seq.slice(i + 7, i + 9), 16);
3078           if ((b2 & 192) === 128 && (b3 & 192) === 128) {
3079             chr = b1 << 12 & 61440 | b2 << 6 & 4032 | b3 & 63;
3080             if (chr < 2048 || chr >= 55296 && chr <= 57343) {
3081               result += "\uFFFD\uFFFD\uFFFD";
3082             } else {
3083               result += String.fromCharCode(chr);
3084             }
3085             i += 6;
3086             continue;
3087           }
3088         }
3089         if ((b1 & 248) === 240 && i + 9 < l) {
3090           b2 = parseInt(seq.slice(i + 4, i + 6), 16);
3091           b3 = parseInt(seq.slice(i + 7, i + 9), 16);
3092           b4 = parseInt(seq.slice(i + 10, i + 12), 16);
3093           if ((b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128) {
3094             chr = b1 << 18 & 1835008 | b2 << 12 & 258048 | b3 << 6 & 4032 | b4 & 63;
3095             if (chr < 65536 || chr > 1114111) {
3096               result += "\uFFFD\uFFFD\uFFFD\uFFFD";
3097             } else {
3098               chr -= 65536;
3099               result += String.fromCharCode(55296 + (chr >> 10), 56320 + (chr & 1023));
3100             }
3101             i += 9;
3102             continue;
3103           }
3104         }
3105         result += "\uFFFD";
3106       }
3107       return result;
3108     });
3109   }
3110   decode.defaultChars = ";/?:@&=+$,#";
3111   decode.componentChars = "";
3112   module2.exports = decode;
3113 });
3114
3115 // node_modules/mdurl/format.js
3116 var require_format = __commonJS((exports2, module2) => {
3117   "use strict";
3118   module2.exports = function format(url) {
3119     var result = "";
3120     result += url.protocol || "";
3121     result += url.slashes ? "//" : "";
3122     result += url.auth ? url.auth + "@" : "";
3123     if (url.hostname && url.hostname.indexOf(":") !== -1) {
3124       result += "[" + url.hostname + "]";
3125     } else {
3126       result += url.hostname || "";
3127     }
3128     result += url.port ? ":" + url.port : "";
3129     result += url.pathname || "";
3130     result += url.search || "";
3131     result += url.hash || "";
3132     return result;
3133   };
3134 });
3135
3136 // node_modules/mdurl/parse.js
3137 var require_parse = __commonJS((exports2, module2) => {
3138   "use strict";
3139   function Url() {
3140     this.protocol = null;
3141     this.slashes = null;
3142     this.auth = null;
3143     this.port = null;
3144     this.hostname = null;
3145     this.hash = null;
3146     this.search = null;
3147     this.pathname = null;
3148   }
3149   var protocolPattern = /^([a-z0-9.+-]+:)/i;
3150   var portPattern = /:[0-9]*$/;
3151   var simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
3152   var delims = ["<", ">", '"', "`", " ", "\r", "\n", "  "];
3153   var unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims);
3154   var autoEscape = ["'"].concat(unwise);
3155   var nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape);
3156   var hostEndingChars = ["/", "?", "#"];
3157   var hostnameMaxLen = 255;
3158   var hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
3159   var hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
3160   var hostlessProtocol = {
3161     javascript: true,
3162     "javascript:": true
3163   };
3164   var slashedProtocol = {
3165     http: true,
3166     https: true,
3167     ftp: true,
3168     gopher: true,
3169     file: true,
3170     "http:": true,
3171     "https:": true,
3172     "ftp:": true,
3173     "gopher:": true,
3174     "file:": true
3175   };
3176   function urlParse(url, slashesDenoteHost) {
3177     if (url && url instanceof Url) {
3178       return url;
3179     }
3180     var u = new Url();
3181     u.parse(url, slashesDenoteHost);
3182     return u;
3183   }
3184   Url.prototype.parse = function(url, slashesDenoteHost) {
3185     var i, l, lowerProto, hec, slashes, rest = url;
3186     rest = rest.trim();
3187     if (!slashesDenoteHost && url.split("#").length === 1) {
3188       var simplePath = simplePathPattern.exec(rest);
3189       if (simplePath) {
3190         this.pathname = simplePath[1];
3191         if (simplePath[2]) {
3192           this.search = simplePath[2];
3193         }
3194         return this;
3195       }
3196     }
3197     var proto = protocolPattern.exec(rest);
3198     if (proto) {
3199       proto = proto[0];
3200       lowerProto = proto.toLowerCase();
3201       this.protocol = proto;
3202       rest = rest.substr(proto.length);
3203     }
3204     if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
3205       slashes = rest.substr(0, 2) === "//";
3206       if (slashes && !(proto && hostlessProtocol[proto])) {
3207         rest = rest.substr(2);
3208         this.slashes = true;
3209       }
3210     }
3211     if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
3212       var hostEnd = -1;
3213       for (i = 0; i < hostEndingChars.length; i++) {
3214         hec = rest.indexOf(hostEndingChars[i]);
3215         if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
3216           hostEnd = hec;
3217         }
3218       }
3219       var auth, atSign;
3220       if (hostEnd === -1) {
3221         atSign = rest.lastIndexOf("@");
3222       } else {
3223         atSign = rest.lastIndexOf("@", hostEnd);
3224       }
3225       if (atSign !== -1) {
3226         auth = rest.slice(0, atSign);
3227         rest = rest.slice(atSign + 1);
3228         this.auth = auth;
3229       }
3230       hostEnd = -1;
3231       for (i = 0; i < nonHostChars.length; i++) {
3232         hec = rest.indexOf(nonHostChars[i]);
3233         if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
3234           hostEnd = hec;
3235         }
3236       }
3237       if (hostEnd === -1) {
3238         hostEnd = rest.length;
3239       }
3240       if (rest[hostEnd - 1] === ":") {
3241         hostEnd--;
3242       }
3243       var host = rest.slice(0, hostEnd);
3244       rest = rest.slice(hostEnd);
3245       this.parseHost(host);
3246       this.hostname = this.hostname || "";
3247       var ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
3248       if (!ipv6Hostname) {
3249         var hostparts = this.hostname.split(/\./);
3250         for (i = 0, l = hostparts.length; i < l; i++) {
3251           var part = hostparts[i];
3252           if (!part) {
3253             continue;
3254           }
3255           if (!part.match(hostnamePartPattern)) {
3256             var newpart = "";
3257             for (var j = 0, k = part.length; j < k; j++) {
3258               if (part.charCodeAt(j) > 127) {
3259                 newpart += "x";
3260               } else {
3261                 newpart += part[j];
3262               }
3263             }
3264             if (!newpart.match(hostnamePartPattern)) {
3265               var validParts = hostparts.slice(0, i);
3266               var notHost = hostparts.slice(i + 1);
3267               var bit = part.match(hostnamePartStart);
3268               if (bit) {
3269                 validParts.push(bit[1]);
3270                 notHost.unshift(bit[2]);
3271               }
3272               if (notHost.length) {
3273                 rest = notHost.join(".") + rest;
3274               }
3275               this.hostname = validParts.join(".");
3276               break;
3277             }
3278           }
3279         }
3280       }
3281       if (this.hostname.length > hostnameMaxLen) {
3282         this.hostname = "";
3283       }
3284       if (ipv6Hostname) {
3285         this.hostname = this.hostname.substr(1, this.hostname.length - 2);
3286       }
3287     }
3288     var hash = rest.indexOf("#");
3289     if (hash !== -1) {
3290       this.hash = rest.substr(hash);
3291       rest = rest.slice(0, hash);
3292     }
3293     var qm = rest.indexOf("?");
3294     if (qm !== -1) {
3295       this.search = rest.substr(qm);
3296       rest = rest.slice(0, qm);
3297     }
3298     if (rest) {
3299       this.pathname = rest;
3300     }
3301     if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
3302       this.pathname = "";
3303     }
3304     return this;
3305   };
3306   Url.prototype.parseHost = function(host) {
3307     var port = portPattern.exec(host);
3308     if (port) {
3309       port = port[0];
3310       if (port !== ":") {
3311         this.port = port.substr(1);
3312       }
3313       host = host.substr(0, host.length - port.length);
3314     }
3315     if (host) {
3316       this.hostname = host;
3317     }
3318   };
3319   module2.exports = urlParse;
3320 });
3321
3322 // node_modules/mdurl/index.js
3323 var require_mdurl = __commonJS((exports2, module2) => {
3324   "use strict";
3325   module2.exports.encode = require_encode();
3326   module2.exports.decode = require_decode();
3327   module2.exports.format = require_format();
3328   module2.exports.parse = require_parse();
3329 });
3330
3331 // node_modules/uc.micro/properties/Any/regex.js
3332 var require_regex2 = __commonJS((exports2, module2) => {
3333   module2.exports = /[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
3334 });
3335
3336 // node_modules/uc.micro/categories/Cc/regex.js
3337 var require_regex3 = __commonJS((exports2, module2) => {
3338   module2.exports = /[\0-\x1F\x7F-\x9F]/;
3339 });
3340
3341 // node_modules/uc.micro/categories/Cf/regex.js
3342 var require_regex4 = __commonJS((exports2, module2) => {
3343   module2.exports = /[\xAD\u0600-\u0605\u061C\u06DD\u070F\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB]|\uD804[\uDCBD\uDCCD]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/;
3344 });
3345
3346 // node_modules/uc.micro/categories/Z/regex.js
3347 var require_regex5 = __commonJS((exports2, module2) => {
3348   module2.exports = /[ \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
3349 });
3350
3351 // node_modules/uc.micro/index.js
3352 var require_uc = __commonJS((exports2) => {
3353   "use strict";
3354   exports2.Any = require_regex2();
3355   exports2.Cc = require_regex3();
3356   exports2.Cf = require_regex4();
3357   exports2.P = require_regex();
3358   exports2.Z = require_regex5();
3359 });
3360
3361 // node_modules/markdown-it/lib/common/utils.js
3362 var require_utils = __commonJS((exports2) => {
3363   "use strict";
3364   function _class(obj) {
3365     return Object.prototype.toString.call(obj);
3366   }
3367   function isString(obj) {
3368     return _class(obj) === "[object String]";
3369   }
3370   var _hasOwnProperty = Object.prototype.hasOwnProperty;
3371   function has(object, key) {
3372     return _hasOwnProperty.call(object, key);
3373   }
3374   function assign(obj) {
3375     var sources = Array.prototype.slice.call(arguments, 1);
3376     sources.forEach(function(source) {
3377       if (!source) {
3378         return;
3379       }
3380       if (typeof source !== "object") {
3381         throw new TypeError(source + "must be object");
3382       }
3383       Object.keys(source).forEach(function(key) {
3384         obj[key] = source[key];
3385       });
3386     });
3387     return obj;
3388   }
3389   function arrayReplaceAt(src, pos, newElements) {
3390     return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
3391   }
3392   function isValidEntityCode(c) {
3393     if (c >= 55296 && c <= 57343) {
3394       return false;
3395     }
3396     if (c >= 64976 && c <= 65007) {
3397       return false;
3398     }
3399     if ((c & 65535) === 65535 || (c & 65535) === 65534) {
3400       return false;
3401     }
3402     if (c >= 0 && c <= 8) {
3403       return false;
3404     }
3405     if (c === 11) {
3406       return false;
3407     }
3408     if (c >= 14 && c <= 31) {
3409       return false;
3410     }
3411     if (c >= 127 && c <= 159) {
3412       return false;
3413     }
3414     if (c > 1114111) {
3415       return false;
3416     }
3417     return true;
3418   }
3419   function fromCodePoint(c) {
3420     if (c > 65535) {
3421       c -= 65536;
3422       var surrogate1 = 55296 + (c >> 10), surrogate2 = 56320 + (c & 1023);
3423       return String.fromCharCode(surrogate1, surrogate2);
3424     }
3425     return String.fromCharCode(c);
3426   }
3427   var UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])/g;
3428   var ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
3429   var UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + "|" + ENTITY_RE.source, "gi");
3430   var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;
3431   var entities = require_entities2();
3432   function replaceEntityPattern(match, name) {
3433     var code = 0;
3434     if (has(entities, name)) {
3435       return entities[name];
3436     }
3437     if (name.charCodeAt(0) === 35 && DIGITAL_ENTITY_TEST_RE.test(name)) {
3438       code = name[1].toLowerCase() === "x" ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
3439       if (isValidEntityCode(code)) {
3440         return fromCodePoint(code);
3441       }
3442     }
3443     return match;
3444   }
3445   function unescapeMd(str) {
3446     if (str.indexOf("\\") < 0) {
3447       return str;
3448     }
3449     return str.replace(UNESCAPE_MD_RE, "$1");
3450   }
3451   function unescapeAll(str) {
3452     if (str.indexOf("\\") < 0 && str.indexOf("&") < 0) {
3453       return str;
3454     }
3455     return str.replace(UNESCAPE_ALL_RE, function(match, escaped, entity) {
3456       if (escaped) {
3457         return escaped;
3458       }
3459       return replaceEntityPattern(match, entity);
3460     });
3461   }
3462   var HTML_ESCAPE_TEST_RE = /[&<>"]/;
3463   var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
3464   var HTML_REPLACEMENTS = {
3465     "&": "&amp;",
3466     "<": "&lt;",
3467     ">": "&gt;",
3468     '"': "&quot;"
3469   };
3470   function replaceUnsafeChar(ch) {
3471     return HTML_REPLACEMENTS[ch];
3472   }
3473   function escapeHtml(str) {
3474     if (HTML_ESCAPE_TEST_RE.test(str)) {
3475       return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
3476     }
3477     return str;
3478   }
3479   var REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;
3480   function escapeRE(str) {
3481     return str.replace(REGEXP_ESCAPE_RE, "\\$&");
3482   }
3483   function isSpace(code) {
3484     switch (code) {
3485       case 9:
3486       case 32:
3487         return true;
3488     }
3489     return false;
3490   }
3491   function isWhiteSpace(code) {
3492     if (code >= 8192 && code <= 8202) {
3493       return true;
3494     }
3495     switch (code) {
3496       case 9:
3497       case 10:
3498       case 11:
3499       case 12:
3500       case 13:
3501       case 32:
3502       case 160:
3503       case 5760:
3504       case 8239:
3505       case 8287:
3506       case 12288:
3507         return true;
3508     }
3509     return false;
3510   }
3511   var UNICODE_PUNCT_RE = require_regex();
3512   function isPunctChar(ch) {
3513     return UNICODE_PUNCT_RE.test(ch);
3514   }
3515   function isMdAsciiPunct(ch) {
3516     switch (ch) {
3517       case 33:
3518       case 34:
3519       case 35:
3520       case 36:
3521       case 37:
3522       case 38:
3523       case 39:
3524       case 40:
3525       case 41:
3526       case 42:
3527       case 43:
3528       case 44:
3529       case 45:
3530       case 46:
3531       case 47:
3532       case 58:
3533       case 59:
3534       case 60:
3535       case 61:
3536       case 62:
3537       case 63:
3538       case 64:
3539       case 91:
3540       case 92:
3541       case 93:
3542       case 94:
3543       case 95:
3544       case 96:
3545       case 123:
3546       case 124:
3547       case 125:
3548       case 126:
3549         return true;
3550       default:
3551         return false;
3552     }
3553   }
3554   function normalizeReference(str) {
3555     str = str.trim().replace(/\s+/g, " ");
3556     if ("\u1E9E".toLowerCase() === "\u1E7E") {
3557       str = str.replace(/ẞ/g, "\xDF");
3558     }
3559     return str.toLowerCase().toUpperCase();
3560   }
3561   exports2.lib = {};
3562   exports2.lib.mdurl = require_mdurl();
3563   exports2.lib.ucmicro = require_uc();
3564   exports2.assign = assign;
3565   exports2.isString = isString;
3566   exports2.has = has;
3567   exports2.unescapeMd = unescapeMd;
3568   exports2.unescapeAll = unescapeAll;
3569   exports2.isValidEntityCode = isValidEntityCode;
3570   exports2.fromCodePoint = fromCodePoint;
3571   exports2.escapeHtml = escapeHtml;
3572   exports2.arrayReplaceAt = arrayReplaceAt;
3573   exports2.isSpace = isSpace;
3574   exports2.isWhiteSpace = isWhiteSpace;
3575   exports2.isMdAsciiPunct = isMdAsciiPunct;
3576   exports2.isPunctChar = isPunctChar;
3577   exports2.escapeRE = escapeRE;
3578   exports2.normalizeReference = normalizeReference;
3579 });
3580
3581 // node_modules/markdown-it/lib/helpers/parse_link_label.js
3582 var require_parse_link_label = __commonJS((exports2, module2) => {
3583   "use strict";
3584   module2.exports = function parseLinkLabel(state, start, disableNested) {
3585     var level, found, marker, prevPos, labelEnd = -1, max = state.posMax, oldPos = state.pos;
3586     state.pos = start + 1;
3587     level = 1;
3588     while (state.pos < max) {
3589       marker = state.src.charCodeAt(state.pos);
3590       if (marker === 93) {
3591         level--;
3592         if (level === 0) {
3593           found = true;
3594           break;
3595         }
3596       }
3597       prevPos = state.pos;
3598       state.md.inline.skipToken(state);
3599       if (marker === 91) {
3600         if (prevPos === state.pos - 1) {
3601           level++;
3602         } else if (disableNested) {
3603           state.pos = oldPos;
3604           return -1;
3605         }
3606       }
3607     }
3608     if (found) {
3609       labelEnd = state.pos;
3610     }
3611     state.pos = oldPos;
3612     return labelEnd;
3613   };
3614 });
3615
3616 // node_modules/markdown-it/lib/helpers/parse_link_destination.js
3617 var require_parse_link_destination = __commonJS((exports2, module2) => {
3618   "use strict";
3619   var unescapeAll = require_utils().unescapeAll;
3620   module2.exports = function parseLinkDestination(str, pos, max) {
3621     var code, level, lines = 0, start = pos, result = {
3622       ok: false,
3623       pos: 0,
3624       lines: 0,
3625       str: ""
3626     };
3627     if (str.charCodeAt(pos) === 60) {
3628       pos++;
3629       while (pos < max) {
3630         code = str.charCodeAt(pos);
3631         if (code === 10) {
3632           return result;
3633         }
3634         if (code === 60) {
3635           return result;
3636         }
3637         if (code === 62) {
3638           result.pos = pos + 1;
3639           result.str = unescapeAll(str.slice(start + 1, pos));
3640           result.ok = true;
3641           return result;
3642         }
3643         if (code === 92 && pos + 1 < max) {
3644           pos += 2;
3645           continue;
3646         }
3647         pos++;
3648       }
3649       return result;
3650     }
3651     level = 0;
3652     while (pos < max) {
3653       code = str.charCodeAt(pos);
3654       if (code === 32) {
3655         break;
3656       }
3657       if (code < 32 || code === 127) {
3658         break;
3659       }
3660       if (code === 92 && pos + 1 < max) {
3661         if (str.charCodeAt(pos + 1) === 32) {
3662           break;
3663         }
3664         pos += 2;
3665         continue;
3666       }
3667       if (code === 40) {
3668         level++;
3669         if (level > 32) {
3670           return result;
3671         }
3672       }
3673       if (code === 41) {
3674         if (level === 0) {
3675           break;
3676         }
3677         level--;
3678       }
3679       pos++;
3680     }
3681     if (start === pos) {
3682       return result;
3683     }
3684     if (level !== 0) {
3685       return result;
3686     }
3687     result.str = unescapeAll(str.slice(start, pos));
3688     result.lines = lines;
3689     result.pos = pos;
3690     result.ok = true;
3691     return result;
3692   };
3693 });
3694
3695 // node_modules/markdown-it/lib/helpers/parse_link_title.js
3696 var require_parse_link_title = __commonJS((exports2, module2) => {
3697   "use strict";
3698   var unescapeAll = require_utils().unescapeAll;
3699   module2.exports = function parseLinkTitle(str, pos, max) {
3700     var code, marker, lines = 0, start = pos, result = {
3701       ok: false,
3702       pos: 0,
3703       lines: 0,
3704       str: ""
3705     };
3706     if (pos >= max) {
3707       return result;
3708     }
3709     marker = str.charCodeAt(pos);
3710     if (marker !== 34 && marker !== 39 && marker !== 40) {
3711       return result;
3712     }
3713     pos++;
3714     if (marker === 40) {
3715       marker = 41;
3716     }
3717     while (pos < max) {
3718       code = str.charCodeAt(pos);
3719       if (code === marker) {
3720         result.pos = pos + 1;
3721         result.lines = lines;
3722         result.str = unescapeAll(str.slice(start + 1, pos));
3723         result.ok = true;
3724         return result;
3725       } else if (code === 40 && marker === 41) {
3726         return result;
3727       } else if (code === 10) {
3728         lines++;
3729       } else if (code === 92 && pos + 1 < max) {
3730         pos++;
3731         if (str.charCodeAt(pos) === 10) {
3732           lines++;
3733         }
3734       }
3735       pos++;
3736     }
3737     return result;
3738   };
3739 });
3740
3741 // node_modules/markdown-it/lib/helpers/index.js
3742 var require_helpers = __commonJS((exports2) => {
3743   "use strict";
3744   exports2.parseLinkLabel = require_parse_link_label();
3745   exports2.parseLinkDestination = require_parse_link_destination();
3746   exports2.parseLinkTitle = require_parse_link_title();
3747 });
3748
3749 // node_modules/markdown-it/lib/renderer.js
3750 var require_renderer = __commonJS((exports2, module2) => {
3751   "use strict";
3752   var assign = require_utils().assign;
3753   var unescapeAll = require_utils().unescapeAll;
3754   var escapeHtml = require_utils().escapeHtml;
3755   var default_rules = {};
3756   default_rules.code_inline = function(tokens, idx, options, env, slf) {
3757     var token = tokens[idx];
3758     return "<code" + slf.renderAttrs(token) + ">" + escapeHtml(tokens[idx].content) + "</code>";
3759   };
3760   default_rules.code_block = function(tokens, idx, options, env, slf) {
3761     var token = tokens[idx];
3762     return "<pre" + slf.renderAttrs(token) + "><code>" + escapeHtml(tokens[idx].content) + "</code></pre>\n";
3763   };
3764   default_rules.fence = function(tokens, idx, options, env, slf) {
3765     var token = tokens[idx], info = token.info ? unescapeAll(token.info).trim() : "", langName = "", langAttrs = "", highlighted, i, arr, tmpAttrs, tmpToken;
3766     if (info) {
3767       arr = info.split(/(\s+)/g);
3768       langName = arr[0];
3769       langAttrs = arr.slice(2).join("");
3770     }
3771     if (options.highlight) {
3772       highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);
3773     } else {
3774       highlighted = escapeHtml(token.content);
3775     }
3776     if (highlighted.indexOf("<pre") === 0) {
3777       return highlighted + "\n";
3778     }
3779     if (info) {
3780       i = token.attrIndex("class");
3781       tmpAttrs = token.attrs ? token.attrs.slice() : [];
3782       if (i < 0) {
3783         tmpAttrs.push(["class", options.langPrefix + langName]);
3784       } else {
3785         tmpAttrs[i] = tmpAttrs[i].slice();
3786         tmpAttrs[i][1] += " " + options.langPrefix + langName;
3787       }
3788       tmpToken = {
3789         attrs: tmpAttrs
3790       };
3791       return "<pre><code" + slf.renderAttrs(tmpToken) + ">" + highlighted + "</code></pre>\n";
3792     }
3793     return "<pre><code" + slf.renderAttrs(token) + ">" + highlighted + "</code></pre>\n";
3794   };
3795   default_rules.image = function(tokens, idx, options, env, slf) {
3796     var token = tokens[idx];
3797     token.attrs[token.attrIndex("alt")][1] = slf.renderInlineAsText(token.children, options, env);
3798     return slf.renderToken(tokens, idx, options);
3799   };
3800   default_rules.hardbreak = function(tokens, idx, options) {
3801     return options.xhtmlOut ? "<br />\n" : "<br>\n";
3802   };
3803   default_rules.softbreak = function(tokens, idx, options) {
3804     return options.breaks ? options.xhtmlOut ? "<br />\n" : "<br>\n" : "\n";
3805   };
3806   default_rules.text = function(tokens, idx) {
3807     return escapeHtml(tokens[idx].content);
3808   };
3809   default_rules.html_block = function(tokens, idx) {
3810     return tokens[idx].content;
3811   };
3812   default_rules.html_inline = function(tokens, idx) {
3813     return tokens[idx].content;
3814   };
3815   function Renderer() {
3816     this.rules = assign({}, default_rules);
3817   }
3818   Renderer.prototype.renderAttrs = function renderAttrs(token) {
3819     var i, l, result;
3820     if (!token.attrs) {
3821       return "";
3822     }
3823     result = "";
3824     for (i = 0, l = token.attrs.length; i < l; i++) {
3825       result += " " + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
3826     }
3827     return result;
3828   };
3829   Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {
3830     var nextToken, result = "", needLf = false, token = tokens[idx];
3831     if (token.hidden) {
3832       return "";
3833     }
3834     if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
3835       result += "\n";
3836     }
3837     result += (token.nesting === -1 ? "</" : "<") + token.tag;
3838     result += this.renderAttrs(token);
3839     if (token.nesting === 0 && options.xhtmlOut) {
3840       result += " /";
3841     }
3842     if (token.block) {
3843       needLf = true;
3844       if (token.nesting === 1) {
3845         if (idx + 1 < tokens.length) {
3846           nextToken = tokens[idx + 1];
3847           if (nextToken.type === "inline" || nextToken.hidden) {
3848             needLf = false;
3849           } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
3850             needLf = false;
3851           }
3852         }
3853       }
3854     }
3855     result += needLf ? ">\n" : ">";
3856     return result;
3857   };
3858   Renderer.prototype.renderInline = function(tokens, options, env) {
3859     var type, result = "", rules = this.rules;
3860     for (var i = 0, len = tokens.length; i < len; i++) {
3861       type = tokens[i].type;
3862       if (typeof rules[type] !== "undefined") {
3863         result += rules[type](tokens, i, options, env, this);
3864       } else {
3865         result += this.renderToken(tokens, i, options);
3866       }
3867     }
3868     return result;
3869   };
3870   Renderer.prototype.renderInlineAsText = function(tokens, options, env) {
3871     var result = "";
3872     for (var i = 0, len = tokens.length; i < len; i++) {
3873       if (tokens[i].type === "text") {
3874         result += tokens[i].content;
3875       } else if (tokens[i].type === "image") {
3876         result += this.renderInlineAsText(tokens[i].children, options, env);
3877       }
3878     }
3879     return result;
3880   };
3881   Renderer.prototype.render = function(tokens, options, env) {
3882     var i, len, type, result = "", rules = this.rules;
3883     for (i = 0, len = tokens.length; i < len; i++) {
3884       type = tokens[i].type;
3885       if (type === "inline") {
3886         result += this.renderInline(tokens[i].children, options, env);
3887       } else if (typeof rules[type] !== "undefined") {
3888         result += rules[tokens[i].type](tokens, i, options, env, this);
3889       } else {
3890         result += this.renderToken(tokens, i, options, env);
3891       }
3892     }
3893     return result;
3894   };
3895   module2.exports = Renderer;
3896 });
3897
3898 // node_modules/markdown-it/lib/ruler.js
3899 var require_ruler = __commonJS((exports2, module2) => {
3900   "use strict";
3901   function Ruler() {
3902     this.__rules__ = [];
3903     this.__cache__ = null;
3904   }
3905   Ruler.prototype.__find__ = function(name) {
3906     for (var i = 0; i < this.__rules__.length; i++) {
3907       if (this.__rules__[i].name === name) {
3908         return i;
3909       }
3910     }
3911     return -1;
3912   };
3913   Ruler.prototype.__compile__ = function() {
3914     var self = this;
3915     var chains = [""];
3916     self.__rules__.forEach(function(rule) {
3917       if (!rule.enabled) {
3918         return;
3919       }
3920       rule.alt.forEach(function(altName) {
3921         if (chains.indexOf(altName) < 0) {
3922           chains.push(altName);
3923         }
3924       });
3925     });
3926     self.__cache__ = {};
3927     chains.forEach(function(chain) {
3928       self.__cache__[chain] = [];
3929       self.__rules__.forEach(function(rule) {
3930         if (!rule.enabled) {
3931           return;
3932         }
3933         if (chain && rule.alt.indexOf(chain) < 0) {
3934           return;
3935         }
3936         self.__cache__[chain].push(rule.fn);
3937       });
3938     });
3939   };
3940   Ruler.prototype.at = function(name, fn, options) {
3941     var index = this.__find__(name);
3942     var opt = options || {};
3943     if (index === -1) {
3944       throw new Error("Parser rule not found: " + name);
3945     }
3946     this.__rules__[index].fn = fn;
3947     this.__rules__[index].alt = opt.alt || [];
3948     this.__cache__ = null;
3949   };
3950   Ruler.prototype.before = function(beforeName, ruleName, fn, options) {
3951     var index = this.__find__(beforeName);
3952     var opt = options || {};
3953     if (index === -1) {
3954       throw new Error("Parser rule not found: " + beforeName);
3955     }
3956     this.__rules__.splice(index, 0, {
3957       name: ruleName,
3958       enabled: true,
3959       fn,
3960       alt: opt.alt || []
3961     });
3962     this.__cache__ = null;
3963   };
3964   Ruler.prototype.after = function(afterName, ruleName, fn, options) {
3965     var index = this.__find__(afterName);
3966     var opt = options || {};
3967     if (index === -1) {
3968       throw new Error("Parser rule not found: " + afterName);
3969     }
3970     this.__rules__.splice(index + 1, 0, {
3971       name: ruleName,
3972       enabled: true,
3973       fn,
3974       alt: opt.alt || []
3975     });
3976     this.__cache__ = null;
3977   };
3978   Ruler.prototype.push = function(ruleName, fn, options) {
3979     var opt = options || {};
3980     this.__rules__.push({
3981       name: ruleName,
3982       enabled: true,
3983       fn,
3984       alt: opt.alt || []
3985     });
3986     this.__cache__ = null;
3987   };
3988   Ruler.prototype.enable = function(list, ignoreInvalid) {
3989     if (!Array.isArray(list)) {
3990       list = [list];
3991     }
3992     var result = [];
3993     list.forEach(function(name) {
3994       var idx = this.__find__(name);
3995       if (idx < 0) {
3996         if (ignoreInvalid) {
3997           return;
3998         }
3999         throw new Error("Rules manager: invalid rule name " + name);
4000       }
4001       this.__rules__[idx].enabled = true;
4002       result.push(name);
4003     }, this);
4004     this.__cache__ = null;
4005     return result;
4006   };
4007   Ruler.prototype.enableOnly = function(list, ignoreInvalid) {
4008     if (!Array.isArray(list)) {
4009       list = [list];
4010     }
4011     this.__rules__.forEach(function(rule) {
4012       rule.enabled = false;
4013     });
4014     this.enable(list, ignoreInvalid);
4015   };
4016   Ruler.prototype.disable = function(list, ignoreInvalid) {
4017     if (!Array.isArray(list)) {
4018       list = [list];
4019     }
4020     var result = [];
4021     list.forEach(function(name) {
4022       var idx = this.__find__(name);
4023       if (idx < 0) {
4024         if (ignoreInvalid) {
4025           return;
4026         }
4027         throw new Error("Rules manager: invalid rule name " + name);
4028       }
4029       this.__rules__[idx].enabled = false;
4030       result.push(name);
4031     }, this);
4032     this.__cache__ = null;
4033     return result;
4034   };
4035   Ruler.prototype.getRules = function(chainName) {
4036     if (this.__cache__ === null) {
4037       this.__compile__();
4038     }
4039     return this.__cache__[chainName] || [];
4040   };
4041   module2.exports = Ruler;
4042 });
4043
4044 // node_modules/markdown-it/lib/rules_core/normalize.js
4045 var require_normalize = __commonJS((exports2, module2) => {
4046   "use strict";
4047   var NEWLINES_RE = /\r\n?|\n/g;
4048   var NULL_RE = /\0/g;
4049   module2.exports = function normalize(state) {
4050     var str;
4051     str = state.src.replace(NEWLINES_RE, "\n");
4052     str = str.replace(NULL_RE, "\uFFFD");
4053     state.src = str;
4054   };
4055 });
4056
4057 // node_modules/markdown-it/lib/rules_core/block.js
4058 var require_block = __commonJS((exports2, module2) => {
4059   "use strict";
4060   module2.exports = function block(state) {
4061     var token;
4062     if (state.inlineMode) {
4063       token = new state.Token("inline", "", 0);
4064       token.content = state.src;
4065       token.map = [0, 1];
4066       token.children = [];
4067       state.tokens.push(token);
4068     } else {
4069       state.md.block.parse(state.src, state.md, state.env, state.tokens);
4070     }
4071   };
4072 });
4073
4074 // node_modules/markdown-it/lib/rules_core/inline.js
4075 var require_inline = __commonJS((exports2, module2) => {
4076   "use strict";
4077   module2.exports = function inline(state) {
4078     var tokens = state.tokens, tok, i, l;
4079     for (i = 0, l = tokens.length; i < l; i++) {
4080       tok = tokens[i];
4081       if (tok.type === "inline") {
4082         state.md.inline.parse(tok.content, state.md, state.env, tok.children);
4083       }
4084     }
4085   };
4086 });
4087
4088 // node_modules/markdown-it/lib/rules_core/linkify.js
4089 var require_linkify = __commonJS((exports2, module2) => {
4090   "use strict";
4091   var arrayReplaceAt = require_utils().arrayReplaceAt;
4092   function isLinkOpen(str) {
4093     return /^<a[>\s]/i.test(str);
4094   }
4095   function isLinkClose(str) {
4096     return /^<\/a\s*>/i.test(str);
4097   }
4098   module2.exports = function linkify(state) {
4099     var i, j, l, tokens, token, currentToken, nodes, ln, text, pos, lastPos, level, htmlLinkLevel, url, fullUrl, urlText, blockTokens = state.tokens, links;
4100     if (!state.md.options.linkify) {
4101       return;
4102     }
4103     for (j = 0, l = blockTokens.length; j < l; j++) {
4104       if (blockTokens[j].type !== "inline" || !state.md.linkify.pretest(blockTokens[j].content)) {
4105         continue;
4106       }
4107       tokens = blockTokens[j].children;
4108       htmlLinkLevel = 0;
4109       for (i = tokens.length - 1; i >= 0; i--) {
4110         currentToken = tokens[i];
4111         if (currentToken.type === "link_close") {
4112           i--;
4113           while (tokens[i].level !== currentToken.level && tokens[i].type !== "link_open") {
4114             i--;
4115           }
4116           continue;
4117         }
4118         if (currentToken.type === "html_inline") {
4119           if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
4120             htmlLinkLevel--;
4121           }
4122           if (isLinkClose(currentToken.content)) {
4123             htmlLinkLevel++;
4124           }
4125         }
4126         if (htmlLinkLevel > 0) {
4127           continue;
4128         }
4129         if (currentToken.type === "text" && state.md.linkify.test(currentToken.content)) {
4130           text = currentToken.content;
4131           links = state.md.linkify.match(text);
4132           nodes = [];
4133           level = currentToken.level;
4134           lastPos = 0;
4135           for (ln = 0; ln < links.length; ln++) {
4136             url = links[ln].url;
4137             fullUrl = state.md.normalizeLink(url);
4138             if (!state.md.validateLink(fullUrl)) {
4139               continue;
4140             }
4141             urlText = links[ln].text;
4142             if (!links[ln].schema) {
4143               urlText = state.md.normalizeLinkText("http://" + urlText).replace(/^http:\/\//, "");
4144             } else if (links[ln].schema === "mailto:" && !/^mailto:/i.test(urlText)) {
4145               urlText = state.md.normalizeLinkText("mailto:" + urlText).replace(/^mailto:/, "");
4146             } else {
4147               urlText = state.md.normalizeLinkText(urlText);
4148             }
4149             pos = links[ln].index;
4150             if (pos > lastPos) {
4151               token = new state.Token("text", "", 0);
4152               token.content = text.slice(lastPos, pos);
4153               token.level = level;
4154               nodes.push(token);
4155             }
4156             token = new state.Token("link_open", "a", 1);
4157             token.attrs = [["href", fullUrl]];
4158             token.level = level++;
4159             token.markup = "linkify";
4160             token.info = "auto";
4161             nodes.push(token);
4162             token = new state.Token("text", "", 0);
4163             token.content = urlText;
4164             token.level = level;
4165             nodes.push(token);
4166             token = new state.Token("link_close", "a", -1);
4167             token.level = --level;
4168             token.markup = "linkify";
4169             token.info = "auto";
4170             nodes.push(token);
4171             lastPos = links[ln].lastIndex;
4172           }
4173           if (lastPos < text.length) {
4174             token = new state.Token("text", "", 0);
4175             token.content = text.slice(lastPos);
4176             token.level = level;
4177             nodes.push(token);
4178           }
4179           blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
4180         }
4181       }
4182     }
4183   };
4184 });
4185
4186 // node_modules/markdown-it/lib/rules_core/replacements.js
4187 var require_replacements = __commonJS((exports2, module2) => {
4188   "use strict";
4189   var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
4190   var SCOPED_ABBR_TEST_RE = /\((c|tm|r|p)\)/i;
4191   var SCOPED_ABBR_RE = /\((c|tm|r|p)\)/ig;
4192   var SCOPED_ABBR = {
4193     c: "\xA9",
4194     r: "\xAE",
4195     p: "\xA7",
4196     tm: "\u2122"
4197   };
4198   function replaceFn(match, name) {
4199     return SCOPED_ABBR[name.toLowerCase()];
4200   }
4201   function replace_scoped(inlineTokens) {
4202     var i, token, inside_autolink = 0;
4203     for (i = inlineTokens.length - 1; i >= 0; i--) {
4204       token = inlineTokens[i];
4205       if (token.type === "text" && !inside_autolink) {
4206         token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
4207       }
4208       if (token.type === "link_open" && token.info === "auto") {
4209         inside_autolink--;
4210       }
4211       if (token.type === "link_close" && token.info === "auto") {
4212         inside_autolink++;
4213       }
4214     }
4215   }
4216   function replace_rare(inlineTokens) {
4217     var i, token, inside_autolink = 0;
4218     for (i = inlineTokens.length - 1; i >= 0; i--) {
4219       token = inlineTokens[i];
4220       if (token.type === "text" && !inside_autolink) {
4221         if (RARE_RE.test(token.content)) {
4222           token.content = token.content.replace(/\+-/g, "\xB1").replace(/\.{2,}/g, "\u2026").replace(/([?!])…/g, "$1..").replace(/([?!]){4,}/g, "$1$1$1").replace(/,{2,}/g, ",").replace(/(^|[^-])---(?=[^-]|$)/mg, "$1\u2014").replace(/(^|\s)--(?=\s|$)/mg, "$1\u2013").replace(/(^|[^-\s])--(?=[^-\s]|$)/mg, "$1\u2013");
4223         }
4224       }
4225       if (token.type === "link_open" && token.info === "auto") {
4226         inside_autolink--;
4227       }
4228       if (token.type === "link_close" && token.info === "auto") {
4229         inside_autolink++;
4230       }
4231     }
4232   }
4233   module2.exports = function replace(state) {
4234     var blkIdx;
4235     if (!state.md.options.typographer) {
4236       return;
4237     }
4238     for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
4239       if (state.tokens[blkIdx].type !== "inline") {
4240         continue;
4241       }
4242       if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
4243         replace_scoped(state.tokens[blkIdx].children);
4244       }
4245       if (RARE_RE.test(state.tokens[blkIdx].content)) {
4246         replace_rare(state.tokens[blkIdx].children);
4247       }
4248     }
4249   };
4250 });
4251
4252 // node_modules/markdown-it/lib/rules_core/smartquotes.js
4253 var require_smartquotes = __commonJS((exports2, module2) => {
4254   "use strict";
4255   var isWhiteSpace = require_utils().isWhiteSpace;
4256   var isPunctChar = require_utils().isPunctChar;
4257   var isMdAsciiPunct = require_utils().isMdAsciiPunct;
4258   var QUOTE_TEST_RE = /['"]/;
4259   var QUOTE_RE = /['"]/g;
4260   var APOSTROPHE = "\u2019";
4261   function replaceAt(str, index, ch) {
4262     return str.substr(0, index) + ch + str.substr(index + 1);
4263   }
4264   function process_inlines(tokens, state) {
4265     var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar, isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace, canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;
4266     stack = [];
4267     for (i = 0; i < tokens.length; i++) {
4268       token = tokens[i];
4269       thisLevel = tokens[i].level;
4270       for (j = stack.length - 1; j >= 0; j--) {
4271         if (stack[j].level <= thisLevel) {
4272           break;
4273         }
4274       }
4275       stack.length = j + 1;
4276       if (token.type !== "text") {
4277         continue;
4278       }
4279       text = token.content;
4280       pos = 0;
4281       max = text.length;
4282       OUTER:
4283         while (pos < max) {
4284           QUOTE_RE.lastIndex = pos;
4285           t = QUOTE_RE.exec(text);
4286           if (!t) {
4287             break;
4288           }
4289           canOpen = canClose = true;
4290           pos = t.index + 1;
4291           isSingle = t[0] === "'";
4292           lastChar = 32;
4293           if (t.index - 1 >= 0) {
4294             lastChar = text.charCodeAt(t.index - 1);
4295           } else {
4296             for (j = i - 1; j >= 0; j--) {
4297               if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak")
4298                 break;
4299               if (!tokens[j].content)
4300                 continue;
4301               lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);
4302               break;
4303             }
4304           }
4305           nextChar = 32;
4306           if (pos < max) {
4307             nextChar = text.charCodeAt(pos);
4308           } else {
4309             for (j = i + 1; j < tokens.length; j++) {
4310               if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak")
4311                 break;
4312               if (!tokens[j].content)
4313                 continue;
4314               nextChar = tokens[j].content.charCodeAt(0);
4315               break;
4316             }
4317           }
4318           isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
4319           isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
4320           isLastWhiteSpace = isWhiteSpace(lastChar);
4321           isNextWhiteSpace = isWhiteSpace(nextChar);
4322           if (isNextWhiteSpace) {
4323             canOpen = false;
4324           } else if (isNextPunctChar) {
4325             if (!(isLastWhiteSpace || isLastPunctChar)) {
4326               canOpen = false;
4327             }
4328           }
4329           if (isLastWhiteSpace) {
4330             canClose = false;
4331           } else if (isLastPunctChar) {
4332             if (!(isNextWhiteSpace || isNextPunctChar)) {
4333               canClose = false;
4334             }
4335           }
4336           if (nextChar === 34 && t[0] === '"') {
4337             if (lastChar >= 48 && lastChar <= 57) {
4338               canClose = canOpen = false;
4339             }
4340           }
4341           if (canOpen && canClose) {
4342             canOpen = isLastPunctChar;
4343             canClose = isNextPunctChar;
4344           }
4345           if (!canOpen && !canClose) {
4346             if (isSingle) {
4347               token.content = replaceAt(token.content, t.index, APOSTROPHE);
4348             }
4349             continue;
4350           }
4351           if (canClose) {
4352             for (j = stack.length - 1; j >= 0; j--) {
4353               item = stack[j];
4354               if (stack[j].level < thisLevel) {
4355                 break;
4356               }
4357               if (item.single === isSingle && stack[j].level === thisLevel) {
4358                 item = stack[j];
4359                 if (isSingle) {
4360                   openQuote = state.md.options.quotes[2];
4361                   closeQuote = state.md.options.quotes[3];
4362                 } else {
4363                   openQuote = state.md.options.quotes[0];
4364                   closeQuote = state.md.options.quotes[1];
4365                 }
4366                 token.content = replaceAt(token.content, t.index, closeQuote);
4367                 tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, openQuote);
4368                 pos += closeQuote.length - 1;
4369                 if (item.token === i) {
4370                   pos += openQuote.length - 1;
4371                 }
4372                 text = token.content;
4373                 max = text.length;
4374                 stack.length = j;
4375                 continue OUTER;
4376               }
4377             }
4378           }
4379           if (canOpen) {
4380             stack.push({
4381               token: i,
4382               pos: t.index,
4383               single: isSingle,
4384               level: thisLevel
4385             });
4386           } else if (canClose && isSingle) {
4387             token.content = replaceAt(token.content, t.index, APOSTROPHE);
4388           }
4389         }
4390     }
4391   }
4392   module2.exports = function smartquotes(state) {
4393     var blkIdx;
4394     if (!state.md.options.typographer) {
4395       return;
4396     }
4397     for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
4398       if (state.tokens[blkIdx].type !== "inline" || !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
4399         continue;
4400       }
4401       process_inlines(state.tokens[blkIdx].children, state);
4402     }
4403   };
4404 });
4405
4406 // node_modules/markdown-it/lib/token.js
4407 var require_token = __commonJS((exports2, module2) => {
4408   "use strict";
4409   function Token(type, tag, nesting) {
4410     this.type = type;
4411     this.tag = tag;
4412     this.attrs = null;
4413     this.map = null;
4414     this.nesting = nesting;
4415     this.level = 0;
4416     this.children = null;
4417     this.content = "";
4418     this.markup = "";
4419     this.info = "";
4420     this.meta = null;
4421     this.block = false;
4422     this.hidden = false;
4423   }
4424   Token.prototype.attrIndex = function attrIndex(name) {
4425     var attrs, i, len;
4426     if (!this.attrs) {
4427       return -1;
4428     }
4429     attrs = this.attrs;
4430     for (i = 0, len = attrs.length; i < len; i++) {
4431       if (attrs[i][0] === name) {
4432         return i;
4433       }
4434     }
4435     return -1;
4436   };
4437   Token.prototype.attrPush = function attrPush(attrData) {
4438     if (this.attrs) {
4439       this.attrs.push(attrData);
4440     } else {
4441       this.attrs = [attrData];
4442     }
4443   };
4444   Token.prototype.attrSet = function attrSet(name, value) {
4445     var idx = this.attrIndex(name), attrData = [name, value];
4446     if (idx < 0) {
4447       this.attrPush(attrData);
4448     } else {
4449       this.attrs[idx] = attrData;
4450     }
4451   };
4452   Token.prototype.attrGet = function attrGet(name) {
4453     var idx = this.attrIndex(name), value = null;
4454     if (idx >= 0) {
4455       value = this.attrs[idx][1];
4456     }
4457     return value;
4458   };
4459   Token.prototype.attrJoin = function attrJoin(name, value) {
4460     var idx = this.attrIndex(name);
4461     if (idx < 0) {
4462       this.attrPush([name, value]);
4463     } else {
4464       this.attrs[idx][1] = this.attrs[idx][1] + " " + value;
4465     }
4466   };
4467   module2.exports = Token;
4468 });
4469
4470 // node_modules/markdown-it/lib/rules_core/state_core.js
4471 var require_state_core = __commonJS((exports2, module2) => {
4472   "use strict";
4473   var Token = require_token();
4474   function StateCore(src, md, env) {
4475     this.src = src;
4476     this.env = env;
4477     this.tokens = [];
4478     this.inlineMode = false;
4479     this.md = md;
4480   }
4481   StateCore.prototype.Token = Token;
4482   module2.exports = StateCore;
4483 });
4484
4485 // node_modules/markdown-it/lib/parser_core.js
4486 var require_parser_core = __commonJS((exports2, module2) => {
4487   "use strict";
4488   var Ruler = require_ruler();
4489   var _rules = [
4490     ["normalize", require_normalize()],
4491     ["block", require_block()],
4492     ["inline", require_inline()],
4493     ["linkify", require_linkify()],
4494     ["replacements", require_replacements()],
4495     ["smartquotes", require_smartquotes()]
4496   ];
4497   function Core() {
4498     this.ruler = new Ruler();
4499     for (var i = 0; i < _rules.length; i++) {
4500       this.ruler.push(_rules[i][0], _rules[i][1]);
4501     }
4502   }
4503   Core.prototype.process = function(state) {
4504     var i, l, rules;
4505     rules = this.ruler.getRules("");
4506     for (i = 0, l = rules.length; i < l; i++) {
4507       rules[i](state);
4508     }
4509   };
4510   Core.prototype.State = require_state_core();
4511   module2.exports = Core;
4512 });
4513
4514 // node_modules/markdown-it/lib/rules_block/table.js
4515 var require_table = __commonJS((exports2, module2) => {
4516   "use strict";
4517   var isSpace = require_utils().isSpace;
4518   function getLine(state, line) {
4519     var pos = state.bMarks[line] + state.tShift[line], max = state.eMarks[line];
4520     return state.src.substr(pos, max - pos);
4521   }
4522   function escapedSplit(str) {
4523     var result = [], pos = 0, max = str.length, ch, isEscaped = false, lastPos = 0, current = "";
4524     ch = str.charCodeAt(pos);
4525     while (pos < max) {
4526       if (ch === 124) {
4527         if (!isEscaped) {
4528           result.push(current + str.substring(lastPos, pos));
4529           current = "";
4530           lastPos = pos + 1;
4531         } else {
4532           current += str.substring(lastPos, pos - 1);
4533           lastPos = pos;
4534         }
4535       }
4536       isEscaped = ch === 92;
4537       pos++;
4538       ch = str.charCodeAt(pos);
4539     }
4540     result.push(current + str.substring(lastPos));
4541     return result;
4542   }
4543   module2.exports = function table(state, startLine, endLine, silent) {
4544     var ch, lineText, pos, i, l, nextLine, columns, columnCount, token, aligns, t, tableLines, tbodyLines, oldParentType, terminate, terminatorRules;
4545     if (startLine + 2 > endLine) {
4546       return false;
4547     }
4548     nextLine = startLine + 1;
4549     if (state.sCount[nextLine] < state.blkIndent) {
4550       return false;
4551     }
4552     if (state.sCount[nextLine] - state.blkIndent >= 4) {
4553       return false;
4554     }
4555     pos = state.bMarks[nextLine] + state.tShift[nextLine];
4556     if (pos >= state.eMarks[nextLine]) {
4557       return false;
4558     }
4559     ch = state.src.charCodeAt(pos++);
4560     if (ch !== 124 && ch !== 45 && ch !== 58) {
4561       return false;
4562     }
4563     while (pos < state.eMarks[nextLine]) {
4564       ch = state.src.charCodeAt(pos);
4565       if (ch !== 124 && ch !== 45 && ch !== 58 && !isSpace(ch)) {
4566         return false;
4567       }
4568       pos++;
4569     }
4570     lineText = getLine(state, startLine + 1);
4571     columns = lineText.split("|");
4572     aligns = [];
4573     for (i = 0; i < columns.length; i++) {
4574       t = columns[i].trim();
4575       if (!t) {
4576         if (i === 0 || i === columns.length - 1) {
4577           continue;
4578         } else {
4579           return false;
4580         }
4581       }
4582       if (!/^:?-+:?$/.test(t)) {
4583         return false;
4584       }
4585       if (t.charCodeAt(t.length - 1) === 58) {
4586         aligns.push(t.charCodeAt(0) === 58 ? "center" : "right");
4587       } else if (t.charCodeAt(0) === 58) {
4588         aligns.push("left");
4589       } else {
4590         aligns.push("");
4591       }
4592     }
4593     lineText = getLine(state, startLine).trim();
4594     if (lineText.indexOf("|") === -1) {
4595       return false;
4596     }
4597     if (state.sCount[startLine] - state.blkIndent >= 4) {
4598       return false;
4599     }
4600     columns = escapedSplit(lineText);
4601     if (columns.length && columns[0] === "")
4602       columns.shift();
4603     if (columns.length && columns[columns.length - 1] === "")
4604       columns.pop();
4605     columnCount = columns.length;
4606     if (columnCount === 0 || columnCount !== aligns.length) {
4607       return false;
4608     }
4609     if (silent) {
4610       return true;
4611     }
4612     oldParentType = state.parentType;
4613     state.parentType = "table";
4614     terminatorRules = state.md.block.ruler.getRules("blockquote");
4615     token = state.push("table_open", "table", 1);
4616     token.map = tableLines = [startLine, 0];
4617     token = state.push("thead_open", "thead", 1);
4618     token.map = [startLine, startLine + 1];
4619     token = state.push("tr_open", "tr", 1);
4620     token.map = [startLine, startLine + 1];
4621     for (i = 0; i < columns.length; i++) {
4622       token = state.push("th_open", "th", 1);
4623       if (aligns[i]) {
4624         token.attrs = [["style", "text-align:" + aligns[i]]];
4625       }
4626       token = state.push("inline", "", 0);
4627       token.content = columns[i].trim();
4628       token.children = [];
4629       token = state.push("th_close", "th", -1);
4630     }
4631     token = state.push("tr_close", "tr", -1);
4632     token = state.push("thead_close", "thead", -1);
4633     for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
4634       if (state.sCount[nextLine] < state.blkIndent) {
4635         break;
4636       }
4637       terminate = false;
4638       for (i = 0, l = terminatorRules.length; i < l; i++) {
4639         if (terminatorRules[i](state, nextLine, endLine, true)) {
4640           terminate = true;
4641           break;
4642         }
4643       }
4644       if (terminate) {
4645         break;
4646       }
4647       lineText = getLine(state, nextLine).trim();
4648       if (!lineText) {
4649         break;
4650       }
4651       if (state.sCount[nextLine] - state.blkIndent >= 4) {
4652         break;
4653       }
4654       columns = escapedSplit(lineText);
4655       if (columns.length && columns[0] === "")
4656         columns.shift();
4657       if (columns.length && columns[columns.length - 1] === "")
4658         columns.pop();
4659       if (nextLine === startLine + 2) {
4660         token = state.push("tbody_open", "tbody", 1);
4661         token.map = tbodyLines = [startLine + 2, 0];
4662       }
4663       token = state.push("tr_open", "tr", 1);
4664       token.map = [nextLine, nextLine + 1];
4665       for (i = 0; i < columnCount; i++) {
4666         token = state.push("td_open", "td", 1);
4667         if (aligns[i]) {
4668           token.attrs = [["style", "text-align:" + aligns[i]]];
4669         }
4670         token = state.push("inline", "", 0);
4671         token.content = columns[i] ? columns[i].trim() : "";
4672         token.children = [];
4673         token = state.push("td_close", "td", -1);
4674       }
4675       token = state.push("tr_close", "tr", -1);
4676     }
4677     if (tbodyLines) {
4678       token = state.push("tbody_close", "tbody", -1);
4679       tbodyLines[1] = nextLine;
4680     }
4681     token = state.push("table_close", "table", -1);
4682     tableLines[1] = nextLine;
4683     state.parentType = oldParentType;
4684     state.line = nextLine;
4685     return true;
4686   };
4687 });
4688
4689 // node_modules/markdown-it/lib/rules_block/code.js
4690 var require_code = __commonJS((exports2, module2) => {
4691   "use strict";
4692   module2.exports = function code(state, startLine, endLine) {
4693     var nextLine, last, token;
4694     if (state.sCount[startLine] - state.blkIndent < 4) {
4695       return false;
4696     }
4697     last = nextLine = startLine + 1;
4698     while (nextLine < endLine) {
4699       if (state.isEmpty(nextLine)) {
4700         nextLine++;
4701         continue;
4702       }
4703       if (state.sCount[nextLine] - state.blkIndent >= 4) {
4704         nextLine++;
4705         last = nextLine;
4706         continue;
4707       }
4708       break;
4709     }
4710     state.line = last;
4711     token = state.push("code_block", "code", 0);
4712     token.content = state.getLines(startLine, last, 4 + state.blkIndent, true);
4713     token.map = [startLine, state.line];
4714     return true;
4715   };
4716 });
4717
4718 // node_modules/markdown-it/lib/rules_block/fence.js
4719 var require_fence = __commonJS((exports2, module2) => {
4720   "use strict";
4721   module2.exports = function fence(state, startLine, endLine, silent) {
4722     var marker, len, params, nextLine, mem, token, markup, haveEndMarker = false, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
4723     if (state.sCount[startLine] - state.blkIndent >= 4) {
4724       return false;
4725     }
4726     if (pos + 3 > max) {
4727       return false;
4728     }
4729     marker = state.src.charCodeAt(pos);
4730     if (marker !== 126 && marker !== 96) {
4731       return false;
4732     }
4733     mem = pos;
4734     pos = state.skipChars(pos, marker);
4735     len = pos - mem;
4736     if (len < 3) {
4737       return false;
4738     }
4739     markup = state.src.slice(mem, pos);
4740     params = state.src.slice(pos, max);
4741     if (marker === 96) {
4742       if (params.indexOf(String.fromCharCode(marker)) >= 0) {
4743         return false;
4744       }
4745     }
4746     if (silent) {
4747       return true;
4748     }
4749     nextLine = startLine;
4750     for (; ; ) {
4751       nextLine++;
4752       if (nextLine >= endLine) {
4753         break;
4754       }
4755       pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
4756       max = state.eMarks[nextLine];
4757       if (pos < max && state.sCount[nextLine] < state.blkIndent) {
4758         break;
4759       }
4760       if (state.src.charCodeAt(pos) !== marker) {
4761         continue;
4762       }
4763       if (state.sCount[nextLine] - state.blkIndent >= 4) {
4764         continue;
4765       }
4766       pos = state.skipChars(pos, marker);
4767       if (pos - mem < len) {
4768         continue;
4769       }
4770       pos = state.skipSpaces(pos);
4771       if (pos < max) {
4772         continue;
4773       }
4774       haveEndMarker = true;
4775       break;
4776     }
4777     len = state.sCount[startLine];
4778     state.line = nextLine + (haveEndMarker ? 1 : 0);
4779     token = state.push("fence", "code", 0);
4780     token.info = params;
4781     token.content = state.getLines(startLine + 1, nextLine, len, true);
4782     token.markup = markup;
4783     token.map = [startLine, state.line];
4784     return true;
4785   };
4786 });
4787
4788 // node_modules/markdown-it/lib/rules_block/blockquote.js
4789 var require_blockquote = __commonJS((exports2, module2) => {
4790   "use strict";
4791   var isSpace = require_utils().isSpace;
4792   module2.exports = function blockquote(state, startLine, endLine, silent) {
4793     var adjustTab, ch, i, initial, l, lastLineEmpty, lines, nextLine, offset, oldBMarks, oldBSCount, oldIndent, oldParentType, oldSCount, oldTShift, spaceAfterMarker, terminate, terminatorRules, token, isOutdented, oldLineMax = state.lineMax, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
4794     if (state.sCount[startLine] - state.blkIndent >= 4) {
4795       return false;
4796     }
4797     if (state.src.charCodeAt(pos++) !== 62) {
4798       return false;
4799     }
4800     if (silent) {
4801       return true;
4802     }
4803     initial = offset = state.sCount[startLine] + 1;
4804     if (state.src.charCodeAt(pos) === 32) {
4805       pos++;
4806       initial++;
4807       offset++;
4808       adjustTab = false;
4809       spaceAfterMarker = true;
4810     } else if (state.src.charCodeAt(pos) === 9) {
4811       spaceAfterMarker = true;
4812       if ((state.bsCount[startLine] + offset) % 4 === 3) {
4813         pos++;
4814         initial++;
4815         offset++;
4816         adjustTab = false;
4817       } else {
4818         adjustTab = true;
4819       }
4820     } else {
4821       spaceAfterMarker = false;
4822     }
4823     oldBMarks = [state.bMarks[startLine]];
4824     state.bMarks[startLine] = pos;
4825     while (pos < max) {
4826       ch = state.src.charCodeAt(pos);
4827       if (isSpace(ch)) {
4828         if (ch === 9) {
4829           offset += 4 - (offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4;
4830         } else {
4831           offset++;
4832         }
4833       } else {
4834         break;
4835       }
4836       pos++;
4837     }
4838     oldBSCount = [state.bsCount[startLine]];
4839     state.bsCount[startLine] = state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0);
4840     lastLineEmpty = pos >= max;
4841     oldSCount = [state.sCount[startLine]];
4842     state.sCount[startLine] = offset - initial;
4843     oldTShift = [state.tShift[startLine]];
4844     state.tShift[startLine] = pos - state.bMarks[startLine];
4845     terminatorRules = state.md.block.ruler.getRules("blockquote");
4846     oldParentType = state.parentType;
4847     state.parentType = "blockquote";
4848     for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
4849       isOutdented = state.sCount[nextLine] < state.blkIndent;
4850       pos = state.bMarks[nextLine] + state.tShift[nextLine];
4851       max = state.eMarks[nextLine];
4852       if (pos >= max) {
4853         break;
4854       }
4855       if (state.src.charCodeAt(pos++) === 62 && !isOutdented) {
4856         initial = offset = state.sCount[nextLine] + 1;
4857         if (state.src.charCodeAt(pos) === 32) {
4858           pos++;
4859           initial++;
4860           offset++;
4861           adjustTab = false;
4862           spaceAfterMarker = true;
4863         } else if (state.src.charCodeAt(pos) === 9) {
4864           spaceAfterMarker = true;
4865           if ((state.bsCount[nextLine] + offset) % 4 === 3) {
4866             pos++;
4867             initial++;
4868             offset++;
4869             adjustTab = false;
4870           } else {
4871             adjustTab = true;
4872           }
4873         } else {
4874           spaceAfterMarker = false;
4875         }
4876         oldBMarks.push(state.bMarks[nextLine]);
4877         state.bMarks[nextLine] = pos;
4878         while (pos < max) {
4879           ch = state.src.charCodeAt(pos);
4880           if (isSpace(ch)) {
4881             if (ch === 9) {
4882               offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
4883             } else {
4884               offset++;
4885             }
4886           } else {
4887             break;
4888           }
4889           pos++;
4890         }
4891         lastLineEmpty = pos >= max;
4892         oldBSCount.push(state.bsCount[nextLine]);
4893         state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);
4894         oldSCount.push(state.sCount[nextLine]);
4895         state.sCount[nextLine] = offset - initial;
4896         oldTShift.push(state.tShift[nextLine]);
4897         state.tShift[nextLine] = pos - state.bMarks[nextLine];
4898         continue;
4899       }
4900       if (lastLineEmpty) {
4901         break;
4902       }
4903       terminate = false;
4904       for (i = 0, l = terminatorRules.length; i < l; i++) {
4905         if (terminatorRules[i](state, nextLine, endLine, true)) {
4906           terminate = true;
4907           break;
4908         }
4909       }
4910       if (terminate) {
4911         state.lineMax = nextLine;
4912         if (state.blkIndent !== 0) {
4913           oldBMarks.push(state.bMarks[nextLine]);
4914           oldBSCount.push(state.bsCount[nextLine]);
4915           oldTShift.push(state.tShift[nextLine]);
4916           oldSCount.push(state.sCount[nextLine]);
4917           state.sCount[nextLine] -= state.blkIndent;
4918         }
4919         break;
4920       }
4921       oldBMarks.push(state.bMarks[nextLine]);
4922       oldBSCount.push(state.bsCount[nextLine]);
4923       oldTShift.push(state.tShift[nextLine]);
4924       oldSCount.push(state.sCount[nextLine]);
4925       state.sCount[nextLine] = -1;
4926     }
4927     oldIndent = state.blkIndent;
4928     state.blkIndent = 0;
4929     token = state.push("blockquote_open", "blockquote", 1);
4930     token.markup = ">";
4931     token.map = lines = [startLine, 0];
4932     state.md.block.tokenize(state, startLine, nextLine);
4933     token = state.push("blockquote_close", "blockquote", -1);
4934     token.markup = ">";
4935     state.lineMax = oldLineMax;
4936     state.parentType = oldParentType;
4937     lines[1] = state.line;
4938     for (i = 0; i < oldTShift.length; i++) {
4939       state.bMarks[i + startLine] = oldBMarks[i];
4940       state.tShift[i + startLine] = oldTShift[i];
4941       state.sCount[i + startLine] = oldSCount[i];
4942       state.bsCount[i + startLine] = oldBSCount[i];
4943     }
4944     state.blkIndent = oldIndent;
4945     return true;
4946   };
4947 });
4948
4949 // node_modules/markdown-it/lib/rules_block/hr.js
4950 var require_hr = __commonJS((exports2, module2) => {
4951   "use strict";
4952   var isSpace = require_utils().isSpace;
4953   module2.exports = function hr(state, startLine, endLine, silent) {
4954     var marker, cnt, ch, token, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
4955     if (state.sCount[startLine] - state.blkIndent >= 4) {
4956       return false;
4957     }
4958     marker = state.src.charCodeAt(pos++);
4959     if (marker !== 42 && marker !== 45 && marker !== 95) {
4960       return false;
4961     }
4962     cnt = 1;
4963     while (pos < max) {
4964       ch = state.src.charCodeAt(pos++);
4965       if (ch !== marker && !isSpace(ch)) {
4966         return false;
4967       }
4968       if (ch === marker) {
4969         cnt++;
4970       }
4971     }
4972     if (cnt < 3) {
4973       return false;
4974     }
4975     if (silent) {
4976       return true;
4977     }
4978     state.line = startLine + 1;
4979     token = state.push("hr", "hr", 0);
4980     token.map = [startLine, state.line];
4981     token.markup = Array(cnt + 1).join(String.fromCharCode(marker));
4982     return true;
4983   };
4984 });
4985
4986 // node_modules/markdown-it/lib/rules_block/list.js
4987 var require_list = __commonJS((exports2, module2) => {
4988   "use strict";
4989   var isSpace = require_utils().isSpace;
4990   function skipBulletListMarker(state, startLine) {
4991     var marker, pos, max, ch;
4992     pos = state.bMarks[startLine] + state.tShift[startLine];
4993     max = state.eMarks[startLine];
4994     marker = state.src.charCodeAt(pos++);
4995     if (marker !== 42 && marker !== 45 && marker !== 43) {
4996       return -1;
4997     }
4998     if (pos < max) {
4999       ch = state.src.charCodeAt(pos);
5000       if (!isSpace(ch)) {
5001         return -1;
5002       }
5003     }
5004     return pos;
5005   }
5006   function skipOrderedListMarker(state, startLine) {
5007     var ch, start = state.bMarks[startLine] + state.tShift[startLine], pos = start, max = state.eMarks[startLine];
5008     if (pos + 1 >= max) {
5009       return -1;
5010     }
5011     ch = state.src.charCodeAt(pos++);
5012     if (ch < 48 || ch > 57) {
5013       return -1;
5014     }
5015     for (; ; ) {
5016       if (pos >= max) {
5017         return -1;
5018       }
5019       ch = state.src.charCodeAt(pos++);
5020       if (ch >= 48 && ch <= 57) {
5021         if (pos - start >= 10) {
5022           return -1;
5023         }
5024         continue;
5025       }
5026       if (ch === 41 || ch === 46) {
5027         break;
5028       }
5029       return -1;
5030     }
5031     if (pos < max) {
5032       ch = state.src.charCodeAt(pos);
5033       if (!isSpace(ch)) {
5034         return -1;
5035       }
5036     }
5037     return pos;
5038   }
5039   function markTightParagraphs(state, idx) {
5040     var i, l, level = state.level + 2;
5041     for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
5042       if (state.tokens[i].level === level && state.tokens[i].type === "paragraph_open") {
5043         state.tokens[i + 2].hidden = true;
5044         state.tokens[i].hidden = true;
5045         i += 2;
5046       }
5047     }
5048   }
5049   module2.exports = function list(state, startLine, endLine, silent) {
5050     var ch, contentStart, i, indent, indentAfterMarker, initial, isOrdered, itemLines, l, listLines, listTokIdx, markerCharCode, markerValue, max, nextLine, offset, oldListIndent, oldParentType, oldSCount, oldTShift, oldTight, pos, posAfterMarker, prevEmptyEnd, start, terminate, terminatorRules, token, isTerminatingParagraph = false, tight = true;
5051     if (state.sCount[startLine] - state.blkIndent >= 4) {
5052       return false;
5053     }
5054     if (state.listIndent >= 0 && state.sCount[startLine] - state.listIndent >= 4 && state.sCount[startLine] < state.blkIndent) {
5055       return false;
5056     }
5057     if (silent && state.parentType === "paragraph") {
5058       if (state.tShift[startLine] >= state.blkIndent) {
5059         isTerminatingParagraph = true;
5060       }
5061     }
5062     if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {
5063       isOrdered = true;
5064       start = state.bMarks[startLine] + state.tShift[startLine];
5065       markerValue = Number(state.src.substr(start, posAfterMarker - start - 1));
5066       if (isTerminatingParagraph && markerValue !== 1)
5067         return false;
5068     } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {
5069       isOrdered = false;
5070     } else {
5071       return false;
5072     }
5073     if (isTerminatingParagraph) {
5074       if (state.skipSpaces(posAfterMarker) >= state.eMarks[startLine])
5075         return false;
5076     }
5077     markerCharCode = state.src.charCodeAt(posAfterMarker - 1);
5078     if (silent) {
5079       return true;
5080     }
5081     listTokIdx = state.tokens.length;
5082     if (isOrdered) {
5083       token = state.push("ordered_list_open", "ol", 1);
5084       if (markerValue !== 1) {
5085         token.attrs = [["start", markerValue]];
5086       }
5087     } else {
5088       token = state.push("bullet_list_open", "ul", 1);
5089     }
5090     token.map = listLines = [startLine, 0];
5091     token.markup = String.fromCharCode(markerCharCode);
5092     nextLine = startLine;
5093     prevEmptyEnd = false;
5094     terminatorRules = state.md.block.ruler.getRules("list");
5095     oldParentType = state.parentType;
5096     state.parentType = "list";
5097     while (nextLine < endLine) {
5098       pos = posAfterMarker;
5099       max = state.eMarks[nextLine];
5100       initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine]);
5101       while (pos < max) {
5102         ch = state.src.charCodeAt(pos);
5103         if (ch === 9) {
5104           offset += 4 - (offset + state.bsCount[nextLine]) % 4;
5105         } else if (ch === 32) {
5106           offset++;
5107         } else {
5108           break;
5109         }
5110         pos++;
5111       }
5112       contentStart = pos;
5113       if (contentStart >= max) {
5114         indentAfterMarker = 1;
5115       } else {
5116         indentAfterMarker = offset - initial;
5117       }
5118       if (indentAfterMarker > 4) {
5119         indentAfterMarker = 1;
5120       }
5121       indent = initial + indentAfterMarker;
5122       token = state.push("list_item_open", "li", 1);
5123       token.markup = String.fromCharCode(markerCharCode);
5124       token.map = itemLines = [startLine, 0];
5125       oldTight = state.tight;
5126       oldTShift = state.tShift[startLine];
5127       oldSCount = state.sCount[startLine];
5128       oldListIndent = state.listIndent;
5129       state.listIndent = state.blkIndent;
5130       state.blkIndent = indent;
5131       state.tight = true;
5132       state.tShift[startLine] = contentStart - state.bMarks[startLine];
5133       state.sCount[startLine] = offset;
5134       if (contentStart >= max && state.isEmpty(startLine + 1)) {
5135         state.line = Math.min(state.line + 2, endLine);
5136       } else {
5137         state.md.block.tokenize(state, startLine, endLine, true);
5138       }
5139       if (!state.tight || prevEmptyEnd) {
5140         tight = false;
5141       }
5142       prevEmptyEnd = state.line - startLine > 1 && state.isEmpty(state.line - 1);
5143       state.blkIndent = state.listIndent;
5144       state.listIndent = oldListIndent;
5145       state.tShift[startLine] = oldTShift;
5146       state.sCount[startLine] = oldSCount;
5147       state.tight = oldTight;
5148       token = state.push("list_item_close", "li", -1);
5149       token.markup = String.fromCharCode(markerCharCode);
5150       nextLine = startLine = state.line;
5151       itemLines[1] = nextLine;
5152       contentStart = state.bMarks[startLine];
5153       if (nextLine >= endLine) {
5154         break;
5155       }
5156       if (state.sCount[nextLine] < state.blkIndent) {
5157         break;
5158       }
5159       if (state.sCount[startLine] - state.blkIndent >= 4) {
5160         break;
5161       }
5162       terminate = false;
5163       for (i = 0, l = terminatorRules.length; i < l; i++) {
5164         if (terminatorRules[i](state, nextLine, endLine, true)) {
5165           terminate = true;
5166           break;
5167         }
5168       }
5169       if (terminate) {
5170         break;
5171       }
5172       if (isOrdered) {
5173         posAfterMarker = skipOrderedListMarker(state, nextLine);
5174         if (posAfterMarker < 0) {
5175           break;
5176         }
5177       } else {
5178         posAfterMarker = skipBulletListMarker(state, nextLine);
5179         if (posAfterMarker < 0) {
5180           break;
5181         }
5182       }
5183       if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {
5184         break;
5185       }
5186     }
5187     if (isOrdered) {
5188       token = state.push("ordered_list_close", "ol", -1);
5189     } else {
5190       token = state.push("bullet_list_close", "ul", -1);
5191     }
5192     token.markup = String.fromCharCode(markerCharCode);
5193     listLines[1] = nextLine;
5194     state.line = nextLine;
5195     state.parentType = oldParentType;
5196     if (tight) {
5197       markTightParagraphs(state, listTokIdx);
5198     }
5199     return true;
5200   };
5201 });
5202
5203 // node_modules/markdown-it/lib/rules_block/reference.js
5204 var require_reference = __commonJS((exports2, module2) => {
5205   "use strict";
5206   var normalizeReference = require_utils().normalizeReference;
5207   var isSpace = require_utils().isSpace;
5208   module2.exports = function reference(state, startLine, _endLine, silent) {
5209     var ch, destEndPos, destEndLineNo, endLine, href, i, l, label, labelEnd, oldParentType, res, start, str, terminate, terminatorRules, title, lines = 0, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine], nextLine = startLine + 1;
5210     if (state.sCount[startLine] - state.blkIndent >= 4) {
5211       return false;
5212     }
5213     if (state.src.charCodeAt(pos) !== 91) {
5214       return false;
5215     }
5216     while (++pos < max) {
5217       if (state.src.charCodeAt(pos) === 93 && state.src.charCodeAt(pos - 1) !== 92) {
5218         if (pos + 1 === max) {
5219           return false;
5220         }
5221         if (state.src.charCodeAt(pos + 1) !== 58) {
5222           return false;
5223         }
5224         break;
5225       }
5226     }
5227     endLine = state.lineMax;
5228     terminatorRules = state.md.block.ruler.getRules("reference");
5229     oldParentType = state.parentType;
5230     state.parentType = "reference";
5231     for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
5232       if (state.sCount[nextLine] - state.blkIndent > 3) {
5233         continue;
5234       }
5235       if (state.sCount[nextLine] < 0) {
5236         continue;
5237       }
5238       terminate = false;
5239       for (i = 0, l = terminatorRules.length; i < l; i++) {
5240         if (terminatorRules[i](state, nextLine, endLine, true)) {
5241           terminate = true;
5242           break;
5243         }
5244       }
5245       if (terminate) {
5246         break;
5247       }
5248     }
5249     str = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
5250     max = str.length;
5251     for (pos = 1; pos < max; pos++) {
5252       ch = str.charCodeAt(pos);
5253       if (ch === 91) {
5254         return false;
5255       } else if (ch === 93) {
5256         labelEnd = pos;
5257         break;
5258       } else if (ch === 10) {
5259         lines++;
5260       } else if (ch === 92) {
5261         pos++;
5262         if (pos < max && str.charCodeAt(pos) === 10) {
5263           lines++;
5264         }
5265       }
5266     }
5267     if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 58) {
5268       return false;
5269     }
5270     for (pos = labelEnd + 2; pos < max; pos++) {
5271       ch = str.charCodeAt(pos);
5272       if (ch === 10) {
5273         lines++;
5274       } else if (isSpace(ch)) {
5275       } else {
5276         break;
5277       }
5278     }
5279     res = state.md.helpers.parseLinkDestination(str, pos, max);
5280     if (!res.ok) {
5281       return false;
5282     }
5283     href = state.md.normalizeLink(res.str);
5284     if (!state.md.validateLink(href)) {
5285       return false;
5286     }
5287     pos = res.pos;
5288     lines += res.lines;
5289     destEndPos = pos;
5290     destEndLineNo = lines;
5291     start = pos;
5292     for (; pos < max; pos++) {
5293       ch = str.charCodeAt(pos);
5294       if (ch === 10) {
5295         lines++;
5296       } else if (isSpace(ch)) {
5297       } else {
5298         break;
5299       }
5300     }
5301     res = state.md.helpers.parseLinkTitle(str, pos, max);
5302     if (pos < max && start !== pos && res.ok) {
5303       title = res.str;
5304       pos = res.pos;
5305       lines += res.lines;
5306     } else {
5307       title = "";
5308       pos = destEndPos;
5309       lines = destEndLineNo;
5310     }
5311     while (pos < max) {
5312       ch = str.charCodeAt(pos);
5313       if (!isSpace(ch)) {
5314         break;
5315       }
5316       pos++;
5317     }
5318     if (pos < max && str.charCodeAt(pos) !== 10) {
5319       if (title) {
5320         title = "";
5321         pos = destEndPos;
5322         lines = destEndLineNo;
5323         while (pos < max) {
5324           ch = str.charCodeAt(pos);
5325           if (!isSpace(ch)) {
5326             break;
5327           }
5328           pos++;
5329         }
5330       }
5331     }
5332     if (pos < max && str.charCodeAt(pos) !== 10) {
5333       return false;
5334     }
5335     label = normalizeReference(str.slice(1, labelEnd));
5336     if (!label) {
5337       return false;
5338     }
5339     if (silent) {
5340       return true;
5341     }
5342     if (typeof state.env.references === "undefined") {
5343       state.env.references = {};
5344     }
5345     if (typeof state.env.references[label] === "undefined") {
5346       state.env.references[label] = {title, href};
5347     }
5348     state.parentType = oldParentType;
5349     state.line = startLine + lines + 1;
5350     return true;
5351   };
5352 });
5353
5354 // node_modules/markdown-it/lib/rules_block/heading.js
5355 var require_heading = __commonJS((exports2, module2) => {
5356   "use strict";
5357   var isSpace = require_utils().isSpace;
5358   module2.exports = function heading(state, startLine, endLine, silent) {
5359     var ch, level, tmp, token, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
5360     if (state.sCount[startLine] - state.blkIndent >= 4) {
5361       return false;
5362     }
5363     ch = state.src.charCodeAt(pos);
5364     if (ch !== 35 || pos >= max) {
5365       return false;
5366     }
5367     level = 1;
5368     ch = state.src.charCodeAt(++pos);
5369     while (ch === 35 && pos < max && level <= 6) {
5370       level++;
5371       ch = state.src.charCodeAt(++pos);
5372     }
5373     if (level > 6 || pos < max && !isSpace(ch)) {
5374       return false;
5375     }
5376     if (silent) {
5377       return true;
5378     }
5379     max = state.skipSpacesBack(max, pos);
5380     tmp = state.skipCharsBack(max, 35, pos);
5381     if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
5382       max = tmp;
5383     }
5384     state.line = startLine + 1;
5385     token = state.push("heading_open", "h" + String(level), 1);
5386     token.markup = "########".slice(0, level);
5387     token.map = [startLine, state.line];
5388     token = state.push("inline", "", 0);
5389     token.content = state.src.slice(pos, max).trim();
5390     token.map = [startLine, state.line];
5391     token.children = [];
5392     token = state.push("heading_close", "h" + String(level), -1);
5393     token.markup = "########".slice(0, level);
5394     return true;
5395   };
5396 });
5397
5398 // node_modules/markdown-it/lib/rules_block/lheading.js
5399 var require_lheading = __commonJS((exports2, module2) => {
5400   "use strict";
5401   module2.exports = function lheading(state, startLine, endLine) {
5402     var content, terminate, i, l, token, pos, max, level, marker, nextLine = startLine + 1, oldParentType, terminatorRules = state.md.block.ruler.getRules("paragraph");
5403     if (state.sCount[startLine] - state.blkIndent >= 4) {
5404       return false;
5405     }
5406     oldParentType = state.parentType;
5407     state.parentType = "paragraph";
5408     for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
5409       if (state.sCount[nextLine] - state.blkIndent > 3) {
5410         continue;
5411       }
5412       if (state.sCount[nextLine] >= state.blkIndent) {
5413         pos = state.bMarks[nextLine] + state.tShift[nextLine];
5414         max = state.eMarks[nextLine];
5415         if (pos < max) {
5416           marker = state.src.charCodeAt(pos);
5417           if (marker === 45 || marker === 61) {
5418             pos = state.skipChars(pos, marker);
5419             pos = state.skipSpaces(pos);
5420             if (pos >= max) {
5421               level = marker === 61 ? 1 : 2;
5422               break;
5423             }
5424           }
5425         }
5426       }
5427       if (state.sCount[nextLine] < 0) {
5428         continue;
5429       }
5430       terminate = false;
5431       for (i = 0, l = terminatorRules.length; i < l; i++) {
5432         if (terminatorRules[i](state, nextLine, endLine, true)) {
5433           terminate = true;
5434           break;
5435         }
5436       }
5437       if (terminate) {
5438         break;
5439       }
5440     }
5441     if (!level) {
5442       return false;
5443     }
5444     content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
5445     state.line = nextLine + 1;
5446     token = state.push("heading_open", "h" + String(level), 1);
5447     token.markup = String.fromCharCode(marker);
5448     token.map = [startLine, state.line];
5449     token = state.push("inline", "", 0);
5450     token.content = content;
5451     token.map = [startLine, state.line - 1];
5452     token.children = [];
5453     token = state.push("heading_close", "h" + String(level), -1);
5454     token.markup = String.fromCharCode(marker);
5455     state.parentType = oldParentType;
5456     return true;
5457   };
5458 });
5459
5460 // node_modules/markdown-it/lib/common/html_blocks.js
5461 var require_html_blocks = __commonJS((exports2, module2) => {
5462   "use strict";
5463   module2.exports = [
5464     "address",
5465     "article",
5466     "aside",
5467     "base",
5468     "basefont",
5469     "blockquote",
5470     "body",
5471     "caption",
5472     "center",
5473     "col",
5474     "colgroup",
5475     "dd",
5476     "details",
5477     "dialog",
5478     "dir",
5479     "div",
5480     "dl",
5481     "dt",
5482     "fieldset",
5483     "figcaption",
5484     "figure",
5485     "footer",
5486     "form",
5487     "frame",
5488     "frameset",
5489     "h1",
5490     "h2",
5491     "h3",
5492     "h4",
5493     "h5",
5494     "h6",
5495     "head",
5496     "header",
5497     "hr",
5498     "html",
5499     "iframe",
5500     "legend",
5501     "li",
5502     "link",
5503     "main",
5504     "menu",
5505     "menuitem",
5506     "nav",
5507     "noframes",
5508     "ol",
5509     "optgroup",
5510     "option",
5511     "p",
5512     "param",
5513     "section",
5514     "source",
5515     "summary",
5516     "table",
5517     "tbody",
5518     "td",
5519     "tfoot",
5520     "th",
5521     "thead",
5522     "title",
5523     "tr",
5524     "track",
5525     "ul"
5526   ];
5527 });
5528
5529 // node_modules/markdown-it/lib/common/html_re.js
5530 var require_html_re = __commonJS((exports2, module2) => {
5531   "use strict";
5532   var attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*";
5533   var unquoted = "[^\"'=<>`\\x00-\\x20]+";
5534   var single_quoted = "'[^']*'";
5535   var double_quoted = '"[^"]*"';
5536   var attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")";
5537   var attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)";
5538   var open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>";
5539   var close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
5540   var comment = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->";
5541   var processing = "<[?][\\s\\S]*?[?]>";
5542   var declaration = "<![A-Z]+\\s+[^>]*>";
5543   var cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
5544   var HTML_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + "|" + comment + "|" + processing + "|" + declaration + "|" + cdata + ")");
5545   var HTML_OPEN_CLOSE_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + ")");
5546   module2.exports.HTML_TAG_RE = HTML_TAG_RE;
5547   module2.exports.HTML_OPEN_CLOSE_TAG_RE = HTML_OPEN_CLOSE_TAG_RE;
5548 });
5549
5550 // node_modules/markdown-it/lib/rules_block/html_block.js
5551 var require_html_block = __commonJS((exports2, module2) => {
5552   "use strict";
5553   var block_names = require_html_blocks();
5554   var HTML_OPEN_CLOSE_TAG_RE = require_html_re().HTML_OPEN_CLOSE_TAG_RE;
5555   var HTML_SEQUENCES = [
5556     [/^<(script|pre|style)(?=(\s|>|$))/i, /<\/(script|pre|style)>/i, true],
5557     [/^<!--/, /-->/, true],
5558     [/^<\?/, /\?>/, true],
5559     [/^<![A-Z]/, />/, true],
5560     [/^<!\[CDATA\[/, /\]\]>/, true],
5561     [new RegExp("^</?(" + block_names.join("|") + ")(?=(\\s|/?>|$))", "i"), /^$/, true],
5562     [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + "\\s*$"), /^$/, false]
5563   ];
5564   module2.exports = function html_block(state, startLine, endLine, silent) {
5565     var i, nextLine, token, lineText, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
5566     if (state.sCount[startLine] - state.blkIndent >= 4) {
5567       return false;
5568     }
5569     if (!state.md.options.html) {
5570       return false;
5571     }
5572     if (state.src.charCodeAt(pos) !== 60) {
5573       return false;
5574     }
5575     lineText = state.src.slice(pos, max);
5576     for (i = 0; i < HTML_SEQUENCES.length; i++) {
5577       if (HTML_SEQUENCES[i][0].test(lineText)) {
5578         break;
5579       }
5580     }
5581     if (i === HTML_SEQUENCES.length) {
5582       return false;
5583     }
5584     if (silent) {
5585       return HTML_SEQUENCES[i][2];
5586     }
5587     nextLine = startLine + 1;
5588     if (!HTML_SEQUENCES[i][1].test(lineText)) {
5589       for (; nextLine < endLine; nextLine++) {
5590         if (state.sCount[nextLine] < state.blkIndent) {
5591           break;
5592         }
5593         pos = state.bMarks[nextLine] + state.tShift[nextLine];
5594         max = state.eMarks[nextLine];
5595         lineText = state.src.slice(pos, max);
5596         if (HTML_SEQUENCES[i][1].test(lineText)) {
5597           if (lineText.length !== 0) {
5598             nextLine++;
5599           }
5600           break;
5601         }
5602       }
5603     }
5604     state.line = nextLine;
5605     token = state.push("html_block", "", 0);
5606     token.map = [startLine, nextLine];
5607     token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
5608     return true;
5609   };
5610 });
5611
5612 // node_modules/markdown-it/lib/rules_block/paragraph.js
5613 var require_paragraph = __commonJS((exports2, module2) => {
5614   "use strict";
5615   module2.exports = function paragraph(state, startLine) {
5616     var content, terminate, i, l, token, oldParentType, nextLine = startLine + 1, terminatorRules = state.md.block.ruler.getRules("paragraph"), endLine = state.lineMax;
5617     oldParentType = state.parentType;
5618     state.parentType = "paragraph";
5619     for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
5620       if (state.sCount[nextLine] - state.blkIndent > 3) {
5621         continue;
5622       }
5623       if (state.sCount[nextLine] < 0) {
5624         continue;
5625       }
5626       terminate = false;
5627       for (i = 0, l = terminatorRules.length; i < l; i++) {
5628         if (terminatorRules[i](state, nextLine, endLine, true)) {
5629           terminate = true;
5630           break;
5631         }
5632       }
5633       if (terminate) {
5634         break;
5635       }
5636     }
5637     content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
5638     state.line = nextLine;
5639     token = state.push("paragraph_open", "p", 1);
5640     token.map = [startLine, state.line];
5641     token = state.push("inline", "", 0);
5642     token.content = content;
5643     token.map = [startLine, state.line];
5644     token.children = [];
5645     token = state.push("paragraph_close", "p", -1);
5646     state.parentType = oldParentType;
5647     return true;
5648   };
5649 });
5650
5651 // node_modules/markdown-it/lib/rules_block/state_block.js
5652 var require_state_block = __commonJS((exports2, module2) => {
5653   "use strict";
5654   var Token = require_token();
5655   var isSpace = require_utils().isSpace;
5656   function StateBlock(src, md, env, tokens) {
5657     var ch, s, start, pos, len, indent, offset, indent_found;
5658     this.src = src;
5659     this.md = md;
5660     this.env = env;
5661     this.tokens = tokens;
5662     this.bMarks = [];
5663     this.eMarks = [];
5664     this.tShift = [];
5665     this.sCount = [];
5666     this.bsCount = [];
5667     this.blkIndent = 0;
5668     this.line = 0;
5669     this.lineMax = 0;
5670     this.tight = false;
5671     this.ddIndent = -1;
5672     this.listIndent = -1;
5673     this.parentType = "root";
5674     this.level = 0;
5675     this.result = "";
5676     s = this.src;
5677     indent_found = false;
5678     for (start = pos = indent = offset = 0, len = s.length; pos < len; pos++) {
5679       ch = s.charCodeAt(pos);
5680       if (!indent_found) {
5681         if (isSpace(ch)) {
5682           indent++;
5683           if (ch === 9) {
5684             offset += 4 - offset % 4;
5685           } else {
5686             offset++;
5687           }
5688           continue;
5689         } else {
5690           indent_found = true;
5691         }
5692       }
5693       if (ch === 10 || pos === len - 1) {
5694         if (ch !== 10) {
5695           pos++;
5696         }
5697         this.bMarks.push(start);
5698         this.eMarks.push(pos);
5699         this.tShift.push(indent);
5700         this.sCount.push(offset);
5701         this.bsCount.push(0);
5702         indent_found = false;
5703         indent = 0;
5704         offset = 0;
5705         start = pos + 1;
5706       }
5707     }
5708     this.bMarks.push(s.length);
5709     this.eMarks.push(s.length);
5710     this.tShift.push(0);
5711     this.sCount.push(0);
5712     this.bsCount.push(0);
5713     this.lineMax = this.bMarks.length - 1;
5714   }
5715   StateBlock.prototype.push = function(type, tag, nesting) {
5716     var token = new Token(type, tag, nesting);
5717     token.block = true;
5718     if (nesting < 0)
5719       this.level--;
5720     token.level = this.level;
5721     if (nesting > 0)
5722       this.level++;
5723     this.tokens.push(token);
5724     return token;
5725   };
5726   StateBlock.prototype.isEmpty = function isEmpty(line) {
5727     return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
5728   };
5729   StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
5730     for (var max = this.lineMax; from < max; from++) {
5731       if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
5732         break;
5733       }
5734     }
5735     return from;
5736   };
5737   StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
5738     var ch;
5739     for (var max = this.src.length; pos < max; pos++) {
5740       ch = this.src.charCodeAt(pos);
5741       if (!isSpace(ch)) {
5742         break;
5743       }
5744     }
5745     return pos;
5746   };
5747   StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
5748     if (pos <= min) {
5749       return pos;
5750     }
5751     while (pos > min) {
5752       if (!isSpace(this.src.charCodeAt(--pos))) {
5753         return pos + 1;
5754       }
5755     }
5756     return pos;
5757   };
5758   StateBlock.prototype.skipChars = function skipChars(pos, code) {
5759     for (var max = this.src.length; pos < max; pos++) {
5760       if (this.src.charCodeAt(pos) !== code) {
5761         break;
5762       }
5763     }
5764     return pos;
5765   };
5766   StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {
5767     if (pos <= min) {
5768       return pos;
5769     }
5770     while (pos > min) {
5771       if (code !== this.src.charCodeAt(--pos)) {
5772         return pos + 1;
5773       }
5774     }
5775     return pos;
5776   };
5777   StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {
5778     var i, lineIndent, ch, first, last, queue, lineStart, line = begin;
5779     if (begin >= end) {
5780       return "";
5781     }
5782     queue = new Array(end - begin);
5783     for (i = 0; line < end; line++, i++) {
5784       lineIndent = 0;
5785       lineStart = first = this.bMarks[line];
5786       if (line + 1 < end || keepLastLF) {
5787         last = this.eMarks[line] + 1;
5788       } else {
5789         last = this.eMarks[line];
5790       }
5791       while (first < last && lineIndent < indent) {
5792         ch = this.src.charCodeAt(first);
5793         if (isSpace(ch)) {
5794           if (ch === 9) {
5795             lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
5796           } else {
5797             lineIndent++;
5798           }
5799         } else if (first - lineStart < this.tShift[line]) {
5800           lineIndent++;
5801         } else {
5802           break;
5803         }
5804         first++;
5805       }
5806       if (lineIndent > indent) {
5807         queue[i] = new Array(lineIndent - indent + 1).join(" ") + this.src.slice(first, last);
5808       } else {
5809         queue[i] = this.src.slice(first, last);
5810       }
5811     }
5812     return queue.join("");
5813   };
5814   StateBlock.prototype.Token = Token;
5815   module2.exports = StateBlock;
5816 });
5817
5818 // node_modules/markdown-it/lib/parser_block.js
5819 var require_parser_block = __commonJS((exports2, module2) => {
5820   "use strict";
5821   var Ruler = require_ruler();
5822   var _rules = [
5823     ["table", require_table(), ["paragraph", "reference"]],
5824     ["code", require_code()],
5825     ["fence", require_fence(), ["paragraph", "reference", "blockquote", "list"]],
5826     ["blockquote", require_blockquote(), ["paragraph", "reference", "blockquote", "list"]],
5827     ["hr", require_hr(), ["paragraph", "reference", "blockquote", "list"]],
5828     ["list", require_list(), ["paragraph", "reference", "blockquote"]],
5829     ["reference", require_reference()],
5830     ["heading", require_heading(), ["paragraph", "reference", "blockquote"]],
5831     ["lheading", require_lheading()],
5832     ["html_block", require_html_block(), ["paragraph", "reference", "blockquote"]],
5833     ["paragraph", require_paragraph()]
5834   ];
5835   function ParserBlock() {
5836     this.ruler = new Ruler();
5837     for (var i = 0; i < _rules.length; i++) {
5838       this.ruler.push(_rules[i][0], _rules[i][1], {alt: (_rules[i][2] || []).slice()});
5839     }
5840   }
5841   ParserBlock.prototype.tokenize = function(state, startLine, endLine) {
5842     var ok, i, rules = this.ruler.getRules(""), len = rules.length, line = startLine, hasEmptyLines = false, maxNesting = state.md.options.maxNesting;
5843     while (line < endLine) {
5844       state.line = line = state.skipEmptyLines(line);
5845       if (line >= endLine) {
5846         break;
5847       }
5848       if (state.sCount[line] < state.blkIndent) {
5849         break;
5850       }
5851       if (state.level >= maxNesting) {
5852         state.line = endLine;
5853         break;
5854       }
5855       for (i = 0; i < len; i++) {
5856         ok = rules[i](state, line, endLine, false);
5857         if (ok) {
5858           break;
5859         }
5860       }
5861       state.tight = !hasEmptyLines;
5862       if (state.isEmpty(state.line - 1)) {
5863         hasEmptyLines = true;
5864       }
5865       line = state.line;
5866       if (line < endLine && state.isEmpty(line)) {
5867         hasEmptyLines = true;
5868         line++;
5869         state.line = line;
5870       }
5871     }
5872   };
5873   ParserBlock.prototype.parse = function(src, md, env, outTokens) {
5874     var state;
5875     if (!src) {
5876       return;
5877     }
5878     state = new this.State(src, md, env, outTokens);
5879     this.tokenize(state, state.line, state.lineMax);
5880   };
5881   ParserBlock.prototype.State = require_state_block();
5882   module2.exports = ParserBlock;
5883 });
5884
5885 // node_modules/markdown-it/lib/rules_inline/text.js
5886 var require_text = __commonJS((exports2, module2) => {
5887   "use strict";
5888   function isTerminatorChar(ch) {
5889     switch (ch) {
5890       case 10:
5891       case 33:
5892       case 35:
5893       case 36:
5894       case 37:
5895       case 38:
5896       case 42:
5897       case 43:
5898       case 45:
5899       case 58:
5900       case 60:
5901       case 61:
5902       case 62:
5903       case 64:
5904       case 91:
5905       case 92:
5906       case 93:
5907       case 94:
5908       case 95:
5909       case 96:
5910       case 123:
5911       case 125:
5912       case 126:
5913         return true;
5914       default:
5915         return false;
5916     }
5917   }
5918   module2.exports = function text(state, silent) {
5919     var pos = state.pos;
5920     while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
5921       pos++;
5922     }
5923     if (pos === state.pos) {
5924       return false;
5925     }
5926     if (!silent) {
5927       state.pending += state.src.slice(state.pos, pos);
5928     }
5929     state.pos = pos;
5930     return true;
5931   };
5932 });
5933
5934 // node_modules/markdown-it/lib/rules_inline/newline.js
5935 var require_newline = __commonJS((exports2, module2) => {
5936   "use strict";
5937   var isSpace = require_utils().isSpace;
5938   module2.exports = function newline(state, silent) {
5939     var pmax, max, pos = state.pos;
5940     if (state.src.charCodeAt(pos) !== 10) {
5941       return false;
5942     }
5943     pmax = state.pending.length - 1;
5944     max = state.posMax;
5945     if (!silent) {
5946       if (pmax >= 0 && state.pending.charCodeAt(pmax) === 32) {
5947         if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 32) {
5948           state.pending = state.pending.replace(/ +$/, "");
5949           state.push("hardbreak", "br", 0);
5950         } else {
5951           state.pending = state.pending.slice(0, -1);
5952           state.push("softbreak", "br", 0);
5953         }
5954       } else {
5955         state.push("softbreak", "br", 0);
5956       }
5957     }
5958     pos++;
5959     while (pos < max && isSpace(state.src.charCodeAt(pos))) {
5960       pos++;
5961     }
5962     state.pos = pos;
5963     return true;
5964   };
5965 });
5966
5967 // node_modules/markdown-it/lib/rules_inline/escape.js
5968 var require_escape = __commonJS((exports2, module2) => {
5969   "use strict";
5970   var isSpace = require_utils().isSpace;
5971   var ESCAPED = [];
5972   for (var i = 0; i < 256; i++) {
5973     ESCAPED.push(0);
5974   }
5975   "\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-".split("").forEach(function(ch) {
5976     ESCAPED[ch.charCodeAt(0)] = 1;
5977   });
5978   module2.exports = function escape(state, silent) {
5979     var ch, pos = state.pos, max = state.posMax;
5980     if (state.src.charCodeAt(pos) !== 92) {
5981       return false;
5982     }
5983     pos++;
5984     if (pos < max) {
5985       ch = state.src.charCodeAt(pos);
5986       if (ch < 256 && ESCAPED[ch] !== 0) {
5987         if (!silent) {
5988           state.pending += state.src[pos];
5989         }
5990         state.pos += 2;
5991         return true;
5992       }
5993       if (ch === 10) {
5994         if (!silent) {
5995           state.push("hardbreak", "br", 0);
5996         }
5997         pos++;
5998         while (pos < max) {
5999           ch = state.src.charCodeAt(pos);
6000           if (!isSpace(ch)) {
6001             break;
6002           }
6003           pos++;
6004         }
6005         state.pos = pos;
6006         return true;
6007       }
6008     }
6009     if (!silent) {
6010       state.pending += "\\";
6011     }
6012     state.pos++;
6013     return true;
6014   };
6015 });
6016
6017 // node_modules/markdown-it/lib/rules_inline/backticks.js
6018 var require_backticks = __commonJS((exports2, module2) => {
6019   "use strict";
6020   module2.exports = function backtick(state, silent) {
6021     var start, max, marker, token, matchStart, matchEnd, openerLength, closerLength, pos = state.pos, ch = state.src.charCodeAt(pos);
6022     if (ch !== 96) {
6023       return false;
6024     }
6025     start = pos;
6026     pos++;
6027     max = state.posMax;
6028     while (pos < max && state.src.charCodeAt(pos) === 96) {
6029       pos++;
6030     }
6031     marker = state.src.slice(start, pos);
6032     openerLength = marker.length;
6033     if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
6034       if (!silent)
6035         state.pending += marker;
6036       state.pos += openerLength;
6037       return true;
6038     }
6039     matchStart = matchEnd = pos;
6040     while ((matchStart = state.src.indexOf("`", matchEnd)) !== -1) {
6041       matchEnd = matchStart + 1;
6042       while (matchEnd < max && state.src.charCodeAt(matchEnd) === 96) {
6043         matchEnd++;
6044       }
6045       closerLength = matchEnd - matchStart;
6046       if (closerLength === openerLength) {
6047         if (!silent) {
6048           token = state.push("code_inline", "code", 0);
6049           token.markup = marker;
6050           token.content = state.src.slice(pos, matchStart).replace(/\n/g, " ").replace(/^ (.+) $/, "$1");
6051         }
6052         state.pos = matchEnd;
6053         return true;
6054       }
6055       state.backticks[closerLength] = matchStart;
6056     }
6057     state.backticksScanned = true;
6058     if (!silent)
6059       state.pending += marker;
6060     state.pos += openerLength;
6061     return true;
6062   };
6063 });
6064
6065 // node_modules/markdown-it/lib/rules_inline/strikethrough.js
6066 var require_strikethrough = __commonJS((exports2, module2) => {
6067   "use strict";
6068   module2.exports.tokenize = function strikethrough(state, silent) {
6069     var i, scanned, token, len, ch, start = state.pos, marker = state.src.charCodeAt(start);
6070     if (silent) {
6071       return false;
6072     }
6073     if (marker !== 126) {
6074       return false;
6075     }
6076     scanned = state.scanDelims(state.pos, true);
6077     len = scanned.length;
6078     ch = String.fromCharCode(marker);
6079     if (len < 2) {
6080       return false;
6081     }
6082     if (len % 2) {
6083       token = state.push("text", "", 0);
6084       token.content = ch;
6085       len--;
6086     }
6087     for (i = 0; i < len; i += 2) {
6088       token = state.push("text", "", 0);
6089       token.content = ch + ch;
6090       state.delimiters.push({
6091         marker,
6092         length: 0,
6093         jump: i / 2,
6094         token: state.tokens.length - 1,
6095         end: -1,
6096         open: scanned.can_open,
6097         close: scanned.can_close
6098       });
6099     }
6100     state.pos += scanned.length;
6101     return true;
6102   };
6103   function postProcess(state, delimiters) {
6104     var i, j, startDelim, endDelim, token, loneMarkers = [], max = delimiters.length;
6105     for (i = 0; i < max; i++) {
6106       startDelim = delimiters[i];
6107       if (startDelim.marker !== 126) {
6108         continue;
6109       }
6110       if (startDelim.end === -1) {
6111         continue;
6112       }
6113       endDelim = delimiters[startDelim.end];
6114       token = state.tokens[startDelim.token];
6115       token.type = "s_open";
6116       token.tag = "s";
6117       token.nesting = 1;
6118       token.markup = "~~";
6119       token.content = "";
6120       token = state.tokens[endDelim.token];
6121       token.type = "s_close";
6122       token.tag = "s";
6123       token.nesting = -1;
6124       token.markup = "~~";
6125       token.content = "";
6126       if (state.tokens[endDelim.token - 1].type === "text" && state.tokens[endDelim.token - 1].content === "~") {
6127         loneMarkers.push(endDelim.token - 1);
6128       }
6129     }
6130     while (loneMarkers.length) {
6131       i = loneMarkers.pop();
6132       j = i + 1;
6133       while (j < state.tokens.length && state.tokens[j].type === "s_close") {
6134         j++;
6135       }
6136       j--;
6137       if (i !== j) {
6138         token = state.tokens[j];
6139         state.tokens[j] = state.tokens[i];
6140         state.tokens[i] = token;
6141       }
6142     }
6143   }
6144   module2.exports.postProcess = function strikethrough(state) {
6145     var curr, tokens_meta = state.tokens_meta, max = state.tokens_meta.length;
6146     postProcess(state, state.delimiters);
6147     for (curr = 0; curr < max; curr++) {
6148       if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
6149         postProcess(state, tokens_meta[curr].delimiters);
6150       }
6151     }
6152   };
6153 });
6154
6155 // node_modules/markdown-it/lib/rules_inline/emphasis.js
6156 var require_emphasis = __commonJS((exports2, module2) => {
6157   "use strict";
6158   module2.exports.tokenize = function emphasis(state, silent) {
6159     var i, scanned, token, start = state.pos, marker = state.src.charCodeAt(start);
6160     if (silent) {
6161       return false;
6162     }
6163     if (marker !== 95 && marker !== 42) {
6164       return false;
6165     }
6166     scanned = state.scanDelims(state.pos, marker === 42);
6167     for (i = 0; i < scanned.length; i++) {
6168       token = state.push("text", "", 0);
6169       token.content = String.fromCharCode(marker);
6170       state.delimiters.push({
6171         marker,
6172         length: scanned.length,
6173         jump: i,
6174         token: state.tokens.length - 1,
6175         end: -1,
6176         open: scanned.can_open,
6177         close: scanned.can_close
6178       });
6179     }
6180     state.pos += scanned.length;
6181     return true;
6182   };
6183   function postProcess(state, delimiters) {
6184     var i, startDelim, endDelim, token, ch, isStrong, max = delimiters.length;
6185     for (i = max - 1; i >= 0; i--) {
6186       startDelim = delimiters[i];
6187       if (startDelim.marker !== 95 && startDelim.marker !== 42) {
6188         continue;
6189       }
6190       if (startDelim.end === -1) {
6191         continue;
6192       }
6193       endDelim = delimiters[startDelim.end];
6194       isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 && delimiters[i - 1].token === startDelim.token - 1 && delimiters[startDelim.end + 1].token === endDelim.token + 1 && delimiters[i - 1].marker === startDelim.marker;
6195       ch = String.fromCharCode(startDelim.marker);
6196       token = state.tokens[startDelim.token];
6197       token.type = isStrong ? "strong_open" : "em_open";
6198       token.tag = isStrong ? "strong" : "em";
6199       token.nesting = 1;
6200       token.markup = isStrong ? ch + ch : ch;
6201       token.content = "";
6202       token = state.tokens[endDelim.token];
6203       token.type = isStrong ? "strong_close" : "em_close";
6204       token.tag = isStrong ? "strong" : "em";
6205       token.nesting = -1;
6206       token.markup = isStrong ? ch + ch : ch;
6207       token.content = "";
6208       if (isStrong) {
6209         state.tokens[delimiters[i - 1].token].content = "";
6210         state.tokens[delimiters[startDelim.end + 1].token].content = "";
6211         i--;
6212       }
6213     }
6214   }
6215   module2.exports.postProcess = function emphasis(state) {
6216     var curr, tokens_meta = state.tokens_meta, max = state.tokens_meta.length;
6217     postProcess(state, state.delimiters);
6218     for (curr = 0; curr < max; curr++) {
6219       if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
6220         postProcess(state, tokens_meta[curr].delimiters);
6221       }
6222     }
6223   };
6224 });
6225
6226 // node_modules/markdown-it/lib/rules_inline/link.js
6227 var require_link = __commonJS((exports2, module2) => {
6228   "use strict";
6229   var normalizeReference = require_utils().normalizeReference;
6230   var isSpace = require_utils().isSpace;
6231   module2.exports = function link(state, silent) {
6232     var attrs, code, label, labelEnd, labelStart, pos, res, ref, token, href = "", title = "", oldPos = state.pos, max = state.posMax, start = state.pos, parseReference = true;
6233     if (state.src.charCodeAt(state.pos) !== 91) {
6234       return false;
6235     }
6236     labelStart = state.pos + 1;
6237     labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
6238     if (labelEnd < 0) {
6239       return false;
6240     }
6241     pos = labelEnd + 1;
6242     if (pos < max && state.src.charCodeAt(pos) === 40) {
6243       parseReference = false;
6244       pos++;
6245       for (; pos < max; pos++) {
6246         code = state.src.charCodeAt(pos);
6247         if (!isSpace(code) && code !== 10) {
6248           break;
6249         }
6250       }
6251       if (pos >= max) {
6252         return false;
6253       }
6254       start = pos;
6255       res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
6256       if (res.ok) {
6257         href = state.md.normalizeLink(res.str);
6258         if (state.md.validateLink(href)) {
6259           pos = res.pos;
6260         } else {
6261           href = "";
6262         }
6263         start = pos;
6264         for (; pos < max; pos++) {
6265           code = state.src.charCodeAt(pos);
6266           if (!isSpace(code) && code !== 10) {
6267             break;
6268           }
6269         }
6270         res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
6271         if (pos < max && start !== pos && res.ok) {
6272           title = res.str;
6273           pos = res.pos;
6274           for (; pos < max; pos++) {
6275             code = state.src.charCodeAt(pos);
6276             if (!isSpace(code) && code !== 10) {
6277               break;
6278             }
6279           }
6280         }
6281       }
6282       if (pos >= max || state.src.charCodeAt(pos) !== 41) {
6283         parseReference = true;
6284       }
6285       pos++;
6286     }
6287     if (parseReference) {
6288       if (typeof state.env.references === "undefined") {
6289         return false;
6290       }
6291       if (pos < max && state.src.charCodeAt(pos) === 91) {
6292         start = pos + 1;
6293         pos = state.md.helpers.parseLinkLabel(state, pos);
6294         if (pos >= 0) {
6295           label = state.src.slice(start, pos++);
6296         } else {
6297           pos = labelEnd + 1;
6298         }
6299       } else {
6300         pos = labelEnd + 1;
6301       }
6302       if (!label) {
6303         label = state.src.slice(labelStart, labelEnd);
6304       }
6305       ref = state.env.references[normalizeReference(label)];
6306       if (!ref) {
6307         state.pos = oldPos;
6308         return false;
6309       }
6310       href = ref.href;
6311       title = ref.title;
6312     }
6313     if (!silent) {
6314       state.pos = labelStart;
6315       state.posMax = labelEnd;
6316       token = state.push("link_open", "a", 1);
6317       token.attrs = attrs = [["href", href]];
6318       if (title) {
6319         attrs.push(["title", title]);
6320       }
6321       state.md.inline.tokenize(state);
6322       token = state.push("link_close", "a", -1);
6323     }
6324     state.pos = pos;
6325     state.posMax = max;
6326     return true;
6327   };
6328 });
6329
6330 // node_modules/markdown-it/lib/rules_inline/image.js
6331 var require_image = __commonJS((exports2, module2) => {
6332   "use strict";
6333   var normalizeReference = require_utils().normalizeReference;
6334   var isSpace = require_utils().isSpace;
6335   module2.exports = function image(state, silent) {
6336     var attrs, code, content, label, labelEnd, labelStart, pos, ref, res, title, token, tokens, start, href = "", oldPos = state.pos, max = state.posMax;
6337     if (state.src.charCodeAt(state.pos) !== 33) {
6338       return false;
6339     }
6340     if (state.src.charCodeAt(state.pos + 1) !== 91) {
6341       return false;
6342     }
6343     labelStart = state.pos + 2;
6344     labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);
6345     if (labelEnd < 0) {
6346       return false;
6347     }
6348     pos = labelEnd + 1;
6349     if (pos < max && state.src.charCodeAt(pos) === 40) {
6350       pos++;
6351       for (; pos < max; pos++) {
6352         code = state.src.charCodeAt(pos);
6353         if (!isSpace(code) && code !== 10) {
6354           break;
6355         }
6356       }
6357       if (pos >= max) {
6358         return false;
6359       }
6360       start = pos;
6361       res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
6362       if (res.ok) {
6363         href = state.md.normalizeLink(res.str);
6364         if (state.md.validateLink(href)) {
6365           pos = res.pos;
6366         } else {
6367           href = "";
6368         }
6369       }
6370       start = pos;
6371       for (; pos < max; pos++) {
6372         code = state.src.charCodeAt(pos);
6373         if (!isSpace(code) && code !== 10) {
6374           break;
6375         }
6376       }
6377       res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
6378       if (pos < max && start !== pos && res.ok) {
6379         title = res.str;
6380         pos = res.pos;
6381         for (; pos < max; pos++) {
6382           code = state.src.charCodeAt(pos);
6383           if (!isSpace(code) && code !== 10) {
6384             break;
6385           }
6386         }
6387       } else {
6388         title = "";
6389       }
6390       if (pos >= max || state.src.charCodeAt(pos) !== 41) {
6391         state.pos = oldPos;
6392         return false;
6393       }
6394       pos++;
6395     } else {
6396       if (typeof state.env.references === "undefined") {
6397         return false;
6398       }
6399       if (pos < max && state.src.charCodeAt(pos) === 91) {
6400         start = pos + 1;
6401         pos = state.md.helpers.parseLinkLabel(state, pos);
6402         if (pos >= 0) {
6403           label = state.src.slice(start, pos++);
6404         } else {
6405           pos = labelEnd + 1;
6406         }
6407       } else {
6408         pos = labelEnd + 1;
6409       }
6410       if (!label) {
6411         label = state.src.slice(labelStart, labelEnd);
6412       }
6413       ref = state.env.references[normalizeReference(label)];
6414       if (!ref) {
6415         state.pos = oldPos;
6416         return false;
6417       }
6418       href = ref.href;
6419       title = ref.title;
6420     }
6421     if (!silent) {
6422       content = state.src.slice(labelStart, labelEnd);
6423       state.md.inline.parse(content, state.md, state.env, tokens = []);
6424       token = state.push("image", "img", 0);
6425       token.attrs = attrs = [["src", href], ["alt", ""]];
6426       token.children = tokens;
6427       token.content = content;
6428       if (title) {
6429         attrs.push(["title", title]);
6430       }
6431     }
6432     state.pos = pos;
6433     state.posMax = max;
6434     return true;
6435   };
6436 });
6437
6438 // node_modules/markdown-it/lib/rules_inline/autolink.js
6439 var require_autolink = __commonJS((exports2, module2) => {
6440   "use strict";
6441   var EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
6442   var AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)$/;
6443   module2.exports = function autolink(state, silent) {
6444     var url, fullUrl, token, ch, start, max, pos = state.pos;
6445     if (state.src.charCodeAt(pos) !== 60) {
6446       return false;
6447     }
6448     start = state.pos;
6449     max = state.posMax;
6450     for (; ; ) {
6451       if (++pos >= max)
6452         return false;
6453       ch = state.src.charCodeAt(pos);
6454       if (ch === 60)
6455         return false;
6456       if (ch === 62)
6457         break;
6458     }
6459     url = state.src.slice(start + 1, pos);
6460     if (AUTOLINK_RE.test(url)) {
6461       fullUrl = state.md.normalizeLink(url);
6462       if (!state.md.validateLink(fullUrl)) {
6463         return false;
6464       }
6465       if (!silent) {
6466         token = state.push("link_open", "a", 1);
6467         token.attrs = [["href", fullUrl]];
6468         token.markup = "autolink";
6469         token.info = "auto";
6470         token = state.push("text", "", 0);
6471         token.content = state.md.normalizeLinkText(url);
6472         token = state.push("link_close", "a", -1);
6473         token.markup = "autolink";
6474         token.info = "auto";
6475       }
6476       state.pos += url.length + 2;
6477       return true;
6478     }
6479     if (EMAIL_RE.test(url)) {
6480       fullUrl = state.md.normalizeLink("mailto:" + url);
6481       if (!state.md.validateLink(fullUrl)) {
6482         return false;
6483       }
6484       if (!silent) {
6485         token = state.push("link_open", "a", 1);
6486         token.attrs = [["href", fullUrl]];
6487         token.markup = "autolink";
6488         token.info = "auto";
6489         token = state.push("text", "", 0);
6490         token.content = state.md.normalizeLinkText(url);
6491         token = state.push("link_close", "a", -1);
6492         token.markup = "autolink";
6493         token.info = "auto";
6494       }
6495       state.pos += url.length + 2;
6496       return true;
6497     }
6498     return false;
6499   };
6500 });
6501
6502 // node_modules/markdown-it/lib/rules_inline/html_inline.js
6503 var require_html_inline = __commonJS((exports2, module2) => {
6504   "use strict";
6505   var HTML_TAG_RE = require_html_re().HTML_TAG_RE;
6506   function isLetter(ch) {
6507     var lc = ch | 32;
6508     return lc >= 97 && lc <= 122;
6509   }
6510   module2.exports = function html_inline(state, silent) {
6511     var ch, match, max, token, pos = state.pos;
6512     if (!state.md.options.html) {
6513       return false;
6514     }
6515     max = state.posMax;
6516     if (state.src.charCodeAt(pos) !== 60 || pos + 2 >= max) {
6517       return false;
6518     }
6519     ch = state.src.charCodeAt(pos + 1);
6520     if (ch !== 33 && ch !== 63 && ch !== 47 && !isLetter(ch)) {
6521       return false;
6522     }
6523     match = state.src.slice(pos).match(HTML_TAG_RE);
6524     if (!match) {
6525       return false;
6526     }
6527     if (!silent) {
6528       token = state.push("html_inline", "", 0);
6529       token.content = state.src.slice(pos, pos + match[0].length);
6530     }
6531     state.pos += match[0].length;
6532     return true;
6533   };
6534 });
6535
6536 // node_modules/markdown-it/lib/rules_inline/entity.js
6537 var require_entity = __commonJS((exports2, module2) => {
6538   "use strict";
6539   var entities = require_entities2();
6540   var has = require_utils().has;
6541   var isValidEntityCode = require_utils().isValidEntityCode;
6542   var fromCodePoint = require_utils().fromCodePoint;
6543   var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
6544   var NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;
6545   module2.exports = function entity(state, silent) {
6546     var ch, code, match, pos = state.pos, max = state.posMax;
6547     if (state.src.charCodeAt(pos) !== 38) {
6548       return false;
6549     }
6550     if (pos + 1 < max) {
6551       ch = state.src.charCodeAt(pos + 1);
6552       if (ch === 35) {
6553         match = state.src.slice(pos).match(DIGITAL_RE);
6554         if (match) {
6555           if (!silent) {
6556             code = match[1][0].toLowerCase() === "x" ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);
6557             state.pending += isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(65533);
6558           }
6559           state.pos += match[0].length;
6560           return true;
6561         }
6562       } else {
6563         match = state.src.slice(pos).match(NAMED_RE);
6564         if (match) {
6565           if (has(entities, match[1])) {
6566             if (!silent) {
6567               state.pending += entities[match[1]];
6568             }
6569             state.pos += match[0].length;
6570             return true;
6571           }
6572         }
6573       }
6574     }
6575     if (!silent) {
6576       state.pending += "&";
6577     }
6578     state.pos++;
6579     return true;
6580   };
6581 });
6582
6583 // node_modules/markdown-it/lib/rules_inline/balance_pairs.js
6584 var require_balance_pairs = __commonJS((exports2, module2) => {
6585   "use strict";
6586   function processDelimiters(state, delimiters) {
6587     var closerIdx, openerIdx, closer, opener, minOpenerIdx, newMinOpenerIdx, isOddMatch, lastJump, openersBottom = {}, max = delimiters.length;
6588     for (closerIdx = 0; closerIdx < max; closerIdx++) {
6589       closer = delimiters[closerIdx];
6590       closer.length = closer.length || 0;
6591       if (!closer.close)
6592         continue;
6593       if (!openersBottom.hasOwnProperty(closer.marker)) {
6594         openersBottom[closer.marker] = [-1, -1, -1];
6595       }
6596       minOpenerIdx = openersBottom[closer.marker][closer.length % 3];
6597       openerIdx = closerIdx - closer.jump - 1;
6598       if (openerIdx < -1)
6599         openerIdx = -1;
6600       newMinOpenerIdx = openerIdx;
6601       for (; openerIdx > minOpenerIdx; openerIdx -= opener.jump + 1) {
6602         opener = delimiters[openerIdx];
6603         if (opener.marker !== closer.marker)
6604           continue;
6605         if (opener.open && opener.end < 0) {
6606           isOddMatch = false;
6607           if (opener.close || closer.open) {
6608             if ((opener.length + closer.length) % 3 === 0) {
6609               if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
6610                 isOddMatch = true;
6611               }
6612             }
6613           }
6614           if (!isOddMatch) {
6615             lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ? delimiters[openerIdx - 1].jump + 1 : 0;
6616             closer.jump = closerIdx - openerIdx + lastJump;
6617             closer.open = false;
6618             opener.end = closerIdx;
6619             opener.jump = lastJump;
6620             opener.close = false;
6621             newMinOpenerIdx = -1;
6622             break;
6623           }
6624         }
6625       }
6626       if (newMinOpenerIdx !== -1) {
6627         openersBottom[closer.marker][(closer.length || 0) % 3] = newMinOpenerIdx;
6628       }
6629     }
6630   }
6631   module2.exports = function link_pairs(state) {
6632     var curr, tokens_meta = state.tokens_meta, max = state.tokens_meta.length;
6633     processDelimiters(state, state.delimiters);
6634     for (curr = 0; curr < max; curr++) {
6635       if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
6636         processDelimiters(state, tokens_meta[curr].delimiters);
6637       }
6638     }
6639   };
6640 });
6641
6642 // node_modules/markdown-it/lib/rules_inline/text_collapse.js
6643 var require_text_collapse = __commonJS((exports2, module2) => {
6644   "use strict";
6645   module2.exports = function text_collapse(state) {
6646     var curr, last, level = 0, tokens = state.tokens, max = state.tokens.length;
6647     for (curr = last = 0; curr < max; curr++) {
6648       if (tokens[curr].nesting < 0)
6649         level--;
6650       tokens[curr].level = level;
6651       if (tokens[curr].nesting > 0)
6652         level++;
6653       if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") {
6654         tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
6655       } else {
6656         if (curr !== last) {
6657           tokens[last] = tokens[curr];
6658         }
6659         last++;
6660       }
6661     }
6662     if (curr !== last) {
6663       tokens.length = last;
6664     }
6665   };
6666 });
6667
6668 // node_modules/markdown-it/lib/rules_inline/state_inline.js
6669 var require_state_inline = __commonJS((exports2, module2) => {
6670   "use strict";
6671   var Token = require_token();
6672   var isWhiteSpace = require_utils().isWhiteSpace;
6673   var isPunctChar = require_utils().isPunctChar;
6674   var isMdAsciiPunct = require_utils().isMdAsciiPunct;
6675   function StateInline(src, md, env, outTokens) {
6676     this.src = src;
6677     this.env = env;
6678     this.md = md;
6679     this.tokens = outTokens;
6680     this.tokens_meta = Array(outTokens.length);
6681     this.pos = 0;
6682     this.posMax = this.src.length;
6683     this.level = 0;
6684     this.pending = "";
6685     this.pendingLevel = 0;
6686     this.cache = {};
6687     this.delimiters = [];
6688     this._prev_delimiters = [];
6689     this.backticks = {};
6690     this.backticksScanned = false;
6691   }
6692   StateInline.prototype.pushPending = function() {
6693     var token = new Token("text", "", 0);
6694     token.content = this.pending;
6695     token.level = this.pendingLevel;
6696     this.tokens.push(token);
6697     this.pending = "";
6698     return token;
6699   };
6700   StateInline.prototype.push = function(type, tag, nesting) {
6701     if (this.pending) {
6702       this.pushPending();
6703     }
6704     var token = new Token(type, tag, nesting);
6705     var token_meta = null;
6706     if (nesting < 0) {
6707       this.level--;
6708       this.delimiters = this._prev_delimiters.pop();
6709     }
6710     token.level = this.level;
6711     if (nesting > 0) {
6712       this.level++;
6713       this._prev_delimiters.push(this.delimiters);
6714       this.delimiters = [];
6715       token_meta = {delimiters: this.delimiters};
6716     }
6717     this.pendingLevel = this.level;
6718     this.tokens.push(token);
6719     this.tokens_meta.push(token_meta);
6720     return token;
6721   };
6722   StateInline.prototype.scanDelims = function(start, canSplitWord) {
6723     var pos = start, lastChar, nextChar, count, can_open, can_close, isLastWhiteSpace, isLastPunctChar, isNextWhiteSpace, isNextPunctChar, left_flanking = true, right_flanking = true, max = this.posMax, marker = this.src.charCodeAt(start);
6724     lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 32;
6725     while (pos < max && this.src.charCodeAt(pos) === marker) {
6726       pos++;
6727     }
6728     count = pos - start;
6729     nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
6730     isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
6731     isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
6732     isLastWhiteSpace = isWhiteSpace(lastChar);
6733     isNextWhiteSpace = isWhiteSpace(nextChar);
6734     if (isNextWhiteSpace) {
6735       left_flanking = false;
6736     } else if (isNextPunctChar) {
6737       if (!(isLastWhiteSpace || isLastPunctChar)) {
6738         left_flanking = false;
6739       }
6740     }
6741     if (isLastWhiteSpace) {
6742       right_flanking = false;
6743     } else if (isLastPunctChar) {
6744       if (!(isNextWhiteSpace || isNextPunctChar)) {
6745         right_flanking = false;
6746       }
6747     }
6748     if (!canSplitWord) {
6749       can_open = left_flanking && (!right_flanking || isLastPunctChar);
6750       can_close = right_flanking && (!left_flanking || isNextPunctChar);
6751     } else {
6752       can_open = left_flanking;
6753       can_close = right_flanking;
6754     }
6755     return {
6756       can_open,
6757       can_close,
6758       length: count
6759     };
6760   };
6761   StateInline.prototype.Token = Token;
6762   module2.exports = StateInline;
6763 });
6764
6765 // node_modules/markdown-it/lib/parser_inline.js
6766 var require_parser_inline = __commonJS((exports2, module2) => {
6767   "use strict";
6768   var Ruler = require_ruler();
6769   var _rules = [
6770     ["text", require_text()],
6771     ["newline", require_newline()],
6772     ["escape", require_escape()],
6773     ["backticks", require_backticks()],
6774     ["strikethrough", require_strikethrough().tokenize],
6775     ["emphasis", require_emphasis().tokenize],
6776     ["link", require_link()],
6777     ["image", require_image()],
6778     ["autolink", require_autolink()],
6779     ["html_inline", require_html_inline()],
6780     ["entity", require_entity()]
6781   ];
6782   var _rules2 = [
6783     ["balance_pairs", require_balance_pairs()],
6784     ["strikethrough", require_strikethrough().postProcess],
6785     ["emphasis", require_emphasis().postProcess],
6786     ["text_collapse", require_text_collapse()]
6787   ];
6788   function ParserInline() {
6789     var i;
6790     this.ruler = new Ruler();
6791     for (i = 0; i < _rules.length; i++) {
6792       this.ruler.push(_rules[i][0], _rules[i][1]);
6793     }
6794     this.ruler2 = new Ruler();
6795     for (i = 0; i < _rules2.length; i++) {
6796       this.ruler2.push(_rules2[i][0], _rules2[i][1]);
6797     }
6798   }
6799   ParserInline.prototype.skipToken = function(state) {
6800     var ok, i, pos = state.pos, rules = this.ruler.getRules(""), len = rules.length, maxNesting = state.md.options.maxNesting, cache = state.cache;
6801     if (typeof cache[pos] !== "undefined") {
6802       state.pos = cache[pos];
6803       return;
6804     }
6805     if (state.level < maxNesting) {
6806       for (i = 0; i < len; i++) {
6807         state.level++;
6808         ok = rules[i](state, true);
6809         state.level--;
6810         if (ok) {
6811           break;
6812         }
6813       }
6814     } else {
6815       state.pos = state.posMax;
6816     }
6817     if (!ok) {
6818       state.pos++;
6819     }
6820     cache[pos] = state.pos;
6821   };
6822   ParserInline.prototype.tokenize = function(state) {
6823     var ok, i, rules = this.ruler.getRules(""), len = rules.length, end = state.posMax, maxNesting = state.md.options.maxNesting;
6824     while (state.pos < end) {
6825       if (state.level < maxNesting) {
6826         for (i = 0; i < len; i++) {
6827           ok = rules[i](state, false);
6828           if (ok) {
6829             break;
6830           }
6831         }
6832       }
6833       if (ok) {
6834         if (state.pos >= end) {
6835           break;
6836         }
6837         continue;
6838       }
6839       state.pending += state.src[state.pos++];
6840     }
6841     if (state.pending) {
6842       state.pushPending();
6843     }
6844   };
6845   ParserInline.prototype.parse = function(str, md, env, outTokens) {
6846     var i, rules, len;
6847     var state = new this.State(str, md, env, outTokens);
6848     this.tokenize(state);
6849     rules = this.ruler2.getRules("");
6850     len = rules.length;
6851     for (i = 0; i < len; i++) {
6852       rules[i](state);
6853     }
6854   };
6855   ParserInline.prototype.State = require_state_inline();
6856   module2.exports = ParserInline;
6857 });
6858
6859 // node_modules/linkify-it/lib/re.js
6860 var require_re = __commonJS((exports2, module2) => {
6861   "use strict";
6862   module2.exports = function(opts) {
6863     var re = {};
6864     re.src_Any = require_regex2().source;
6865     re.src_Cc = require_regex3().source;
6866     re.src_Z = require_regex5().source;
6867     re.src_P = require_regex().source;
6868     re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join("|");
6869     re.src_ZCc = [re.src_Z, re.src_Cc].join("|");
6870     var text_separators = "[><\uFF5C]";
6871     re.src_pseudo_letter = "(?:(?!" + text_separators + "|" + re.src_ZPCc + ")" + re.src_Any + ")";
6872     re.src_ip4 = "(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
6873     re.src_auth = "(?:(?:(?!" + re.src_ZCc + "|[@/\\[\\]()]).)+@)?";
6874     re.src_port = "(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?";
6875     re.src_host_terminator = "(?=$|" + text_separators + "|" + re.src_ZPCc + ")(?!-|_|:\\d|\\.-|\\.(?!$|" + re.src_ZPCc + "))";
6876     re.src_path = "(?:[/?#](?:(?!" + re.src_ZCc + "|" + text_separators + `|[()[\\]{}.,"'?!\\-]).|\\[(?:(?!` + re.src_ZCc + "|\\]).)*\\]|\\((?:(?!" + re.src_ZCc + "|[)]).)*\\)|\\{(?:(?!" + re.src_ZCc + '|[}]).)*\\}|\\"(?:(?!' + re.src_ZCc + `|["]).)+\\"|\\'(?:(?!` + re.src_ZCc + "|[']).)+\\'|\\'(?=" + re.src_pseudo_letter + "|[-]).|\\.{2,}[a-zA-Z0-9%/&]|\\.(?!" + re.src_ZCc + "|[.]).|" + (opts && opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + "\\,(?!" + re.src_ZCc + ").|\\!+(?!" + re.src_ZCc + "|[!]).|\\?(?!" + re.src_ZCc + "|[?]).)+|\\/)?";
6877     re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
6878     re.src_xn = "xn--[a-z0-9\\-]{1,59}";
6879     re.src_domain_root = "(?:" + re.src_xn + "|" + re.src_pseudo_letter + "{1,63})";
6880     re.src_domain = "(?:" + re.src_xn + "|(?:" + re.src_pseudo_letter + ")|(?:" + re.src_pseudo_letter + "(?:-|" + re.src_pseudo_letter + "){0,61}" + re.src_pseudo_letter + "))";
6881     re.src_host = "(?:(?:(?:(?:" + re.src_domain + ")\\.)*" + re.src_domain + "))";
6882     re.tpl_host_fuzzy = "(?:" + re.src_ip4 + "|(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%)))";
6883     re.tpl_host_no_ip_fuzzy = "(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%))";
6884     re.src_host_strict = re.src_host + re.src_host_terminator;
6885     re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
6886     re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
6887     re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
6888     re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
6889     re.tpl_host_fuzzy_test = "localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:" + re.src_ZPCc + "|>|$))";
6890     re.tpl_email_fuzzy = "(^|" + text_separators + '|"|\\(|' + re.src_ZCc + ")(" + re.src_email_name + "@" + re.tpl_host_fuzzy_strict + ")";
6891     re.tpl_link_fuzzy = "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_fuzzy_strict + re.src_path + ")";
6892     re.tpl_link_no_ip_fuzzy = "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ")";
6893     return re;
6894   };
6895 });
6896
6897 // node_modules/linkify-it/index.js
6898 var require_linkify_it = __commonJS((exports2, module2) => {
6899   "use strict";
6900   function assign(obj) {
6901     var sources = Array.prototype.slice.call(arguments, 1);
6902     sources.forEach(function(source) {
6903       if (!source) {
6904         return;
6905       }
6906       Object.keys(source).forEach(function(key) {
6907         obj[key] = source[key];
6908       });
6909     });
6910     return obj;
6911   }
6912   function _class(obj) {
6913     return Object.prototype.toString.call(obj);
6914   }
6915   function isString(obj) {
6916     return _class(obj) === "[object String]";
6917   }
6918   function isObject(obj) {
6919     return _class(obj) === "[object Object]";
6920   }
6921   function isRegExp(obj) {
6922     return _class(obj) === "[object RegExp]";
6923   }
6924   function isFunction(obj) {
6925     return _class(obj) === "[object Function]";
6926   }
6927   function escapeRE(str) {
6928     return str.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
6929   }
6930   var defaultOptions = {
6931     fuzzyLink: true,
6932     fuzzyEmail: true,
6933     fuzzyIP: false
6934   };
6935   function isOptionsObj(obj) {
6936     return Object.keys(obj || {}).reduce(function(acc, k) {
6937       return acc || defaultOptions.hasOwnProperty(k);
6938     }, false);
6939   }
6940   var defaultSchemas = {
6941     "http:": {
6942       validate: function(text, pos, self) {
6943         var tail = text.slice(pos);
6944         if (!self.re.http) {
6945           self.re.http = new RegExp("^\\/\\/" + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path, "i");
6946         }
6947         if (self.re.http.test(tail)) {
6948           return tail.match(self.re.http)[0].length;
6949         }
6950         return 0;
6951       }
6952     },
6953     "https:": "http:",
6954     "ftp:": "http:",
6955     "//": {
6956       validate: function(text, pos, self) {
6957         var tail = text.slice(pos);
6958         if (!self.re.no_http) {
6959           self.re.no_http = new RegExp("^" + self.re.src_auth + "(?:localhost|(?:(?:" + self.re.src_domain + ")\\.)+" + self.re.src_domain_root + ")" + self.re.src_port + self.re.src_host_terminator + self.re.src_path, "i");
6960         }
6961         if (self.re.no_http.test(tail)) {
6962           if (pos >= 3 && text[pos - 3] === ":") {
6963             return 0;
6964           }
6965           if (pos >= 3 && text[pos - 3] === "/") {
6966             return 0;
6967           }
6968           return tail.match(self.re.no_http)[0].length;
6969         }
6970         return 0;
6971       }
6972     },
6973     "mailto:": {
6974       validate: function(text, pos, self) {
6975         var tail = text.slice(pos);
6976         if (!self.re.mailto) {
6977           self.re.mailto = new RegExp("^" + self.re.src_email_name + "@" + self.re.src_host_strict, "i");
6978         }
6979         if (self.re.mailto.test(tail)) {
6980           return tail.match(self.re.mailto)[0].length;
6981         }
6982         return 0;
6983       }
6984     }
6985   };
6986   var tlds_2ch_src_re = "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
6987   var tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|\u0440\u0444".split("|");
6988   function resetScanCache(self) {
6989     self.__index__ = -1;
6990     self.__text_cache__ = "";
6991   }
6992   function createValidator(re) {
6993     return function(text, pos) {
6994       var tail = text.slice(pos);
6995       if (re.test(tail)) {
6996         return tail.match(re)[0].length;
6997       }
6998       return 0;
6999     };
7000   }
7001   function createNormalizer() {
7002     return function(match, self) {
7003       self.normalize(match);
7004     };
7005   }
7006   function compile(self) {
7007     var re = self.re = require_re()(self.__opts__);
7008     var tlds = self.__tlds__.slice();
7009     self.onCompile();
7010     if (!self.__tlds_replaced__) {
7011       tlds.push(tlds_2ch_src_re);
7012     }
7013     tlds.push(re.src_xn);
7014     re.src_tlds = tlds.join("|");
7015     function untpl(tpl) {
7016       return tpl.replace("%TLDS%", re.src_tlds);
7017     }
7018     re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), "i");
7019     re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), "i");
7020     re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
7021     re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
7022     var aliases = [];
7023     self.__compiled__ = {};
7024     function schemaError(name, val) {
7025       throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
7026     }
7027     Object.keys(self.__schemas__).forEach(function(name) {
7028       var val = self.__schemas__[name];
7029       if (val === null) {
7030         return;
7031       }
7032       var compiled = {validate: null, link: null};
7033       self.__compiled__[name] = compiled;
7034       if (isObject(val)) {
7035         if (isRegExp(val.validate)) {
7036           compiled.validate = createValidator(val.validate);
7037         } else if (isFunction(val.validate)) {
7038           compiled.validate = val.validate;
7039         } else {
7040           schemaError(name, val);
7041         }
7042         if (isFunction(val.normalize)) {
7043           compiled.normalize = val.normalize;
7044         } else if (!val.normalize) {
7045           compiled.normalize = createNormalizer();
7046         } else {
7047           schemaError(name, val);
7048         }
7049         return;
7050       }
7051       if (isString(val)) {
7052         aliases.push(name);
7053         return;
7054       }
7055       schemaError(name, val);
7056     });
7057     aliases.forEach(function(alias) {
7058       if (!self.__compiled__[self.__schemas__[alias]]) {
7059         return;
7060       }
7061       self.__compiled__[alias].validate = self.__compiled__[self.__schemas__[alias]].validate;
7062       self.__compiled__[alias].normalize = self.__compiled__[self.__schemas__[alias]].normalize;
7063     });
7064     self.__compiled__[""] = {validate: null, normalize: createNormalizer()};
7065     var slist = Object.keys(self.__compiled__).filter(function(name) {
7066       return name.length > 0 && self.__compiled__[name];
7067     }).map(escapeRE).join("|");
7068     self.re.schema_test = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "i");
7069     self.re.schema_search = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
7070     self.re.pretest = RegExp("(" + self.re.schema_test.source + ")|(" + self.re.host_fuzzy_test.source + ")|@", "i");
7071     resetScanCache(self);
7072   }
7073   function Match(self, shift) {
7074     var start = self.__index__, end = self.__last_index__, text = self.__text_cache__.slice(start, end);
7075     this.schema = self.__schema__.toLowerCase();
7076     this.index = start + shift;
7077     this.lastIndex = end + shift;
7078     this.raw = text;
7079     this.text = text;
7080     this.url = text;
7081   }
7082   function createMatch(self, shift) {
7083     var match = new Match(self, shift);
7084     self.__compiled__[match.schema].normalize(match, self);
7085     return match;
7086   }
7087   function LinkifyIt(schemas, options) {
7088     if (!(this instanceof LinkifyIt)) {
7089       return new LinkifyIt(schemas, options);
7090     }
7091     if (!options) {
7092       if (isOptionsObj(schemas)) {
7093         options = schemas;
7094         schemas = {};
7095       }
7096     }
7097     this.__opts__ = assign({}, defaultOptions, options);
7098     this.__index__ = -1;
7099     this.__last_index__ = -1;
7100     this.__schema__ = "";
7101     this.__text_cache__ = "";
7102     this.__schemas__ = assign({}, defaultSchemas, schemas);
7103     this.__compiled__ = {};
7104     this.__tlds__ = tlds_default;
7105     this.__tlds_replaced__ = false;
7106     this.re = {};
7107     compile(this);
7108   }
7109   LinkifyIt.prototype.add = function add(schema, definition) {
7110     this.__schemas__[schema] = definition;
7111     compile(this);
7112     return this;
7113   };
7114   LinkifyIt.prototype.set = function set(options) {
7115     this.__opts__ = assign(this.__opts__, options);
7116     return this;
7117   };
7118   LinkifyIt.prototype.test = function test(text) {
7119     this.__text_cache__ = text;
7120     this.__index__ = -1;
7121     if (!text.length) {
7122       return false;
7123     }
7124     var m, ml, me, len, shift, next, re, tld_pos, at_pos;
7125     if (this.re.schema_test.test(text)) {
7126       re = this.re.schema_search;
7127       re.lastIndex = 0;
7128       while ((m = re.exec(text)) !== null) {
7129         len = this.testSchemaAt(text, m[2], re.lastIndex);
7130         if (len) {
7131           this.__schema__ = m[2];
7132           this.__index__ = m.index + m[1].length;
7133           this.__last_index__ = m.index + m[0].length + len;
7134           break;
7135         }
7136       }
7137     }
7138     if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
7139       tld_pos = text.search(this.re.host_fuzzy_test);
7140       if (tld_pos >= 0) {
7141         if (this.__index__ < 0 || tld_pos < this.__index__) {
7142           if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
7143             shift = ml.index + ml[1].length;
7144             if (this.__index__ < 0 || shift < this.__index__) {
7145               this.__schema__ = "";
7146               this.__index__ = shift;
7147               this.__last_index__ = ml.index + ml[0].length;
7148             }
7149           }
7150         }
7151       }
7152     }
7153     if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
7154       at_pos = text.indexOf("@");
7155       if (at_pos >= 0) {
7156         if ((me = text.match(this.re.email_fuzzy)) !== null) {
7157           shift = me.index + me[1].length;
7158           next = me.index + me[0].length;
7159           if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {
7160             this.__schema__ = "mailto:";
7161             this.__index__ = shift;
7162             this.__last_index__ = next;
7163           }
7164         }
7165       }
7166     }
7167     return this.__index__ >= 0;
7168   };
7169   LinkifyIt.prototype.pretest = function pretest(text) {
7170     return this.re.pretest.test(text);
7171   };
7172   LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
7173     if (!this.__compiled__[schema.toLowerCase()]) {
7174       return 0;
7175     }
7176     return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
7177   };
7178   LinkifyIt.prototype.match = function match(text) {
7179     var shift = 0, result = [];
7180     if (this.__index__ >= 0 && this.__text_cache__ === text) {
7181       result.push(createMatch(this, shift));
7182       shift = this.__last_index__;
7183     }
7184     var tail = shift ? text.slice(shift) : text;
7185     while (this.test(tail)) {
7186       result.push(createMatch(this, shift));
7187       tail = tail.slice(this.__last_index__);
7188       shift += this.__last_index__;
7189     }
7190     if (result.length) {
7191       return result;
7192     }
7193     return null;
7194   };
7195   LinkifyIt.prototype.tlds = function tlds(list, keepOld) {
7196     list = Array.isArray(list) ? list : [list];
7197     if (!keepOld) {
7198       this.__tlds__ = list.slice();
7199       this.__tlds_replaced__ = true;
7200       compile(this);
7201       return this;
7202     }
7203     this.__tlds__ = this.__tlds__.concat(list).sort().filter(function(el, idx, arr) {
7204       return el !== arr[idx - 1];
7205     }).reverse();
7206     compile(this);
7207     return this;
7208   };
7209   LinkifyIt.prototype.normalize = function normalize(match) {
7210     if (!match.schema) {
7211       match.url = "http://" + match.url;
7212     }
7213     if (match.schema === "mailto:" && !/^mailto:/i.test(match.url)) {
7214       match.url = "mailto:" + match.url;
7215     }
7216   };
7217   LinkifyIt.prototype.onCompile = function onCompile() {
7218   };
7219   module2.exports = LinkifyIt;
7220 });
7221
7222 // node_modules/markdown-it/lib/presets/default.js
7223 var require_default = __commonJS((exports2, module2) => {
7224   "use strict";
7225   module2.exports = {
7226     options: {
7227       html: false,
7228       xhtmlOut: false,
7229       breaks: false,
7230       langPrefix: "language-",
7231       linkify: false,
7232       typographer: false,
7233       quotes: "\u201C\u201D\u2018\u2019",
7234       highlight: null,
7235       maxNesting: 100
7236     },
7237     components: {
7238       core: {},
7239       block: {},
7240       inline: {}
7241     }
7242   };
7243 });
7244
7245 // node_modules/markdown-it/lib/presets/zero.js
7246 var require_zero = __commonJS((exports2, module2) => {
7247   "use strict";
7248   module2.exports = {
7249     options: {
7250       html: false,
7251       xhtmlOut: false,
7252       breaks: false,
7253       langPrefix: "language-",
7254       linkify: false,
7255       typographer: false,
7256       quotes: "\u201C\u201D\u2018\u2019",
7257       highlight: null,
7258       maxNesting: 20
7259     },
7260     components: {
7261       core: {
7262         rules: [
7263           "normalize",
7264           "block",
7265           "inline"
7266         ]
7267       },
7268       block: {
7269         rules: [
7270           "paragraph"
7271         ]
7272       },
7273       inline: {
7274         rules: [
7275           "text"
7276         ],
7277         rules2: [
7278           "balance_pairs",
7279           "text_collapse"
7280         ]
7281       }
7282     }
7283   };
7284 });
7285
7286 // node_modules/markdown-it/lib/presets/commonmark.js
7287 var require_commonmark = __commonJS((exports2, module2) => {
7288   "use strict";
7289   module2.exports = {
7290     options: {
7291       html: true,
7292       xhtmlOut: true,
7293       breaks: false,
7294       langPrefix: "language-",
7295       linkify: false,
7296       typographer: false,
7297       quotes: "\u201C\u201D\u2018\u2019",
7298       highlight: null,
7299       maxNesting: 20
7300     },
7301     components: {
7302       core: {
7303         rules: [
7304           "normalize",
7305           "block",
7306           "inline"
7307         ]
7308       },
7309       block: {
7310         rules: [
7311           "blockquote",
7312           "code",
7313           "fence",
7314           "heading",
7315           "hr",
7316           "html_block",
7317           "lheading",
7318           "list",
7319           "reference",
7320           "paragraph"
7321         ]
7322       },
7323       inline: {
7324         rules: [
7325           "autolink",
7326           "backticks",
7327           "emphasis",
7328           "entity",
7329           "escape",
7330           "html_inline",
7331           "image",
7332           "link",
7333           "newline",
7334           "text"
7335         ],
7336         rules2: [
7337           "balance_pairs",
7338           "emphasis",
7339           "text_collapse"
7340         ]
7341       }
7342     }
7343   };
7344 });
7345
7346 // node_modules/markdown-it/lib/index.js
7347 var require_lib = __commonJS((exports2, module2) => {
7348   "use strict";
7349   var utils = require_utils();
7350   var helpers = require_helpers();
7351   var Renderer = require_renderer();
7352   var ParserCore = require_parser_core();
7353   var ParserBlock = require_parser_block();
7354   var ParserInline = require_parser_inline();
7355   var LinkifyIt = require_linkify_it();
7356   var mdurl = require_mdurl();
7357   var punycode = require("punycode");
7358   var config2 = {
7359     default: require_default(),
7360     zero: require_zero(),
7361     commonmark: require_commonmark()
7362   };
7363   var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
7364   var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
7365   function validateLink(url) {
7366     var str = url.trim().toLowerCase();
7367     return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) ? true : false : true;
7368   }
7369   var RECODE_HOSTNAME_FOR = ["http:", "https:", "mailto:"];
7370   function normalizeLink(url) {
7371     var parsed = mdurl.parse(url, true);
7372     if (parsed.hostname) {
7373       if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
7374         try {
7375           parsed.hostname = punycode.toASCII(parsed.hostname);
7376         } catch (er) {
7377         }
7378       }
7379     }
7380     return mdurl.encode(mdurl.format(parsed));
7381   }
7382   function normalizeLinkText(url) {
7383     var parsed = mdurl.parse(url, true);
7384     if (parsed.hostname) {
7385       if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
7386         try {
7387           parsed.hostname = punycode.toUnicode(parsed.hostname);
7388         } catch (er) {
7389         }
7390       }
7391     }
7392     return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + "%");
7393   }
7394   function MarkdownIt(presetName, options) {
7395     if (!(this instanceof MarkdownIt)) {
7396       return new MarkdownIt(presetName, options);
7397     }
7398     if (!options) {
7399       if (!utils.isString(presetName)) {
7400         options = presetName || {};
7401         presetName = "default";
7402       }
7403     }
7404     this.inline = new ParserInline();
7405     this.block = new ParserBlock();
7406     this.core = new ParserCore();
7407     this.renderer = new Renderer();
7408     this.linkify = new LinkifyIt();
7409     this.validateLink = validateLink;
7410     this.normalizeLink = normalizeLink;
7411     this.normalizeLinkText = normalizeLinkText;
7412     this.utils = utils;
7413     this.helpers = utils.assign({}, helpers);
7414     this.options = {};
7415     this.configure(presetName);
7416     if (options) {
7417       this.set(options);
7418     }
7419   }
7420   MarkdownIt.prototype.set = function(options) {
7421     utils.assign(this.options, options);
7422     return this;
7423   };
7424   MarkdownIt.prototype.configure = function(presets) {
7425     var self = this, presetName;
7426     if (utils.isString(presets)) {
7427       presetName = presets;
7428       presets = config2[presetName];
7429       if (!presets) {
7430         throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name');
7431       }
7432     }
7433     if (!presets) {
7434       throw new Error("Wrong `markdown-it` preset, can't be empty");
7435     }
7436     if (presets.options) {
7437       self.set(presets.options);
7438     }
7439     if (presets.components) {
7440       Object.keys(presets.components).forEach(function(name) {
7441         if (presets.components[name].rules) {
7442           self[name].ruler.enableOnly(presets.components[name].rules);
7443         }
7444         if (presets.components[name].rules2) {
7445           self[name].ruler2.enableOnly(presets.components[name].rules2);
7446         }
7447       });
7448     }
7449     return this;
7450   };
7451   MarkdownIt.prototype.enable = function(list, ignoreInvalid) {
7452     var result = [];
7453     if (!Array.isArray(list)) {
7454       list = [list];
7455     }
7456     ["core", "block", "inline"].forEach(function(chain) {
7457       result = result.concat(this[chain].ruler.enable(list, true));
7458     }, this);
7459     result = result.concat(this.inline.ruler2.enable(list, true));
7460     var missed = list.filter(function(name) {
7461       return result.indexOf(name) < 0;
7462     });
7463     if (missed.length && !ignoreInvalid) {
7464       throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + missed);
7465     }
7466     return this;
7467   };
7468   MarkdownIt.prototype.disable = function(list, ignoreInvalid) {
7469     var result = [];
7470     if (!Array.isArray(list)) {
7471       list = [list];
7472     }
7473     ["core", "block", "inline"].forEach(function(chain) {
7474       result = result.concat(this[chain].ruler.disable(list, true));
7475     }, this);
7476     result = result.concat(this.inline.ruler2.disable(list, true));
7477     var missed = list.filter(function(name) {
7478       return result.indexOf(name) < 0;
7479     });
7480     if (missed.length && !ignoreInvalid) {
7481       throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + missed);
7482     }
7483     return this;
7484   };
7485   MarkdownIt.prototype.use = function(plugin) {
7486     var args = [this].concat(Array.prototype.slice.call(arguments, 1));
7487     plugin.apply(plugin, args);
7488     return this;
7489   };
7490   MarkdownIt.prototype.parse = function(src, env) {
7491     if (typeof src !== "string") {
7492       throw new Error("Input data should be a String");
7493     }
7494     var state = new this.core.State(src, this, env);
7495     this.core.process(state);
7496     return state.tokens;
7497   };
7498   MarkdownIt.prototype.render = function(src, env) {
7499     env = env || {};
7500     return this.renderer.render(this.parse(src, env), this.options, env);
7501   };
7502   MarkdownIt.prototype.parseInline = function(src, env) {
7503     var state = new this.core.State(src, this, env);
7504     state.inlineMode = true;
7505     this.core.process(state);
7506     return state.tokens;
7507   };
7508   MarkdownIt.prototype.renderInline = function(src, env) {
7509     env = env || {};
7510     return this.renderer.render(this.parseInline(src, env), this.options, env);
7511   };
7512   module2.exports = MarkdownIt;
7513 });
7514
7515 // node_modules/markdown-it/index.js
7516 var require_markdown_it = __commonJS((exports2, module2) => {
7517   "use strict";
7518   module2.exports = require_lib();
7519 });
7520
7521 // node_modules/markdownlint/package.json
7522 var require_package = __commonJS((exports2, module2) => {
7523   module2.exports = {
7524     name: "markdownlint",
7525     version: "0.23.1",
7526     description: "A Node.js style checker and lint tool for Markdown/CommonMark files.",
7527     main: "lib/markdownlint.js",
7528     types: "lib/markdownlint.d.ts",
7529     author: "David Anson (https://dlaa.me/)",
7530     license: "MIT",
7531     homepage: "https://github.com/DavidAnson/markdownlint",
7532     repository: {
7533       type: "git",
7534       url: "https://github.com/DavidAnson/markdownlint.git"
7535     },
7536     bugs: "https://github.com/DavidAnson/markdownlint/issues",
7537     scripts: {
7538       "build-config": "npm run build-config-schema && npm run build-config-example",
7539       "build-config-example": "node schema/build-config-example.js",
7540       "build-config-schema": "node schema/build-config-schema.js",
7541       "build-declaration": "tsc --allowJs --declaration --emitDeclarationOnly --resolveJsonModule lib/markdownlint.js && rimraf 'lib/{c,md,r}*.d.ts' 'helpers/*.d.ts'",
7542       "build-demo": "cpy node_modules/markdown-it/dist/markdown-it.min.js demo && cd demo && rimraf markdownlint-browser.* && webpack --no-stats",
7543       "build-example": "npm install --no-save --ignore-scripts grunt grunt-cli gulp through2",
7544       ci: "npm-run-all --continue-on-error --parallel test-cover lint declaration build-config build-demo && git diff --exit-code",
7545       "clean-test-repos": "rimraf test-repos",
7546       "clone-test-repos": "mkdir test-repos && cd test-repos && git clone https://github.com/eslint/eslint eslint-eslint --depth 1 --no-tags --quiet && git clone https://github.com/mkdocs/mkdocs mkdocs-mkdocs --depth 1 --no-tags --quiet && git clone https://github.com/pi-hole/docs pi-hole-docs --depth 1 --no-tags --quiet",
7547       "clone-test-repos-large": "npm run clone-test-repos && cd test-repos && git clone https://github.com/dotnet/docs dotnet-docs --depth 1 --no-tags --quiet",
7548       declaration: "npm run build-declaration && npm run test-declaration",
7549       example: "cd example && node standalone.js && grunt markdownlint --force && gulp markdownlint",
7550       lint: "eslint --max-warnings 0 .",
7551       "lint-test-repos": "ava --timeout=5m test/markdownlint-test-repos.js",
7552       test: "ava test/markdownlint-test.js test/markdownlint-test-custom-rules.js test/markdownlint-test-helpers.js test/markdownlint-test-result-object.js test/markdownlint-test-scenarios.js",
7553       "test-cover": "c8 --check-coverage --branches 100 --functions 100 --lines 100 --statements 100 npm test",
7554       "test-declaration": "cd example/typescript && tsc && node type-check.js",
7555       "test-extra": "ava --timeout=5m test/markdownlint-test-extra.js"
7556     },
7557     engines: {
7558       node: ">=10"
7559     },
7560     dependencies: {
7561       "markdown-it": "12.0.4"
7562     },
7563     devDependencies: {
7564       ava: "~3.15.0",
7565       c8: "~7.5.0",
7566       "cpy-cli": "~3.1.1",
7567       eslint: "~7.19.0",
7568       "eslint-plugin-jsdoc": "~31.6.0",
7569       "eslint-plugin-node": "~11.1.0",
7570       "eslint-plugin-unicorn": "~27.0.0",
7571       globby: "~11.0.2",
7572       "js-yaml": "~4.0.0",
7573       "markdown-it-for-inline": "~0.1.1",
7574       "markdown-it-sub": "~1.0.0",
7575       "markdown-it-sup": "~1.0.0",
7576       "markdown-it-texmath": "~0.8.0",
7577       "markdownlint-rule-helpers": "~0.13.0",
7578       "npm-run-all": "~4.1.5",
7579       rimraf: "~3.0.2",
7580       "strip-json-comments": "~3.1.1",
7581       toml: "~3.0.0",
7582       "ts-loader": "~8.0.15",
7583       tv4: "~1.3.0",
7584       typescript: "~4.1.3",
7585       webpack: "~5.21.1",
7586       "webpack-cli": "~4.5.0"
7587     },
7588     keywords: [
7589       "markdown",
7590       "lint",
7591       "md",
7592       "CommonMark",
7593       "markdownlint"
7594     ]
7595   };
7596 });
7597
7598 // node_modules/markdownlint/helpers/helpers.js
7599 var require_helpers2 = __commonJS((exports2, module2) => {
7600   "use strict";
7601   var os = require("os");
7602   var newLineRe = /\r\n?|\n/g;
7603   module2.exports.newLineRe = newLineRe;
7604   module2.exports.frontMatterRe = /((^---\s*$[^]*?^---\s*$)|(^\+\+\+\s*$[^]*?^(\+\+\+|\.\.\.)\s*$)|(^\{\s*$[^]*?^\}\s*$))(\r\n|\r|\n|$)/m;
7605   var inlineCommentRe = /<!--\s*markdownlint-(?:(?:(disable|enable|capture|restore|disable-file|enable-file|disable-next-line)((?:\s+[a-z0-9_-]+)*))|(?:(configure-file)\s+([\s\S]*?)))\s*-->/ig;
7606   module2.exports.inlineCommentRe = inlineCommentRe;
7607   module2.exports.bareUrlRe = /(?:http|ftp)s?:\/\/[^\s\]"']*(?:\/|[^\s\]"'\W])/ig;
7608   module2.exports.listItemMarkerRe = /^([\s>]*)(?:[*+-]|\d+[.)])\s+/;
7609   module2.exports.orderedListItemMarkerRe = /^[\s>]*0*(\d+)[.)]/;
7610   var emphasisMarkersRe = /[_*]/g;
7611   var linkRe = /\[(?:[^[\]]|\[[^\]]*\])*\](?:\(\S*\))?/g;
7612   module2.exports.utf8Encoding = "utf8";
7613   var allPunctuation = ".,;:!?\u3002\uFF0C\uFF1B\uFF1A\uFF01\uFF1F";
7614   module2.exports.allPunctuation = allPunctuation;
7615   module2.exports.allPunctuationNoQuestion = allPunctuation.replace(/[?？]/gu, "");
7616   module2.exports.isNumber = function isNumber(obj) {
7617     return typeof obj === "number";
7618   };
7619   module2.exports.isString = function isString(obj) {
7620     return typeof obj === "string";
7621   };
7622   module2.exports.isEmptyString = function isEmptyString(str) {
7623     return str.length === 0;
7624   };
7625   module2.exports.isObject = function isObject(obj) {
7626     return obj !== null && typeof obj === "object" && !Array.isArray(obj);
7627   };
7628   var blankLineRe = />|(?:<!--.*?-->)/g;
7629   module2.exports.isBlankLine = function isBlankLine(line) {
7630     return !line || !line.trim() || !line.replace(blankLineRe, "").trim();
7631   };
7632   module2.exports.numericSortAscending = function numericSortAscending(a, b) {
7633     return a - b;
7634   };
7635   module2.exports.includesSorted = function includesSorted(array, element) {
7636     let left = 0;
7637     let right = array.length - 1;
7638     while (left <= right) {
7639       const mid = left + right >> 1;
7640       if (array[mid] < element) {
7641         left = mid + 1;
7642       } else if (array[mid] > element) {
7643         right = mid - 1;
7644       } else {
7645         return true;
7646       }
7647     }
7648     return false;
7649   };
7650   var htmlCommentBegin = "<!--";
7651   var htmlCommentEnd = "-->";
7652   module2.exports.clearHtmlCommentText = function clearHtmlCommentText(text) {
7653     let i = 0;
7654     while ((i = text.indexOf(htmlCommentBegin, i)) !== -1) {
7655       const j = text.indexOf(htmlCommentEnd, i + 2);
7656       if (j === -1) {
7657         break;
7658       }
7659       if (j > i + htmlCommentBegin.length) {
7660         let k = i - 1;
7661         while (text[k] === " ") {
7662           k--;
7663         }
7664         if (k >= i - 4) {
7665           const content = text.slice(i + htmlCommentBegin.length, j);
7666           const isBlock = k < 0 || text[k] === "\n";
7667           const isValid = isBlock || !content.startsWith(">") && !content.startsWith("->") && !content.endsWith("-") && !content.includes("--");
7668           if (isValid) {
7669             const inlineCommentIndex = text.slice(i, j + htmlCommentEnd.length).search(inlineCommentRe);
7670             if (inlineCommentIndex === -1) {
7671               text = text.slice(0, i + htmlCommentBegin.length) + content.replace(/[^\r\n]/g, ".") + text.slice(j);
7672             }
7673           }
7674         }
7675       }
7676       i = j + htmlCommentEnd.length;
7677     }
7678     return text;
7679   };
7680   module2.exports.escapeForRegExp = function escapeForRegExp(str) {
7681     return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
7682   };
7683   var escapedMarkdownRe = /\\./g;
7684   module2.exports.unescapeMarkdown = function unescapeMarkdown(markdown, replacement) {
7685     return markdown.replace(escapedMarkdownRe, (match) => {
7686       const char = match[1];
7687       if ("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~".includes(char)) {
7688         return replacement || char;
7689       }
7690       return match;
7691     });
7692   };
7693   module2.exports.fencedCodeBlockStyleFor = function fencedCodeBlockStyleFor(markup) {
7694     switch (markup[0]) {
7695       case "~":
7696         return "tilde";
7697       default:
7698         return "backtick";
7699     }
7700   };
7701   function indentFor(token) {
7702     const line = token.line.replace(/^[\s>]*(> |>)/, "");
7703     return line.length - line.trimStart().length;
7704   }
7705   module2.exports.indentFor = indentFor;
7706   module2.exports.headingStyleFor = function headingStyleFor(token) {
7707     if (token.map[1] - token.map[0] === 1) {
7708       if (/[^\\]#\s*$/.test(token.line)) {
7709         return "atx_closed";
7710       }
7711       return "atx";
7712     }
7713     return "setext";
7714   };
7715   module2.exports.unorderedListStyleFor = function unorderedListStyleFor(token) {
7716     switch (token.markup) {
7717       case "-":
7718         return "dash";
7719       case "+":
7720         return "plus";
7721       default:
7722         return "asterisk";
7723     }
7724   };
7725   function filterTokens(params, type, handler) {
7726     params.tokens.forEach(function forToken(token) {
7727       if (token.type === type) {
7728         handler(token);
7729       }
7730     });
7731   }
7732   module2.exports.filterTokens = filterTokens;
7733   function isMathBlock(token) {
7734     return token.tag === "math" && token.type.startsWith("math_block") && !token.type.endsWith("_end");
7735   }
7736   module2.exports.getLineMetadata = function getLineMetadata(params) {
7737     const lineMetadata = params.lines.map((line, index) => [line, index, false, 0, false, false, false, false]);
7738     filterTokens(params, "fence", (token) => {
7739       lineMetadata[token.map[0]][3] = 1;
7740       lineMetadata[token.map[1] - 1][3] = -1;
7741       for (let i = token.map[0] + 1; i < token.map[1] - 1; i++) {
7742         lineMetadata[i][2] = true;
7743       }
7744     });
7745     filterTokens(params, "code_block", (token) => {
7746       for (let i = token.map[0]; i < token.map[1]; i++) {
7747         lineMetadata[i][2] = true;
7748       }
7749     });
7750     filterTokens(params, "table_open", (token) => {
7751       for (let i = token.map[0]; i < token.map[1]; i++) {
7752         lineMetadata[i][4] = true;
7753       }
7754     });
7755     filterTokens(params, "list_item_open", (token) => {
7756       let count = 1;
7757       for (let i = token.map[0]; i < token.map[1]; i++) {
7758         lineMetadata[i][5] = count;
7759         count++;
7760       }
7761     });
7762     filterTokens(params, "hr", (token) => {
7763       lineMetadata[token.map[0]][6] = true;
7764     });
7765     params.tokens.filter(isMathBlock).forEach((token) => {
7766       for (let i = token.map[0]; i < token.map[1]; i++) {
7767         lineMetadata[i][7] = true;
7768       }
7769     });
7770     return lineMetadata;
7771   };
7772   module2.exports.forEachLine = function forEachLine(lineMetadata, handler) {
7773     lineMetadata.forEach(function forMetadata(metadata) {
7774       handler(...metadata);
7775     });
7776   };
7777   module2.exports.flattenLists = function flattenLists(params) {
7778     const flattenedLists = [];
7779     const stack = [];
7780     let current = null;
7781     let nesting = 0;
7782     const nestingStack = [];
7783     let lastWithMap = {map: [0, 1]};
7784     params.tokens.forEach((token) => {
7785       if (isMathBlock(token) && token.map[1]) {
7786         token.map[1]++;
7787       }
7788       if (token.type === "bullet_list_open" || token.type === "ordered_list_open") {
7789         stack.push(current);
7790         current = {
7791           unordered: token.type === "bullet_list_open",
7792           parentsUnordered: !current || current.unordered && current.parentsUnordered,
7793           open: token,
7794           indent: indentFor(token),
7795           parentIndent: current && current.indent || 0,
7796           items: [],
7797           nesting,
7798           lastLineIndex: -1,
7799           insert: flattenedLists.length
7800         };
7801         nesting++;
7802       } else if (token.type === "bullet_list_close" || token.type === "ordered_list_close") {
7803         current.lastLineIndex = lastWithMap.map[1];
7804         flattenedLists.splice(current.insert, 0, current);
7805         delete current.insert;
7806         current = stack.pop();
7807         nesting--;
7808       } else if (token.type === "list_item_open") {
7809         current.items.push(token);
7810       } else if (token.type === "blockquote_open") {
7811         nestingStack.push(nesting);
7812         nesting = 0;
7813       } else if (token.type === "blockquote_close") {
7814         nesting = nestingStack.pop();
7815       } else if (token.map) {
7816         lastWithMap = token;
7817       }
7818     });
7819     return flattenedLists;
7820   };
7821   module2.exports.forEachInlineChild = function forEachInlineChild(params, type, handler) {
7822     filterTokens(params, "inline", function forToken(token) {
7823       token.children.forEach(function forChild(child) {
7824         if (child.type === type) {
7825           handler(child, token);
7826         }
7827       });
7828     });
7829   };
7830   module2.exports.forEachHeading = function forEachHeading(params, handler) {
7831     let heading = null;
7832     params.tokens.forEach(function forToken(token) {
7833       if (token.type === "heading_open") {
7834         heading = token;
7835       } else if (token.type === "heading_close") {
7836         heading = null;
7837       } else if (token.type === "inline" && heading) {
7838         handler(heading, token.content);
7839       }
7840     });
7841   };
7842   function forEachInlineCodeSpan(input, handler) {
7843     let currentLine = 0;
7844     let currentColumn = 0;
7845     let index = 0;
7846     while (index < input.length) {
7847       let startIndex = -1;
7848       let startLine = -1;
7849       let startColumn = -1;
7850       let tickCount = 0;
7851       let currentTicks = 0;
7852       let state = "normal";
7853       for (; index <= input.length; index++) {
7854         const char = input[index];
7855         if (char === "[" && state === "normal") {
7856           state = "linkTextOpen";
7857         } else if (char === "]" && state === "linkTextOpen") {
7858           state = "linkTextClosed";
7859         } else if (char === "(" && state === "linkTextClosed") {
7860           state = "linkDestinationOpen";
7861         } else if (char === "(" && state === "linkDestinationOpen" || char === ")" && state === "linkDestinationOpen" || state === "linkTextClosed") {
7862           state = "normal";
7863         }
7864         if (char === "`" && state !== "linkDestinationOpen") {
7865           currentTicks++;
7866           if (startIndex === -1 || startColumn === -1) {
7867             startIndex = index + 1;
7868           }
7869         } else {
7870           if (startIndex >= 0 && startColumn >= 0 && tickCount === currentTicks) {
7871             handler(input.substring(startIndex, index - currentTicks), startLine, startColumn, tickCount);
7872             startIndex = -1;
7873             startColumn = -1;
7874           } else if (startIndex >= 0 && startColumn === -1) {
7875             tickCount = currentTicks;
7876             startLine = currentLine;
7877             startColumn = currentColumn;
7878           }
7879           currentTicks = 0;
7880         }
7881         if (char === "\n") {
7882           currentLine++;
7883           currentColumn = 0;
7884         } else if (char === "\\" && (startIndex === -1 || startColumn === -1) && input[index + 1] !== "\n") {
7885           index++;
7886           currentColumn += 2;
7887         } else {
7888           currentColumn++;
7889         }
7890       }
7891       if (startIndex >= 0) {
7892         index = startIndex;
7893         currentLine = startLine;
7894         currentColumn = startColumn;
7895       }
7896     }
7897   }
7898   module2.exports.forEachInlineCodeSpan = forEachInlineCodeSpan;
7899   function addError(onError, lineNumber, detail, context, range, fixInfo) {
7900     onError({
7901       lineNumber,
7902       detail,
7903       context,
7904       range,
7905       fixInfo
7906     });
7907   }
7908   module2.exports.addError = addError;
7909   module2.exports.addErrorDetailIf = function addErrorDetailIf(onError, lineNumber, expected, actual, detail, context, range, fixInfo) {
7910     if (expected !== actual) {
7911       addError(onError, lineNumber, "Expected: " + expected + "; Actual: " + actual + (detail ? "; " + detail : ""), context, range, fixInfo);
7912     }
7913   };
7914   module2.exports.addErrorContext = function addErrorContext(onError, lineNumber, context, left, right, range, fixInfo) {
7915     if (context.length <= 30) {
7916     } else if (left && right) {
7917       context = context.substr(0, 15) + "..." + context.substr(-15);
7918     } else if (right) {
7919       context = "..." + context.substr(-30);
7920     } else {
7921       context = context.substr(0, 30) + "...";
7922     }
7923     addError(onError, lineNumber, null, context, range, fixInfo);
7924   };
7925   module2.exports.rangeFromRegExp = function rangeFromRegExp(line, regexp) {
7926     let range = null;
7927     const match = line.match(regexp);
7928     if (match) {
7929       const column = match.index + 1;
7930       const length = match[0].length;
7931       range = [column, length];
7932     }
7933     return range;
7934   };
7935   module2.exports.frontMatterHasTitle = function frontMatterHasTitle(frontMatterLines, frontMatterTitlePattern) {
7936     const ignoreFrontMatter = frontMatterTitlePattern !== void 0 && !frontMatterTitlePattern;
7937     const frontMatterTitleRe = new RegExp(String(frontMatterTitlePattern || '^\\s*"?title"?\\s*[:=]'), "i");
7938     return !ignoreFrontMatter && frontMatterLines.some((line) => frontMatterTitleRe.test(line));
7939   };
7940   function emphasisMarkersInContent(params) {
7941     const {lines} = params;
7942     const byLine = new Array(lines.length);
7943     filterTokens(params, "inline", (token) => {
7944       const {children, lineNumber, map} = token;
7945       if (children.some((child) => child.type === "code_inline")) {
7946         const tokenLines = lines.slice(map[0], map[1]);
7947         forEachInlineCodeSpan(tokenLines.join("\n"), (code, lineIndex, column, tickCount) => {
7948           const codeLines = code.split(newLineRe);
7949           codeLines.forEach((codeLine, codeLineIndex) => {
7950             let match = null;
7951             while (match = emphasisMarkersRe.exec(codeLine)) {
7952               const byLineIndex = lineNumber - 1 + lineIndex + codeLineIndex;
7953               const inLine = byLine[byLineIndex] || [];
7954               const codeLineOffset = codeLineIndex ? 0 : column - 1 + tickCount;
7955               inLine.push(codeLineOffset + match.index);
7956               byLine[byLineIndex] = inLine;
7957             }
7958           });
7959         });
7960       }
7961     });
7962     lines.forEach((tokenLine, tokenLineIndex) => {
7963       let linkMatch = null;
7964       while (linkMatch = linkRe.exec(tokenLine)) {
7965         let markerMatch = null;
7966         while (markerMatch = emphasisMarkersRe.exec(linkMatch[0])) {
7967           const inLine = byLine[tokenLineIndex] || [];
7968           inLine.push(linkMatch.index + markerMatch.index);
7969           byLine[tokenLineIndex] = inLine;
7970         }
7971       }
7972     });
7973     return byLine;
7974   }
7975   module2.exports.emphasisMarkersInContent = emphasisMarkersInContent;
7976   function getPreferredLineEnding(input) {
7977     let cr = 0;
7978     let lf = 0;
7979     let crlf = 0;
7980     const endings = input.match(newLineRe) || [];
7981     endings.forEach((ending) => {
7982       switch (ending) {
7983         case "\r":
7984           cr++;
7985           break;
7986         case "\n":
7987           lf++;
7988           break;
7989         case "\r\n":
7990           crlf++;
7991           break;
7992       }
7993     });
7994     let preferredLineEnding = null;
7995     if (!cr && !lf && !crlf) {
7996       preferredLineEnding = os.EOL;
7997     } else if (lf >= crlf && lf >= cr) {
7998       preferredLineEnding = "\n";
7999     } else if (crlf >= cr) {
8000       preferredLineEnding = "\r\n";
8001     } else {
8002       preferredLineEnding = "\r";
8003     }
8004     return preferredLineEnding;
8005   }
8006   module2.exports.getPreferredLineEnding = getPreferredLineEnding;
8007   function normalizeFixInfo(fixInfo, lineNumber) {
8008     return {
8009       lineNumber: fixInfo.lineNumber || lineNumber,
8010       editColumn: fixInfo.editColumn || 1,
8011       deleteCount: fixInfo.deleteCount || 0,
8012       insertText: fixInfo.insertText || ""
8013     };
8014   }
8015   function applyFix2(line, fixInfo, lineEnding) {
8016     const {editColumn, deleteCount, insertText} = normalizeFixInfo(fixInfo);
8017     const editIndex = editColumn - 1;
8018     return deleteCount === -1 ? null : line.slice(0, editIndex) + insertText.replace(/\n/g, lineEnding || "\n") + line.slice(editIndex + deleteCount);
8019   }
8020   module2.exports.applyFix = applyFix2;
8021   module2.exports.applyFixes = function applyFixes2(input, errors) {
8022     const lineEnding = getPreferredLineEnding(input);
8023     const lines = input.split(newLineRe);
8024     let fixInfos = errors.filter((error) => error.fixInfo).map((error) => normalizeFixInfo(error.fixInfo, error.lineNumber));
8025     fixInfos.sort((a, b) => {
8026       const aDeletingLine = a.deleteCount === -1;
8027       const bDeletingLine = b.deleteCount === -1;
8028       return b.lineNumber - a.lineNumber || (aDeletingLine ? 1 : bDeletingLine ? -1 : 0) || b.editColumn - a.editColumn || b.insertText.length - a.insertText.length;
8029     });
8030     let lastFixInfo = {};
8031     fixInfos = fixInfos.filter((fixInfo) => {
8032       const unique = fixInfo.lineNumber !== lastFixInfo.lineNumber || fixInfo.editColumn !== lastFixInfo.editColumn || fixInfo.deleteCount !== lastFixInfo.deleteCount || fixInfo.insertText !== lastFixInfo.insertText;
8033       lastFixInfo = fixInfo;
8034       return unique;
8035     });
8036     lastFixInfo = {};
8037     fixInfos.forEach((fixInfo) => {
8038       if (fixInfo.lineNumber === lastFixInfo.lineNumber && fixInfo.editColumn === lastFixInfo.editColumn && !fixInfo.insertText && fixInfo.deleteCount > 0 && lastFixInfo.insertText && !lastFixInfo.deleteCount) {
8039         fixInfo.insertText = lastFixInfo.insertText;
8040         lastFixInfo.lineNumber = 0;
8041       }
8042       lastFixInfo = fixInfo;
8043     });
8044     fixInfos = fixInfos.filter((fixInfo) => fixInfo.lineNumber);
8045     let lastLineIndex = -1;
8046     let lastEditIndex = -1;
8047     fixInfos.forEach((fixInfo) => {
8048       const {lineNumber, editColumn, deleteCount} = fixInfo;
8049       const lineIndex = lineNumber - 1;
8050       const editIndex = editColumn - 1;
8051       if (lineIndex !== lastLineIndex || deleteCount === -1 || editIndex + deleteCount <= lastEditIndex - (deleteCount > 0 ? 0 : 1)) {
8052         lines[lineIndex] = applyFix2(lines[lineIndex], fixInfo, lineEnding);
8053       }
8054       lastLineIndex = lineIndex;
8055       lastEditIndex = editIndex;
8056     });
8057     return lines.filter((line) => line !== null).join(lineEnding);
8058   };
8059 });
8060
8061 // node_modules/markdownlint/lib/md001.js
8062 var require_md001 = __commonJS((exports2, module2) => {
8063   "use strict";
8064   var {addErrorDetailIf, filterTokens} = require_helpers2();
8065   module2.exports = {
8066     names: ["MD001", "heading-increment", "header-increment"],
8067     description: "Heading levels should only increment by one level at a time",
8068     tags: ["headings", "headers"],
8069     function: function MD001(params, onError) {
8070       let prevLevel = 0;
8071       filterTokens(params, "heading_open", function forToken(token) {
8072         const level = Number.parseInt(token.tag.slice(1), 10);
8073         if (prevLevel && level > prevLevel) {
8074           addErrorDetailIf(onError, token.lineNumber, "h" + (prevLevel + 1), "h" + level);
8075         }
8076         prevLevel = level;
8077       });
8078     }
8079   };
8080 });
8081
8082 // node_modules/markdownlint/lib/md002.js
8083 var require_md002 = __commonJS((exports2, module2) => {
8084   "use strict";
8085   var {addErrorDetailIf} = require_helpers2();
8086   module2.exports = {
8087     names: ["MD002", "first-heading-h1", "first-header-h1"],
8088     description: "First heading should be a top-level heading",
8089     tags: ["headings", "headers"],
8090     function: function MD002(params, onError) {
8091       const level = Number(params.config.level || 1);
8092       const tag = "h" + level;
8093       params.tokens.every(function forToken(token) {
8094         if (token.type === "heading_open") {
8095           addErrorDetailIf(onError, token.lineNumber, tag, token.tag);
8096           return false;
8097         }
8098         return true;
8099       });
8100     }
8101   };
8102 });
8103
8104 // node_modules/markdownlint/lib/md003.js
8105 var require_md003 = __commonJS((exports2, module2) => {
8106   "use strict";
8107   var {addErrorDetailIf, filterTokens, headingStyleFor} = require_helpers2();
8108   module2.exports = {
8109     names: ["MD003", "heading-style", "header-style"],
8110     description: "Heading style",
8111     tags: ["headings", "headers"],
8112     function: function MD003(params, onError) {
8113       let style = String(params.config.style || "consistent");
8114       filterTokens(params, "heading_open", function forToken(token) {
8115         const styleForToken = headingStyleFor(token);
8116         if (style === "consistent") {
8117           style = styleForToken;
8118         }
8119         if (styleForToken !== style) {
8120           const h12 = /h[12]/.test(token.tag);
8121           const setextWithAtx = style === "setext_with_atx" && (h12 && styleForToken === "setext" || !h12 && styleForToken === "atx");
8122           const setextWithAtxClosed = style === "setext_with_atx_closed" && (h12 && styleForToken === "setext" || !h12 && styleForToken === "atx_closed");
8123           if (!setextWithAtx && !setextWithAtxClosed) {
8124             let expected = style;
8125             if (style === "setext_with_atx") {
8126               expected = h12 ? "setext" : "atx";
8127             } else if (style === "setext_with_atx_closed") {
8128               expected = h12 ? "setext" : "atx_closed";
8129             }
8130             addErrorDetailIf(onError, token.lineNumber, expected, styleForToken);
8131           }
8132         }
8133       });
8134     }
8135   };
8136 });
8137
8138 // node_modules/markdownlint/lib/cache.js
8139 var require_cache = __commonJS((exports2, module2) => {
8140   "use strict";
8141   var lineMetadata = null;
8142   module2.exports.lineMetadata = (value) => {
8143     if (value) {
8144       lineMetadata = value;
8145     }
8146     return lineMetadata;
8147   };
8148   var flattenedLists = null;
8149   module2.exports.flattenedLists = (value) => {
8150     if (value) {
8151       flattenedLists = value;
8152     }
8153     return flattenedLists;
8154   };
8155   module2.exports.clear = () => {
8156     lineMetadata = null;
8157     flattenedLists = null;
8158   };
8159 });
8160
8161 // node_modules/markdownlint/lib/md004.js
8162 var require_md004 = __commonJS((exports2, module2) => {
8163   "use strict";
8164   var {addErrorDetailIf, listItemMarkerRe, unorderedListStyleFor} = require_helpers2();
8165   var {flattenedLists} = require_cache();
8166   var expectedStyleToMarker = {
8167     dash: "-",
8168     plus: "+",
8169     asterisk: "*"
8170   };
8171   var differentItemStyle = {
8172     dash: "plus",
8173     plus: "asterisk",
8174     asterisk: "dash"
8175   };
8176   var validStyles = Object.keys(expectedStyleToMarker);
8177   module2.exports = {
8178     names: ["MD004", "ul-style"],
8179     description: "Unordered list style",
8180     tags: ["bullet", "ul"],
8181     function: function MD004(params, onError) {
8182       const style = String(params.config.style || "consistent");
8183       let expectedStyle = style;
8184       const nestingStyles = [];
8185       flattenedLists().forEach((list) => {
8186         if (list.unordered) {
8187           if (expectedStyle === "consistent") {
8188             expectedStyle = unorderedListStyleFor(list.items[0]);
8189           }
8190           list.items.forEach((item) => {
8191             const itemStyle = unorderedListStyleFor(item);
8192             if (style === "sublist") {
8193               const nesting = list.nesting;
8194               if (!nestingStyles[nesting]) {
8195                 nestingStyles[nesting] = itemStyle === nestingStyles[nesting - 1] ? differentItemStyle[itemStyle] : itemStyle;
8196               }
8197               expectedStyle = nestingStyles[nesting];
8198             }
8199             if (!validStyles.includes(expectedStyle)) {
8200               expectedStyle = validStyles[0];
8201             }
8202             let range = null;
8203             let fixInfo = null;
8204             const match = item.line.match(listItemMarkerRe);
8205             if (match) {
8206               const column = match.index + 1;
8207               const length = match[0].length;
8208               range = [column, length];
8209               fixInfo = {
8210                 editColumn: match[1].length + 1,
8211                 deleteCount: 1,
8212                 insertText: expectedStyleToMarker[expectedStyle]
8213               };
8214             }
8215             addErrorDetailIf(onError, item.lineNumber, expectedStyle, itemStyle, null, null, range, fixInfo);
8216           });
8217         }
8218       });
8219     }
8220   };
8221 });
8222
8223 // node_modules/markdownlint/lib/md005.js
8224 var require_md005 = __commonJS((exports2, module2) => {
8225   "use strict";
8226   var {
8227     addError,
8228     addErrorDetailIf,
8229     indentFor,
8230     listItemMarkerRe,
8231     orderedListItemMarkerRe,
8232     rangeFromRegExp
8233   } = require_helpers2();
8234   var {flattenedLists} = require_cache();
8235   module2.exports = {
8236     names: ["MD005", "list-indent"],
8237     description: "Inconsistent indentation for list items at the same level",
8238     tags: ["bullet", "ul", "indentation"],
8239     function: function MD005(params, onError) {
8240       flattenedLists().forEach((list) => {
8241         const expectedIndent = list.indent;
8242         let expectedEnd = 0;
8243         let actualEnd = -1;
8244         let endMatching = false;
8245         list.items.forEach((item) => {
8246           const {line, lineNumber} = item;
8247           const actualIndent = indentFor(item);
8248           let match = null;
8249           if (list.unordered) {
8250             addErrorDetailIf(onError, lineNumber, expectedIndent, actualIndent, null, null, rangeFromRegExp(line, listItemMarkerRe));
8251           } else if (match = orderedListItemMarkerRe.exec(line)) {
8252             actualEnd = match[0].length;
8253             expectedEnd = expectedEnd || actualEnd;
8254             const markerLength = match[1].length + 1;
8255             if (expectedIndent !== actualIndent || endMatching) {
8256               if (expectedEnd === actualEnd) {
8257                 endMatching = true;
8258               } else {
8259                 const detail = endMatching ? `Expected: (${expectedEnd}); Actual: (${actualEnd})` : `Expected: ${expectedIndent}; Actual: ${actualIndent}`;
8260                 const expected = endMatching ? expectedEnd - markerLength : expectedIndent;
8261                 const actual = endMatching ? actualEnd - markerLength : actualIndent;
8262                 addError(onError, lineNumber, detail, null, rangeFromRegExp(line, listItemMarkerRe), {
8263                   editColumn: Math.min(actual, expected) + 1,
8264                   deleteCount: Math.max(actual - expected, 0),
8265                   insertText: "".padEnd(Math.max(expected - actual, 0))
8266                 });
8267               }
8268             }
8269           }
8270         });
8271       });
8272     }
8273   };
8274 });
8275
8276 // node_modules/markdownlint/lib/md006.js
8277 var require_md006 = __commonJS((exports2, module2) => {
8278   "use strict";
8279   var {addErrorDetailIf, listItemMarkerRe, rangeFromRegExp} = require_helpers2();
8280   var {flattenedLists} = require_cache();
8281   module2.exports = {
8282     names: ["MD006", "ul-start-left"],
8283     description: "Consider starting bulleted lists at the beginning of the line",
8284     tags: ["bullet", "ul", "indentation"],
8285     function: function MD006(params, onError) {
8286       flattenedLists().forEach((list) => {
8287         if (list.unordered && !list.nesting && list.indent !== 0) {
8288           list.items.forEach((item) => {
8289             const {lineNumber, line} = item;
8290             addErrorDetailIf(onError, lineNumber, 0, list.indent, null, null, rangeFromRegExp(line, listItemMarkerRe), {
8291               deleteCount: line.length - line.trimStart().length
8292             });
8293           });
8294         }
8295       });
8296     }
8297   };
8298 });
8299
8300 // node_modules/markdownlint/lib/md007.js
8301 var require_md007 = __commonJS((exports2, module2) => {
8302   "use strict";
8303   var {addErrorDetailIf, indentFor, listItemMarkerRe} = require_helpers2();
8304   var {flattenedLists} = require_cache();
8305   module2.exports = {
8306     names: ["MD007", "ul-indent"],
8307     description: "Unordered list indentation",
8308     tags: ["bullet", "ul", "indentation"],
8309     function: function MD007(params, onError) {
8310       const indent = Number(params.config.indent || 2);
8311       const startIndented = !!params.config.start_indented;
8312       flattenedLists().forEach((list) => {
8313         if (list.unordered && list.parentsUnordered) {
8314           list.items.forEach((item) => {
8315             const {lineNumber, line} = item;
8316             const expectedNesting = list.nesting + (startIndented ? 1 : 0);
8317             const expectedIndent = expectedNesting * indent;
8318             const actualIndent = indentFor(item);
8319             let range = null;
8320             let editColumn = 1;
8321             const match = line.match(listItemMarkerRe);
8322             if (match) {
8323               range = [1, match[0].length];
8324               editColumn += match[1].length - actualIndent;
8325             }
8326             addErrorDetailIf(onError, lineNumber, expectedIndent, actualIndent, null, null, range, {
8327               editColumn,
8328               deleteCount: actualIndent,
8329               insertText: "".padEnd(expectedIndent)
8330             });
8331           });
8332         }
8333       });
8334     }
8335   };
8336 });
8337
8338 // node_modules/markdownlint/lib/md009.js
8339 var require_md009 = __commonJS((exports2, module2) => {
8340   "use strict";
8341   var {
8342     addError,
8343     filterTokens,
8344     forEachInlineCodeSpan,
8345     forEachLine,
8346     includesSorted,
8347     newLineRe,
8348     numericSortAscending
8349   } = require_helpers2();
8350   var {lineMetadata} = require_cache();
8351   module2.exports = {
8352     names: ["MD009", "no-trailing-spaces"],
8353     description: "Trailing spaces",
8354     tags: ["whitespace"],
8355     function: function MD009(params, onError) {
8356       let brSpaces = params.config.br_spaces;
8357       brSpaces = Number(brSpaces === void 0 ? 2 : brSpaces);
8358       const listItemEmptyLines = !!params.config.list_item_empty_lines;
8359       const strict = !!params.config.strict;
8360       const listItemLineNumbers = [];
8361       if (listItemEmptyLines) {
8362         filterTokens(params, "list_item_open", (token) => {
8363           for (let i = token.map[0]; i < token.map[1]; i++) {
8364             listItemLineNumbers.push(i + 1);
8365           }
8366         });
8367         listItemLineNumbers.sort(numericSortAscending);
8368       }
8369       const paragraphLineNumbers = [];
8370       const codeInlineLineNumbers = [];
8371       if (strict) {
8372         filterTokens(params, "paragraph_open", (token) => {
8373           for (let i = token.map[0]; i < token.map[1] - 1; i++) {
8374             paragraphLineNumbers.push(i + 1);
8375           }
8376         });
8377         paragraphLineNumbers.sort(numericSortAscending);
8378         filterTokens(params, "inline", (token) => {
8379           if (token.children.some((child) => child.type === "code_inline")) {
8380             const tokenLines = params.lines.slice(token.map[0], token.map[1]);
8381             forEachInlineCodeSpan(tokenLines.join("\n"), (code, lineIndex) => {
8382               const codeLineCount = code.split(newLineRe).length;
8383               for (let i = 0; i < codeLineCount; i++) {
8384                 codeInlineLineNumbers.push(token.lineNumber + lineIndex + i);
8385               }
8386             });
8387           }
8388         });
8389         codeInlineLineNumbers.sort(numericSortAscending);
8390       }
8391       const expected = brSpaces < 2 ? 0 : brSpaces;
8392       forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
8393         const lineNumber = lineIndex + 1;
8394         const trailingSpaces = line.length - line.trimEnd().length;
8395         if (trailingSpaces && !inCode && !includesSorted(listItemLineNumbers, lineNumber) && (expected !== trailingSpaces || strict && (!includesSorted(paragraphLineNumbers, lineNumber) || includesSorted(codeInlineLineNumbers, lineNumber)))) {
8396           const column = line.length - trailingSpaces + 1;
8397           addError(onError, lineNumber, "Expected: " + (expected === 0 ? "" : "0 or ") + expected + "; Actual: " + trailingSpaces, null, [column, trailingSpaces], {
8398             editColumn: column,
8399             deleteCount: trailingSpaces
8400           });
8401         }
8402       });
8403     }
8404   };
8405 });
8406
8407 // node_modules/markdownlint/lib/md010.js
8408 var require_md010 = __commonJS((exports2, module2) => {
8409   "use strict";
8410   var {addError, forEachLine} = require_helpers2();
8411   var {lineMetadata} = require_cache();
8412   var tabRe = /\t+/g;
8413   module2.exports = {
8414     names: ["MD010", "no-hard-tabs"],
8415     description: "Hard tabs",
8416     tags: ["whitespace", "hard_tab"],
8417     function: function MD010(params, onError) {
8418       const codeBlocks = params.config.code_blocks;
8419       const includeCodeBlocks = codeBlocks === void 0 ? true : !!codeBlocks;
8420       forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
8421         if (!inCode || includeCodeBlocks) {
8422           let match = null;
8423           while ((match = tabRe.exec(line)) !== null) {
8424             const column = match.index + 1;
8425             const length = match[0].length;
8426             addError(onError, lineIndex + 1, "Column: " + column, null, [column, length], {
8427               editColumn: column,
8428               deleteCount: length,
8429               insertText: "".padEnd(length)
8430             });
8431           }
8432         }
8433       });
8434     }
8435   };
8436 });
8437
8438 // node_modules/markdownlint/lib/md011.js
8439 var require_md011 = __commonJS((exports2, module2) => {
8440   "use strict";
8441   var {addError, forEachInlineChild, unescapeMarkdown} = require_helpers2();
8442   var reversedLinkRe = /\(([^)]+)\)\[([^\]^][^\]]*)]/g;
8443   module2.exports = {
8444     names: ["MD011", "no-reversed-links"],
8445     description: "Reversed link syntax",
8446     tags: ["links"],
8447     function: function MD011(params, onError) {
8448       forEachInlineChild(params, "text", (token) => {
8449         const {lineNumber, content} = token;
8450         let match = null;
8451         while ((match = reversedLinkRe.exec(content)) !== null) {
8452           const [reversedLink, linkText, linkDestination] = match;
8453           const line = params.lines[lineNumber - 1];
8454           const column = unescapeMarkdown(line).indexOf(reversedLink) + 1;
8455           const length = reversedLink.length;
8456           const range = column ? [column, length] : null;
8457           const fixInfo = column ? {
8458             editColumn: column,
8459             deleteCount: length,
8460             insertText: `[${linkText}](${linkDestination})`
8461           } : null;
8462           addError(onError, lineNumber, reversedLink, null, range, fixInfo);
8463         }
8464       });
8465     }
8466   };
8467 });
8468
8469 // node_modules/markdownlint/lib/md012.js
8470 var require_md012 = __commonJS((exports2, module2) => {
8471   "use strict";
8472   var {addErrorDetailIf, forEachLine} = require_helpers2();
8473   var {lineMetadata} = require_cache();
8474   module2.exports = {
8475     names: ["MD012", "no-multiple-blanks"],
8476     description: "Multiple consecutive blank lines",
8477     tags: ["whitespace", "blank_lines"],
8478     function: function MD012(params, onError) {
8479       const maximum = Number(params.config.maximum || 1);
8480       let count = 0;
8481       forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
8482         count = inCode || line.trim().length > 0 ? 0 : count + 1;
8483         if (maximum < count) {
8484           addErrorDetailIf(onError, lineIndex + 1, maximum, count, null, null, null, {
8485             deleteCount: -1
8486           });
8487         }
8488       });
8489     }
8490   };
8491 });
8492
8493 // node_modules/markdownlint/lib/md013.js
8494 var require_md013 = __commonJS((exports2, module2) => {
8495   "use strict";
8496   var {
8497     addErrorDetailIf,
8498     filterTokens,
8499     forEachHeading,
8500     forEachLine,
8501     includesSorted
8502   } = require_helpers2();
8503   var {lineMetadata} = require_cache();
8504   var longLineRePrefix = "^.{";
8505   var longLineRePostfixRelaxed = "}.*\\s.*$";
8506   var longLineRePostfixStrict = "}.+$";
8507   var labelRe = /^\s*\[.*[^\\]]:/;
8508   var linkOrImageOnlyLineRe = /^[es]*(lT?L|I)[ES]*$/;
8509   var sternModeRe = /^([#>\s]*\s)?\S*$/;
8510   var tokenTypeMap = {
8511     em_open: "e",
8512     em_close: "E",
8513     image: "I",
8514     link_open: "l",
8515     link_close: "L",
8516     strong_open: "s",
8517     strong_close: "S",
8518     text: "T"
8519   };
8520   module2.exports = {
8521     names: ["MD013", "line-length"],
8522     description: "Line length",
8523     tags: ["line_length"],
8524     function: function MD013(params, onError) {
8525       const lineLength = Number(params.config.line_length || 80);
8526       const headingLineLength = Number(params.config.heading_line_length || lineLength);
8527       const codeLineLength = Number(params.config.code_block_line_length || lineLength);
8528       const strict = !!params.config.strict;
8529       const stern = !!params.config.stern;
8530       const longLineRePostfix = strict || stern ? longLineRePostfixStrict : longLineRePostfixRelaxed;
8531       const longLineRe = new RegExp(longLineRePrefix + lineLength + longLineRePostfix);
8532       const longHeadingLineRe = new RegExp(longLineRePrefix + headingLineLength + longLineRePostfix);
8533       const longCodeLineRe = new RegExp(longLineRePrefix + codeLineLength + longLineRePostfix);
8534       const codeBlocks = params.config.code_blocks;
8535       const includeCodeBlocks = codeBlocks === void 0 ? true : !!codeBlocks;
8536       const tables = params.config.tables;
8537       const includeTables = tables === void 0 ? true : !!tables;
8538       let headings = params.config.headings;
8539       if (headings === void 0) {
8540         headings = params.config.headers;
8541       }
8542       const includeHeadings = headings === void 0 ? true : !!headings;
8543       const headingLineNumbers = [];
8544       forEachHeading(params, (heading) => {
8545         headingLineNumbers.push(heading.lineNumber);
8546       });
8547       const linkOnlyLineNumbers = [];
8548       filterTokens(params, "inline", (token) => {
8549         let childTokenTypes = "";
8550         token.children.forEach((child) => {
8551           if (child.type !== "text" || child.content !== "") {
8552             childTokenTypes += tokenTypeMap[child.type] || "x";
8553           }
8554         });
8555         if (linkOrImageOnlyLineRe.test(childTokenTypes)) {
8556           linkOnlyLineNumbers.push(token.lineNumber);
8557         }
8558       });
8559       forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence, inTable) => {
8560         const lineNumber = lineIndex + 1;
8561         const isHeading = includesSorted(headingLineNumbers, lineNumber);
8562         const length = inCode ? codeLineLength : isHeading ? headingLineLength : lineLength;
8563         const lengthRe = inCode ? longCodeLineRe : isHeading ? longHeadingLineRe : longLineRe;
8564         if ((includeCodeBlocks || !inCode) && (includeTables || !inTable) && (includeHeadings || !isHeading) && (strict || !(stern && sternModeRe.test(line)) && !includesSorted(linkOnlyLineNumbers, lineNumber) && !labelRe.test(line)) && lengthRe.test(line)) {
8565           addErrorDetailIf(onError, lineNumber, length, line.length, null, null, [length + 1, line.length - length]);
8566         }
8567       });
8568     }
8569   };
8570 });
8571
8572 // node_modules/markdownlint/lib/md014.js
8573 var require_md014 = __commonJS((exports2, module2) => {
8574   "use strict";
8575   var {addErrorContext, filterTokens} = require_helpers2();
8576   var dollarCommandRe = /^(\s*)(\$\s+)/;
8577   module2.exports = {
8578     names: ["MD014", "commands-show-output"],
8579     description: "Dollar signs used before commands without showing output",
8580     tags: ["code"],
8581     function: function MD014(params, onError) {
8582       ["code_block", "fence"].forEach((type) => {
8583         filterTokens(params, type, (token) => {
8584           const margin = token.type === "fence" ? 1 : 0;
8585           const dollarInstances = [];
8586           let allDollars = true;
8587           for (let i = token.map[0] + margin; i < token.map[1] - margin; i++) {
8588             const line = params.lines[i];
8589             const lineTrim = line.trim();
8590             if (lineTrim) {
8591               const match = dollarCommandRe.exec(line);
8592               if (match) {
8593                 const column = match[1].length + 1;
8594                 const length = match[2].length;
8595                 dollarInstances.push([i, lineTrim, column, length]);
8596               } else {
8597                 allDollars = false;
8598               }
8599             }
8600           }
8601           if (allDollars) {
8602             dollarInstances.forEach((instance) => {
8603               const [i, lineTrim, column, length] = instance;
8604               addErrorContext(onError, i + 1, lineTrim, null, null, [column, length], {
8605                 editColumn: column,
8606                 deleteCount: length
8607               });
8608             });
8609           }
8610         });
8611       });
8612     }
8613   };
8614 });
8615
8616 // node_modules/markdownlint/lib/md018.js
8617 var require_md018 = __commonJS((exports2, module2) => {
8618   "use strict";
8619   var {addErrorContext, forEachLine} = require_helpers2();
8620   var {lineMetadata} = require_cache();
8621   module2.exports = {
8622     names: ["MD018", "no-missing-space-atx"],
8623     description: "No space after hash on atx style heading",
8624     tags: ["headings", "headers", "atx", "spaces"],
8625     function: function MD018(params, onError) {
8626       forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
8627         if (!inCode && /^#+[^# \t]/.test(line) && !/#\s*$/.test(line) && !line.startsWith("#\uFE0F\u20E3")) {
8628           const hashCount = /^#+/.exec(line)[0].length;
8629           addErrorContext(onError, lineIndex + 1, line.trim(), null, null, [1, hashCount + 1], {
8630             editColumn: hashCount + 1,
8631             insertText: " "
8632           });
8633         }
8634       });
8635     }
8636   };
8637 });
8638
8639 // node_modules/markdownlint/lib/md019.js
8640 var require_md019 = __commonJS((exports2, module2) => {
8641   "use strict";
8642   var {addErrorContext, filterTokens, headingStyleFor} = require_helpers2();
8643   module2.exports = {
8644     names: ["MD019", "no-multiple-space-atx"],
8645     description: "Multiple spaces after hash on atx style heading",
8646     tags: ["headings", "headers", "atx", "spaces"],
8647     function: function MD019(params, onError) {
8648       filterTokens(params, "heading_open", (token) => {
8649         if (headingStyleFor(token) === "atx") {
8650           const {line, lineNumber} = token;
8651           const match = /^(#+)([ \t]{2,})(?:\S)/.exec(line);
8652           if (match) {
8653             const [
8654               ,
8655               {length: hashLength},
8656               {length: spacesLength}
8657             ] = match;
8658             addErrorContext(onError, lineNumber, line.trim(), null, null, [1, hashLength + spacesLength + 1], {
8659               editColumn: hashLength + 1,
8660               deleteCount: spacesLength - 1
8661             });
8662           }
8663         }
8664       });
8665     }
8666   };
8667 });
8668
8669 // node_modules/markdownlint/lib/md020.js
8670 var require_md020 = __commonJS((exports2, module2) => {
8671   "use strict";
8672   var {addErrorContext, forEachLine} = require_helpers2();
8673   var {lineMetadata} = require_cache();
8674   module2.exports = {
8675     names: ["MD020", "no-missing-space-closed-atx"],
8676     description: "No space inside hashes on closed atx style heading",
8677     tags: ["headings", "headers", "atx_closed", "spaces"],
8678     function: function MD020(params, onError) {
8679       forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
8680         if (!inCode) {
8681           const match = /^(#+)([ \t]*)([^#]*?[^#\\])([ \t]*)((?:\\#)?)(#+)(\s*)$/.exec(line);
8682           if (match) {
8683             const [
8684               ,
8685               leftHash,
8686               {length: leftSpaceLength},
8687               content,
8688               {length: rightSpaceLength},
8689               rightEscape,
8690               rightHash,
8691               {length: trailSpaceLength}
8692             ] = match;
8693             const leftHashLength = leftHash.length;
8694             const rightHashLength = rightHash.length;
8695             const left = !leftSpaceLength;
8696             const right = !rightSpaceLength || rightEscape;
8697             const rightEscapeReplacement = rightEscape ? `${rightEscape} ` : "";
8698             if (left || right) {
8699               const range = left ? [
8700                 1,
8701                 leftHashLength + 1
8702               ] : [
8703                 line.length - trailSpaceLength - rightHashLength,
8704                 rightHashLength + 1
8705               ];
8706               addErrorContext(onError, lineIndex + 1, line.trim(), left, right, range, {
8707                 editColumn: 1,
8708                 deleteCount: line.length,
8709                 insertText: `${leftHash} ${content} ${rightEscapeReplacement}${rightHash}`
8710               });
8711             }
8712           }
8713         }
8714       });
8715     }
8716   };
8717 });
8718
8719 // node_modules/markdownlint/lib/md021.js
8720 var require_md021 = __commonJS((exports2, module2) => {
8721   "use strict";
8722   var {addErrorContext, filterTokens, headingStyleFor} = require_helpers2();
8723   module2.exports = {
8724     names: ["MD021", "no-multiple-space-closed-atx"],
8725     description: "Multiple spaces inside hashes on closed atx style heading",
8726     tags: ["headings", "headers", "atx_closed", "spaces"],
8727     function: function MD021(params, onError) {
8728       filterTokens(params, "heading_open", (token) => {
8729         if (headingStyleFor(token) === "atx_closed") {
8730           const {line, lineNumber} = token;
8731           const match = /^(#+)([ \t]+)([^#]+?)([ \t]+)(#+)(\s*)$/.exec(line);
8732           if (match) {
8733             const [
8734               ,
8735               leftHash,
8736               {length: leftSpaceLength},
8737               content,
8738               {length: rightSpaceLength},
8739               rightHash,
8740               {length: trailSpaceLength}
8741             ] = match;
8742             const left = leftSpaceLength > 1;
8743             const right = rightSpaceLength > 1;
8744             if (left || right) {
8745               const length = line.length;
8746               const leftHashLength = leftHash.length;
8747               const rightHashLength = rightHash.length;
8748               const range = left ? [
8749                 1,
8750                 leftHashLength + leftSpaceLength + 1
8751               ] : [
8752                 length - trailSpaceLength - rightHashLength - rightSpaceLength,
8753                 rightSpaceLength + rightHashLength + 1
8754               ];
8755               addErrorContext(onError, lineNumber, line.trim(), left, right, range, {
8756                 editColumn: 1,
8757                 deleteCount: length,
8758                 insertText: `${leftHash} ${content} ${rightHash}`
8759               });
8760             }
8761           }
8762         }
8763       });
8764     }
8765   };
8766 });
8767
8768 // node_modules/markdownlint/lib/md022.js
8769 var require_md022 = __commonJS((exports2, module2) => {
8770   "use strict";
8771   var {addErrorDetailIf, filterTokens, isBlankLine} = require_helpers2();
8772   module2.exports = {
8773     names: ["MD022", "blanks-around-headings", "blanks-around-headers"],
8774     description: "Headings should be surrounded by blank lines",
8775     tags: ["headings", "headers", "blank_lines"],
8776     function: function MD022(params, onError) {
8777       let linesAbove = params.config.lines_above;
8778       linesAbove = Number(linesAbove === void 0 ? 1 : linesAbove);
8779       let linesBelow = params.config.lines_below;
8780       linesBelow = Number(linesBelow === void 0 ? 1 : linesBelow);
8781       const {lines} = params;
8782       filterTokens(params, "heading_open", (token) => {
8783         const [topIndex, nextIndex] = token.map;
8784         let actualAbove = 0;
8785         for (let i = 0; i < linesAbove; i++) {
8786           if (isBlankLine(lines[topIndex - i - 1])) {
8787             actualAbove++;
8788           }
8789         }
8790         addErrorDetailIf(onError, topIndex + 1, linesAbove, actualAbove, "Above", lines[topIndex].trim(), null, {
8791           insertText: "".padEnd(linesAbove - actualAbove, "\n")
8792         });
8793         let actualBelow = 0;
8794         for (let i = 0; i < linesBelow; i++) {
8795           if (isBlankLine(lines[nextIndex + i])) {
8796             actualBelow++;
8797           }
8798         }
8799         addErrorDetailIf(onError, topIndex + 1, linesBelow, actualBelow, "Below", lines[topIndex].trim(), null, {
8800           lineNumber: nextIndex + 1,
8801           insertText: "".padEnd(linesBelow - actualBelow, "\n")
8802         });
8803       });
8804     }
8805   };
8806 });
8807
8808 // node_modules/markdownlint/lib/md023.js
8809 var require_md023 = __commonJS((exports2, module2) => {
8810   "use strict";
8811   var {addErrorContext, filterTokens} = require_helpers2();
8812   var spaceBeforeHeadingRe = /^((?:\s+)|(?:[>\s]+\s\s))[^>\s]/;
8813   module2.exports = {
8814     names: ["MD023", "heading-start-left", "header-start-left"],
8815     description: "Headings must start at the beginning of the line",
8816     tags: ["headings", "headers", "spaces"],
8817     function: function MD023(params, onError) {
8818       filterTokens(params, "heading_open", function forToken(token) {
8819         const {lineNumber, line} = token;
8820         const match = line.match(spaceBeforeHeadingRe);
8821         if (match) {
8822           const [prefixAndFirstChar, prefix] = match;
8823           let deleteCount = prefix.length;
8824           const prefixLengthNoSpace = prefix.trimEnd().length;
8825           if (prefixLengthNoSpace) {
8826             deleteCount -= prefixLengthNoSpace - 1;
8827           }
8828           addErrorContext(onError, lineNumber, line, null, null, [1, prefixAndFirstChar.length], {
8829             editColumn: prefixLengthNoSpace + 1,
8830             deleteCount
8831           });
8832         }
8833       });
8834     }
8835   };
8836 });
8837
8838 // node_modules/markdownlint/lib/md024.js
8839 var require_md024 = __commonJS((exports2, module2) => {
8840   "use strict";
8841   var {addErrorContext, forEachHeading} = require_helpers2();
8842   module2.exports = {
8843     names: ["MD024", "no-duplicate-heading", "no-duplicate-header"],
8844     description: "Multiple headings with the same content",
8845     tags: ["headings", "headers"],
8846     function: function MD024(params, onError) {
8847       const siblingsOnly = !!params.config.siblings_only || !!params.config.allow_different_nesting || false;
8848       const knownContents = [null, []];
8849       let lastLevel = 1;
8850       let knownContent = knownContents[lastLevel];
8851       forEachHeading(params, (heading, content) => {
8852         if (siblingsOnly) {
8853           const newLevel = heading.tag.slice(1);
8854           while (lastLevel < newLevel) {
8855             lastLevel++;
8856             knownContents[lastLevel] = [];
8857           }
8858           while (lastLevel > newLevel) {
8859             knownContents[lastLevel] = [];
8860             lastLevel--;
8861           }
8862           knownContent = knownContents[newLevel];
8863         }
8864         if (knownContent.includes(content)) {
8865           addErrorContext(onError, heading.lineNumber, heading.line.trim());
8866         } else {
8867           knownContent.push(content);
8868         }
8869       });
8870     }
8871   };
8872 });
8873
8874 // node_modules/markdownlint/lib/md025.js
8875 var require_md025 = __commonJS((exports2, module2) => {
8876   "use strict";
8877   var {addErrorContext, filterTokens, frontMatterHasTitle} = require_helpers2();
8878   module2.exports = {
8879     names: ["MD025", "single-title", "single-h1"],
8880     description: "Multiple top-level headings in the same document",
8881     tags: ["headings", "headers"],
8882     function: function MD025(params, onError) {
8883       const level = Number(params.config.level || 1);
8884       const tag = "h" + level;
8885       const foundFrontMatterTitle = frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title);
8886       let hasTopLevelHeading = false;
8887       filterTokens(params, "heading_open", function forToken(token) {
8888         if (token.tag === tag) {
8889           if (hasTopLevelHeading || foundFrontMatterTitle) {
8890             addErrorContext(onError, token.lineNumber, token.line.trim());
8891           } else if (token.lineNumber === 1) {
8892             hasTopLevelHeading = true;
8893           }
8894         }
8895       });
8896     }
8897   };
8898 });
8899
8900 // node_modules/markdownlint/lib/md026.js
8901 var require_md026 = __commonJS((exports2, module2) => {
8902   "use strict";
8903   var {addError, allPunctuationNoQuestion, escapeForRegExp, forEachHeading} = require_helpers2();
8904   var endOfLineHtmlEntityRe = /&#?[0-9a-zA-Z]+;$/;
8905   module2.exports = {
8906     names: ["MD026", "no-trailing-punctuation"],
8907     description: "Trailing punctuation in heading",
8908     tags: ["headings", "headers"],
8909     function: function MD026(params, onError) {
8910       let punctuation = params.config.punctuation;
8911       punctuation = String(punctuation === void 0 ? allPunctuationNoQuestion : punctuation);
8912       const trailingPunctuationRe = new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
8913       forEachHeading(params, (heading) => {
8914         const {line, lineNumber} = heading;
8915         const trimmedLine = line.replace(/[\s#]*$/, "");
8916         const match = trailingPunctuationRe.exec(trimmedLine);
8917         if (match && !endOfLineHtmlEntityRe.test(trimmedLine)) {
8918           const fullMatch = match[0];
8919           const column = match.index + 1;
8920           const length = fullMatch.length;
8921           addError(onError, lineNumber, `Punctuation: '${fullMatch}'`, null, [column, length], {
8922             editColumn: column,
8923             deleteCount: length
8924           });
8925         }
8926       });
8927     }
8928   };
8929 });
8930
8931 // node_modules/markdownlint/lib/md027.js
8932 var require_md027 = __commonJS((exports2, module2) => {
8933   "use strict";
8934   var {addErrorContext, newLineRe} = require_helpers2();
8935   var spaceAfterBlockQuoteRe = /^((?:\s*>)+)(\s{2,})\S/;
8936   module2.exports = {
8937     names: ["MD027", "no-multiple-space-blockquote"],
8938     description: "Multiple spaces after blockquote symbol",
8939     tags: ["blockquote", "whitespace", "indentation"],
8940     function: function MD027(params, onError) {
8941       let blockquoteNesting = 0;
8942       let listItemNesting = 0;
8943       params.tokens.forEach((token) => {
8944         const {content, lineNumber, type} = token;
8945         if (type === "blockquote_open") {
8946           blockquoteNesting++;
8947         } else if (type === "blockquote_close") {
8948           blockquoteNesting--;
8949         } else if (type === "list_item_open") {
8950           listItemNesting++;
8951         } else if (type === "list_item_close") {
8952           listItemNesting--;
8953         } else if (type === "inline" && blockquoteNesting) {
8954           const lineCount = content.split(newLineRe).length;
8955           for (let i = 0; i < lineCount; i++) {
8956             const line = params.lines[lineNumber + i - 1];
8957             const match = line.match(spaceAfterBlockQuoteRe);
8958             if (match) {
8959               const [
8960                 fullMatch,
8961                 {length: blockquoteLength},
8962                 {length: spaceLength}
8963               ] = match;
8964               if (!listItemNesting || fullMatch[fullMatch.length - 1] === ">") {
8965                 addErrorContext(onError, lineNumber + i, line, null, null, [1, fullMatch.length], {
8966                   editColumn: blockquoteLength + 1,
8967                   deleteCount: spaceLength - 1
8968                 });
8969               }
8970             }
8971           }
8972         }
8973       });
8974     }
8975   };
8976 });
8977
8978 // node_modules/markdownlint/lib/md028.js
8979 var require_md028 = __commonJS((exports2, module2) => {
8980   "use strict";
8981   var {addError} = require_helpers2();
8982   module2.exports = {
8983     names: ["MD028", "no-blanks-blockquote"],
8984     description: "Blank line inside blockquote",
8985     tags: ["blockquote", "whitespace"],
8986     function: function MD028(params, onError) {
8987       let prevToken = {};
8988       let prevLineNumber = null;
8989       params.tokens.forEach(function forToken(token) {
8990         if (token.type === "blockquote_open" && prevToken.type === "blockquote_close") {
8991           for (let lineNumber = prevLineNumber; lineNumber < token.lineNumber; lineNumber++) {
8992             addError(onError, lineNumber);
8993           }
8994         }
8995         prevToken = token;
8996         if (token.type === "blockquote_open") {
8997           prevLineNumber = token.map[1] + 1;
8998         }
8999       });
9000     }
9001   };
9002 });
9003
9004 // node_modules/markdownlint/lib/md029.js
9005 var require_md029 = __commonJS((exports2, module2) => {
9006   "use strict";
9007   var {
9008     addErrorDetailIf,
9009     listItemMarkerRe,
9010     orderedListItemMarkerRe,
9011     rangeFromRegExp
9012   } = require_helpers2();
9013   var {flattenedLists} = require_cache();
9014   var listStyleExamples = {
9015     one: "1/1/1",
9016     ordered: "1/2/3",
9017     zero: "0/0/0"
9018   };
9019   module2.exports = {
9020     names: ["MD029", "ol-prefix"],
9021     description: "Ordered list item prefix",
9022     tags: ["ol"],
9023     function: function MD029(params, onError) {
9024       const style = String(params.config.style || "one_or_ordered");
9025       flattenedLists().filter((list) => !list.unordered).forEach((list) => {
9026         const {items} = list;
9027         let current = 1;
9028         let incrementing = false;
9029         if (items.length >= 2) {
9030           const first = orderedListItemMarkerRe.exec(items[0].line);
9031           const second = orderedListItemMarkerRe.exec(items[1].line);
9032           if (first && second) {
9033             const [, firstNumber] = first;
9034             const [, secondNumber] = second;
9035             if (secondNumber !== "1" || firstNumber === "0") {
9036               incrementing = true;
9037               if (firstNumber === "0") {
9038                 current = 0;
9039               }
9040             }
9041           }
9042         }
9043         let listStyle = style;
9044         if (listStyle === "one_or_ordered") {
9045           listStyle = incrementing ? "ordered" : "one";
9046         }
9047         if (listStyle === "zero") {
9048           current = 0;
9049         } else if (listStyle === "one") {
9050           current = 1;
9051         }
9052         items.forEach((item) => {
9053           const match = orderedListItemMarkerRe.exec(item.line);
9054           if (match) {
9055             addErrorDetailIf(onError, item.lineNumber, String(current), match[1], "Style: " + listStyleExamples[listStyle], null, rangeFromRegExp(item.line, listItemMarkerRe));
9056             if (listStyle === "ordered") {
9057               current++;
9058             }
9059           }
9060         });
9061       });
9062     }
9063   };
9064 });
9065
9066 // node_modules/markdownlint/lib/md030.js
9067 var require_md030 = __commonJS((exports2, module2) => {
9068   "use strict";
9069   var {addErrorDetailIf} = require_helpers2();
9070   var {flattenedLists} = require_cache();
9071   module2.exports = {
9072     names: ["MD030", "list-marker-space"],
9073     description: "Spaces after list markers",
9074     tags: ["ol", "ul", "whitespace"],
9075     function: function MD030(params, onError) {
9076       const ulSingle = Number(params.config.ul_single || 1);
9077       const olSingle = Number(params.config.ol_single || 1);
9078       const ulMulti = Number(params.config.ul_multi || 1);
9079       const olMulti = Number(params.config.ol_multi || 1);
9080       flattenedLists().forEach((list) => {
9081         const lineCount = list.lastLineIndex - list.open.map[0];
9082         const allSingle = lineCount === list.items.length;
9083         const expectedSpaces = list.unordered ? allSingle ? ulSingle : ulMulti : allSingle ? olSingle : olMulti;
9084         list.items.forEach((item) => {
9085           const {line, lineNumber} = item;
9086           const match = /^[\s>]*\S+(\s*)/.exec(line);
9087           const [{length: matchLength}, {length: actualSpaces}] = match;
9088           if (matchLength < line.length) {
9089             let fixInfo = null;
9090             if (expectedSpaces !== actualSpaces) {
9091               fixInfo = {
9092                 editColumn: matchLength - actualSpaces + 1,
9093                 deleteCount: actualSpaces,
9094                 insertText: "".padEnd(expectedSpaces)
9095               };
9096             }
9097             addErrorDetailIf(onError, lineNumber, expectedSpaces, actualSpaces, null, null, [1, matchLength], fixInfo);
9098           }
9099         });
9100       });
9101     }
9102   };
9103 });
9104
9105 // node_modules/markdownlint/lib/md031.js
9106 var require_md031 = __commonJS((exports2, module2) => {
9107   "use strict";
9108   var {addErrorContext, forEachLine, isBlankLine} = require_helpers2();
9109   var {lineMetadata} = require_cache();
9110   var codeFencePrefixRe = /^(.*?)\s*[`~]/;
9111   module2.exports = {
9112     names: ["MD031", "blanks-around-fences"],
9113     description: "Fenced code blocks should be surrounded by blank lines",
9114     tags: ["code", "blank_lines"],
9115     function: function MD031(params, onError) {
9116       const listItems = params.config.list_items;
9117       const includeListItems = listItems === void 0 ? true : !!listItems;
9118       const {lines} = params;
9119       forEachLine(lineMetadata(), (line, i, inCode, onFence, inTable, inItem) => {
9120         const onTopFence = onFence > 0;
9121         const onBottomFence = onFence < 0;
9122         if ((includeListItems || !inItem) && (onTopFence && !isBlankLine(lines[i - 1]) || onBottomFence && !isBlankLine(lines[i + 1]))) {
9123           const [, prefix] = line.match(codeFencePrefixRe) || [];
9124           const fixInfo = prefix === void 0 ? null : {
9125             lineNumber: i + (onTopFence ? 1 : 2),
9126             insertText: `${prefix}
9127 `
9128           };
9129           addErrorContext(onError, i + 1, lines[i].trim(), null, null, null, fixInfo);
9130         }
9131       });
9132     }
9133   };
9134 });
9135
9136 // node_modules/markdownlint/lib/md032.js
9137 var require_md032 = __commonJS((exports2, module2) => {
9138   "use strict";
9139   var {addErrorContext, isBlankLine} = require_helpers2();
9140   var {flattenedLists} = require_cache();
9141   var quotePrefixRe = /^[>\s]*/;
9142   module2.exports = {
9143     names: ["MD032", "blanks-around-lists"],
9144     description: "Lists should be surrounded by blank lines",
9145     tags: ["bullet", "ul", "ol", "blank_lines"],
9146     function: function MD032(params, onError) {
9147       const {lines} = params;
9148       flattenedLists().filter((list) => !list.nesting).forEach((list) => {
9149         const firstIndex = list.open.map[0];
9150         if (!isBlankLine(lines[firstIndex - 1])) {
9151           const line = lines[firstIndex];
9152           const quotePrefix = line.match(quotePrefixRe)[0].trimEnd();
9153           addErrorContext(onError, firstIndex + 1, line.trim(), null, null, null, {
9154             insertText: `${quotePrefix}
9155 `
9156           });
9157         }
9158         const lastIndex = list.lastLineIndex - 1;
9159         if (!isBlankLine(lines[lastIndex + 1])) {
9160           const line = lines[lastIndex];
9161           const quotePrefix = line.match(quotePrefixRe)[0].trimEnd();
9162           addErrorContext(onError, lastIndex + 1, line.trim(), null, null, null, {
9163             lineNumber: lastIndex + 2,
9164             insertText: `${quotePrefix}
9165 `
9166           });
9167         }
9168       });
9169     }
9170   };
9171 });
9172
9173 // node_modules/markdownlint/lib/md033.js
9174 var require_md033 = __commonJS((exports2, module2) => {
9175   "use strict";
9176   var {addError, forEachLine, unescapeMarkdown} = require_helpers2();
9177   var {lineMetadata} = require_cache();
9178   var htmlElementRe = /<(([A-Za-z][A-Za-z0-9-]*)(?:\s[^>]*)?)\/?>/g;
9179   var linkDestinationRe = /]\(\s*$/;
9180   var inlineCodeRe = /^[^`]*(`+[^`]+`+[^`]+)*`+[^`]*$/;
9181   var emailAddressRe = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
9182   module2.exports = {
9183     names: ["MD033", "no-inline-html"],
9184     description: "Inline HTML",
9185     tags: ["html"],
9186     function: function MD033(params, onError) {
9187       let allowedElements = params.config.allowed_elements;
9188       allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
9189       allowedElements = allowedElements.map((element) => element.toLowerCase());
9190       forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
9191         let match = null;
9192         while (!inCode && (match = htmlElementRe.exec(line)) !== null) {
9193           const [tag, content, element] = match;
9194           if (!allowedElements.includes(element.toLowerCase()) && !tag.endsWith("\\>") && !emailAddressRe.test(content)) {
9195             const prefix = line.substring(0, match.index);
9196             if (!linkDestinationRe.test(prefix) && !inlineCodeRe.test(prefix)) {
9197               const unescaped = unescapeMarkdown(prefix + "<", "_");
9198               if (!unescaped.endsWith("_") && (unescaped + "`").match(/`/g).length % 2) {
9199                 addError(onError, lineIndex + 1, "Element: " + element, null, [match.index + 1, tag.length]);
9200               }
9201             }
9202           }
9203         }
9204       });
9205     }
9206   };
9207 });
9208
9209 // node_modules/markdownlint/lib/md034.js
9210 var require_md034 = __commonJS((exports2, module2) => {
9211   "use strict";
9212   var {addErrorContext, bareUrlRe, filterTokens} = require_helpers2();
9213   module2.exports = {
9214     names: ["MD034", "no-bare-urls"],
9215     description: "Bare URL used",
9216     tags: ["links", "url"],
9217     function: function MD034(params, onError) {
9218       filterTokens(params, "inline", (token) => {
9219         let inLink = false;
9220         token.children.forEach((child) => {
9221           const {content, line, lineNumber, type} = child;
9222           let match = null;
9223           if (type === "link_open") {
9224             inLink = true;
9225           } else if (type === "link_close") {
9226             inLink = false;
9227           } else if (type === "text" && !inLink) {
9228             while ((match = bareUrlRe.exec(content)) !== null) {
9229               const [bareUrl] = match;
9230               const matchIndex = match.index;
9231               const bareUrlLength = bareUrl.length;
9232               const leftChar = content[matchIndex - 1];
9233               const rightChar = content[matchIndex + bareUrlLength];
9234               if (!(leftChar === "[" && rightChar === "]") && !(leftChar === '"' && rightChar === '"') && !(leftChar === "'" && rightChar === "'")) {
9235                 const index = line.indexOf(content);
9236                 const range = index === -1 ? null : [
9237                   index + matchIndex + 1,
9238                   bareUrlLength
9239                 ];
9240                 const fixInfo = range ? {
9241                   editColumn: range[0],
9242                   deleteCount: range[1],
9243                   insertText: `<${bareUrl}>`
9244                 } : null;
9245                 addErrorContext(onError, lineNumber, bareUrl, null, null, range, fixInfo);
9246               }
9247             }
9248           }
9249         });
9250       });
9251     }
9252   };
9253 });
9254
9255 // node_modules/markdownlint/lib/md035.js
9256 var require_md035 = __commonJS((exports2, module2) => {
9257   "use strict";
9258   var {addErrorDetailIf, filterTokens} = require_helpers2();
9259   module2.exports = {
9260     names: ["MD035", "hr-style"],
9261     description: "Horizontal rule style",
9262     tags: ["hr"],
9263     function: function MD035(params, onError) {
9264       let style = String(params.config.style || "consistent");
9265       filterTokens(params, "hr", function forToken(token) {
9266         const lineTrim = token.line.trim();
9267         if (style === "consistent") {
9268           style = lineTrim;
9269         }
9270         addErrorDetailIf(onError, token.lineNumber, style, lineTrim);
9271       });
9272     }
9273   };
9274 });
9275
9276 // node_modules/markdownlint/lib/md036.js
9277 var require_md036 = __commonJS((exports2, module2) => {
9278   "use strict";
9279   var {addErrorContext, allPunctuation} = require_helpers2();
9280   module2.exports = {
9281     names: ["MD036", "no-emphasis-as-heading", "no-emphasis-as-header"],
9282     description: "Emphasis used instead of a heading",
9283     tags: ["headings", "headers", "emphasis"],
9284     function: function MD036(params, onError) {
9285       let punctuation = params.config.punctuation;
9286       punctuation = String(punctuation === void 0 ? allPunctuation : punctuation);
9287       const re = new RegExp("[" + punctuation + "]$");
9288       function base(token) {
9289         if (token.type === "paragraph_open") {
9290           return function inParagraph(t) {
9291             const children = t.children.filter(function notEmptyText(child) {
9292               return child.type !== "text" || child.content !== "";
9293             });
9294             if (children.length === 3 && (children[0].type === "strong_open" || children[0].type === "em_open") && children[1].type === "text" && !re.test(children[1].content)) {
9295               addErrorContext(onError, t.lineNumber, children[1].content);
9296             }
9297             return base;
9298           };
9299         } else if (token.type === "blockquote_open") {
9300           return function inBlockquote(t) {
9301             if (t.type !== "blockquote_close") {
9302               return inBlockquote;
9303             }
9304             return base;
9305           };
9306         } else if (token.type === "list_item_open") {
9307           return function inListItem(t) {
9308             if (t.type !== "list_item_close") {
9309               return inListItem;
9310             }
9311             return base;
9312           };
9313         }
9314         return base;
9315       }
9316       let state = base;
9317       params.tokens.forEach(function forToken(token) {
9318         state = state(token);
9319       });
9320     }
9321   };
9322 });
9323
9324 // node_modules/markdownlint/lib/md037.js
9325 var require_md037 = __commonJS((exports2, module2) => {
9326   "use strict";
9327   var {addErrorContext, emphasisMarkersInContent, forEachLine, isBlankLine} = require_helpers2();
9328   var {lineMetadata} = require_cache();
9329   var emphasisRe = /(^|[^\\]|\\\\)(?:(\*\*?\*?)|(__?_?))/g;
9330   var asteriskListItemMarkerRe = /^([\s>]*)\*(\s+)/;
9331   var leftSpaceRe = /^\s+/;
9332   var rightSpaceRe = /\s+$/;
9333   var tablePipeRe = /\|/;
9334   module2.exports = {
9335     names: ["MD037", "no-space-in-emphasis"],
9336     description: "Spaces inside emphasis markers",
9337     tags: ["whitespace", "emphasis"],
9338     function: function MD037(params, onError) {
9339       let effectiveEmphasisLength, emphasisIndex, emphasisKind, emphasisLength, pendingError = null;
9340       function resetRunTracking() {
9341         emphasisIndex = -1;
9342         emphasisLength = 0;
9343         emphasisKind = "";
9344         effectiveEmphasisLength = 0;
9345         pendingError = null;
9346       }
9347       function handleRunEnd(line, lineIndex, contextLength, match, matchIndex, inTable) {
9348         let content = line.substring(emphasisIndex, matchIndex);
9349         if (!emphasisLength) {
9350           content = content.trimStart();
9351         }
9352         if (!match) {
9353           content = content.trimEnd();
9354         }
9355         const leftSpace = leftSpaceRe.test(content);
9356         const rightSpace = rightSpaceRe.test(content);
9357         if ((leftSpace || rightSpace) && (!inTable || !tablePipeRe.test(content))) {
9358           const contextStart = emphasisIndex - emphasisLength;
9359           const contextEnd = matchIndex + contextLength;
9360           const context = line.substring(contextStart, contextEnd);
9361           const column = contextStart + 1;
9362           const length = contextEnd - contextStart;
9363           const leftMarker = line.substring(contextStart, emphasisIndex);
9364           const rightMarker = match ? match[2] || match[3] : "";
9365           const fixedText = `${leftMarker}${content.trim()}${rightMarker}`;
9366           return [
9367             onError,
9368             lineIndex + 1,
9369             context,
9370             leftSpace,
9371             rightSpace,
9372             [column, length],
9373             {
9374               editColumn: column,
9375               deleteCount: length,
9376               insertText: fixedText
9377             }
9378           ];
9379         }
9380         return null;
9381       }
9382       const ignoreMarkersByLine = emphasisMarkersInContent(params);
9383       resetRunTracking();
9384       forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence, inTable, inItem, onBreak, inMath) => {
9385         const onItemStart = inItem === 1;
9386         if (inCode || inTable || onBreak || onItemStart || isBlankLine(line)) {
9387           resetRunTracking();
9388         }
9389         if (inCode || onBreak || inMath) {
9390           return;
9391         }
9392         if (onItemStart) {
9393           line = line.replace(asteriskListItemMarkerRe, "$1 $2");
9394         }
9395         let match = null;
9396         while (match = emphasisRe.exec(line)) {
9397           const ignoreMarkersForLine = ignoreMarkersByLine[lineIndex] || [];
9398           const matchIndex = match.index + match[1].length;
9399           if (ignoreMarkersForLine.includes(matchIndex)) {
9400             continue;
9401           }
9402           const matchLength = match[0].length - match[1].length;
9403           const matchKind = (match[2] || match[3])[0];
9404           if (emphasisIndex === -1) {
9405             emphasisIndex = matchIndex + matchLength;
9406             emphasisLength = matchLength;
9407             emphasisKind = matchKind;
9408             effectiveEmphasisLength = matchLength;
9409           } else if (matchKind === emphasisKind) {
9410             if (matchLength === effectiveEmphasisLength) {
9411               if (pendingError) {
9412                 addErrorContext(...pendingError);
9413                 pendingError = null;
9414               }
9415               const error = handleRunEnd(line, lineIndex, effectiveEmphasisLength, match, matchIndex, inTable);
9416               if (error) {
9417                 addErrorContext(...error);
9418               }
9419               resetRunTracking();
9420             } else if (matchLength === 3) {
9421               effectiveEmphasisLength = matchLength - effectiveEmphasisLength;
9422             } else if (effectiveEmphasisLength === 3) {
9423               effectiveEmphasisLength -= matchLength;
9424             } else {
9425               effectiveEmphasisLength += matchLength;
9426             }
9427             if (emphasisRe.lastIndex > 1) {
9428               emphasisRe.lastIndex--;
9429             }
9430           } else if (emphasisRe.lastIndex > 1) {
9431             emphasisRe.lastIndex--;
9432           }
9433         }
9434         if (emphasisIndex !== -1) {
9435           pendingError = pendingError || handleRunEnd(line, lineIndex, 0, null, line.length, inTable);
9436           emphasisIndex = 0;
9437           emphasisLength = 0;
9438         }
9439       });
9440     }
9441   };
9442 });
9443
9444 // node_modules/markdownlint/lib/md038.js
9445 var require_md038 = __commonJS((exports2, module2) => {
9446   "use strict";
9447   var {addErrorContext, filterTokens, forEachInlineCodeSpan, newLineRe} = require_helpers2();
9448   var leftSpaceRe = /^\s([^`]|$)/;
9449   var rightSpaceRe = /[^`]\s$/;
9450   var singleLeftRightSpaceRe = /^\s(?:\S.*\S|\S)\s$/;
9451   module2.exports = {
9452     names: ["MD038", "no-space-in-code"],
9453     description: "Spaces inside code span elements",
9454     tags: ["whitespace", "code"],
9455     function: function MD038(params, onError) {
9456       filterTokens(params, "inline", (token) => {
9457         if (token.children.some((child) => child.type === "code_inline")) {
9458           const tokenLines = params.lines.slice(token.map[0], token.map[1]);
9459           forEachInlineCodeSpan(tokenLines.join("\n"), (code, lineIndex, columnIndex, tickCount) => {
9460             let rangeIndex = columnIndex - tickCount;
9461             let rangeLength = code.length + 2 * tickCount;
9462             let rangeLineOffset = 0;
9463             let fixIndex = columnIndex;
9464             let fixLength = code.length;
9465             const codeLines = code.split(newLineRe);
9466             const left = leftSpaceRe.test(code);
9467             const right = !left && rightSpaceRe.test(code);
9468             if (right && codeLines.length > 1) {
9469               rangeIndex = 0;
9470               rangeLineOffset = codeLines.length - 1;
9471               fixIndex = 0;
9472             }
9473             const allowed = singleLeftRightSpaceRe.test(code);
9474             if ((left || right) && !allowed) {
9475               const codeLinesRange = codeLines[rangeLineOffset];
9476               if (codeLines.length > 1) {
9477                 rangeLength = codeLinesRange.length + tickCount;
9478                 fixLength = codeLinesRange.length;
9479               }
9480               const context = tokenLines[lineIndex + rangeLineOffset].substring(rangeIndex, rangeIndex + rangeLength);
9481               const codeLinesRangeTrim = codeLinesRange.trim();
9482               const fixText = (codeLinesRangeTrim.startsWith("`") ? " " : "") + codeLinesRangeTrim + (codeLinesRangeTrim.endsWith("`") ? " " : "");
9483               addErrorContext(onError, token.lineNumber + lineIndex + rangeLineOffset, context, left, right, [rangeIndex + 1, rangeLength], {
9484                 editColumn: fixIndex + 1,
9485                 deleteCount: fixLength,
9486                 insertText: fixText
9487               });
9488             }
9489           });
9490         }
9491       });
9492     }
9493   };
9494 });
9495
9496 // node_modules/markdownlint/lib/md039.js
9497 var require_md039 = __commonJS((exports2, module2) => {
9498   "use strict";
9499   var {addErrorContext, filterTokens} = require_helpers2();
9500   var spaceInLinkRe = /\[(?:\s+(?:[^\]]*?)\s*|(?:[^\]]*?)\s+)](?=\(\S*\))/;
9501   module2.exports = {
9502     names: ["MD039", "no-space-in-links"],
9503     description: "Spaces inside link text",
9504     tags: ["whitespace", "links"],
9505     function: function MD039(params, onError) {
9506       filterTokens(params, "inline", (token) => {
9507         const {children} = token;
9508         let {lineNumber} = token;
9509         let inLink = false;
9510         let linkText = "";
9511         let lineIndex = 0;
9512         children.forEach((child) => {
9513           const {content, type} = child;
9514           if (type === "link_open") {
9515             inLink = true;
9516             linkText = "";
9517           } else if (type === "link_close") {
9518             inLink = false;
9519             const left = linkText.trimStart().length !== linkText.length;
9520             const right = linkText.trimEnd().length !== linkText.length;
9521             if (left || right) {
9522               const line = params.lines[lineNumber - 1];
9523               let range = null;
9524               let fixInfo = null;
9525               const match = line.slice(lineIndex).match(spaceInLinkRe);
9526               if (match) {
9527                 const column = match.index + lineIndex + 1;
9528                 const length = match[0].length;
9529                 range = [column, length];
9530                 fixInfo = {
9531                   editColumn: column + 1,
9532                   deleteCount: length - 2,
9533                   insertText: linkText.trim()
9534                 };
9535                 lineIndex = column + length - 1;
9536               }
9537               addErrorContext(onError, lineNumber, `[${linkText}]`, left, right, range, fixInfo);
9538             }
9539           } else if (type === "softbreak" || type === "hardbreak") {
9540             lineNumber++;
9541             lineIndex = 0;
9542           } else if (inLink) {
9543             linkText += content;
9544           }
9545         });
9546       });
9547     }
9548   };
9549 });
9550
9551 // node_modules/markdownlint/lib/md040.js
9552 var require_md040 = __commonJS((exports2, module2) => {
9553   "use strict";
9554   var {addErrorContext, filterTokens} = require_helpers2();
9555   module2.exports = {
9556     names: ["MD040", "fenced-code-language"],
9557     description: "Fenced code blocks should have a language specified",
9558     tags: ["code", "language"],
9559     function: function MD040(params, onError) {
9560       filterTokens(params, "fence", function forToken(token) {
9561         if (!token.info.trim()) {
9562           addErrorContext(onError, token.lineNumber, token.line);
9563         }
9564       });
9565     }
9566   };
9567 });
9568
9569 // node_modules/markdownlint/lib/md041.js
9570 var require_md041 = __commonJS((exports2, module2) => {
9571   "use strict";
9572   var {addErrorContext, frontMatterHasTitle} = require_helpers2();
9573   module2.exports = {
9574     names: ["MD041", "first-line-heading", "first-line-h1"],
9575     description: "First line in a file should be a top-level heading",
9576     tags: ["headings", "headers"],
9577     function: function MD041(params, onError) {
9578       const level = Number(params.config.level || 1);
9579       const tag = "h" + level;
9580       const foundFrontMatterTitle = frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title);
9581       if (!foundFrontMatterTitle) {
9582         const htmlHeadingRe = new RegExp(`^<h${level}[ />]`, "i");
9583         params.tokens.every((token) => {
9584           let isError = false;
9585           if (token.type === "html_block") {
9586             if (token.content.startsWith("<!--")) {
9587               return true;
9588             } else if (!htmlHeadingRe.test(token.content)) {
9589               isError = true;
9590             }
9591           } else if (token.type !== "heading_open" || token.tag !== tag) {
9592             isError = true;
9593           }
9594           if (isError) {
9595             addErrorContext(onError, token.lineNumber, token.line);
9596           }
9597           return false;
9598         });
9599       }
9600     }
9601   };
9602 });
9603
9604 // node_modules/markdownlint/lib/md042.js
9605 var require_md042 = __commonJS((exports2, module2) => {
9606   "use strict";
9607   var {addErrorContext, filterTokens, rangeFromRegExp} = require_helpers2();
9608   var emptyLinkRe = /\[[^\]]*](?:\((?:#?|(?:<>))\))/;
9609   module2.exports = {
9610     names: ["MD042", "no-empty-links"],
9611     description: "No empty links",
9612     tags: ["links"],
9613     function: function MD042(params, onError) {
9614       filterTokens(params, "inline", function forToken(token) {
9615         let inLink = false;
9616         let linkText = "";
9617         let emptyLink = false;
9618         token.children.forEach(function forChild(child) {
9619           if (child.type === "link_open") {
9620             inLink = true;
9621             linkText = "";
9622             child.attrs.forEach(function forAttr(attr) {
9623               if (attr[0] === "href" && (!attr[1] || attr[1] === "#")) {
9624                 emptyLink = true;
9625               }
9626             });
9627           } else if (child.type === "link_close") {
9628             inLink = false;
9629             if (emptyLink) {
9630               addErrorContext(onError, child.lineNumber, "[" + linkText + "]()", null, null, rangeFromRegExp(child.line, emptyLinkRe));
9631               emptyLink = false;
9632             }
9633           } else if (inLink) {
9634             linkText += child.content;
9635           }
9636         });
9637       });
9638     }
9639   };
9640 });
9641
9642 // node_modules/markdownlint/lib/md043.js
9643 var require_md043 = __commonJS((exports2, module2) => {
9644   "use strict";
9645   var {addErrorContext, addErrorDetailIf, forEachHeading} = require_helpers2();
9646   module2.exports = {
9647     names: ["MD043", "required-headings", "required-headers"],
9648     description: "Required heading structure",
9649     tags: ["headings", "headers"],
9650     function: function MD043(params, onError) {
9651       const requiredHeadings = params.config.headings || params.config.headers;
9652       if (Array.isArray(requiredHeadings)) {
9653         const levels = {};
9654         [1, 2, 3, 4, 5, 6].forEach((level) => {
9655           levels["h" + level] = "######".substr(-level);
9656         });
9657         let i = 0;
9658         let matchAny = false;
9659         let hasError = false;
9660         let anyHeadings = false;
9661         const getExpected = () => requiredHeadings[i++] || "[None]";
9662         forEachHeading(params, (heading, content) => {
9663           if (!hasError) {
9664             anyHeadings = true;
9665             const actual = levels[heading.tag] + " " + content;
9666             const expected = getExpected();
9667             if (expected === "*") {
9668               matchAny = true;
9669               getExpected();
9670             } else if (expected === "+") {
9671               matchAny = true;
9672             } else if (expected.toLowerCase() === actual.toLowerCase()) {
9673               matchAny = false;
9674             } else if (matchAny) {
9675               i--;
9676             } else {
9677               addErrorDetailIf(onError, heading.lineNumber, expected, actual);
9678               hasError = true;
9679             }
9680           }
9681         });
9682         if (!hasError && i < requiredHeadings.length && (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))) {
9683           addErrorContext(onError, params.lines.length, requiredHeadings[i]);
9684         }
9685       }
9686     }
9687   };
9688 });
9689
9690 // node_modules/markdownlint/lib/md044.js
9691 var require_md044 = __commonJS((exports2, module2) => {
9692   "use strict";
9693   var {
9694     addErrorDetailIf,
9695     bareUrlRe,
9696     escapeForRegExp,
9697     filterTokens,
9698     forEachInlineChild,
9699     newLineRe
9700   } = require_helpers2();
9701   var startNonWordRe = /^\W/;
9702   var endNonWordRe = /\W$/;
9703   module2.exports = {
9704     names: ["MD044", "proper-names"],
9705     description: "Proper names should have the correct capitalization",
9706     tags: ["spelling"],
9707     function: function MD044(params, onError) {
9708       let names = params.config.names;
9709       names = Array.isArray(names) ? names : [];
9710       const codeBlocks = params.config.code_blocks;
9711       const includeCodeBlocks = codeBlocks === void 0 ? true : !!codeBlocks;
9712       const autolinkText = new Set();
9713       filterTokens(params, "inline", (token) => {
9714         let inAutoLink = false;
9715         token.children.forEach((child) => {
9716           const {info, type} = child;
9717           if (type === "link_open" && info === "auto") {
9718             inAutoLink = true;
9719           } else if (type === "link_close") {
9720             inAutoLink = false;
9721           } else if (type === "text" && inAutoLink) {
9722             autolinkText.add(child);
9723           }
9724         });
9725       });
9726       names.forEach((name) => {
9727         const escapedName = escapeForRegExp(name);
9728         const startNamePattern = startNonWordRe.test(name) ? "" : "\\S*\\b";
9729         const endNamePattern = endNonWordRe.test(name) ? "" : "\\b\\S*";
9730         const namePattern = `(${startNamePattern})(${escapedName})(${endNamePattern})`;
9731         const anyNameRe = new RegExp(namePattern, "gi");
9732         function forToken(token) {
9733           if (!autolinkText.has(token)) {
9734             const fenceOffset = token.type === "fence" ? 1 : 0;
9735             token.content.split(newLineRe).forEach((line, index) => {
9736               let match = null;
9737               while ((match = anyNameRe.exec(line)) !== null) {
9738                 const [fullMatch, leftMatch, nameMatch, rightMatch] = match;
9739                 if (fullMatch.search(bareUrlRe) === -1) {
9740                   const wordMatch = fullMatch.replace(new RegExp(`^\\W{0,${leftMatch.length}}`), "").replace(new RegExp(`\\W{0,${rightMatch.length}}$`), "");
9741                   if (!names.includes(wordMatch)) {
9742                     const lineNumber = token.lineNumber + index + fenceOffset;
9743                     const fullLine = params.lines[lineNumber - 1];
9744                     const matchLength = wordMatch.length;
9745                     const matchIndex = fullLine.indexOf(wordMatch);
9746                     const range = matchIndex === -1 ? null : [matchIndex + 1, matchLength];
9747                     const fixInfo = matchIndex === -1 ? null : {
9748                       editColumn: matchIndex + 1,
9749                       deleteCount: matchLength,
9750                       insertText: name
9751                     };
9752                     addErrorDetailIf(onError, lineNumber, name, nameMatch, null, null, range, fixInfo);
9753                   }
9754                 }
9755               }
9756             });
9757           }
9758         }
9759         forEachInlineChild(params, "text", forToken);
9760         if (includeCodeBlocks) {
9761           forEachInlineChild(params, "code_inline", forToken);
9762           filterTokens(params, "code_block", forToken);
9763           filterTokens(params, "fence", forToken);
9764         }
9765       });
9766     }
9767   };
9768 });
9769
9770 // node_modules/markdownlint/lib/md045.js
9771 var require_md045 = __commonJS((exports2, module2) => {
9772   "use strict";
9773   var {addError, forEachInlineChild} = require_helpers2();
9774   module2.exports = {
9775     names: ["MD045", "no-alt-text"],
9776     description: "Images should have alternate text (alt text)",
9777     tags: ["accessibility", "images"],
9778     function: function MD045(params, onError) {
9779       forEachInlineChild(params, "image", function forToken(token) {
9780         if (token.content === "") {
9781           addError(onError, token.lineNumber);
9782         }
9783       });
9784     }
9785   };
9786 });
9787
9788 // node_modules/markdownlint/lib/md046.js
9789 var require_md046 = __commonJS((exports2, module2) => {
9790   "use strict";
9791   var {addErrorDetailIf} = require_helpers2();
9792   var tokenTypeToStyle = {
9793     fence: "fenced",
9794     code_block: "indented"
9795   };
9796   module2.exports = {
9797     names: ["MD046", "code-block-style"],
9798     description: "Code block style",
9799     tags: ["code"],
9800     function: function MD046(params, onError) {
9801       let expectedStyle = String(params.config.style || "consistent");
9802       params.tokens.filter((token) => token.type === "code_block" || token.type === "fence").forEach((token) => {
9803         const {lineNumber, type} = token;
9804         if (expectedStyle === "consistent") {
9805           expectedStyle = tokenTypeToStyle[type];
9806         }
9807         addErrorDetailIf(onError, lineNumber, expectedStyle, tokenTypeToStyle[type]);
9808       });
9809     }
9810   };
9811 });
9812
9813 // node_modules/markdownlint/lib/md047.js
9814 var require_md047 = __commonJS((exports2, module2) => {
9815   "use strict";
9816   var {addError, isBlankLine} = require_helpers2();
9817   module2.exports = {
9818     names: ["MD047", "single-trailing-newline"],
9819     description: "Files should end with a single newline character",
9820     tags: ["blank_lines"],
9821     function: function MD047(params, onError) {
9822       const lastLineNumber = params.lines.length;
9823       const lastLine = params.lines[lastLineNumber - 1];
9824       if (!isBlankLine(lastLine)) {
9825         addError(onError, lastLineNumber, null, null, [lastLine.length, 1], {
9826           insertText: "\n",
9827           editColumn: lastLine.length + 1
9828         });
9829       }
9830     }
9831   };
9832 });
9833
9834 // node_modules/markdownlint/lib/md048.js
9835 var require_md048 = __commonJS((exports2, module2) => {
9836   "use strict";
9837   var {addErrorDetailIf, fencedCodeBlockStyleFor} = require_helpers2();
9838   module2.exports = {
9839     names: ["MD048", "code-fence-style"],
9840     description: "Code fence style",
9841     tags: ["code"],
9842     function: function MD048(params, onError) {
9843       const style = String(params.config.style || "consistent");
9844       let expectedStyle = style;
9845       params.tokens.filter((token) => token.type === "fence").forEach((fenceToken) => {
9846         const {lineNumber, markup} = fenceToken;
9847         if (expectedStyle === "consistent") {
9848           expectedStyle = fencedCodeBlockStyleFor(markup);
9849         }
9850         addErrorDetailIf(onError, lineNumber, expectedStyle, fencedCodeBlockStyleFor(markup));
9851       });
9852     }
9853   };
9854 });
9855
9856 // node_modules/markdownlint/lib/rules.js
9857 var require_rules = __commonJS((exports2, module2) => {
9858   "use strict";
9859   var URL2 = require("url").URL;
9860   var packageJson = require_package();
9861   var homepage = packageJson.homepage;
9862   var version = packageJson.version;
9863   var rules = [
9864     require_md001(),
9865     require_md002(),
9866     require_md003(),
9867     require_md004(),
9868     require_md005(),
9869     require_md006(),
9870     require_md007(),
9871     require_md009(),
9872     require_md010(),
9873     require_md011(),
9874     require_md012(),
9875     require_md013(),
9876     require_md014(),
9877     require_md018(),
9878     require_md019(),
9879     require_md020(),
9880     require_md021(),
9881     require_md022(),
9882     require_md023(),
9883     require_md024(),
9884     require_md025(),
9885     require_md026(),
9886     require_md027(),
9887     require_md028(),
9888     require_md029(),
9889     require_md030(),
9890     require_md031(),
9891     require_md032(),
9892     require_md033(),
9893     require_md034(),
9894     require_md035(),
9895     require_md036(),
9896     require_md037(),
9897     require_md038(),
9898     require_md039(),
9899     require_md040(),
9900     require_md041(),
9901     require_md042(),
9902     require_md043(),
9903     require_md044(),
9904     require_md045(),
9905     require_md046(),
9906     require_md047(),
9907     require_md048()
9908   ];
9909   rules.forEach((rule) => {
9910     const name = rule.names[0].toLowerCase();
9911     rule["information"] = new URL2(`${homepage}/blob/v${version}/doc/Rules.md#${name}`);
9912   });
9913   module2.exports = rules;
9914 });
9915
9916 // node_modules/markdownlint/lib/markdownlint.js
9917 var require_markdownlint = __commonJS((exports2, module2) => {
9918   "use strict";
9919   var fs2 = require("fs");
9920   var path2 = require("path");
9921   var {promisify} = require("util");
9922   var markdownIt = require_markdown_it();
9923   var rules = require_rules();
9924   var helpers = require_helpers2();
9925   var cache = require_cache();
9926   var dynamicRequire = typeof __non_webpack_require__ === "undefined" ? require : __non_webpack_require__;
9927   var deprecatedRuleNames = ["MD002", "MD006"];
9928   function validateRuleList(ruleList) {
9929     let result = null;
9930     if (ruleList.length === rules.length) {
9931       return result;
9932     }
9933     const allIds = {};
9934     ruleList.forEach(function forRule(rule, index) {
9935       const customIndex = index - rules.length;
9936       function newError(property) {
9937         return new Error("Property '" + property + "' of custom rule at index " + customIndex + " is incorrect.");
9938       }
9939       ["names", "tags"].forEach(function forProperty(property) {
9940         const value = rule[property];
9941         if (!result && (!value || !Array.isArray(value) || value.length === 0 || !value.every(helpers.isString) || value.some(helpers.isEmptyString))) {
9942           result = newError(property);
9943         }
9944       });
9945       [
9946         ["description", "string"],
9947         ["function", "function"]
9948       ].forEach(function forProperty(propertyInfo) {
9949         const property = propertyInfo[0];
9950         const value = rule[property];
9951         if (!result && (!value || typeof value !== propertyInfo[1])) {
9952           result = newError(property);
9953         }
9954       });
9955       if (!result && rule.information && Object.getPrototypeOf(rule.information) !== URL.prototype) {
9956         result = newError("information");
9957       }
9958       if (!result) {
9959         rule.names.forEach(function forName(name) {
9960           const nameUpper = name.toUpperCase();
9961           if (!result && allIds[nameUpper] !== void 0) {
9962             result = new Error("Name '" + name + "' of custom rule at index " + customIndex + " is already used as a name or tag.");
9963           }
9964           allIds[nameUpper] = true;
9965         });
9966         rule.tags.forEach(function forTag(tag) {
9967           const tagUpper = tag.toUpperCase();
9968           if (!result && allIds[tagUpper]) {
9969             result = new Error("Tag '" + tag + "' of custom rule at index " + customIndex + " is already used as a name.");
9970           }
9971           allIds[tagUpper] = false;
9972         });
9973       }
9974     });
9975     return result;
9976   }
9977   function newResults(ruleList) {
9978     const lintResults = {};
9979     function toString(useAlias) {
9980       let ruleNameToRule = null;
9981       const results = [];
9982       const keys = Object.keys(lintResults);
9983       keys.sort();
9984       keys.forEach(function forFile(file) {
9985         const fileResults = lintResults[file];
9986         if (Array.isArray(fileResults)) {
9987           fileResults.forEach(function forResult(result) {
9988             const ruleMoniker = result.ruleNames ? result.ruleNames.join("/") : result.ruleName + "/" + result.ruleAlias;
9989             results.push(file + ": " + result.lineNumber + ": " + ruleMoniker + " " + result.ruleDescription + (result.errorDetail ? " [" + result.errorDetail + "]" : "") + (result.errorContext ? ' [Context: "' + result.errorContext + '"]' : ""));
9990           });
9991         } else {
9992           if (!ruleNameToRule) {
9993             ruleNameToRule = {};
9994             ruleList.forEach(function forRule(rule) {
9995               const ruleName = rule.names[0].toUpperCase();
9996               ruleNameToRule[ruleName] = rule;
9997             });
9998           }
9999           Object.keys(fileResults).forEach(function forRule(ruleName) {
10000             const rule = ruleNameToRule[ruleName.toUpperCase()];
10001             const ruleResults = fileResults[ruleName];
10002             ruleResults.forEach(function forLine(lineNumber) {
10003               const nameIndex = Math.min(useAlias ? 1 : 0, rule.names.length - 1);
10004               const result = file + ": " + lineNumber + ": " + rule.names[nameIndex] + " " + rule.description;
10005               results.push(result);
10006             });
10007           });
10008         }
10009       });
10010       return results.join("\n");
10011     }
10012     Object.defineProperty(lintResults, "toString", {value: toString});
10013     return lintResults;
10014   }
10015   function removeFrontMatter(content, frontMatter) {
10016     let frontMatterLines = [];
10017     if (frontMatter) {
10018       const frontMatterMatch = content.match(frontMatter);
10019       if (frontMatterMatch && !frontMatterMatch.index) {
10020         const contentMatched = frontMatterMatch[0];
10021         content = content.slice(contentMatched.length);
10022         frontMatterLines = contentMatched.split(helpers.newLineRe);
10023         if (frontMatterLines.length > 0 && frontMatterLines[frontMatterLines.length - 1] === "") {
10024           frontMatterLines.length--;
10025         }
10026       }
10027     }
10028     return {
10029       content,
10030       frontMatterLines
10031     };
10032   }
10033   function annotateTokens(tokens, lines) {
10034     let tableMap = null;
10035     tokens.forEach(function forToken(token) {
10036       if (token.type === "thead_open" || token.type === "tbody_open") {
10037         tableMap = token.map.slice();
10038       } else if (token.type === "tr_close" && tableMap) {
10039         tableMap[0]++;
10040       } else if (token.type === "thead_close" || token.type === "tbody_close") {
10041         tableMap = null;
10042       }
10043       if (tableMap && !token.map) {
10044         token.map = tableMap.slice();
10045       }
10046       if (token.map) {
10047         token.line = lines[token.map[0]];
10048         token.lineNumber = token.map[0] + 1;
10049         while (token.map[1] && !(lines[token.map[1] - 1] || "").trim()) {
10050           token.map[1]--;
10051         }
10052         let lineNumber = token.lineNumber;
10053         const codeSpanExtraLines = [];
10054         helpers.forEachInlineCodeSpan(token.content, function handleInlineCodeSpan(code) {
10055           codeSpanExtraLines.push(code.split(helpers.newLineRe).length - 1);
10056         });
10057         (token.children || []).forEach(function forChild(child) {
10058           child.lineNumber = lineNumber;
10059           child.line = lines[lineNumber - 1];
10060           if (child.type === "softbreak" || child.type === "hardbreak") {
10061             lineNumber++;
10062           } else if (child.type === "code_inline") {
10063             lineNumber += codeSpanExtraLines.shift();
10064           }
10065         });
10066       }
10067     });
10068   }
10069   function mapAliasToRuleNames(ruleList) {
10070     const aliasToRuleNames = {};
10071     ruleList.forEach(function forRule(rule) {
10072       const ruleName = rule.names[0].toUpperCase();
10073       rule.names.forEach(function forName(name) {
10074         const nameUpper = name.toUpperCase();
10075         aliasToRuleNames[nameUpper] = [ruleName];
10076       });
10077       rule.tags.forEach(function forTag(tag) {
10078         const tagUpper = tag.toUpperCase();
10079         const ruleNames = aliasToRuleNames[tagUpper] || [];
10080         ruleNames.push(ruleName);
10081         aliasToRuleNames[tagUpper] = ruleNames;
10082       });
10083     });
10084     return aliasToRuleNames;
10085   }
10086   function getEffectiveConfig(ruleList, config2, aliasToRuleNames) {
10087     const defaultKey = Object.keys(config2).filter((key) => key.toUpperCase() === "DEFAULT");
10088     const ruleDefault = defaultKey.length === 0 || !!config2[defaultKey[0]];
10089     const effectiveConfig = {};
10090     ruleList.forEach((rule) => {
10091       const ruleName = rule.names[0].toUpperCase();
10092       effectiveConfig[ruleName] = ruleDefault;
10093     });
10094     deprecatedRuleNames.forEach((ruleName) => {
10095       effectiveConfig[ruleName] = false;
10096     });
10097     Object.keys(config2).forEach((key) => {
10098       let value = config2[key];
10099       if (value) {
10100         if (!(value instanceof Object)) {
10101           value = {};
10102         }
10103       } else {
10104         value = false;
10105       }
10106       const keyUpper = key.toUpperCase();
10107       (aliasToRuleNames[keyUpper] || []).forEach((ruleName) => {
10108         effectiveConfig[ruleName] = value;
10109       });
10110     });
10111     return effectiveConfig;
10112   }
10113   function getEnabledRulesPerLineNumber(ruleList, lines, frontMatterLines, noInlineConfig, config2, aliasToRuleNames) {
10114     let enabledRules = {};
10115     let capturedRules = {};
10116     const allRuleNames = [];
10117     const enabledRulesPerLineNumber = new Array(1 + frontMatterLines.length);
10118     function handleInlineConfig(perLine, forEachMatch, forEachLine) {
10119       const input = perLine ? lines : [lines.join("\n")];
10120       input.forEach((line, lineIndex) => {
10121         if (!noInlineConfig) {
10122           let match = null;
10123           while (match = helpers.inlineCommentRe.exec(line)) {
10124             const action = (match[1] || match[3]).toUpperCase();
10125             const parameter = match[2] || match[4];
10126             forEachMatch(action, parameter, lineIndex + 1);
10127           }
10128         }
10129         if (forEachLine) {
10130           forEachLine();
10131         }
10132       });
10133     }
10134     function configureFile(action, parameter) {
10135       if (action === "CONFIGURE-FILE") {
10136         try {
10137           const json = JSON.parse(parameter);
10138           config2 = {
10139             ...config2,
10140             ...json
10141           };
10142         } catch {
10143         }
10144       }
10145     }
10146     function applyEnableDisable(action, parameter, state) {
10147       const enabled = action.startsWith("ENABLE");
10148       const items = parameter ? parameter.trim().toUpperCase().split(/\s+/) : allRuleNames;
10149       items.forEach((nameUpper) => {
10150         (aliasToRuleNames[nameUpper] || []).forEach((ruleName) => {
10151           state[ruleName] = enabled;
10152         });
10153       });
10154     }
10155     function enableDisableFile(action, parameter) {
10156       if (action === "ENABLE-FILE" || action === "DISABLE-FILE") {
10157         applyEnableDisable(action, parameter, enabledRules);
10158       }
10159     }
10160     function captureRestoreEnableDisable(action, parameter) {
10161       if (action === "CAPTURE") {
10162         capturedRules = {...enabledRules};
10163       } else if (action === "RESTORE") {
10164         enabledRules = {...capturedRules};
10165       } else if (action === "ENABLE" || action === "DISABLE") {
10166         enabledRules = {...enabledRules};
10167         applyEnableDisable(action, parameter, enabledRules);
10168       }
10169     }
10170     function updateLineState() {
10171       enabledRulesPerLineNumber.push({...enabledRules});
10172     }
10173     function disableNextLine(action, parameter, lineNumber) {
10174       if (action === "DISABLE-NEXT-LINE") {
10175         applyEnableDisable(action, parameter, enabledRulesPerLineNumber[lineNumber + 1] || {});
10176       }
10177     }
10178     handleInlineConfig(false, configureFile);
10179     const effectiveConfig = getEffectiveConfig(ruleList, config2, aliasToRuleNames);
10180     ruleList.forEach((rule) => {
10181       const ruleName = rule.names[0].toUpperCase();
10182       allRuleNames.push(ruleName);
10183       enabledRules[ruleName] = !!effectiveConfig[ruleName];
10184     });
10185     capturedRules = enabledRules;
10186     handleInlineConfig(true, enableDisableFile);
10187     handleInlineConfig(true, captureRestoreEnableDisable, updateLineState);
10188     handleInlineConfig(true, disableNextLine);
10189     return {
10190       effectiveConfig,
10191       enabledRulesPerLineNumber
10192     };
10193   }
10194   function lineNumberComparison(a, b) {
10195     return a.lineNumber - b.lineNumber;
10196   }
10197   function filterAllValues() {
10198     return true;
10199   }
10200   function uniqueFilterForSortedErrors(value, index, array) {
10201     return index === 0 || value.lineNumber > array[index - 1].lineNumber;
10202   }
10203   function lintContent(ruleList, name, content, md, config2, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, callback) {
10204     content = content.replace(/^\uFEFF/, "");
10205     const removeFrontMatterResult = removeFrontMatter(content, frontMatter);
10206     const frontMatterLines = removeFrontMatterResult.frontMatterLines;
10207     content = helpers.clearHtmlCommentText(removeFrontMatterResult.content);
10208     const tokens = md.parse(content, {});
10209     const lines = content.split(helpers.newLineRe);
10210     annotateTokens(tokens, lines);
10211     const aliasToRuleNames = mapAliasToRuleNames(ruleList);
10212     const {effectiveConfig, enabledRulesPerLineNumber} = getEnabledRulesPerLineNumber(ruleList, lines, frontMatterLines, noInlineConfig, config2, aliasToRuleNames);
10213     const params = {
10214       name,
10215       tokens,
10216       lines,
10217       frontMatterLines
10218     };
10219     cache.lineMetadata(helpers.getLineMetadata(params));
10220     cache.flattenedLists(helpers.flattenLists(params));
10221     const result = resultVersion === 0 ? {} : [];
10222     function forRule(rule) {
10223       const ruleNameFriendly = rule.names[0];
10224       const ruleName = ruleNameFriendly.toUpperCase();
10225       params.config = effectiveConfig[ruleName];
10226       function throwError(property) {
10227         throw new Error("Property '" + property + "' of onError parameter is incorrect.");
10228       }
10229       const errors = [];
10230       function onError(errorInfo) {
10231         if (!errorInfo || !helpers.isNumber(errorInfo.lineNumber) || errorInfo.lineNumber < 1 || errorInfo.lineNumber > lines.length) {
10232           throwError("lineNumber");
10233         }
10234         if (errorInfo.detail && !helpers.isString(errorInfo.detail)) {
10235           throwError("detail");
10236         }
10237         if (errorInfo.context && !helpers.isString(errorInfo.context)) {
10238           throwError("context");
10239         }
10240         if (errorInfo.range && (!Array.isArray(errorInfo.range) || errorInfo.range.length !== 2 || !helpers.isNumber(errorInfo.range[0]) || errorInfo.range[0] < 1 || !helpers.isNumber(errorInfo.range[1]) || errorInfo.range[1] < 1 || errorInfo.range[0] + errorInfo.range[1] - 1 > lines[errorInfo.lineNumber - 1].length)) {
10241           throwError("range");
10242         }
10243         const fixInfo = errorInfo.fixInfo;
10244         const cleanFixInfo = {};
10245         if (fixInfo) {
10246           if (!helpers.isObject(fixInfo)) {
10247             throwError("fixInfo");
10248           }
10249           if (fixInfo.lineNumber !== void 0) {
10250             if (!helpers.isNumber(fixInfo.lineNumber) || fixInfo.lineNumber < 1 || fixInfo.lineNumber > lines.length) {
10251               throwError("fixInfo.lineNumber");
10252             }
10253             cleanFixInfo.lineNumber = fixInfo.lineNumber + frontMatterLines.length;
10254           }
10255           const effectiveLineNumber = fixInfo.lineNumber || errorInfo.lineNumber;
10256           if (fixInfo.editColumn !== void 0) {
10257             if (!helpers.isNumber(fixInfo.editColumn) || fixInfo.editColumn < 1 || fixInfo.editColumn > lines[effectiveLineNumber - 1].length + 1) {
10258               throwError("fixInfo.editColumn");
10259             }
10260             cleanFixInfo.editColumn = fixInfo.editColumn;
10261           }
10262           if (fixInfo.deleteCount !== void 0) {
10263             if (!helpers.isNumber(fixInfo.deleteCount) || fixInfo.deleteCount < -1 || fixInfo.deleteCount > lines[effectiveLineNumber - 1].length) {
10264               throwError("fixInfo.deleteCount");
10265             }
10266             cleanFixInfo.deleteCount = fixInfo.deleteCount;
10267           }
10268           if (fixInfo.insertText !== void 0) {
10269             if (!helpers.isString(fixInfo.insertText)) {
10270               throwError("fixInfo.insertText");
10271             }
10272             cleanFixInfo.insertText = fixInfo.insertText;
10273           }
10274         }
10275         errors.push({
10276           lineNumber: errorInfo.lineNumber + frontMatterLines.length,
10277           detail: errorInfo.detail || null,
10278           context: errorInfo.context || null,
10279           range: errorInfo.range ? [...errorInfo.range] : null,
10280           fixInfo: fixInfo ? cleanFixInfo : null
10281         });
10282       }
10283       if (handleRuleFailures) {
10284         try {
10285           rule.function(params, onError);
10286         } catch (error) {
10287           onError({
10288             lineNumber: 1,
10289             detail: `This rule threw an exception: ${error.message}`
10290           });
10291         }
10292       } else {
10293         rule.function(params, onError);
10294       }
10295       if (errors.length > 0) {
10296         errors.sort(lineNumberComparison);
10297         const filteredErrors = errors.filter(resultVersion === 3 ? filterAllValues : uniqueFilterForSortedErrors).filter(function removeDisabledRules(error) {
10298           return enabledRulesPerLineNumber[error.lineNumber][ruleName];
10299         }).map(function formatResults(error) {
10300           if (resultVersion === 0) {
10301             return error.lineNumber;
10302           }
10303           const errorObject = {};
10304           errorObject.lineNumber = error.lineNumber;
10305           if (resultVersion === 1) {
10306             errorObject.ruleName = ruleNameFriendly;
10307             errorObject.ruleAlias = rule.names[1] || rule.names[0];
10308           } else {
10309             errorObject.ruleNames = rule.names;
10310           }
10311           errorObject.ruleDescription = rule.description;
10312           errorObject.ruleInformation = rule.information ? rule.information.href : null;
10313           errorObject.errorDetail = error.detail;
10314           errorObject.errorContext = error.context;
10315           errorObject.errorRange = error.range;
10316           if (resultVersion === 3) {
10317             errorObject.fixInfo = error.fixInfo;
10318           }
10319           return errorObject;
10320         });
10321         if (filteredErrors.length > 0) {
10322           if (resultVersion === 0) {
10323             result[ruleNameFriendly] = filteredErrors;
10324           } else {
10325             Array.prototype.push.apply(result, filteredErrors);
10326           }
10327         }
10328       }
10329     }
10330     try {
10331       ruleList.forEach(forRule);
10332     } catch (error) {
10333       cache.clear();
10334       return callback(error);
10335     }
10336     cache.clear();
10337     return callback(null, result);
10338   }
10339   function lintFile(ruleList, file, md, config2, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, synchronous, callback) {
10340     function lintContentWrapper(err, content) {
10341       if (err) {
10342         return callback(err);
10343       }
10344       return lintContent(ruleList, file, content, md, config2, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, callback);
10345     }
10346     if (synchronous) {
10347       lintContentWrapper(null, fs2.readFileSync(file, helpers.utf8Encoding));
10348     } else {
10349       fs2.readFile(file, helpers.utf8Encoding, lintContentWrapper);
10350     }
10351   }
10352   function lintInput(options, synchronous, callback) {
10353     options = options || {};
10354     callback = callback || function noop() {
10355     };
10356     const ruleList = rules.concat(options.customRules || []);
10357     const ruleErr = validateRuleList(ruleList);
10358     if (ruleErr) {
10359       return callback(ruleErr);
10360     }
10361     let files = [];
10362     if (Array.isArray(options.files)) {
10363       files = options.files.slice();
10364     } else if (options.files) {
10365       files = [String(options.files)];
10366     }
10367     const strings = options.strings || {};
10368     const stringsKeys = Object.keys(strings);
10369     const config2 = options.config || {default: true};
10370     const frontMatter = options.frontMatter === void 0 ? helpers.frontMatterRe : options.frontMatter;
10371     const handleRuleFailures = !!options.handleRuleFailures;
10372     const noInlineConfig = !!options.noInlineConfig;
10373     const resultVersion = options.resultVersion === void 0 ? 2 : options.resultVersion;
10374     const md = markdownIt({html: true});
10375     const markdownItPlugins = options.markdownItPlugins || [];
10376     markdownItPlugins.forEach(function forPlugin(plugin) {
10377       md.use(...plugin);
10378     });
10379     const results = newResults(ruleList);
10380     let done = false;
10381     let syncItem = null;
10382     function syncCallback(err, result) {
10383       if (err) {
10384         done = true;
10385         return callback(err);
10386       }
10387       results[syncItem] = result;
10388       return null;
10389     }
10390     while (!done && (syncItem = stringsKeys.shift())) {
10391       lintContent(ruleList, syncItem, strings[syncItem] || "", md, config2, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, syncCallback);
10392     }
10393     if (synchronous) {
10394       while (!done && (syncItem = files.shift())) {
10395         lintFile(ruleList, syncItem, md, config2, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, synchronous, syncCallback);
10396       }
10397       return done || callback(null, results);
10398     }
10399     let concurrency = 0;
10400     function lintConcurrently() {
10401       const asyncItem = files.shift();
10402       if (done) {
10403       } else if (asyncItem) {
10404         concurrency++;
10405         lintFile(ruleList, asyncItem, md, config2, frontMatter, handleRuleFailures, noInlineConfig, resultVersion, synchronous, (err, result) => {
10406           concurrency--;
10407           if (err) {
10408             done = true;
10409             return callback(err);
10410           }
10411           results[asyncItem] = result;
10412           lintConcurrently();
10413           return null;
10414         });
10415       } else if (concurrency === 0) {
10416         done = true;
10417         return callback(null, results);
10418       }
10419       return null;
10420     }
10421     lintConcurrently();
10422     lintConcurrently();
10423     lintConcurrently();
10424     lintConcurrently();
10425     lintConcurrently();
10426     lintConcurrently();
10427     lintConcurrently();
10428     lintConcurrently();
10429     return null;
10430   }
10431   function markdownlint2(options, callback) {
10432     return lintInput(options, false, callback);
10433   }
10434   var markdownlintPromisify = promisify && promisify(markdownlint2);
10435   function markdownlintPromise(options) {
10436     return markdownlintPromisify(options);
10437   }
10438   function markdownlintSync(options) {
10439     let results = null;
10440     lintInput(options, true, function callback(error, res) {
10441       if (error) {
10442         throw error;
10443       }
10444       results = res;
10445     });
10446     return results;
10447   }
10448   function parseConfiguration(name, content, parsers) {
10449     let config2 = null;
10450     let message = "";
10451     const errors = [];
10452     (parsers || [JSON.parse]).every((parser) => {
10453       try {
10454         config2 = parser(content);
10455       } catch (error) {
10456         errors.push(error.message);
10457       }
10458       return !config2;
10459     });
10460     if (!config2) {
10461       errors.unshift(`Unable to parse '${name}'`);
10462       message = errors.join("; ");
10463     }
10464     return {
10465       config: config2,
10466       message
10467     };
10468   }
10469   function resolveConfigExtends(configFile, referenceId) {
10470     const configFileDirname = path2.dirname(configFile);
10471     const resolvedExtendsFile = path2.resolve(configFileDirname, referenceId);
10472     try {
10473       if (fs2.statSync(resolvedExtendsFile).isFile()) {
10474         return resolvedExtendsFile;
10475       }
10476     } catch {
10477     }
10478     try {
10479       return dynamicRequire.resolve(referenceId, {paths: [configFileDirname]});
10480     } catch {
10481     }
10482     return resolvedExtendsFile;
10483   }
10484   function readConfig(file, parsers, callback) {
10485     if (!callback) {
10486       callback = parsers;
10487       parsers = null;
10488     }
10489     fs2.readFile(file, helpers.utf8Encoding, (err, content) => {
10490       if (err) {
10491         return callback(err);
10492       }
10493       const {config: config2, message} = parseConfiguration(file, content, parsers);
10494       if (!config2) {
10495         return callback(new Error(message));
10496       }
10497       const configExtends = config2.extends;
10498       if (configExtends) {
10499         delete config2.extends;
10500         const resolvedExtends = resolveConfigExtends(file, configExtends);
10501         return readConfig(resolvedExtends, parsers, (errr, extendsConfig) => {
10502           if (errr) {
10503             return callback(errr);
10504           }
10505           return callback(null, {
10506             ...extendsConfig,
10507             ...config2
10508           });
10509         });
10510       }
10511       return callback(null, config2);
10512     });
10513   }
10514   var readConfigPromisify = promisify && promisify(readConfig);
10515   function readConfigPromise(file, parsers) {
10516     return readConfigPromisify(file, parsers);
10517   }
10518   function readConfigSync(file, parsers) {
10519     const content = fs2.readFileSync(file, helpers.utf8Encoding);
10520     const {config: config2, message} = parseConfiguration(file, content, parsers);
10521     if (!config2) {
10522       throw new Error(message);
10523     }
10524     const configExtends = config2.extends;
10525     if (configExtends) {
10526       delete config2.extends;
10527       const resolvedExtends = resolveConfigExtends(file, configExtends);
10528       return {
10529         ...readConfigSync(resolvedExtends, parsers),
10530         ...config2
10531       };
10532     }
10533     return config2;
10534   }
10535   function getVersion() {
10536     return require_package().version;
10537   }
10538   markdownlint2.sync = markdownlintSync;
10539   markdownlint2.readConfig = readConfig;
10540   markdownlint2.readConfigSync = readConfigSync;
10541   markdownlint2.getVersion = getVersion;
10542   markdownlint2.promises = {
10543     markdownlint: markdownlintPromise,
10544     readConfig: readConfigPromise
10545   };
10546   module2.exports = markdownlint2;
10547 });
10548
10549 // node_modules/markdownlint-rule-helpers/helpers.js
10550 var require_helpers3 = __commonJS((exports2, module2) => {
10551   "use strict";
10552   var os = require("os");
10553   var newLineRe = /\r\n?|\n/g;
10554   module2.exports.newLineRe = newLineRe;
10555   module2.exports.frontMatterRe = /((^---\s*$[^]*?^---\s*$)|(^\+\+\+\s*$[^]*?^(\+\+\+|\.\.\.)\s*$)|(^\{\s*$[^]*?^\}\s*$))(\r\n|\r|\n|$)/m;
10556   var inlineCommentRe = /<!--\s*markdownlint-(?:(?:(disable|enable|capture|restore|disable-file|enable-file|disable-next-line)((?:\s+[a-z0-9_-]+)*))|(?:(configure-file)\s+([\s\S]*?)))\s*-->/ig;
10557   module2.exports.inlineCommentRe = inlineCommentRe;
10558   module2.exports.bareUrlRe = /(?:http|ftp)s?:\/\/[^\s\]"']*(?:\/|[^\s\]"'\W])/ig;
10559   module2.exports.listItemMarkerRe = /^([\s>]*)(?:[*+-]|\d+[.)])\s+/;
10560   module2.exports.orderedListItemMarkerRe = /^[\s>]*0*(\d+)[.)]/;
10561   var emphasisMarkersRe = /[_*]/g;
10562   var linkRe = /\[(?:[^[\]]|\[[^\]]*\])*\](?:\(\S*\))?/g;
10563   module2.exports.utf8Encoding = "utf8";
10564   var allPunctuation = ".,;:!?\u3002\uFF0C\uFF1B\uFF1A\uFF01\uFF1F";
10565   module2.exports.allPunctuation = allPunctuation;
10566   module2.exports.allPunctuationNoQuestion = allPunctuation.replace(/[?？]/gu, "");
10567   module2.exports.isNumber = function isNumber(obj) {
10568     return typeof obj === "number";
10569   };
10570   module2.exports.isString = function isString(obj) {
10571     return typeof obj === "string";
10572   };
10573   module2.exports.isEmptyString = function isEmptyString(str) {
10574     return str.length === 0;
10575   };
10576   module2.exports.isObject = function isObject(obj) {
10577     return obj !== null && typeof obj === "object" && !Array.isArray(obj);
10578   };
10579   var blankLineRe = />|(?:<!--.*?-->)/g;
10580   module2.exports.isBlankLine = function isBlankLine(line) {
10581     return !line || !line.trim() || !line.replace(blankLineRe, "").trim();
10582   };
10583   module2.exports.numericSortAscending = function numericSortAscending(a, b) {
10584     return a - b;
10585   };
10586   module2.exports.includesSorted = function includesSorted(array, element) {
10587     let left = 0;
10588     let right = array.length - 1;
10589     while (left <= right) {
10590       const mid = left + right >> 1;
10591       if (array[mid] < element) {
10592         left = mid + 1;
10593       } else if (array[mid] > element) {
10594         right = mid - 1;
10595       } else {
10596         return true;
10597       }
10598     }
10599     return false;
10600   };
10601   var htmlCommentBegin = "<!--";
10602   var htmlCommentEnd = "-->";
10603   module2.exports.clearHtmlCommentText = function clearHtmlCommentText(text) {
10604     let i = 0;
10605     while ((i = text.indexOf(htmlCommentBegin, i)) !== -1) {
10606       const j = text.indexOf(htmlCommentEnd, i + 2);
10607       if (j === -1) {
10608         break;
10609       }
10610       if (j > i + htmlCommentBegin.length) {
10611         let k = i - 1;
10612         while (text[k] === " ") {
10613           k--;
10614         }
10615         if (k >= i - 4) {
10616           const content = text.slice(i + htmlCommentBegin.length, j);
10617           const isBlock = k < 0 || text[k] === "\n";
10618           const isValid = isBlock || !content.startsWith(">") && !content.startsWith("->") && !content.endsWith("-") && !content.includes("--");
10619           if (isValid) {
10620             const inlineCommentIndex = text.slice(i, j + htmlCommentEnd.length).search(inlineCommentRe);
10621             if (inlineCommentIndex === -1) {
10622               text = text.slice(0, i + htmlCommentBegin.length) + content.replace(/[^\r\n]/g, ".") + text.slice(j);
10623             }
10624           }
10625         }
10626       }
10627       i = j + htmlCommentEnd.length;
10628     }
10629     return text;
10630   };
10631   module2.exports.escapeForRegExp = function escapeForRegExp(str) {
10632     return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
10633   };
10634   var escapedMarkdownRe = /\\./g;
10635   module2.exports.unescapeMarkdown = function unescapeMarkdown(markdown, replacement) {
10636     return markdown.replace(escapedMarkdownRe, (match) => {
10637       const char = match[1];
10638       if ("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~".includes(char)) {
10639         return replacement || char;
10640       }
10641       return match;
10642     });
10643   };
10644   module2.exports.fencedCodeBlockStyleFor = function fencedCodeBlockStyleFor(markup) {
10645     switch (markup[0]) {
10646       case "~":
10647         return "tilde";
10648       default:
10649         return "backtick";
10650     }
10651   };
10652   function indentFor(token) {
10653     const line = token.line.replace(/^[\s>]*(> |>)/, "");
10654     return line.length - line.trimStart().length;
10655   }
10656   module2.exports.indentFor = indentFor;
10657   module2.exports.headingStyleFor = function headingStyleFor(token) {
10658     if (token.map[1] - token.map[0] === 1) {
10659       if (/[^\\]#\s*$/.test(token.line)) {
10660         return "atx_closed";
10661       }
10662       return "atx";
10663     }
10664     return "setext";
10665   };
10666   module2.exports.unorderedListStyleFor = function unorderedListStyleFor(token) {
10667     switch (token.markup) {
10668       case "-":
10669         return "dash";
10670       case "+":
10671         return "plus";
10672       default:
10673         return "asterisk";
10674     }
10675   };
10676   function filterTokens(params, type, handler) {
10677     params.tokens.forEach(function forToken(token) {
10678       if (token.type === type) {
10679         handler(token);
10680       }
10681     });
10682   }
10683   module2.exports.filterTokens = filterTokens;
10684   function isMathBlock(token) {
10685     return token.tag === "math" && token.type.startsWith("math_block") && !token.type.endsWith("_end");
10686   }
10687   module2.exports.getLineMetadata = function getLineMetadata(params) {
10688     const lineMetadata = params.lines.map((line, index) => [line, index, false, 0, false, false, false, false]);
10689     filterTokens(params, "fence", (token) => {
10690       lineMetadata[token.map[0]][3] = 1;
10691       lineMetadata[token.map[1] - 1][3] = -1;
10692       for (let i = token.map[0] + 1; i < token.map[1] - 1; i++) {
10693         lineMetadata[i][2] = true;
10694       }
10695     });
10696     filterTokens(params, "code_block", (token) => {
10697       for (let i = token.map[0]; i < token.map[1]; i++) {
10698         lineMetadata[i][2] = true;
10699       }
10700     });
10701     filterTokens(params, "table_open", (token) => {
10702       for (let i = token.map[0]; i < token.map[1]; i++) {
10703         lineMetadata[i][4] = true;
10704       }
10705     });
10706     filterTokens(params, "list_item_open", (token) => {
10707       let count = 1;
10708       for (let i = token.map[0]; i < token.map[1]; i++) {
10709         lineMetadata[i][5] = count;
10710         count++;
10711       }
10712     });
10713     filterTokens(params, "hr", (token) => {
10714       lineMetadata[token.map[0]][6] = true;
10715     });
10716     params.tokens.filter(isMathBlock).forEach((token) => {
10717       for (let i = token.map[0]; i < token.map[1]; i++) {
10718         lineMetadata[i][7] = true;
10719       }
10720     });
10721     return lineMetadata;
10722   };
10723   module2.exports.forEachLine = function forEachLine(lineMetadata, handler) {
10724     lineMetadata.forEach(function forMetadata(metadata) {
10725       handler(...metadata);
10726     });
10727   };
10728   module2.exports.flattenLists = function flattenLists(params) {
10729     const flattenedLists = [];
10730     const stack = [];
10731     let current = null;
10732     let nesting = 0;
10733     const nestingStack = [];
10734     let lastWithMap = {map: [0, 1]};
10735     params.tokens.forEach((token) => {
10736       if (isMathBlock(token) && token.map[1]) {
10737         token.map[1]++;
10738       }
10739       if (token.type === "bullet_list_open" || token.type === "ordered_list_open") {
10740         stack.push(current);
10741         current = {
10742           unordered: token.type === "bullet_list_open",
10743           parentsUnordered: !current || current.unordered && current.parentsUnordered,
10744           open: token,
10745           indent: indentFor(token),
10746           parentIndent: current && current.indent || 0,
10747           items: [],
10748           nesting,
10749           lastLineIndex: -1,
10750           insert: flattenedLists.length
10751         };
10752         nesting++;
10753       } else if (token.type === "bullet_list_close" || token.type === "ordered_list_close") {
10754         current.lastLineIndex = lastWithMap.map[1];
10755         flattenedLists.splice(current.insert, 0, current);
10756         delete current.insert;
10757         current = stack.pop();
10758         nesting--;
10759       } else if (token.type === "list_item_open") {
10760         current.items.push(token);
10761       } else if (token.type === "blockquote_open") {
10762         nestingStack.push(nesting);
10763         nesting = 0;
10764       } else if (token.type === "blockquote_close") {
10765         nesting = nestingStack.pop();
10766       } else if (token.map) {
10767         lastWithMap = token;
10768       }
10769     });
10770     return flattenedLists;
10771   };
10772   module2.exports.forEachInlineChild = function forEachInlineChild(params, type, handler) {
10773     filterTokens(params, "inline", function forToken(token) {
10774       token.children.forEach(function forChild(child) {
10775         if (child.type === type) {
10776           handler(child, token);
10777         }
10778       });
10779     });
10780   };
10781   module2.exports.forEachHeading = function forEachHeading(params, handler) {
10782     let heading = null;
10783     params.tokens.forEach(function forToken(token) {
10784       if (token.type === "heading_open") {
10785         heading = token;
10786       } else if (token.type === "heading_close") {
10787         heading = null;
10788       } else if (token.type === "inline" && heading) {
10789         handler(heading, token.content);
10790       }
10791     });
10792   };
10793   function forEachInlineCodeSpan(input, handler) {
10794     let currentLine = 0;
10795     let currentColumn = 0;
10796     let index = 0;
10797     while (index < input.length) {
10798       let startIndex = -1;
10799       let startLine = -1;
10800       let startColumn = -1;
10801       let tickCount = 0;
10802       let currentTicks = 0;
10803       let state = "normal";
10804       for (; index <= input.length; index++) {
10805         const char = input[index];
10806         if (char === "[" && state === "normal") {
10807           state = "linkTextOpen";
10808         } else if (char === "]" && state === "linkTextOpen") {
10809           state = "linkTextClosed";
10810         } else if (char === "(" && state === "linkTextClosed") {
10811           state = "linkDestinationOpen";
10812         } else if (char === "(" && state === "linkDestinationOpen" || char === ")" && state === "linkDestinationOpen" || state === "linkTextClosed") {
10813           state = "normal";
10814         }
10815         if (char === "`" && state !== "linkDestinationOpen") {
10816           currentTicks++;
10817           if (startIndex === -1 || startColumn === -1) {
10818             startIndex = index + 1;
10819           }
10820         } else {
10821           if (startIndex >= 0 && startColumn >= 0 && tickCount === currentTicks) {
10822             handler(input.substring(startIndex, index - currentTicks), startLine, startColumn, tickCount);
10823             startIndex = -1;
10824             startColumn = -1;
10825           } else if (startIndex >= 0 && startColumn === -1) {
10826             tickCount = currentTicks;
10827             startLine = currentLine;
10828             startColumn = currentColumn;
10829           }
10830           currentTicks = 0;
10831         }
10832         if (char === "\n") {
10833           currentLine++;
10834           currentColumn = 0;
10835         } else if (char === "\\" && (startIndex === -1 || startColumn === -1) && input[index + 1] !== "\n") {
10836           index++;
10837           currentColumn += 2;
10838         } else {
10839           currentColumn++;
10840         }
10841       }
10842       if (startIndex >= 0) {
10843         index = startIndex;
10844         currentLine = startLine;
10845         currentColumn = startColumn;
10846       }
10847     }
10848   }
10849   module2.exports.forEachInlineCodeSpan = forEachInlineCodeSpan;
10850   function addError(onError, lineNumber, detail, context, range, fixInfo) {
10851     onError({
10852       lineNumber,
10853       detail,
10854       context,
10855       range,
10856       fixInfo
10857     });
10858   }
10859   module2.exports.addError = addError;
10860   module2.exports.addErrorDetailIf = function addErrorDetailIf(onError, lineNumber, expected, actual, detail, context, range, fixInfo) {
10861     if (expected !== actual) {
10862       addError(onError, lineNumber, "Expected: " + expected + "; Actual: " + actual + (detail ? "; " + detail : ""), context, range, fixInfo);
10863     }
10864   };
10865   module2.exports.addErrorContext = function addErrorContext(onError, lineNumber, context, left, right, range, fixInfo) {
10866     if (context.length <= 30) {
10867     } else if (left && right) {
10868       context = context.substr(0, 15) + "..." + context.substr(-15);
10869     } else if (right) {
10870       context = "..." + context.substr(-30);
10871     } else {
10872       context = context.substr(0, 30) + "...";
10873     }
10874     addError(onError, lineNumber, null, context, range, fixInfo);
10875   };
10876   module2.exports.rangeFromRegExp = function rangeFromRegExp(line, regexp) {
10877     let range = null;
10878     const match = line.match(regexp);
10879     if (match) {
10880       const column = match.index + 1;
10881       const length = match[0].length;
10882       range = [column, length];
10883     }
10884     return range;
10885   };
10886   module2.exports.frontMatterHasTitle = function frontMatterHasTitle(frontMatterLines, frontMatterTitlePattern) {
10887     const ignoreFrontMatter = frontMatterTitlePattern !== void 0 && !frontMatterTitlePattern;
10888     const frontMatterTitleRe = new RegExp(String(frontMatterTitlePattern || '^\\s*"?title"?\\s*[:=]'), "i");
10889     return !ignoreFrontMatter && frontMatterLines.some((line) => frontMatterTitleRe.test(line));
10890   };
10891   function emphasisMarkersInContent(params) {
10892     const {lines} = params;
10893     const byLine = new Array(lines.length);
10894     filterTokens(params, "inline", (token) => {
10895       const {children, lineNumber, map} = token;
10896       if (children.some((child) => child.type === "code_inline")) {
10897         const tokenLines = lines.slice(map[0], map[1]);
10898         forEachInlineCodeSpan(tokenLines.join("\n"), (code, lineIndex, column, tickCount) => {
10899           const codeLines = code.split(newLineRe);
10900           codeLines.forEach((codeLine, codeLineIndex) => {
10901             let match = null;
10902             while (match = emphasisMarkersRe.exec(codeLine)) {
10903               const byLineIndex = lineNumber - 1 + lineIndex + codeLineIndex;
10904               const inLine = byLine[byLineIndex] || [];
10905               const codeLineOffset = codeLineIndex ? 0 : column - 1 + tickCount;
10906               inLine.push(codeLineOffset + match.index);
10907               byLine[byLineIndex] = inLine;
10908             }
10909           });
10910         });
10911       }
10912     });
10913     lines.forEach((tokenLine, tokenLineIndex) => {
10914       let linkMatch = null;
10915       while (linkMatch = linkRe.exec(tokenLine)) {
10916         let markerMatch = null;
10917         while (markerMatch = emphasisMarkersRe.exec(linkMatch[0])) {
10918           const inLine = byLine[tokenLineIndex] || [];
10919           inLine.push(linkMatch.index + markerMatch.index);
10920           byLine[tokenLineIndex] = inLine;
10921         }
10922       }
10923     });
10924     return byLine;
10925   }
10926   module2.exports.emphasisMarkersInContent = emphasisMarkersInContent;
10927   function getPreferredLineEnding(input) {
10928     let cr = 0;
10929     let lf = 0;
10930     let crlf = 0;
10931     const endings = input.match(newLineRe) || [];
10932     endings.forEach((ending) => {
10933       switch (ending) {
10934         case "\r":
10935           cr++;
10936           break;
10937         case "\n":
10938           lf++;
10939           break;
10940         case "\r\n":
10941           crlf++;
10942           break;
10943       }
10944     });
10945     let preferredLineEnding = null;
10946     if (!cr && !lf && !crlf) {
10947       preferredLineEnding = os.EOL;
10948     } else if (lf >= crlf && lf >= cr) {
10949       preferredLineEnding = "\n";
10950     } else if (crlf >= cr) {
10951       preferredLineEnding = "\r\n";
10952     } else {
10953       preferredLineEnding = "\r";
10954     }
10955     return preferredLineEnding;
10956   }
10957   module2.exports.getPreferredLineEnding = getPreferredLineEnding;
10958   function normalizeFixInfo(fixInfo, lineNumber) {
10959     return {
10960       lineNumber: fixInfo.lineNumber || lineNumber,
10961       editColumn: fixInfo.editColumn || 1,
10962       deleteCount: fixInfo.deleteCount || 0,
10963       insertText: fixInfo.insertText || ""
10964     };
10965   }
10966   function applyFix2(line, fixInfo, lineEnding) {
10967     const {editColumn, deleteCount, insertText} = normalizeFixInfo(fixInfo);
10968     const editIndex = editColumn - 1;
10969     return deleteCount === -1 ? null : line.slice(0, editIndex) + insertText.replace(/\n/g, lineEnding || "\n") + line.slice(editIndex + deleteCount);
10970   }
10971   module2.exports.applyFix = applyFix2;
10972   module2.exports.applyFixes = function applyFixes2(input, errors) {
10973     const lineEnding = getPreferredLineEnding(input);
10974     const lines = input.split(newLineRe);
10975     let fixInfos = errors.filter((error) => error.fixInfo).map((error) => normalizeFixInfo(error.fixInfo, error.lineNumber));
10976     fixInfos.sort((a, b) => {
10977       const aDeletingLine = a.deleteCount === -1;
10978       const bDeletingLine = b.deleteCount === -1;
10979       return b.lineNumber - a.lineNumber || (aDeletingLine ? 1 : bDeletingLine ? -1 : 0) || b.editColumn - a.editColumn || b.insertText.length - a.insertText.length;
10980     });
10981     let lastFixInfo = {};
10982     fixInfos = fixInfos.filter((fixInfo) => {
10983       const unique = fixInfo.lineNumber !== lastFixInfo.lineNumber || fixInfo.editColumn !== lastFixInfo.editColumn || fixInfo.deleteCount !== lastFixInfo.deleteCount || fixInfo.insertText !== lastFixInfo.insertText;
10984       lastFixInfo = fixInfo;
10985       return unique;
10986     });
10987     lastFixInfo = {};
10988     fixInfos.forEach((fixInfo) => {
10989       if (fixInfo.lineNumber === lastFixInfo.lineNumber && fixInfo.editColumn === lastFixInfo.editColumn && !fixInfo.insertText && fixInfo.deleteCount > 0 && lastFixInfo.insertText && !lastFixInfo.deleteCount) {
10990         fixInfo.insertText = lastFixInfo.insertText;
10991         lastFixInfo.lineNumber = 0;
10992       }
10993       lastFixInfo = fixInfo;
10994     });
10995     fixInfos = fixInfos.filter((fixInfo) => fixInfo.lineNumber);
10996     let lastLineIndex = -1;
10997     let lastEditIndex = -1;
10998     fixInfos.forEach((fixInfo) => {
10999       const {lineNumber, editColumn, deleteCount} = fixInfo;
11000       const lineIndex = lineNumber - 1;
11001       const editIndex = editColumn - 1;
11002       if (lineIndex !== lastLineIndex || deleteCount === -1 || editIndex + deleteCount <= lastEditIndex - (deleteCount > 0 ? 0 : 1)) {
11003         lines[lineIndex] = applyFix2(lines[lineIndex], fixInfo, lineEnding);
11004       }
11005       lastLineIndex = lineIndex;
11006       lastEditIndex = editIndex;
11007     });
11008     return lines.filter((line) => line !== null).join(lineEnding);
11009   };
11010 });
11011
11012 // node_modules/ini/ini.js
11013 var require_ini = __commonJS((exports2) => {
11014   exports2.parse = exports2.decode = decode;
11015   exports2.stringify = exports2.encode = encode;
11016   exports2.safe = safe;
11017   exports2.unsafe = unsafe;
11018   var eol = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
11019   function encode(obj, opt) {
11020     var children = [];
11021     var out = "";
11022     if (typeof opt === "string") {
11023       opt = {
11024         section: opt,
11025         whitespace: false
11026       };
11027     } else {
11028       opt = opt || Object.create(null);
11029       opt.whitespace = opt.whitespace === true;
11030     }
11031     var separator = opt.whitespace ? " = " : "=";
11032     Object.keys(obj).forEach(function(k, _, __) {
11033       var val = obj[k];
11034       if (val && Array.isArray(val)) {
11035         val.forEach(function(item) {
11036           out += safe(k + "[]") + separator + safe(item) + "\n";
11037         });
11038       } else if (val && typeof val === "object")
11039         children.push(k);
11040       else
11041         out += safe(k) + separator + safe(val) + eol;
11042     });
11043     if (opt.section && out.length)
11044       out = "[" + safe(opt.section) + "]" + eol + out;
11045     children.forEach(function(k, _, __) {
11046       var nk = dotSplit(k).join("\\.");
11047       var section = (opt.section ? opt.section + "." : "") + nk;
11048       var child = encode(obj[k], {
11049         section,
11050         whitespace: opt.whitespace
11051       });
11052       if (out.length && child.length)
11053         out += eol;
11054       out += child;
11055     });
11056     return out;
11057   }
11058   function dotSplit(str) {
11059     return str.replace(/\1/g, "\ 2LITERAL\\1LITERAL\ 2").replace(/\\\./g, "\ 1").split(/\./).map(function(part) {
11060       return part.replace(/\1/g, "\\.").replace(/\2LITERAL\\1LITERAL\2/g, "\ 1");
11061     });
11062   }
11063   function decode(str) {
11064     var out = Object.create(null);
11065     var p = out;
11066     var section = null;
11067     var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
11068     var lines = str.split(/[\r\n]+/g);
11069     lines.forEach(function(line, _, __) {
11070       if (!line || line.match(/^\s*[;#]/))
11071         return;
11072       var match = line.match(re);
11073       if (!match)
11074         return;
11075       if (match[1] !== void 0) {
11076         section = unsafe(match[1]);
11077         if (section === "__proto__") {
11078           p = Object.create(null);
11079           return;
11080         }
11081         p = out[section] = out[section] || Object.create(null);
11082         return;
11083       }
11084       var key = unsafe(match[2]);
11085       if (key === "__proto__")
11086         return;
11087       var value = match[3] ? unsafe(match[4]) : true;
11088       switch (value) {
11089         case "true":
11090         case "false":
11091         case "null":
11092           value = JSON.parse(value);
11093       }
11094       if (key.length > 2 && key.slice(-2) === "[]") {
11095         key = key.substring(0, key.length - 2);
11096         if (key === "__proto__")
11097           return;
11098         if (!p[key])
11099           p[key] = [];
11100         else if (!Array.isArray(p[key]))
11101           p[key] = [p[key]];
11102       }
11103       if (Array.isArray(p[key]))
11104         p[key].push(value);
11105       else
11106         p[key] = value;
11107     });
11108     Object.keys(out).filter(function(k, _, __) {
11109       if (!out[k] || typeof out[k] !== "object" || Array.isArray(out[k]))
11110         return false;
11111       var parts = dotSplit(k);
11112       var p2 = out;
11113       var l = parts.pop();
11114       var nl = l.replace(/\\\./g, ".");
11115       parts.forEach(function(part, _2, __2) {
11116         if (part === "__proto__")
11117           return;
11118         if (!p2[part] || typeof p2[part] !== "object")
11119           p2[part] = Object.create(null);
11120         p2 = p2[part];
11121       });
11122       if (p2 === out && nl === l)
11123         return false;
11124       p2[nl] = out[k];
11125       return true;
11126     }).forEach(function(del, _, __) {
11127       delete out[del];
11128     });
11129     return out;
11130   }
11131   function isQuoted(val) {
11132     return val.charAt(0) === '"' && val.slice(-1) === '"' || val.charAt(0) === "'" && val.slice(-1) === "'";
11133   }
11134   function safe(val) {
11135     return typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim() ? JSON.stringify(val) : val.replace(/;/g, "\\;").replace(/#/g, "\\#");
11136   }
11137   function unsafe(val, doUnesc) {
11138     val = (val || "").trim();
11139     if (isQuoted(val)) {
11140       if (val.charAt(0) === "'")
11141         val = val.substr(1, val.length - 2);
11142       try {
11143         val = JSON.parse(val);
11144       } catch (_) {
11145       }
11146     } else {
11147       var esc = false;
11148       var unesc = "";
11149       for (var i = 0, l = val.length; i < l; i++) {
11150         var c = val.charAt(i);
11151         if (esc) {
11152           if ("\\;#".indexOf(c) !== -1)
11153             unesc += c;
11154           else
11155             unesc += "\\" + c;
11156           esc = false;
11157         } else if (";#".indexOf(c) !== -1)
11158           break;
11159         else if (c === "\\")
11160           esc = true;
11161         else
11162           unesc += c;
11163       }
11164       if (esc)
11165         unesc += "\\";
11166       return unesc.trim();
11167     }
11168     return val;
11169   }
11170 });
11171
11172 // node_modules/rc/node_modules/strip-json-comments/index.js
11173 var require_strip_json_comments = __commonJS((exports2, module2) => {
11174   "use strict";
11175   var singleComment = 1;
11176   var multiComment = 2;
11177   function stripWithoutWhitespace() {
11178     return "";
11179   }
11180   function stripWithWhitespace(str, start, end) {
11181     return str.slice(start, end).replace(/\S/g, " ");
11182   }
11183   module2.exports = function(str, opts) {
11184     opts = opts || {};
11185     var currentChar;
11186     var nextChar;
11187     var insideString = false;
11188     var insideComment = false;
11189     var offset = 0;
11190     var ret = "";
11191     var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
11192     for (var i = 0; i < str.length; i++) {
11193       currentChar = str[i];
11194       nextChar = str[i + 1];
11195       if (!insideComment && currentChar === '"') {
11196         var escaped = str[i - 1] === "\\" && str[i - 2] !== "\\";
11197         if (!escaped) {
11198           insideString = !insideString;
11199         }
11200       }
11201       if (insideString) {
11202         continue;
11203       }
11204       if (!insideComment && currentChar + nextChar === "//") {
11205         ret += str.slice(offset, i);
11206         offset = i;
11207         insideComment = singleComment;
11208         i++;
11209       } else if (insideComment === singleComment && currentChar + nextChar === "\r\n") {
11210         i++;
11211         insideComment = false;
11212         ret += strip(str, offset, i);
11213         offset = i;
11214         continue;
11215       } else if (insideComment === singleComment && currentChar === "\n") {
11216         insideComment = false;
11217         ret += strip(str, offset, i);
11218         offset = i;
11219       } else if (!insideComment && currentChar + nextChar === "/*") {
11220         ret += str.slice(offset, i);
11221         offset = i;
11222         insideComment = multiComment;
11223         i++;
11224         continue;
11225       } else if (insideComment === multiComment && currentChar + nextChar === "*/") {
11226         i++;
11227         insideComment = false;
11228         ret += strip(str, offset, i + 1);
11229         offset = i + 1;
11230         continue;
11231       }
11232     }
11233     return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
11234   };
11235 });
11236
11237 // node_modules/rc/lib/utils.js
11238 var require_utils2 = __commonJS((exports2) => {
11239   "use strict";
11240   var fs2 = require("fs");
11241   var ini = require_ini();
11242   var path2 = require("path");
11243   var stripJsonComments = require_strip_json_comments();
11244   var parse = exports2.parse = function(content) {
11245     if (/^\s*{/.test(content))
11246       return JSON.parse(stripJsonComments(content));
11247     return ini.parse(content);
11248   };
11249   var file = exports2.file = function() {
11250     var args = [].slice.call(arguments).filter(function(arg) {
11251       return arg != null;
11252     });
11253     for (var i in args)
11254       if (typeof args[i] !== "string")
11255         return;
11256     var file2 = path2.join.apply(null, args);
11257     var content;
11258     try {
11259       return fs2.readFileSync(file2, "utf-8");
11260     } catch (err) {
11261       return;
11262     }
11263   };
11264   var json = exports2.json = function() {
11265     var content = file.apply(null, arguments);
11266     return content ? parse(content) : null;
11267   };
11268   var env = exports2.env = function(prefix, env2) {
11269     env2 = env2 || process.env;
11270     var obj = {};
11271     var l = prefix.length;
11272     for (var k in env2) {
11273       if (k.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
11274         var keypath = k.substring(l).split("__");
11275         var _emptyStringIndex;
11276         while ((_emptyStringIndex = keypath.indexOf("")) > -1) {
11277           keypath.splice(_emptyStringIndex, 1);
11278         }
11279         var cursor = obj;
11280         keypath.forEach(function _buildSubObj(_subkey, i) {
11281           if (!_subkey || typeof cursor !== "object")
11282             return;
11283           if (i === keypath.length - 1)
11284             cursor[_subkey] = env2[k];
11285           if (cursor[_subkey] === void 0)
11286             cursor[_subkey] = {};
11287           cursor = cursor[_subkey];
11288         });
11289       }
11290     }
11291     return obj;
11292   };
11293   var find = exports2.find = function() {
11294     var rel = path2.join.apply(null, [].slice.call(arguments));
11295     function find2(start, rel2) {
11296       var file2 = path2.join(start, rel2);
11297       try {
11298         fs2.statSync(file2);
11299         return file2;
11300       } catch (err) {
11301         if (path2.dirname(start) !== start)
11302           return find2(path2.dirname(start), rel2);
11303       }
11304     }
11305     return find2(process.cwd(), rel);
11306   };
11307 });
11308
11309 // node_modules/minimist/index.js
11310 var require_minimist = __commonJS((exports2, module2) => {
11311   module2.exports = function(args, opts) {
11312     if (!opts)
11313       opts = {};
11314     var flags = {bools: {}, strings: {}, unknownFn: null};
11315     if (typeof opts["unknown"] === "function") {
11316       flags.unknownFn = opts["unknown"];
11317     }
11318     if (typeof opts["boolean"] === "boolean" && opts["boolean"]) {
11319       flags.allBools = true;
11320     } else {
11321       [].concat(opts["boolean"]).filter(Boolean).forEach(function(key2) {
11322         flags.bools[key2] = true;
11323       });
11324     }
11325     var aliases = {};
11326     Object.keys(opts.alias || {}).forEach(function(key2) {
11327       aliases[key2] = [].concat(opts.alias[key2]);
11328       aliases[key2].forEach(function(x) {
11329         aliases[x] = [key2].concat(aliases[key2].filter(function(y) {
11330           return x !== y;
11331         }));
11332       });
11333     });
11334     [].concat(opts.string).filter(Boolean).forEach(function(key2) {
11335       flags.strings[key2] = true;
11336       if (aliases[key2]) {
11337         flags.strings[aliases[key2]] = true;
11338       }
11339     });
11340     var defaults = opts["default"] || {};
11341     var argv = {_: []};
11342     Object.keys(flags.bools).forEach(function(key2) {
11343       setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
11344     });
11345     var notFlags = [];
11346     if (args.indexOf("--") !== -1) {
11347       notFlags = args.slice(args.indexOf("--") + 1);
11348       args = args.slice(0, args.indexOf("--"));
11349     }
11350     function argDefined(key2, arg2) {
11351       return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
11352     }
11353     function setArg(key2, val, arg2) {
11354       if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
11355         if (flags.unknownFn(arg2) === false)
11356           return;
11357       }
11358       var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
11359       setKey(argv, key2.split("."), value2);
11360       (aliases[key2] || []).forEach(function(x) {
11361         setKey(argv, x.split("."), value2);
11362       });
11363     }
11364     function setKey(obj, keys, value2) {
11365       var o = obj;
11366       for (var i2 = 0; i2 < keys.length - 1; i2++) {
11367         var key2 = keys[i2];
11368         if (key2 === "__proto__")
11369           return;
11370         if (o[key2] === void 0)
11371           o[key2] = {};
11372         if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype)
11373           o[key2] = {};
11374         if (o[key2] === Array.prototype)
11375           o[key2] = [];
11376         o = o[key2];
11377       }
11378       var key2 = keys[keys.length - 1];
11379       if (key2 === "__proto__")
11380         return;
11381       if (o === Object.prototype || o === Number.prototype || o === String.prototype)
11382         o = {};
11383       if (o === Array.prototype)
11384         o = [];
11385       if (o[key2] === void 0 || flags.bools[key2] || typeof o[key2] === "boolean") {
11386         o[key2] = value2;
11387       } else if (Array.isArray(o[key2])) {
11388         o[key2].push(value2);
11389       } else {
11390         o[key2] = [o[key2], value2];
11391       }
11392     }
11393     function aliasIsBoolean(key2) {
11394       return aliases[key2].some(function(x) {
11395         return flags.bools[x];
11396       });
11397     }
11398     for (var i = 0; i < args.length; i++) {
11399       var arg = args[i];
11400       if (/^--.+=/.test(arg)) {
11401         var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
11402         var key = m[1];
11403         var value = m[2];
11404         if (flags.bools[key]) {
11405           value = value !== "false";
11406         }
11407         setArg(key, value, arg);
11408       } else if (/^--no-.+/.test(arg)) {
11409         var key = arg.match(/^--no-(.+)/)[1];
11410         setArg(key, false, arg);
11411       } else if (/^--.+/.test(arg)) {
11412         var key = arg.match(/^--(.+)/)[1];
11413         var next = args[i + 1];
11414         if (next !== void 0 && !/^-/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
11415           setArg(key, next, arg);
11416           i++;
11417         } else if (/^(true|false)$/.test(next)) {
11418           setArg(key, next === "true", arg);
11419           i++;
11420         } else {
11421           setArg(key, flags.strings[key] ? "" : true, arg);
11422         }
11423       } else if (/^-[^-]+/.test(arg)) {
11424         var letters = arg.slice(1, -1).split("");
11425         var broken = false;
11426         for (var j = 0; j < letters.length; j++) {
11427           var next = arg.slice(j + 2);
11428           if (next === "-") {
11429             setArg(letters[j], next, arg);
11430             continue;
11431           }
11432           if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
11433             setArg(letters[j], next.split("=")[1], arg);
11434             broken = true;
11435             break;
11436           }
11437           if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
11438             setArg(letters[j], next, arg);
11439             broken = true;
11440             break;
11441           }
11442           if (letters[j + 1] && letters[j + 1].match(/\W/)) {
11443             setArg(letters[j], arg.slice(j + 2), arg);
11444             broken = true;
11445             break;
11446           } else {
11447             setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
11448           }
11449         }
11450         var key = arg.slice(-1)[0];
11451         if (!broken && key !== "-") {
11452           if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
11453             setArg(key, args[i + 1], arg);
11454             i++;
11455           } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
11456             setArg(key, args[i + 1] === "true", arg);
11457             i++;
11458           } else {
11459             setArg(key, flags.strings[key] ? "" : true, arg);
11460           }
11461         }
11462       } else {
11463         if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
11464           argv._.push(flags.strings["_"] || !isNumber(arg) ? arg : Number(arg));
11465         }
11466         if (opts.stopEarly) {
11467           argv._.push.apply(argv._, args.slice(i + 1));
11468           break;
11469         }
11470       }
11471     }
11472     Object.keys(defaults).forEach(function(key2) {
11473       if (!hasKey(argv, key2.split("."))) {
11474         setKey(argv, key2.split("."), defaults[key2]);
11475         (aliases[key2] || []).forEach(function(x) {
11476           setKey(argv, x.split("."), defaults[key2]);
11477         });
11478       }
11479     });
11480     if (opts["--"]) {
11481       argv["--"] = new Array();
11482       notFlags.forEach(function(key2) {
11483         argv["--"].push(key2);
11484       });
11485     } else {
11486       notFlags.forEach(function(key2) {
11487         argv._.push(key2);
11488       });
11489     }
11490     return argv;
11491   };
11492   function hasKey(obj, keys) {
11493     var o = obj;
11494     keys.slice(0, -1).forEach(function(key2) {
11495       o = o[key2] || {};
11496     });
11497     var key = keys[keys.length - 1];
11498     return key in o;
11499   }
11500   function isNumber(x) {
11501     if (typeof x === "number")
11502       return true;
11503     if (/^0x[0-9a-f]+$/i.test(x))
11504       return true;
11505     return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
11506   }
11507 });
11508
11509 // node_modules/rc/index.js
11510 var require_rc = __commonJS((exports2, module2) => {
11511   var cc = require_utils2();
11512   var join = require("path").join;
11513   var deepExtend = require_deep_extend();
11514   var etc = "/etc";
11515   var win = process.platform === "win32";
11516   var home = win ? process.env.USERPROFILE : process.env.HOME;
11517   module2.exports = function(name, defaults, argv, parse) {
11518     if (typeof name !== "string")
11519       throw new Error("rc(name): name *must* be string");
11520     if (!argv)
11521       argv = require_minimist()(process.argv.slice(2));
11522     defaults = (typeof defaults === "string" ? cc.json(defaults) : defaults) || {};
11523     parse = parse || cc.parse;
11524     var env = cc.env(name + "_");
11525     var configs = [defaults];
11526     var configFiles = [];
11527     function addConfigFile(file) {
11528       if (configFiles.indexOf(file) >= 0)
11529         return;
11530       var fileConfig = cc.file(file);
11531       if (fileConfig) {
11532         configs.push(parse(fileConfig));
11533         configFiles.push(file);
11534       }
11535     }
11536     if (!win)
11537       [
11538         join(etc, name, "config"),
11539         join(etc, name + "rc")
11540       ].forEach(addConfigFile);
11541     if (home)
11542       [
11543         join(home, ".config", name, "config"),
11544         join(home, ".config", name),
11545         join(home, "." + name, "config"),
11546         join(home, "." + name + "rc")
11547       ].forEach(addConfigFile);
11548     addConfigFile(cc.find("." + name + "rc"));
11549     if (env.config)
11550       addConfigFile(env.config);
11551     if (argv.config)
11552       addConfigFile(argv.config);
11553     return deepExtend.apply(null, configs.concat([
11554       env,
11555       argv,
11556       configFiles.length ? {configs: configFiles, config: configFiles[configFiles.length - 1]} : void 0
11557     ]));
11558   };
11559 });
11560
11561 // src/index.ts
11562 __markAsModule(exports);
11563 __export(exports, {
11564   activate: () => activate
11565 });
11566 var import_coc2 = __toModule(require("coc.nvim"));
11567
11568 // src/engine.ts
11569 var import_coc = __toModule(require("coc.nvim"));
11570 var import_deep_extend = __toModule(require_deep_extend());
11571 var import_fs = __toModule(require("fs"));
11572 var import_js_yaml = __toModule(require_js_yaml2());
11573 var import_markdownlint = __toModule(require_markdownlint());
11574 var import_markdownlint_rule_helpers = __toModule(require_helpers3());
11575 var import_path = __toModule(require("path"));
11576 var import_rc = __toModule(require_rc());
11577 var projectConfigFiles = [".markdownlint.json", ".markdownlint.yaml", ".markdownlint.yml"];
11578 var configFileParsers = [JSON.parse, import_js_yaml.default.safeLoad];
11579 var MarkdownlintEngine = class {
11580   constructor() {
11581     this.fixAllCommandName = "markdownlint.fixAll";
11582     this.source = "markdownlint";
11583     this.outputChannel = import_coc.window.createOutputChannel(this.source);
11584     this.diagnosticCollection = import_coc.languages.createDiagnosticCollection(this.source);
11585     this.config = {};
11586   }
11587   outputLine(message) {
11588     if (this.outputChannel) {
11589       this.outputChannel.appendLine(`[${new Date().toLocaleTimeString()}] ${message}`);
11590     }
11591   }
11592   async parseConfig() {
11593     try {
11594       this.config = import_rc.default(this.source, {});
11595       this.outputLine(`Info: global config: ${JSON.stringify(import_rc.default(this.source, {}))}`);
11596     } catch (e) {
11597       this.outputLine(`Error: global config parse failed: ${e}`);
11598     }
11599     try {
11600       for (const projectConfigFile of projectConfigFiles) {
11601         const fullPath = import_path.default.join(import_coc.workspace.root, projectConfigFile);
11602         if (import_fs.default.existsSync(fullPath)) {
11603           const projectConfig = import_markdownlint.default.readConfigSync(fullPath, configFileParsers);
11604           this.config = import_deep_extend.default(this.config, projectConfig);
11605           this.outputLine(`Info: local config: ${fullPath}, ${JSON.stringify(projectConfig)}`);
11606           break;
11607         }
11608       }
11609     } catch (e) {
11610       this.outputLine(`Error: local config parse failed: ${e}`);
11611     }
11612     const cocConfig = import_coc.workspace.getConfiguration("markdownlint").get("config");
11613     if (cocConfig) {
11614       this.config = import_deep_extend.default(this.config, cocConfig);
11615       this.outputLine(`Info: config from coc-settings.json: ${JSON.stringify(cocConfig)}`);
11616     }
11617     this.outputLine(`Info: full config: ${JSON.stringify(this.config)}`);
11618   }
11619   markdownlintWrapper(document) {
11620     const options = {
11621       resultVersion: 3,
11622       config: this.config,
11623       strings: {
11624         [document.uri]: document.getText()
11625       }
11626     };
11627     let results = [];
11628     try {
11629       results = import_markdownlint.default.sync(options)[document.uri];
11630     } catch (e) {
11631       this.outputLine(`Error: lint exception: ${e.stack}`);
11632     }
11633     return results;
11634   }
11635   async provideCodeActions(document, range, context) {
11636     const doc = import_coc.workspace.getDocument(document.uri);
11637     const wholeRange = import_coc.Range.create(0, 0, doc.lineCount, 0);
11638     let whole = false;
11639     if (range.start.line === wholeRange.start.line && range.start.character === wholeRange.start.character && range.end.line === wholeRange.end.line && range.end.character === wholeRange.end.character) {
11640       whole = true;
11641     }
11642     const codeActions = [];
11643     const fixInfoDiagnostics = [];
11644     for (const diagnostic of context.diagnostics) {
11645       if (diagnostic.fixInfo) {
11646         const lineNumber = diagnostic.fixInfo.lineNumber - 1 || diagnostic.range.start.line;
11647         const line = await import_coc.workspace.getLine(document.uri, lineNumber);
11648         const newText = import_markdownlint_rule_helpers.applyFix(line, diagnostic.fixInfo, "\n");
11649         const edit = {changes: {}};
11650         if (typeof newText === "string") {
11651           const range2 = import_coc.Range.create(lineNumber, 0, lineNumber, line.length);
11652           edit.changes[document.uri] = [import_coc.TextEdit.replace(range2, newText)];
11653         } else {
11654           edit.changes[document.uri] = [import_coc.TextEdit.del(diagnostic.range)];
11655         }
11656         const title = `Fix: ${diagnostic.message.split(":")[0]}`;
11657         const action = {
11658           title,
11659           edit,
11660           diagnostics: [...context.diagnostics]
11661         };
11662         fixInfoDiagnostics.push(diagnostic);
11663         if (!whole) {
11664           codeActions.push(action);
11665         }
11666       }
11667     }
11668     if (range.start.line === range.end.line && range.start.character === 0) {
11669       const edit = import_coc.TextEdit.insert(import_coc.Position.create(range.start.line, 0), "<!-- markdownlint-disable-next-line -->\n");
11670       codeActions.push({
11671         title: "Disable markdownlint for current line",
11672         edit: {
11673           changes: {
11674             [doc.uri]: [edit]
11675           }
11676         }
11677       });
11678     }
11679     if (whole) {
11680       const edit = import_coc.TextEdit.insert(import_coc.Position.create(0, 0), "<!-- markdownlint-disable-file -->\n");
11681       codeActions.push({
11682         title: "Disable markdownlint for current file",
11683         edit: {
11684           changes: {
11685             [doc.uri]: [edit]
11686           }
11687         }
11688       });
11689     }
11690     if (fixInfoDiagnostics.length) {
11691       const title = "Fix All error found by markdownlint";
11692       const sourceFixAllAction = {
11693         title,
11694         kind: import_coc.CodeActionKind.SourceFixAll,
11695         diagnostics: fixInfoDiagnostics,
11696         command: {
11697           title,
11698           command: this.fixAllCommandName
11699         }
11700       };
11701       codeActions.push(sourceFixAllAction);
11702     }
11703     return codeActions;
11704   }
11705   lint(document) {
11706     if (document.languageId !== "markdown") {
11707       return;
11708     }
11709     this.diagnosticCollection.clear();
11710     const results = this.markdownlintWrapper(document);
11711     if (!results.length) {
11712       return;
11713     }
11714     const diagnostics = [];
11715     results.forEach((result) => {
11716       const ruleDescription = result.ruleDescription;
11717       let message = result.ruleNames.join("/") + ": " + ruleDescription;
11718       if (result.errorDetail) {
11719         message += " [" + result.errorDetail + "]";
11720       }
11721       const start = import_coc.Position.create(result.lineNumber - 1, 0);
11722       const end = import_coc.Position.create(result.lineNumber - 1, 0);
11723       if (result.errorRange) {
11724         start.character = result.errorRange[0] - 1;
11725         end.character = start.character + result.errorRange[1];
11726       }
11727       const range = import_coc.Range.create(start, end);
11728       const diagnostic = import_coc.Diagnostic.create(range, message);
11729       diagnostic.severity = import_coc.DiagnosticSeverity.Warning;
11730       diagnostic.source = this.source;
11731       diagnostic.fixInfo = result.fixInfo;
11732       diagnostics.push(diagnostic);
11733     });
11734     this.diagnosticCollection.set(document.uri, diagnostics);
11735   }
11736   async fixAll(document) {
11737     const results = this.markdownlintWrapper(document);
11738     if (!results.length) {
11739       return;
11740     }
11741     const text = document.getText();
11742     const fixedText = import_markdownlint_rule_helpers.applyFixes(text, results);
11743     if (text != fixedText) {
11744       const doc = import_coc.workspace.getDocument(document.uri);
11745       const end = import_coc.Position.create(doc.lineCount - 1, doc.getline(doc.lineCount - 1).length);
11746       const edit = {
11747         changes: {
11748           [document.uri]: [import_coc.TextEdit.replace(import_coc.Range.create(import_coc.Position.create(0, 0), end), fixedText)]
11749         }
11750       };
11751       await import_coc.workspace.applyEdit(edit);
11752     }
11753   }
11754 };
11755
11756 // src/index.ts
11757 var documentSelector = [
11758   {
11759     language: "markdown",
11760     scheme: "file"
11761   },
11762   {
11763     language: "markdown",
11764     scheme: "untitled"
11765   }
11766 ];
11767 var documentVersion = 0;
11768 var engine = new MarkdownlintEngine();
11769 var config = import_coc2.workspace.getConfiguration("markdownlint");
11770 function didOpenTextDocument(document) {
11771   if (config.get("onOpen", true)) {
11772     engine.lint(document);
11773   }
11774 }
11775 async function didChangeTextDocument(params) {
11776   if (!config.get("onChange", true)) {
11777     return;
11778   }
11779   if (params.textDocument.version && documentVersion !== params.textDocument.version) {
11780     documentVersion = params.textDocument.version;
11781     const {document} = await import_coc2.workspace.getCurrentState();
11782     engine.lint(document);
11783   }
11784 }
11785 async function didSaveTextDocument(document) {
11786   if (config.get("onSave", true)) {
11787     engine.lint(document);
11788   }
11789 }
11790 async function activate(context) {
11791   await engine.parseConfig();
11792   context.subscriptions.push(import_coc2.languages.registerCodeActionProvider(documentSelector, engine, "markdownlint"), import_coc2.commands.registerCommand(engine.fixAllCommandName, async () => {
11793     const {document} = await import_coc2.workspace.getCurrentState();
11794     engine.fixAll(document);
11795   }), import_coc2.workspace.onDidOpenTextDocument(didOpenTextDocument), import_coc2.workspace.onDidChangeTextDocument(didChangeTextDocument), import_coc2.workspace.onDidSaveTextDocument(didSaveTextDocument));
11796   import_coc2.workspace.documents.map((doc) => {
11797     didOpenTextDocument(doc.textDocument);
11798   });
11799 }