Skip to content
Snippets Groups Projects
Select Git revision
  • 5e905a86242e43511be5f09db6e9fe352b6e179c
  • main default protected
  • renovate/esbuild-0.x-lockfile
  • renovate/vitest-3.x-lockfile
  • renovate/node-22.x-lockfile
  • renovate/node-24.x
  • renovate/pnpm-10.x
  • renovate/prettier-3.x-lockfile
  • renovate/bootstrap-5.x
  • feat/prettier-attendence-sum
  • local-test
  • show_missing
  • feat/show-which-resolutions-are-void
  • cedric-hates-this
14 results

out.js

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    out.js 814.19 KiB
    var __create = Object.create;
    var __defProp = Object.defineProperty;
    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames = Object.getOwnPropertyNames;
    var __getProtoOf = Object.getPrototypeOf;
    var __hasOwnProp = Object.prototype.hasOwnProperty;
    var __commonJS = (cb, mod) => function __require() {
      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
    };
    var __copyProps = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames(from))
          if (!__hasOwnProp.call(to, key) && key !== except)
            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
      // If the importer is in node compatibility mode or this is not an ESM
      // file that has been converted to a CommonJS file using a Babel-
      // compatible transform (i.e. "__esModule" has not been set), then set
      // "default" to the CommonJS "module.exports" for node compatibility.
      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
      mod
    ));
    
    // node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/error.js
    var require_error = __commonJS({
      "node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/error.js"(exports2) {
        var CommanderError2 = class extends Error {
          /**
           * Constructs the CommanderError class
           * @param {number} exitCode suggested exit code which could be used with process.exit
           * @param {string} code an id string representing the error
           * @param {string} message human-readable description of the error
           * @constructor
           */
          constructor(exitCode, code, message) {
            super(message);
            Error.captureStackTrace(this, this.constructor);
            this.name = this.constructor.name;
            this.code = code;
            this.exitCode = exitCode;
            this.nestedError = void 0;
          }
        };
        var InvalidArgumentError2 = class extends CommanderError2 {
          /**
           * Constructs the InvalidArgumentError class
           * @param {string} [message] explanation of why argument is invalid
           * @constructor
           */
          constructor(message) {
            super(1, "commander.invalidArgument", message);
            Error.captureStackTrace(this, this.constructor);
            this.name = this.constructor.name;
          }
        };
        exports2.CommanderError = CommanderError2;
        exports2.InvalidArgumentError = InvalidArgumentError2;
      }
    });
    
    // node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/argument.js
    var require_argument = __commonJS({
      "node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/argument.js"(exports2) {
        var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
        var Argument2 = class {
          /**
           * Initialize a new command argument with the given name and description.
           * The default is that the argument is required, and you can explicitly
           * indicate this with <> around the name. Put [] around the name for an optional argument.
           *
           * @param {string} name
           * @param {string} [description]
           */
          constructor(name, description) {
            this.description = description || "";
            this.variadic = false;
            this.parseArg = void 0;
            this.defaultValue = void 0;
            this.defaultValueDescription = void 0;
            this.argChoices = void 0;
            switch (name[0]) {
              case "<":
                this.required = true;
                this._name = name.slice(1, -1);
                break;
              case "[":
                this.required = false;
                this._name = name.slice(1, -1);
                break;
              default:
                this.required = true;
                this._name = name;
                break;
            }
            if (this._name.length > 3 && this._name.slice(-3) === "...") {
              this.variadic = true;
              this._name = this._name.slice(0, -3);
            }
          }
          /**
           * Return argument name.
           *
           * @return {string}
           */
          name() {
            return this._name;
          }
          /**
           * @api private
           */
          _concatValue(value, previous) {
            if (previous === this.defaultValue || !Array.isArray(previous)) {
              return [value];
            }
            return previous.concat(value);
          }
          /**
           * Set the default value, and optionally supply the description to be displayed in the help.
           *
           * @param {any} value
           * @param {string} [description]
           * @return {Argument}
           */
          default(value, description) {
            this.defaultValue = value;
            this.defaultValueDescription = description;
            return this;
          }
          /**
           * Set the custom handler for processing CLI command arguments into argument values.
           *
           * @param {Function} [fn]
           * @return {Argument}
           */
          argParser(fn) {
            this.parseArg = fn;
            return this;
          }
          /**
           * Only allow argument value to be one of choices.
           *
           * @param {string[]} values
           * @return {Argument}
           */
          choices(values) {
            this.argChoices = values.slice();
            this.parseArg = (arg, previous) => {
              if (!this.argChoices.includes(arg)) {
                throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
              }
              if (this.variadic) {
                return this._concatValue(arg, previous);
              }
              return arg;
            };
            return this;
          }
          /**
           * Make argument required.
           */
          argRequired() {
            this.required = true;
            return this;
          }
          /**
           * Make argument optional.
           */
          argOptional() {
            this.required = false;
            return this;
          }
        };
        function humanReadableArgName(arg) {
          const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
          return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
        }
        exports2.Argument = Argument2;
        exports2.humanReadableArgName = humanReadableArgName;
      }
    });
    
    // node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/help.js
    var require_help = __commonJS({
      "node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/help.js"(exports2) {
        var { humanReadableArgName } = require_argument();
        var Help2 = class {
          constructor() {
            this.helpWidth = void 0;
            this.sortSubcommands = false;
            this.sortOptions = false;
            this.showGlobalOptions = false;
          }
          /**
           * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
           *
           * @param {Command} cmd
           * @returns {Command[]}
           */
          visibleCommands(cmd) {
            const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
            if (cmd._hasImplicitHelpCommand()) {
              const [, helpName, helpArgs] = cmd._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
              const helpCommand = cmd.createCommand(helpName).helpOption(false);
              helpCommand.description(cmd._helpCommandDescription);
              if (helpArgs)
                helpCommand.arguments(helpArgs);
              visibleCommands.push(helpCommand);
            }
            if (this.sortSubcommands) {
              visibleCommands.sort((a, b) => {
                return a.name().localeCompare(b.name());
              });
            }
            return visibleCommands;
          }
          /**
           * Compare options for sort.
           *
           * @param {Option} a
           * @param {Option} b
           * @returns number
           */
          compareOptions(a, b) {
            const getSortKey = (option) => {
              return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
            };
            return getSortKey(a).localeCompare(getSortKey(b));
          }
          /**
           * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
           *
           * @param {Command} cmd
           * @returns {Option[]}
           */
          visibleOptions(cmd) {
            const visibleOptions = cmd.options.filter((option) => !option.hidden);
            const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
            const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
            if (showShortHelpFlag || showLongHelpFlag) {
              let helpOption;
              if (!showShortHelpFlag) {
                helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
              } else if (!showLongHelpFlag) {
                helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
              } else {
                helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
              }
              visibleOptions.push(helpOption);
            }
            if (this.sortOptions) {
              visibleOptions.sort(this.compareOptions);
            }
            return visibleOptions;
          }
          /**
           * Get an array of the visible global options. (Not including help.)
           *
           * @param {Command} cmd
           * @returns {Option[]}
           */
          visibleGlobalOptions(cmd) {
            if (!this.showGlobalOptions)
              return [];
            const globalOptions = [];
            for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
              const visibleOptions = parentCmd.options.filter((option) => !option.hidden);
              globalOptions.push(...visibleOptions);
            }
            if (this.sortOptions) {
              globalOptions.sort(this.compareOptions);
            }
            return globalOptions;
          }
          /**
           * Get an array of the arguments if any have a description.
           *
           * @param {Command} cmd
           * @returns {Argument[]}
           */
          visibleArguments(cmd) {
            if (cmd._argsDescription) {
              cmd._args.forEach((argument) => {
                argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
              });
            }
            if (cmd._args.find((argument) => argument.description)) {
              return cmd._args;
            }
            return [];
          }
          /**
           * Get the command term to show in the list of subcommands.
           *
           * @param {Command} cmd
           * @returns {string}
           */
          subcommandTerm(cmd) {
            const args = cmd._args.map((arg) => humanReadableArgName(arg)).join(" ");
            return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + // simplistic check for non-help option
            (args ? " " + args : "");
          }
          /**
           * Get the option term to show in the list of options.
           *
           * @param {Option} option
           * @returns {string}
           */
          optionTerm(option) {
            return option.flags;
          }
          /**
           * Get the argument term to show in the list of arguments.
           *
           * @param {Argument} argument
           * @returns {string}
           */
          argumentTerm(argument) {
            return argument.name();
          }
          /**
           * Get the longest command term length.
           *
           * @param {Command} cmd
           * @param {Help} helper
           * @returns {number}
           */
          longestSubcommandTermLength(cmd, helper) {
            return helper.visibleCommands(cmd).reduce((max, command) => {
              return Math.max(max, helper.subcommandTerm(command).length);
            }, 0);
          }
          /**
           * Get the longest option term length.
           *
           * @param {Command} cmd
           * @param {Help} helper
           * @returns {number}
           */
          longestOptionTermLength(cmd, helper) {
            return helper.visibleOptions(cmd).reduce((max, option) => {
              return Math.max(max, helper.optionTerm(option).length);
            }, 0);
          }
          /**
           * Get the longest global option term length.
           *
           * @param {Command} cmd
           * @param {Help} helper
           * @returns {number}
           */
          longestGlobalOptionTermLength(cmd, helper) {
            return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
              return Math.max(max, helper.optionTerm(option).length);
            }, 0);
          }
          /**
           * Get the longest argument term length.
           *
           * @param {Command} cmd
           * @param {Help} helper
           * @returns {number}
           */
          longestArgumentTermLength(cmd, helper) {
            return helper.visibleArguments(cmd).reduce((max, argument) => {
              return Math.max(max, helper.argumentTerm(argument).length);
            }, 0);
          }
          /**
           * Get the command usage to be displayed at the top of the built-in help.
           *
           * @param {Command} cmd
           * @returns {string}
           */
          commandUsage(cmd) {
            let cmdName = cmd._name;
            if (cmd._aliases[0]) {
              cmdName = cmdName + "|" + cmd._aliases[0];
            }
            let parentCmdNames = "";
            for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
              parentCmdNames = parentCmd.name() + " " + parentCmdNames;
            }
            return parentCmdNames + cmdName + " " + cmd.usage();
          }
          /**
           * Get the description for the command.
           *
           * @param {Command} cmd
           * @returns {string}
           */
          commandDescription(cmd) {
            return cmd.description();
          }
          /**
           * Get the subcommand summary to show in the list of subcommands.
           * (Fallback to description for backwards compatibility.)
           *
           * @param {Command} cmd
           * @returns {string}
           */
          subcommandDescription(cmd) {
            return cmd.summary() || cmd.description();
          }
          /**
           * Get the option description to show in the list of options.
           *
           * @param {Option} option
           * @return {string}
           */
          optionDescription(option) {
            const extraInfo = [];
            if (option.argChoices) {
              extraInfo.push(
                // use stringify to match the display of the default value
                `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`
              );
            }
            if (option.defaultValue !== void 0) {
              const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
              if (showDefault) {
                extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
              }
            }
            if (option.presetArg !== void 0 && option.optional) {
              extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
            }
            if (option.envVar !== void 0) {
              extraInfo.push(`env: ${option.envVar}`);
            }
            if (extraInfo.length > 0) {
              return `${option.description} (${extraInfo.join(", ")})`;
            }
            return option.description;
          }
          /**
           * Get the argument description to show in the list of arguments.
           *
           * @param {Argument} argument
           * @return {string}
           */
          argumentDescription(argument) {
            const extraInfo = [];
            if (argument.argChoices) {
              extraInfo.push(
                // use stringify to match the display of the default value
                `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`
              );
            }
            if (argument.defaultValue !== void 0) {
              extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
            }
            if (extraInfo.length > 0) {
              const extraDescripton = `(${extraInfo.join(", ")})`;
              if (argument.description) {
                return `${argument.description} ${extraDescripton}`;
              }
              return extraDescripton;
            }
            return argument.description;
          }
          /**
           * Generate the built-in help text.
           *
           * @param {Command} cmd
           * @param {Help} helper
           * @returns {string}
           */
          formatHelp(cmd, helper) {
            const termWidth = helper.padWidth(cmd, helper);
            const helpWidth = helper.helpWidth || 80;
            const itemIndentWidth = 2;
            const itemSeparatorWidth = 2;
            function formatItem(term, description) {
              if (description) {
                const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
                return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
              }
              return term;
            }
            function formatList(textArray) {
              return textArray.join("\n").replace(/^/gm, " ".repeat(itemIndentWidth));
            }
            let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
            const commandDescription = helper.commandDescription(cmd);
            if (commandDescription.length > 0) {
              output = output.concat([helper.wrap(commandDescription, helpWidth, 0), ""]);
            }
            const argumentList = helper.visibleArguments(cmd).map((argument) => {
              return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
            });
            if (argumentList.length > 0) {
              output = output.concat(["Arguments:", formatList(argumentList), ""]);
            }
            const optionList = helper.visibleOptions(cmd).map((option) => {
              return formatItem(helper.optionTerm(option), helper.optionDescription(option));
            });
            if (optionList.length > 0) {
              output = output.concat(["Options:", formatList(optionList), ""]);
            }
            if (this.showGlobalOptions) {
              const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
                return formatItem(helper.optionTerm(option), helper.optionDescription(option));
              });
              if (globalOptionList.length > 0) {
                output = output.concat(["Global Options:", formatList(globalOptionList), ""]);
              }
            }
            const commandList = helper.visibleCommands(cmd).map((cmd2) => {
              return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
            });
            if (commandList.length > 0) {
              output = output.concat(["Commands:", formatList(commandList), ""]);
            }
            return output.join("\n");
          }
          /**
           * Calculate the pad width from the maximum term length.
           *
           * @param {Command} cmd
           * @param {Help} helper
           * @returns {number}
           */
          padWidth(cmd, helper) {
            return Math.max(
              helper.longestOptionTermLength(cmd, helper),
              helper.longestGlobalOptionTermLength(cmd, helper),
              helper.longestSubcommandTermLength(cmd, helper),
              helper.longestArgumentTermLength(cmd, helper)
            );
          }
          /**
           * Wrap the given string to width characters per line, with lines after the first indented.
           * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
           *
           * @param {string} str
           * @param {number} width
           * @param {number} indent
           * @param {number} [minColumnWidth=40]
           * @return {string}
           *
           */
          wrap(str2, width, indent, minColumnWidth = 40) {
            const indents = " \\f\\t\\v\xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF";
            const manualIndent = new RegExp(`[\\n][${indents}]+`);
            if (str2.match(manualIndent))
              return str2;
            const columnWidth = width - indent;
            if (columnWidth < minColumnWidth)
              return str2;
            const leadingStr = str2.slice(0, indent);
            const columnText = str2.slice(indent).replace("\r\n", "\n");
            const indentString = " ".repeat(indent);
            const zeroWidthSpace = "\u200B";
            const breaks = `\\s${zeroWidthSpace}`;
            const regex = new RegExp(`
    |.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, "g");
            const lines = columnText.match(regex) || [];
            return leadingStr + lines.map((line, i) => {
              if (line === "\n")
                return "";
              return (i > 0 ? indentString : "") + line.trimEnd();
            }).join("\n");
          }
        };
        exports2.Help = Help2;
      }
    });
    
    // node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/option.js
    var require_option = __commonJS({
      "node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/option.js"(exports2) {
        var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
        var Option2 = class {
          /**
           * Initialize a new `Option` with the given `flags` and `description`.
           *
           * @param {string} flags
           * @param {string} [description]
           */
          constructor(flags, description) {
            this.flags = flags;
            this.description = description || "";
            this.required = flags.includes("<");
            this.optional = flags.includes("[");
            this.variadic = /\w\.\.\.[>\]]$/.test(flags);
            this.mandatory = false;
            const optionFlags = splitOptionFlags(flags);
            this.short = optionFlags.shortFlag;
            this.long = optionFlags.longFlag;
            this.negate = false;
            if (this.long) {
              this.negate = this.long.startsWith("--no-");
            }
            this.defaultValue = void 0;
            this.defaultValueDescription = void 0;
            this.presetArg = void 0;
            this.envVar = void 0;
            this.parseArg = void 0;
            this.hidden = false;
            this.argChoices = void 0;
            this.conflictsWith = [];
            this.implied = void 0;
          }
          /**
           * Set the default value, and optionally supply the description to be displayed in the help.
           *
           * @param {any} value
           * @param {string} [description]
           * @return {Option}
           */
          default(value, description) {
            this.defaultValue = value;
            this.defaultValueDescription = description;
            return this;
          }
          /**
           * Preset to use when option used without option-argument, especially optional but also boolean and negated.
           * The custom processing (parseArg) is called.
           *
           * @example
           * new Option('--color').default('GREYSCALE').preset('RGB');
           * new Option('--donate [amount]').preset('20').argParser(parseFloat);
           *
           * @param {any} arg
           * @return {Option}
           */
          preset(arg) {
            this.presetArg = arg;
            return this;
          }
          /**
           * Add option name(s) that conflict with this option.
           * An error will be displayed if conflicting options are found during parsing.
           *
           * @example
           * new Option('--rgb').conflicts('cmyk');
           * new Option('--js').conflicts(['ts', 'jsx']);
           *
           * @param {string | string[]} names
           * @return {Option}
           */
          conflicts(names) {
            this.conflictsWith = this.conflictsWith.concat(names);
            return this;
          }
          /**
           * Specify implied option values for when this option is set and the implied options are not.
           *
           * The custom processing (parseArg) is not called on the implied values.
           *
           * @example
           * program
           *   .addOption(new Option('--log', 'write logging information to file'))
           *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
           *
           * @param {Object} impliedOptionValues
           * @return {Option}
           */
          implies(impliedOptionValues) {
            let newImplied = impliedOptionValues;
            if (typeof impliedOptionValues === "string") {
              newImplied = { [impliedOptionValues]: true };
            }
            this.implied = Object.assign(this.implied || {}, newImplied);
            return this;
          }
          /**
           * Set environment variable to check for option value.
           *
           * An environment variable is only used if when processed the current option value is
           * undefined, or the source of the current value is 'default' or 'config' or 'env'.
           *
           * @param {string} name
           * @return {Option}
           */
          env(name) {
            this.envVar = name;
            return this;
          }
          /**
           * Set the custom handler for processing CLI option arguments into option values.
           *
           * @param {Function} [fn]
           * @return {Option}
           */
          argParser(fn) {
            this.parseArg = fn;
            return this;
          }
          /**
           * Whether the option is mandatory and must have a value after parsing.
           *
           * @param {boolean} [mandatory=true]
           * @return {Option}
           */
          makeOptionMandatory(mandatory = true) {
            this.mandatory = !!mandatory;
            return this;
          }
          /**
           * Hide option in help.
           *
           * @param {boolean} [hide=true]
           * @return {Option}
           */
          hideHelp(hide = true) {
            this.hidden = !!hide;
            return this;
          }
          /**
           * @api private
           */
          _concatValue(value, previous) {
            if (previous === this.defaultValue || !Array.isArray(previous)) {
              return [value];
            }
            return previous.concat(value);
          }
          /**
           * Only allow option value to be one of choices.
           *
           * @param {string[]} values
           * @return {Option}
           */
          choices(values) {
            this.argChoices = values.slice();
            this.parseArg = (arg, previous) => {
              if (!this.argChoices.includes(arg)) {
                throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
              }
              if (this.variadic) {
                return this._concatValue(arg, previous);
              }
              return arg;
            };
            return this;
          }
          /**
           * Return option name.
           *
           * @return {string}
           */
          name() {
            if (this.long) {
              return this.long.replace(/^--/, "");
            }
            return this.short.replace(/^-/, "");
          }
          /**
           * Return option name, in a camelcase format that can be used
           * as a object attribute key.
           *
           * @return {string}
           * @api private
           */
          attributeName() {
            return camelcase(this.name().replace(/^no-/, ""));
          }
          /**
           * Check if `arg` matches the short or long flag.
           *
           * @param {string} arg
           * @return {boolean}
           * @api private
           */
          is(arg) {
            return this.short === arg || this.long === arg;
          }
          /**
           * Return whether a boolean option.
           *
           * Options are one of boolean, negated, required argument, or optional argument.
           *
           * @return {boolean}
           * @api private
           */
          isBoolean() {
            return !this.required && !this.optional && !this.negate;
          }
        };
        var DualOptions = class {
          /**
           * @param {Option[]} options
           */
          constructor(options2) {
            this.positiveOptions = /* @__PURE__ */ new Map();
            this.negativeOptions = /* @__PURE__ */ new Map();
            this.dualOptions = /* @__PURE__ */ new Set();
            options2.forEach((option) => {
              if (option.negate) {
                this.negativeOptions.set(option.attributeName(), option);
              } else {
                this.positiveOptions.set(option.attributeName(), option);
              }
            });
            this.negativeOptions.forEach((value, key) => {
              if (this.positiveOptions.has(key)) {
                this.dualOptions.add(key);
              }
            });
          }
          /**
           * Did the value come from the option, and not from possible matching dual option?
           *
           * @param {any} value
           * @param {Option} option
           * @returns {boolean}
           */
          valueFromOption(value, option) {
            const optionKey = option.attributeName();
            if (!this.dualOptions.has(optionKey))
              return true;
            const preset = this.negativeOptions.get(optionKey).presetArg;
            const negativeValue = preset !== void 0 ? preset : false;
            return option.negate === (negativeValue === value);
          }
        };
        function camelcase(str2) {
          return str2.split("-").reduce((str3, word) => {
            return str3 + word[0].toUpperCase() + word.slice(1);
          });
        }
        function splitOptionFlags(flags) {
          let shortFlag;
          let longFlag;
          const flagParts = flags.split(/[ |,]+/);
          if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
            shortFlag = flagParts.shift();
          longFlag = flagParts.shift();
          if (!shortFlag && /^-[^-]$/.test(longFlag)) {
            shortFlag = longFlag;
            longFlag = void 0;
          }
          return { shortFlag, longFlag };
        }
        exports2.Option = Option2;
        exports2.splitOptionFlags = splitOptionFlags;
        exports2.DualOptions = DualOptions;
      }
    });
    
    // node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/suggestSimilar.js
    var require_suggestSimilar = __commonJS({
      "node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/suggestSimilar.js"(exports2) {
        var maxDistance = 3;
        function editDistance(a, b) {
          if (Math.abs(a.length - b.length) > maxDistance)
            return Math.max(a.length, b.length);
          const d = [];
          for (let i = 0; i <= a.length; i++) {
            d[i] = [i];
          }
          for (let j = 0; j <= b.length; j++) {
            d[0][j] = j;
          }
          for (let j = 1; j <= b.length; j++) {
            for (let i = 1; i <= a.length; i++) {
              let cost = 1;
              if (a[i - 1] === b[j - 1]) {
                cost = 0;
              } else {
                cost = 1;
              }
              d[i][j] = Math.min(
                d[i - 1][j] + 1,
                // deletion
                d[i][j - 1] + 1,
                // insertion
                d[i - 1][j - 1] + cost
                // substitution
              );
              if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
              }
            }
          }
          return d[a.length][b.length];
        }
        function suggestSimilar(word, candidates) {
          if (!candidates || candidates.length === 0)
            return "";
          candidates = Array.from(new Set(candidates));
          const searchingOptions = word.startsWith("--");
          if (searchingOptions) {
            word = word.slice(2);
            candidates = candidates.map((candidate) => candidate.slice(2));
          }
          let similar = [];
          let bestDistance = maxDistance;
          const minSimilarity = 0.4;
          candidates.forEach((candidate) => {
            if (candidate.length <= 1)
              return;
            const distance = editDistance(word, candidate);
            const length = Math.max(word.length, candidate.length);
            const similarity = (length - distance) / length;
            if (similarity > minSimilarity) {
              if (distance < bestDistance) {
                bestDistance = distance;
                similar = [candidate];
              } else if (distance === bestDistance) {
                similar.push(candidate);
              }
            }
          });
          similar.sort((a, b) => a.localeCompare(b));
          if (searchingOptions) {
            similar = similar.map((candidate) => `--${candidate}`);
          }
          if (similar.length > 1) {
            return `
    (Did you mean one of ${similar.join(", ")}?)`;
          }
          if (similar.length === 1) {
            return `
    (Did you mean ${similar[0]}?)`;
          }
          return "";
        }
        exports2.suggestSimilar = suggestSimilar;
      }
    });
    
    // node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/command.js
    var require_command = __commonJS({
      "node_modules/.pnpm/commander@10.0.1/node_modules/commander/lib/command.js"(exports2) {
        var EventEmitter = require("events").EventEmitter;
        var childProcess = require("child_process");
        var path = require("path");
        var fs2 = require("fs");
        var process2 = require("process");
        var { Argument: Argument2, humanReadableArgName } = require_argument();
        var { CommanderError: CommanderError2 } = require_error();
        var { Help: Help2 } = require_help();
        var { Option: Option2, splitOptionFlags, DualOptions } = require_option();
        var { suggestSimilar } = require_suggestSimilar();
        var Command2 = class extends EventEmitter {
          /**
           * Initialize a new `Command`.
           *
           * @param {string} [name]
           */
          constructor(name) {
            super();
            this.commands = [];
            this.options = [];
            this.parent = null;
            this._allowUnknownOption = false;
            this._allowExcessArguments = true;
            this._args = [];
            this.args = [];
            this.rawArgs = [];
            this.processedArgs = [];
            this._scriptPath = null;
            this._name = name || "";
            this._optionValues = {};
            this._optionValueSources = {};
            this._storeOptionsAsProperties = false;
            this._actionHandler = null;
            this._executableHandler = false;
            this._executableFile = null;
            this._executableDir = null;
            this._defaultCommandName = null;
            this._exitCallback = null;
            this._aliases = [];
            this._combineFlagAndOptionalValue = true;
            this._description = "";
            this._summary = "";
            this._argsDescription = void 0;
            this._enablePositionalOptions = false;
            this._passThroughOptions = false;
            this._lifeCycleHooks = {};
            this._showHelpAfterError = false;
            this._showSuggestionAfterError = true;
            this._outputConfiguration = {
              writeOut: (str2) => process2.stdout.write(str2),
              writeErr: (str2) => process2.stderr.write(str2),
              getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : void 0,
              getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : void 0,
              outputError: (str2, write) => write(str2)
            };
            this._hidden = false;
            this._hasHelpOption = true;
            this._helpFlags = "-h, --help";
            this._helpDescription = "display help for command";
            this._helpShortFlag = "-h";
            this._helpLongFlag = "--help";
            this._addImplicitHelpCommand = void 0;
            this._helpCommandName = "help";
            this._helpCommandnameAndArgs = "help [command]";
            this._helpCommandDescription = "display help for command";
            this._helpConfiguration = {};
          }
          /**
           * Copy settings that are useful to have in common across root command and subcommands.
           *
           * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.)
           *
           * @param {Command} sourceCommand
           * @return {Command} `this` command for chaining
           */
          copyInheritedSettings(sourceCommand) {
            this._outputConfiguration = sourceCommand._outputConfiguration;
            this._hasHelpOption = sourceCommand._hasHelpOption;
            this._helpFlags = sourceCommand._helpFlags;
            this._helpDescription = sourceCommand._helpDescription;
            this._helpShortFlag = sourceCommand._helpShortFlag;
            this._helpLongFlag = sourceCommand._helpLongFlag;
            this._helpCommandName = sourceCommand._helpCommandName;
            this._helpCommandnameAndArgs = sourceCommand._helpCommandnameAndArgs;
            this._helpCommandDescription = sourceCommand._helpCommandDescription;
            this._helpConfiguration = sourceCommand._helpConfiguration;
            this._exitCallback = sourceCommand._exitCallback;
            this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
            this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
            this._allowExcessArguments = sourceCommand._allowExcessArguments;
            this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
            this._showHelpAfterError = sourceCommand._showHelpAfterError;
            this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
            return this;
          }
          /**
           * Define a command.
           *
           * There are two styles of command: pay attention to where to put the description.
           *
           * @example
           * // Command implemented using action handler (description is supplied separately to `.command`)
           * program
           *   .command('clone <source> [destination]')
           *   .description('clone a repository into a newly created directory')
           *   .action((source, destination) => {
           *     console.log('clone command called');
           *   });
           *
           * // Command implemented using separate executable file (description is second parameter to `.command`)
           * program
           *   .command('start <service>', 'start named service')
           *   .command('stop [service]', 'stop named service, or all if no name supplied');
           *
           * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
           * @param {Object|string} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)
           * @param {Object} [execOpts] - configuration options (for executable)
           * @return {Command} returns new command for action handler, or `this` for executable command
           */
          command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
            let desc = actionOptsOrExecDesc;
            let opts = execOpts;
            if (typeof desc === "object" && desc !== null) {
              opts = desc;
              desc = null;
            }
            opts = opts || {};
            const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
            const cmd = this.createCommand(name);
            if (desc) {
              cmd.description(desc);
              cmd._executableHandler = true;
            }
            if (opts.isDefault)
              this._defaultCommandName = cmd._name;
            cmd._hidden = !!(opts.noHelp || opts.hidden);
            cmd._executableFile = opts.executableFile || null;
            if (args)
              cmd.arguments(args);
            this.commands.push(cmd);
            cmd.parent = this;
            cmd.copyInheritedSettings(this);
            if (desc)
              return this;
            return cmd;
          }
          /**
           * Factory routine to create a new unattached command.
           *
           * See .command() for creating an attached subcommand, which uses this routine to
           * create the command. You can override createCommand to customise subcommands.
           *
           * @param {string} [name]
           * @return {Command} new command
           */
          createCommand(name) {
            return new Command2(name);
          }
          /**
           * You can customise the help with a subclass of Help by overriding createHelp,
           * or by overriding Help properties using configureHelp().
           *
           * @return {Help}
           */
          createHelp() {
            return Object.assign(new Help2(), this.configureHelp());
          }
          /**
           * You can customise the help by overriding Help properties using configureHelp(),
           * or with a subclass of Help by overriding createHelp().
           *
           * @param {Object} [configuration] - configuration options
           * @return {Command|Object} `this` command for chaining, or stored configuration
           */
          configureHelp(configuration) {
            if (configuration === void 0)
              return this._helpConfiguration;
            this._helpConfiguration = configuration;
            return this;
          }
          /**
           * The default output goes to stdout and stderr. You can customise this for special
           * applications. You can also customise the display of errors by overriding outputError.
           *
           * The configuration properties are all functions:
           *
           *     // functions to change where being written, stdout and stderr
           *     writeOut(str)
           *     writeErr(str)
           *     // matching functions to specify width for wrapping help
           *     getOutHelpWidth()
           *     getErrHelpWidth()
           *     // functions based on what is being written out
           *     outputError(str, write) // used for displaying errors, and not used for displaying help
           *
           * @param {Object} [configuration] - configuration options
           * @return {Command|Object} `this` command for chaining, or stored configuration
           */
          configureOutput(configuration) {
            if (configuration === void 0)
              return this._outputConfiguration;
            Object.assign(this._outputConfiguration, configuration);
            return this;
          }
          /**
           * Display the help or a custom message after an error occurs.
           *
           * @param {boolean|string} [displayHelp]
           * @return {Command} `this` command for chaining
           */
          showHelpAfterError(displayHelp = true) {
            if (typeof displayHelp !== "string")
              displayHelp = !!displayHelp;
            this._showHelpAfterError = displayHelp;
            return this;
          }
          /**
           * Display suggestion of similar commands for unknown commands, or options for unknown options.
           *
           * @param {boolean} [displaySuggestion]
           * @return {Command} `this` command for chaining
           */
          showSuggestionAfterError(displaySuggestion = true) {
            this._showSuggestionAfterError = !!displaySuggestion;
            return this;
          }
          /**
           * Add a prepared subcommand.
           *
           * See .command() for creating an attached subcommand which inherits settings from its parent.
           *
           * @param {Command} cmd - new subcommand
           * @param {Object} [opts] - configuration options
           * @return {Command} `this` command for chaining
           */
          addCommand(cmd, opts) {
            if (!cmd._name) {
              throw new Error(`Command passed to .addCommand() must have a name
    - specify the name in Command constructor or using .name()`);
            }
            opts = opts || {};
            if (opts.isDefault)
              this._defaultCommandName = cmd._name;
            if (opts.noHelp || opts.hidden)
              cmd._hidden = true;
            this.commands.push(cmd);
            cmd.parent = this;
            return this;
          }
          /**
           * Factory routine to create a new unattached argument.
           *
           * See .argument() for creating an attached argument, which uses this routine to
           * create the argument. You can override createArgument to return a custom argument.
           *
           * @param {string} name
           * @param {string} [description]
           * @return {Argument} new argument
           */
          createArgument(name, description) {
            return new Argument2(name, description);
          }
          /**
           * Define argument syntax for command.
           *
           * The default is that the argument is required, and you can explicitly
           * indicate this with <> around the name. Put [] around the name for an optional argument.
           *
           * @example
           * program.argument('<input-file>');
           * program.argument('[output-file]');
           *
           * @param {string} name
           * @param {string} [description]
           * @param {Function|*} [fn] - custom argument processing function
           * @param {*} [defaultValue]
           * @return {Command} `this` command for chaining
           */
          argument(name, description, fn, defaultValue) {
            const argument = this.createArgument(name, description);
            if (typeof fn === "function") {
              argument.default(defaultValue).argParser(fn);
            } else {
              argument.default(fn);
            }
            this.addArgument(argument);
            return this;
          }
          /**
           * Define argument syntax for command, adding multiple at once (without descriptions).
           *
           * See also .argument().
           *
           * @example
           * program.arguments('<cmd> [env]');
           *
           * @param {string} names
           * @return {Command} `this` command for chaining
           */
          arguments(names) {
            names.split(/ +/).forEach((detail) => {
              this.argument(detail);
            });
            return this;
          }
          /**
           * Define argument syntax for command, adding a prepared argument.
           *
           * @param {Argument} argument
           * @return {Command} `this` command for chaining
           */
          addArgument(argument) {
            const previousArgument = this._args.slice(-1)[0];
            if (previousArgument && previousArgument.variadic) {
              throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
            }
            if (argument.required && argument.defaultValue !== void 0 && argument.parseArg === void 0) {
              throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
            }
            this._args.push(argument);
            return this;
          }
          /**
           * Override default decision whether to add implicit help command.
           *
           *    addHelpCommand() // force on
           *    addHelpCommand(false); // force off
           *    addHelpCommand('help [cmd]', 'display help for [cmd]'); // force on with custom details
           *
           * @return {Command} `this` command for chaining
           */
          addHelpCommand(enableOrNameAndArgs, description) {
            if (enableOrNameAndArgs === false) {
              this._addImplicitHelpCommand = false;
            } else {
              this._addImplicitHelpCommand = true;
              if (typeof enableOrNameAndArgs === "string") {
                this._helpCommandName = enableOrNameAndArgs.split(" ")[0];
                this._helpCommandnameAndArgs = enableOrNameAndArgs;
              }
              this._helpCommandDescription = description || this._helpCommandDescription;
            }
            return this;
          }
          /**
           * @return {boolean}
           * @api private
           */
          _hasImplicitHelpCommand() {
            if (this._addImplicitHelpCommand === void 0) {
              return this.commands.length && !this._actionHandler && !this._findCommand("help");
            }
            return this._addImplicitHelpCommand;
          }
          /**
           * Add hook for life cycle event.
           *
           * @param {string} event
           * @param {Function} listener
           * @return {Command} `this` command for chaining
           */
          hook(event, listener) {
            const allowedValues = ["preSubcommand", "preAction", "postAction"];
            if (!allowedValues.includes(event)) {
              throw new Error(`Unexpected value for event passed to hook : '${event}'.
    Expecting one of '${allowedValues.join("', '")}'`);
            }
            if (this._lifeCycleHooks[event]) {
              this._lifeCycleHooks[event].push(listener);
            } else {
              this._lifeCycleHooks[event] = [listener];
            }
            return this;
          }
          /**
           * Register callback to use as replacement for calling process.exit.
           *
           * @param {Function} [fn] optional callback which will be passed a CommanderError, defaults to throwing
           * @return {Command} `this` command for chaining
           */
          exitOverride(fn) {
            if (fn) {
              this._exitCallback = fn;
            } else {
              this._exitCallback = (err) => {
                if (err.code !== "commander.executeSubCommandAsync") {
                  throw err;
                } else {
                }
              };
            }
            return this;
          }
          /**
           * Call process.exit, and _exitCallback if defined.
           *
           * @param {number} exitCode exit code for using with process.exit
           * @param {string} code an id string representing the error
           * @param {string} message human-readable description of the error
           * @return never
           * @api private
           */
          _exit(exitCode, code, message) {
            if (this._exitCallback) {
              this._exitCallback(new CommanderError2(exitCode, code, message));
            }
            process2.exit(exitCode);
          }
          /**
           * Register callback `fn` for the command.
           *
           * @example
           * program
           *   .command('serve')
           *   .description('start service')
           *   .action(function() {
           *      // do work here
           *   });
           *
           * @param {Function} fn
           * @return {Command} `this` command for chaining
           */
          action(fn) {
            const listener = (args) => {
              const expectedArgsCount = this._args.length;
              const actionArgs = args.slice(0, expectedArgsCount);
              if (this._storeOptionsAsProperties) {
                actionArgs[expectedArgsCount] = this;
              } else {
                actionArgs[expectedArgsCount] = this.opts();
              }
              actionArgs.push(this);
              return fn.apply(this, actionArgs);
            };
            this._actionHandler = listener;
            return this;
          }
          /**
           * Factory routine to create a new unattached option.
           *
           * See .option() for creating an attached option, which uses this routine to
           * create the option. You can override createOption to return a custom option.
           *
           * @param {string} flags
           * @param {string} [description]
           * @return {Option} new option
           */
          createOption(flags, description) {
            return new Option2(flags, description);
          }
          /**
           * Add an option.
           *
           * @param {Option} option
           * @return {Command} `this` command for chaining
           */
          addOption(option) {
            const oname = option.name();
            const name = option.attributeName();
            if (option.negate) {
              const positiveLongFlag = option.long.replace(/^--no-/, "--");
              if (!this._findOption(positiveLongFlag)) {
                this.setOptionValueWithSource(name, option.defaultValue === void 0 ? true : option.defaultValue, "default");
              }
            } else if (option.defaultValue !== void 0) {
              this.setOptionValueWithSource(name, option.defaultValue, "default");
            }
            this.options.push(option);
            const handleOptionValue = (val, invalidValueMessage, valueSource) => {
              if (val == null && option.presetArg !== void 0) {
                val = option.presetArg;
              }
              const oldValue = this.getOptionValue(name);
              if (val !== null && option.parseArg) {
                try {
                  val = option.parseArg(val, oldValue);
                } catch (err) {
                  if (err.code === "commander.invalidArgument") {
                    const message = `${invalidValueMessage} ${err.message}`;
                    this.error(message, { exitCode: err.exitCode, code: err.code });
                  }
                  throw err;
                }
              } else if (val !== null && option.variadic) {
                val = option._concatValue(val, oldValue);
              }
              if (val == null) {
                if (option.negate) {
                  val = false;
                } else if (option.isBoolean() || option.optional) {
                  val = true;
                } else {
                  val = "";
                }
              }
              this.setOptionValueWithSource(name, val, valueSource);
            };
            this.on("option:" + oname, (val) => {
              const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
              handleOptionValue(val, invalidValueMessage, "cli");
            });
            if (option.envVar) {
              this.on("optionEnv:" + oname, (val) => {
                const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
                handleOptionValue(val, invalidValueMessage, "env");
              });
            }
            return this;
          }
          /**
           * Internal implementation shared by .option() and .requiredOption()
           *
           * @api private
           */
          _optionEx(config, flags, description, fn, defaultValue) {
            if (typeof flags === "object" && flags instanceof Option2) {
              throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
            }
            const option = this.createOption(flags, description);
            option.makeOptionMandatory(!!config.mandatory);
            if (typeof fn === "function") {
              option.default(defaultValue).argParser(fn);
            } else if (fn instanceof RegExp) {
              const regex = fn;
              fn = (val, def) => {
                const m = regex.exec(val);
                return m ? m[0] : def;
              };
              option.default(defaultValue).argParser(fn);
            } else {
              option.default(fn);
            }
            return this.addOption(option);
          }
          /**
           * Define option with `flags`, `description` and optional
           * coercion `fn`.
           *
           * The `flags` string contains the short and/or long flags,
           * separated by comma, a pipe or space. The following are all valid
           * all will output this way when `--help` is used.
           *
           *     "-p, --pepper"
           *     "-p|--pepper"
           *     "-p --pepper"
           *
           * @example
           * // simple boolean defaulting to undefined
           * program.option('-p, --pepper', 'add pepper');
           *
           * program.pepper
           * // => undefined
           *
           * --pepper
           * program.pepper
           * // => true
           *
           * // simple boolean defaulting to true (unless non-negated option is also defined)
           * program.option('-C, --no-cheese', 'remove cheese');
           *
           * program.cheese
           * // => true
           *
           * --no-cheese
           * program.cheese
           * // => false
           *
           * // required argument
           * program.option('-C, --chdir <path>', 'change the working directory');
           *
           * --chdir /tmp
           * program.chdir
           * // => "/tmp"
           *
           * // optional argument
           * program.option('-c, --cheese [type]', 'add cheese [marble]');
           *
           * @param {string} flags
           * @param {string} [description]
           * @param {Function|*} [fn] - custom option processing function or default value
           * @param {*} [defaultValue]
           * @return {Command} `this` command for chaining
           */
          option(flags, description, fn, defaultValue) {
            return this._optionEx({}, flags, description, fn, defaultValue);
          }
          /**
          * Add a required option which must have a value after parsing. This usually means
          * the option must be specified on the command line. (Otherwise the same as .option().)
          *
          * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
          *
          * @param {string} flags
          * @param {string} [description]
          * @param {Function|*} [fn] - custom option processing function or default value
          * @param {*} [defaultValue]
          * @return {Command} `this` command for chaining
          */
          requiredOption(flags, description, fn, defaultValue) {
            return this._optionEx({ mandatory: true }, flags, description, fn, defaultValue);
          }
          /**
           * Alter parsing of short flags with optional values.
           *
           * @example
           * // for `.option('-f,--flag [value]'):
           * program.combineFlagAndOptionalValue(true);  // `-f80` is treated like `--flag=80`, this is the default behaviour
           * program.combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
           *
           * @param {Boolean} [combine=true] - if `true` or omitted, an optional value can be specified directly after the flag.
           */
          combineFlagAndOptionalValue(combine = true) {
            this._combineFlagAndOptionalValue = !!combine;
            return this;
          }
          /**
           * Allow unknown options on the command line.
           *
           * @param {Boolean} [allowUnknown=true] - if `true` or omitted, no error will be thrown
           * for unknown options.
           */
          allowUnknownOption(allowUnknown = true) {
            this._allowUnknownOption = !!allowUnknown;
            return this;
          }
          /**
           * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
           *
           * @param {Boolean} [allowExcess=true] - if `true` or omitted, no error will be thrown
           * for excess arguments.
           */
          allowExcessArguments(allowExcess = true) {
            this._allowExcessArguments = !!allowExcess;
            return this;
          }
          /**
           * Enable positional options. Positional means global options are specified before subcommands which lets
           * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
           * The default behaviour is non-positional and global options may appear anywhere on the command line.
           *
           * @param {Boolean} [positional=true]
           */
          enablePositionalOptions(positional = true) {
            this._enablePositionalOptions = !!positional;
            return this;
          }
          /**
           * Pass through options that come after command-arguments rather than treat them as command-options,
           * so actual command-options come before command-arguments. Turning this on for a subcommand requires
           * positional options to have been enabled on the program (parent commands).
           * The default behaviour is non-positional and options may appear before or after command-arguments.
           *
           * @param {Boolean} [passThrough=true]
           * for unknown options.
           */
          passThroughOptions(passThrough = true) {
            this._passThroughOptions = !!passThrough;
            if (!!this.parent && passThrough && !this.parent._enablePositionalOptions) {
              throw new Error("passThroughOptions can not be used without turning on enablePositionalOptions for parent command(s)");
            }
            return this;
          }
          /**
            * Whether to store option values as properties on command object,
            * or store separately (specify false). In both cases the option values can be accessed using .opts().
            *
            * @param {boolean} [storeAsProperties=true]
            * @return {Command} `this` command for chaining
            */
          storeOptionsAsProperties(storeAsProperties = true) {
            this._storeOptionsAsProperties = !!storeAsProperties;
            if (this.options.length) {
              throw new Error("call .storeOptionsAsProperties() before adding options");
            }
            return this;
          }
          /**
           * Retrieve option value.
           *
           * @param {string} key
           * @return {Object} value
           */
          getOptionValue(key) {
            if (this._storeOptionsAsProperties) {
              return this[key];
            }
            return this._optionValues[key];
          }
          /**
           * Store option value.
           *
           * @param {string} key
           * @param {Object} value
           * @return {Command} `this` command for chaining
           */
          setOptionValue(key, value) {
            return this.setOptionValueWithSource(key, value, void 0);
          }
          /**
            * Store option value and where the value came from.
            *
            * @param {string} key
            * @param {Object} value
            * @param {string} source - expected values are default/config/env/cli/implied
            * @return {Command} `this` command for chaining
            */
          setOptionValueWithSource(key, value, source) {
            if (this._storeOptionsAsProperties) {
              this[key] = value;
            } else {
              this._optionValues[key] = value;
            }
            this._optionValueSources[key] = source;
            return this;
          }
          /**
            * Get source of option value.
            * Expected values are default | config | env | cli | implied
            *
            * @param {string} key
            * @return {string}
            */
          getOptionValueSource(key) {
            return this._optionValueSources[key];
          }
          /**
            * Get source of option value. See also .optsWithGlobals().
            * Expected values are default | config | env | cli | implied
            *
            * @param {string} key
            * @return {string}
            */
          getOptionValueSourceWithGlobals(key) {
            let source;
            getCommandAndParents(this).forEach((cmd) => {
              if (cmd.getOptionValueSource(key) !== void 0) {
                source = cmd.getOptionValueSource(key);
              }
            });
            return source;
          }
          /**
           * Get user arguments from implied or explicit arguments.
           * Side-effects: set _scriptPath if args included script. Used for default program name, and subcommand searches.
           *
           * @api private
           */
          _prepareUserArgs(argv, parseOptions) {
            if (argv !== void 0 && !Array.isArray(argv)) {
              throw new Error("first parameter to parse must be array or undefined");
            }
            parseOptions = parseOptions || {};
            if (argv === void 0) {
              argv = process2.argv;
              if (process2.versions && process2.versions.electron) {
                parseOptions.from = "electron";
              }
            }
            this.rawArgs = argv.slice();
            let userArgs;
            switch (parseOptions.from) {
              case void 0:
              case "node":
                this._scriptPath = argv[1];
                userArgs = argv.slice(2);
                break;
              case "electron":
                if (process2.defaultApp) {
                  this._scriptPath = argv[1];
                  userArgs = argv.slice(2);
                } else {
                  userArgs = argv.slice(1);
                }
                break;
              case "user":
                userArgs = argv.slice(0);
                break;
              default:
                throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
            }
            if (!this._name && this._scriptPath)
              this.nameFromFilename(this._scriptPath);
            this._name = this._name || "program";
            return userArgs;
          }
          /**
           * Parse `argv`, setting options and invoking commands when defined.
           *
           * The default expectation is that the arguments are from node and have the application as argv[0]
           * and the script being run in argv[1], with user parameters after that.
           *
           * @example
           * program.parse(process.argv);
           * program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
           * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
           *
           * @param {string[]} [argv] - optional, defaults to process.argv
           * @param {Object} [parseOptions] - optionally specify style of options with from: node/user/electron
           * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
           * @return {Command} `this` command for chaining
           */
          parse(argv, parseOptions) {
            const userArgs = this._prepareUserArgs(argv, parseOptions);
            this._parseCommand([], userArgs);
            return this;
          }
          /**
           * Parse `argv`, setting options and invoking commands when defined.
           *
           * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
           *
           * The default expectation is that the arguments are from node and have the application as argv[0]
           * and the script being run in argv[1], with user parameters after that.
           *
           * @example
           * await program.parseAsync(process.argv);
           * await program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
           * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
           *
           * @param {string[]} [argv]
           * @param {Object} [parseOptions]
           * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
           * @return {Promise}
           */
          async parseAsync(argv, parseOptions) {
            const userArgs = this._prepareUserArgs(argv, parseOptions);
            await this._parseCommand([], userArgs);
            return this;
          }
          /**
           * Execute a sub-command executable.
           *
           * @api private
           */
          _executeSubCommand(subcommand, args) {
            args = args.slice();
            let launchWithNode = false;
            const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
            function findFile(baseDir, baseName) {
              const localBin = path.resolve(baseDir, baseName);
              if (fs2.existsSync(localBin))
                return localBin;
              if (sourceExt.includes(path.extname(baseName)))
                return void 0;
              const foundExt = sourceExt.find((ext) => fs2.existsSync(`${localBin}${ext}`));
              if (foundExt)
                return `${localBin}${foundExt}`;
              return void 0;
            }
            this._checkForMissingMandatoryOptions();
            this._checkForConflictingOptions();
            let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
            let executableDir = this._executableDir || "";
            if (this._scriptPath) {
              let resolvedScriptPath;
              try {
                resolvedScriptPath = fs2.realpathSync(this._scriptPath);
              } catch (err) {
                resolvedScriptPath = this._scriptPath;
              }
              executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
            }
            if (executableDir) {
              let localFile = findFile(executableDir, executableFile);
              if (!localFile && !subcommand._executableFile && this._scriptPath) {
                const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
                if (legacyName !== this._name) {
                  localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
                }
              }
              executableFile = localFile || executableFile;
            }
            launchWithNode = sourceExt.includes(path.extname(executableFile));
            let proc;
            if (process2.platform !== "win32") {
              if (launchWithNode) {
                args.unshift(executableFile);
                args = incrementNodeInspectorPort(process2.execArgv).concat(args);
                proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
              } else {
                proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
              }
            } else {
              args.unshift(executableFile);
              args = incrementNodeInspectorPort(process2.execArgv).concat(args);
              proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
            }
            if (!proc.killed) {
              const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
              signals.forEach((signal) => {
                process2.on(signal, () => {
                  if (proc.killed === false && proc.exitCode === null) {
                    proc.kill(signal);
                  }
                });
              });
            }
            const exitCallback = this._exitCallback;
            if (!exitCallback) {
              proc.on("close", process2.exit.bind(process2));
            } else {
              proc.on("close", () => {
                exitCallback(new CommanderError2(process2.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
              });
            }
            proc.on("error", (err) => {
              if (err.code === "ENOENT") {
                const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
                const executableMissing = `'${executableFile}' does not exist
     - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
     - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
     - ${executableDirMessage}`;
                throw new Error(executableMissing);
              } else if (err.code === "EACCES") {
                throw new Error(`'${executableFile}' not executable`);
              }
              if (!exitCallback) {
                process2.exit(1);
              } else {
                const wrappedError = new CommanderError2(1, "commander.executeSubCommandAsync", "(error)");
                wrappedError.nestedError = err;
                exitCallback(wrappedError);
              }
            });
            this.runningCommand = proc;
          }
          /**
           * @api private
           */
          _dispatchSubcommand(commandName, operands, unknown) {
            const subCommand = this._findCommand(commandName);
            if (!subCommand)
              this.help({ error: true });
            let hookResult;
            hookResult = this._chainOrCallSubCommandHook(hookResult, subCommand, "preSubcommand");
            hookResult = this._chainOrCall(hookResult, () => {
              if (subCommand._executableHandler) {
                this._executeSubCommand(subCommand, operands.concat(unknown));
              } else {
                return subCommand._parseCommand(operands, unknown);
              }
            });
            return hookResult;
          }
          /**
           * Check this.args against expected this._args.
           *
           * @api private
           */
          _checkNumberOfArguments() {
            this._args.forEach((arg, i) => {
              if (arg.required && this.args[i] == null) {
                this.missingArgument(arg.name());
              }
            });
            if (this._args.length > 0 && this._args[this._args.length - 1].variadic) {
              return;
            }
            if (this.args.length > this._args.length) {
              this._excessArguments(this.args);
            }
          }
          /**
           * Process this.args using this._args and save as this.processedArgs!
           *
           * @api private
           */
          _processArguments() {
            const myParseArg = (argument, value, previous) => {
              let parsedValue = value;
              if (value !== null && argument.parseArg) {
                try {
                  parsedValue = argument.parseArg(value, previous);
                } catch (err) {
                  if (err.code === "commander.invalidArgument") {
                    const message = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'. ${err.message}`;
                    this.error(message, { exitCode: err.exitCode, code: err.code });
                  }
                  throw err;
                }
              }
              return parsedValue;
            };
            this._checkNumberOfArguments();
            const processedArgs = [];
            this._args.forEach((declaredArg, index) => {
              let value = declaredArg.defaultValue;
              if (declaredArg.variadic) {
                if (index < this.args.length) {
                  value = this.args.slice(index);
                  if (declaredArg.parseArg) {
                    value = value.reduce((processed, v) => {
                      return myParseArg(declaredArg, v, processed);
                    }, declaredArg.defaultValue);
                  }
                } else if (value === void 0) {
                  value = [];
                }
              } else if (index < this.args.length) {
                value = this.args[index];
                if (declaredArg.parseArg) {
                  value = myParseArg(declaredArg, value, declaredArg.defaultValue);
                }
              }
              processedArgs[index] = value;
            });
            this.processedArgs = processedArgs;
          }
          /**
           * Once we have a promise we chain, but call synchronously until then.
           *
           * @param {Promise|undefined} promise
           * @param {Function} fn
           * @return {Promise|undefined}
           * @api private
           */
          _chainOrCall(promise, fn) {
            if (promise && promise.then && typeof promise.then === "function") {
              return promise.then(() => fn());
            }
            return fn();
          }
          /**
           *
           * @param {Promise|undefined} promise
           * @param {string} event
           * @return {Promise|undefined}
           * @api private
           */
          _chainOrCallHooks(promise, event) {
            let result = promise;
            const hooks = [];
            getCommandAndParents(this).reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== void 0).forEach((hookedCommand) => {
              hookedCommand._lifeCycleHooks[event].forEach((callback) => {
                hooks.push({ hookedCommand, callback });
              });
            });
            if (event === "postAction") {
              hooks.reverse();
            }
            hooks.forEach((hookDetail) => {
              result = this._chainOrCall(result, () => {
                return hookDetail.callback(hookDetail.hookedCommand, this);
              });
            });
            return result;
          }
          /**
           *
           * @param {Promise|undefined} promise
           * @param {Command} subCommand
           * @param {string} event
           * @return {Promise|undefined}
           * @api private
           */
          _chainOrCallSubCommandHook(promise, subCommand, event) {
            let result = promise;
            if (this._lifeCycleHooks[event] !== void 0) {
              this._lifeCycleHooks[event].forEach((hook) => {
                result = this._chainOrCall(result, () => {
                  return hook(this, subCommand);
                });
              });
            }
            return result;
          }
          /**
           * Process arguments in context of this command.
           * Returns action result, in case it is a promise.
           *
           * @api private
           */
          _parseCommand(operands, unknown) {
            const parsed = this.parseOptions(unknown);
            this._parseOptionsEnv();
            this._parseOptionsImplied();
            operands = operands.concat(parsed.operands);
            unknown = parsed.unknown;
            this.args = operands.concat(unknown);
            if (operands && this._findCommand(operands[0])) {
              return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
            }
            if (this._hasImplicitHelpCommand() && operands[0] === this._helpCommandName) {
              if (operands.length === 1) {
                this.help();
              }
              return this._dispatchSubcommand(operands[1], [], [this._helpLongFlag]);
            }
            if (this._defaultCommandName) {
              outputHelpIfRequested(this, unknown);
              return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
            }
            if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
              this.help({ error: true });
            }
            outputHelpIfRequested(this, parsed.unknown);
            this._checkForMissingMandatoryOptions();
            this._checkForConflictingOptions();
            const checkForUnknownOptions = () => {
              if (parsed.unknown.length > 0) {
                this.unknownOption(parsed.unknown[0]);
              }
            };
            const commandEvent = `command:${this.name()}`;
            if (this._actionHandler) {
              checkForUnknownOptions();
              this._processArguments();
              let actionResult;
              actionResult = this._chainOrCallHooks(actionResult, "preAction");
              actionResult = this._chainOrCall(actionResult, () => this._actionHandler(this.processedArgs));
              if (this.parent) {
                actionResult = this._chainOrCall(actionResult, () => {
                  this.parent.emit(commandEvent, operands, unknown);
                });
              }
              actionResult = this._chainOrCallHooks(actionResult, "postAction");
              return actionResult;
            }
            if (this.parent && this.parent.listenerCount(commandEvent)) {
              checkForUnknownOptions();
              this._processArguments();
              this.parent.emit(commandEvent, operands, unknown);
            } else if (operands.length) {
              if (this._findCommand("*")) {
                return this._dispatchSubcommand("*", operands, unknown);
              }
              if (this.listenerCount("command:*")) {
                this.emit("command:*", operands, unknown);
              } else if (this.commands.length) {
                this.unknownCommand();
              } else {
                checkForUnknownOptions();
                this._processArguments();
              }
            } else if (this.commands.length) {
              checkForUnknownOptions();
              this.help({ error: true });
            } else {
              checkForUnknownOptions();
              this._processArguments();
            }
          }
          /**
           * Find matching command.
           *
           * @api private
           */
          _findCommand(name) {
            if (!name)
              return void 0;
            return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
          }
          /**
           * Return an option matching `arg` if any.
           *
           * @param {string} arg
           * @return {Option}
           * @api private
           */
          _findOption(arg) {
            return this.options.find((option) => option.is(arg));
          }
          /**
           * Display an error message if a mandatory option does not have a value.
           * Called after checking for help flags in leaf subcommand.
           *
           * @api private
           */
          _checkForMissingMandatoryOptions() {
            for (let cmd = this; cmd; cmd = cmd.parent) {
              cmd.options.forEach((anOption) => {
                if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === void 0) {
                  cmd.missingMandatoryOptionValue(anOption);
                }
              });
            }
          }
          /**
           * Display an error message if conflicting options are used together in this.
           *
           * @api private
           */
          _checkForConflictingLocalOptions() {
            const definedNonDefaultOptions = this.options.filter(
              (option) => {
                const optionKey = option.attributeName();
                if (this.getOptionValue(optionKey) === void 0) {
                  return false;
                }
                return this.getOptionValueSource(optionKey) !== "default";
              }
            );
            const optionsWithConflicting = definedNonDefaultOptions.filter(
              (option) => option.conflictsWith.length > 0
            );
            optionsWithConflicting.forEach((option) => {
              const conflictingAndDefined = definedNonDefaultOptions.find(
                (defined) => option.conflictsWith.includes(defined.attributeName())
              );
              if (conflictingAndDefined) {
                this._conflictingOption(option, conflictingAndDefined);
              }
            });
          }
          /**
           * Display an error message if conflicting options are used together.
           * Called after checking for help flags in leaf subcommand.
           *
           * @api private
           */
          _checkForConflictingOptions() {
            for (let cmd = this; cmd; cmd = cmd.parent) {
              cmd._checkForConflictingLocalOptions();
            }
          }
          /**
           * Parse options from `argv` removing known options,
           * and return argv split into operands and unknown arguments.
           *
           * Examples:
           *
           *     argv => operands, unknown
           *     --known kkk op => [op], []
           *     op --known kkk => [op], []
           *     sub --unknown uuu op => [sub], [--unknown uuu op]
           *     sub -- --unknown uuu op => [sub --unknown uuu op], []
           *
           * @param {String[]} argv
           * @return {{operands: String[], unknown: String[]}}
           */
          parseOptions(argv) {
            const operands = [];
            const unknown = [];
            let dest = operands;
            const args = argv.slice();
            function maybeOption(arg) {
              return arg.length > 1 && arg[0] === "-";
            }
            let activeVariadicOption = null;
            while (args.length) {
              const arg = args.shift();
              if (arg === "--") {
                if (dest === unknown)
                  dest.push(arg);
                dest.push(...args);
                break;
              }
              if (activeVariadicOption && !maybeOption(arg)) {
                this.emit(`option:${activeVariadicOption.name()}`, arg);
                continue;
              }
              activeVariadicOption = null;
              if (maybeOption(arg)) {
                const option = this._findOption(arg);
                if (option) {
                  if (option.required) {
                    const value = args.shift();
                    if (value === void 0)
                      this.optionMissingArgument(option);
                    this.emit(`option:${option.name()}`, value);
                  } else if (option.optional) {
                    let value = null;
                    if (args.length > 0 && !maybeOption(args[0])) {
                      value = args.shift();
                    }
                    this.emit(`option:${option.name()}`, value);
                  } else {
                    this.emit(`option:${option.name()}`);
                  }
                  activeVariadicOption = option.variadic ? option : null;
                  continue;
                }
              }
              if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
                const option = this._findOption(`-${arg[1]}`);
                if (option) {
                  if (option.required || option.optional && this._combineFlagAndOptionalValue) {
                    this.emit(`option:${option.name()}`, arg.slice(2));
                  } else {
                    this.emit(`option:${option.name()}`);
                    args.unshift(`-${arg.slice(2)}`);
                  }
                  continue;
                }
              }
              if (/^--[^=]+=/.test(arg)) {
                const index = arg.indexOf("=");
                const option = this._findOption(arg.slice(0, index));
                if (option && (option.required || option.optional)) {
                  this.emit(`option:${option.name()}`, arg.slice(index + 1));
                  continue;
                }
              }
              if (maybeOption(arg)) {
                dest = unknown;
              }
              if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
                if (this._findCommand(arg)) {
                  operands.push(arg);
                  if (args.length > 0)
                    unknown.push(...args);
                  break;
                } else if (arg === this._helpCommandName && this._hasImplicitHelpCommand()) {
                  operands.push(arg);
                  if (args.length > 0)
                    operands.push(...args);
                  break;
                } else if (this._defaultCommandName) {
                  unknown.push(arg);
                  if (args.length > 0)
                    unknown.push(...args);
                  break;
                }
              }
              if (this._passThroughOptions) {
                dest.push(arg);
                if (args.length > 0)
                  dest.push(...args);
                break;
              }
              dest.push(arg);
            }
            return { operands, unknown };
          }
          /**
           * Return an object containing local option values as key-value pairs.
           *
           * @return {Object}
           */
          opts() {
            if (this._storeOptionsAsProperties) {
              const result = {};
              const len = this.options.length;
              for (let i = 0; i < len; i++) {
                const key = this.options[i].attributeName();
                result[key] = key === this._versionOptionName ? this._version : this[key];
              }
              return result;
            }
            return this._optionValues;
          }
          /**
           * Return an object containing merged local and global option values as key-value pairs.
           *
           * @return {Object}
           */
          optsWithGlobals() {
            return getCommandAndParents(this).reduce(
              (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),
              {}
            );
          }
          /**
           * Display error message and exit (or call exitOverride).
           *
           * @param {string} message
           * @param {Object} [errorOptions]
           * @param {string} [errorOptions.code] - an id string representing the error
           * @param {number} [errorOptions.exitCode] - used with process.exit
           */
          error(message, errorOptions) {
            this._outputConfiguration.outputError(`${message}
    `, this._outputConfiguration.writeErr);
            if (typeof this._showHelpAfterError === "string") {
              this._outputConfiguration.writeErr(`${this._showHelpAfterError}
    `);
            } else if (this._showHelpAfterError) {
              this._outputConfiguration.writeErr("\n");
              this.outputHelp({ error: true });
            }
            const config = errorOptions || {};
            const exitCode = config.exitCode || 1;
            const code = config.code || "commander.error";
            this._exit(exitCode, code, message);
          }
          /**
           * Apply any option related environment variables, if option does
           * not have a value from cli or client code.
           *
           * @api private
           */
          _parseOptionsEnv() {
            this.options.forEach((option) => {
              if (option.envVar && option.envVar in process2.env) {
                const optionKey = option.attributeName();
                if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
                  if (option.required || option.optional) {
                    this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
                  } else {
                    this.emit(`optionEnv:${option.name()}`);
                  }
                }
              }
            });
          }
          /**
           * Apply any implied option values, if option is undefined or default value.
           *
           * @api private
           */
          _parseOptionsImplied() {
            const dualHelper = new DualOptions(this.options);
            const hasCustomOptionValue = (optionKey) => {
              return this.getOptionValue(optionKey) !== void 0 && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
            };
            this.options.filter((option) => option.implied !== void 0 && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option)).forEach((option) => {
              Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
                this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], "implied");
              });
            });
          }
          /**
           * Argument `name` is missing.
           *
           * @param {string} name
           * @api private
           */
          missingArgument(name) {
            const message = `error: missing required argument '${name}'`;
            this.error(message, { code: "commander.missingArgument" });
          }
          /**
           * `Option` is missing an argument.
           *
           * @param {Option} option
           * @api private
           */
          optionMissingArgument(option) {
            const message = `error: option '${option.flags}' argument missing`;
            this.error(message, { code: "commander.optionMissingArgument" });
          }
          /**
           * `Option` does not have a value, and is a mandatory option.
           *
           * @param {Option} option
           * @api private
           */
          missingMandatoryOptionValue(option) {
            const message = `error: required option '${option.flags}' not specified`;
            this.error(message, { code: "commander.missingMandatoryOptionValue" });
          }
          /**
           * `Option` conflicts with another option.
           *
           * @param {Option} option
           * @param {Option} conflictingOption
           * @api private
           */
          _conflictingOption(option, conflictingOption) {
            const findBestOptionFromValue = (option2) => {
              const optionKey = option2.attributeName();
              const optionValue = this.getOptionValue(optionKey);
              const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
              const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
              if (negativeOption && (negativeOption.presetArg === void 0 && optionValue === false || negativeOption.presetArg !== void 0 && optionValue === negativeOption.presetArg)) {
                return negativeOption;
              }
              return positiveOption || option2;
            };
            const getErrorMessage = (option2) => {
              const bestOption = findBestOptionFromValue(option2);
              const optionKey = bestOption.attributeName();
              const source = this.getOptionValueSource(optionKey);
              if (source === "env") {
                return `environment variable '${bestOption.envVar}'`;
              }
              return `option '${bestOption.flags}'`;
            };
            const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
            this.error(message, { code: "commander.conflictingOption" });
          }
          /**
           * Unknown option `flag`.
           *
           * @param {string} flag
           * @api private
           */
          unknownOption(flag) {
            if (this._allowUnknownOption)
              return;
            let suggestion = "";
            if (flag.startsWith("--") && this._showSuggestionAfterError) {
              let candidateFlags = [];
              let command = this;
              do {
                const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
                candidateFlags = candidateFlags.concat(moreFlags);
                command = command.parent;
              } while (command && !command._enablePositionalOptions);
              suggestion = suggestSimilar(flag, candidateFlags);
            }
            const message = `error: unknown option '${flag}'${suggestion}`;
            this.error(message, { code: "commander.unknownOption" });
          }
          /**
           * Excess arguments, more than expected.
           *
           * @param {string[]} receivedArgs
           * @api private
           */
          _excessArguments(receivedArgs) {
            if (this._allowExcessArguments)
              return;
            const expected = this._args.length;
            const s = expected === 1 ? "" : "s";
            const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
            const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
            this.error(message, { code: "commander.excessArguments" });
          }
          /**
           * Unknown command.
           *
           * @api private
           */
          unknownCommand() {
            const unknownName = this.args[0];
            let suggestion = "";
            if (this._showSuggestionAfterError) {
              const candidateNames = [];
              this.createHelp().visibleCommands(this).forEach((command) => {
                candidateNames.push(command.name());
                if (command.alias())
                  candidateNames.push(command.alias());
              });
              suggestion = suggestSimilar(unknownName, candidateNames);
            }
            const message = `error: unknown command '${unknownName}'${suggestion}`;
            this.error(message, { code: "commander.unknownCommand" });
          }
          /**
           * Set the program version to `str`.
           *
           * This method auto-registers the "-V, --version" flag
           * which will print the version number when passed.
           *
           * You can optionally supply the  flags and description to override the defaults.
           *
           * @param {string} str
           * @param {string} [flags]
           * @param {string} [description]
           * @return {this | string} `this` command for chaining, or version string if no arguments
           */
          version(str2, flags, description) {
            if (str2 === void 0)
              return this._version;
            this._version = str2;
            flags = flags || "-V, --version";
            description = description || "output the version number";
            const versionOption = this.createOption(flags, description);
            this._versionOptionName = versionOption.attributeName();
            this.options.push(versionOption);
            this.on("option:" + versionOption.name(), () => {
              this._outputConfiguration.writeOut(`${str2}
    `);
              this._exit(0, "commander.version", str2);
            });
            return this;
          }
          /**
           * Set the description.
           *
           * @param {string} [str]
           * @param {Object} [argsDescription]
           * @return {string|Command}
           */
          description(str2, argsDescription) {
            if (str2 === void 0 && argsDescription === void 0)
              return this._description;
            this._description = str2;
            if (argsDescription) {
              this._argsDescription = argsDescription;
            }
            return this;
          }
          /**
           * Set the summary. Used when listed as subcommand of parent.
           *
           * @param {string} [str]
           * @return {string|Command}
           */
          summary(str2) {
            if (str2 === void 0)
              return this._summary;
            this._summary = str2;
            return this;
          }
          /**
           * Set an alias for the command.
           *
           * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
           *
           * @param {string} [alias]
           * @return {string|Command}
           */
          alias(alias) {
            if (alias === void 0)
              return this._aliases[0];
            let command = this;
            if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
              command = this.commands[this.commands.length - 1];
            }
            if (alias === command._name)
              throw new Error("Command alias can't be the same as its name");
            command._aliases.push(alias);
            return this;
          }
          /**
           * Set aliases for the command.
           *
           * Only the first alias is shown in the auto-generated help.
           *
           * @param {string[]} [aliases]
           * @return {string[]|Command}
           */
          aliases(aliases) {
            if (aliases === void 0)
              return this._aliases;
            aliases.forEach((alias) => this.alias(alias));
            return this;
          }
          /**
           * Set / get the command usage `str`.
           *
           * @param {string} [str]
           * @return {String|Command}
           */
          usage(str2) {
            if (str2 === void 0) {
              if (this._usage)
                return this._usage;
              const args = this._args.map((arg) => {
                return humanReadableArgName(arg);
              });
              return [].concat(
                this.options.length || this._hasHelpOption ? "[options]" : [],
                this.commands.length ? "[command]" : [],
                this._args.length ? args : []
              ).join(" ");
            }
            this._usage = str2;
            return this;
          }
          /**
           * Get or set the name of the command.
           *
           * @param {string} [str]
           * @return {string|Command}
           */
          name(str2) {
            if (str2 === void 0)
              return this._name;
            this._name = str2;
            return this;
          }
          /**
           * Set the name of the command from script filename, such as process.argv[1],
           * or require.main.filename, or __filename.
           *
           * (Used internally and public although not documented in README.)
           *
           * @example
           * program.nameFromFilename(require.main.filename);
           *
           * @param {string} filename
           * @return {Command}
           */
          nameFromFilename(filename) {
            this._name = path.basename(filename, path.extname(filename));
            return this;
          }
          /**
           * Get or set the directory for searching for executable subcommands of this command.
           *
           * @example
           * program.executableDir(__dirname);
           * // or
           * program.executableDir('subcommands');
           *
           * @param {string} [path]
           * @return {string|Command}
           */
          executableDir(path2) {
            if (path2 === void 0)
              return this._executableDir;
            this._executableDir = path2;
            return this;
          }
          /**
           * Return program help documentation.
           *
           * @param {{ error: boolean }} [contextOptions] - pass {error:true} to wrap for stderr instead of stdout
           * @return {string}
           */
          helpInformation(contextOptions) {
            const helper = this.createHelp();
            if (helper.helpWidth === void 0) {
              helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
            }
            return helper.formatHelp(this, helper);
          }
          /**
           * @api private
           */
          _getHelpContext(contextOptions) {
            contextOptions = contextOptions || {};
            const context = { error: !!contextOptions.error };
            let write;
            if (context.error) {
              write = (arg) => this._outputConfiguration.writeErr(arg);
            } else {
              write = (arg) => this._outputConfiguration.writeOut(arg);
            }
            context.write = contextOptions.write || write;
            context.command = this;
            return context;
          }
          /**
           * Output help information for this command.
           *
           * Outputs built-in help, and custom text added using `.addHelpText()`.
           *
           * @param {{ error: boolean } | Function} [contextOptions] - pass {error:true} to write to stderr instead of stdout
           */
          outputHelp(contextOptions) {
            let deprecatedCallback;
            if (typeof contextOptions === "function") {
              deprecatedCallback = contextOptions;
              contextOptions = void 0;
            }
            const context = this._getHelpContext(contextOptions);
            getCommandAndParents(this).reverse().forEach((command) => command.emit("beforeAllHelp", context));
            this.emit("beforeHelp", context);
            let helpInformation = this.helpInformation(context);
            if (deprecatedCallback) {
              helpInformation = deprecatedCallback(helpInformation);
              if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
                throw new Error("outputHelp callback must return a string or a Buffer");
              }
            }
            context.write(helpInformation);
            this.emit(this._helpLongFlag);
            this.emit("afterHelp", context);
            getCommandAndParents(this).forEach((command) => command.emit("afterAllHelp", context));
          }
          /**
           * You can pass in flags and a description to override the help
           * flags and help description for your command. Pass in false to
           * disable the built-in help option.
           *
           * @param {string | boolean} [flags]
           * @param {string} [description]
           * @return {Command} `this` command for chaining
           */
          helpOption(flags, description) {
            if (typeof flags === "boolean") {
              this._hasHelpOption = flags;
              return this;
            }
            this._helpFlags = flags || this._helpFlags;
            this._helpDescription = description || this._helpDescription;
            const helpFlags = splitOptionFlags(this._helpFlags);
            this._helpShortFlag = helpFlags.shortFlag;
            this._helpLongFlag = helpFlags.longFlag;
            return this;
          }
          /**
           * Output help information and exit.
           *
           * Outputs built-in help, and custom text added using `.addHelpText()`.
           *
           * @param {{ error: boolean }} [contextOptions] - pass {error:true} to write to stderr instead of stdout
           */
          help(contextOptions) {
            this.outputHelp(contextOptions);
            let exitCode = process2.exitCode || 0;
            if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
              exitCode = 1;
            }
            this._exit(exitCode, "commander.help", "(outputHelp)");
          }
          /**
           * Add additional text to be displayed with the built-in help.
           *
           * Position is 'before' or 'after' to affect just this command,
           * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
           *
           * @param {string} position - before or after built-in help
           * @param {string | Function} text - string to add, or a function returning a string
           * @return {Command} `this` command for chaining
           */
          addHelpText(position, text) {
            const allowedValues = ["beforeAll", "before", "after", "afterAll"];
            if (!allowedValues.includes(position)) {
              throw new Error(`Unexpected value for position to addHelpText.
    Expecting one of '${allowedValues.join("', '")}'`);
            }
            const helpEvent = `${position}Help`;
            this.on(helpEvent, (context) => {
              let helpStr;
              if (typeof text === "function") {
                helpStr = text({ error: context.error, command: context.command });
              } else {
                helpStr = text;
              }
              if (helpStr) {
                context.write(`${helpStr}
    `);
              }
            });
            return this;
          }
        };
        function outputHelpIfRequested(cmd, args) {
          const helpOption = cmd._hasHelpOption && args.find((arg) => arg === cmd._helpLongFlag || arg === cmd._helpShortFlag);
          if (helpOption) {
            cmd.outputHelp();
            cmd._exit(0, "commander.helpDisplayed", "(outputHelp)");
          }
        }
        function incrementNodeInspectorPort(args) {
          return args.map((arg) => {
            if (!arg.startsWith("--inspect")) {
              return arg;
            }
            let debugOption;
            let debugHost = "127.0.0.1";
            let debugPort = "9229";
            let match;
            if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
              debugOption = match[1];
            } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
              debugOption = match[1];
              if (/^\d+$/.test(match[3])) {
                debugPort = match[3];
              } else {
                debugHost = match[3];
              }
            } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
              debugOption = match[1];
              debugHost = match[3];
              debugPort = match[4];
            }
            if (debugOption && debugPort !== "0") {
              return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
            }
            return arg;
          });
        }
        function getCommandAndParents(startCommand) {
          const result = [];
          for (let command = startCommand; command; command = command.parent) {
            result.push(command);
          }
          return result;
        }
        exports2.Command = Command2;
      }
    });
    
    // node_modules/.pnpm/commander@10.0.1/node_modules/commander/index.js
    var require_commander = __commonJS({
      "node_modules/.pnpm/commander@10.0.1/node_modules/commander/index.js"(exports2, module2) {
        var { Argument: Argument2 } = require_argument();
        var { Command: Command2 } = require_command();
        var { CommanderError: CommanderError2, InvalidArgumentError: InvalidArgumentError2 } = require_error();
        var { Help: Help2 } = require_help();
        var { Option: Option2 } = require_option();
        exports2 = module2.exports = new Command2();
        exports2.program = exports2;
        exports2.Argument = Argument2;
        exports2.Command = Command2;
        exports2.CommanderError = CommanderError2;
        exports2.Help = Help2;
        exports2.InvalidArgumentError = InvalidArgumentError2;
        exports2.InvalidOptionArgumentError = InvalidArgumentError2;
        exports2.Option = Option2;
      }
    });
    
    // node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js
    var require_kind_of = __commonJS({
      "node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"(exports2, module2) {
        var toString = Object.prototype.toString;
        module2.exports = function kindOf(val) {
          if (val === void 0)
            return "undefined";
          if (val === null)
            return "null";
          var type = typeof val;
          if (type === "boolean")
            return "boolean";
          if (type === "string")
            return "string";
          if (type === "number")
            return "number";
          if (type === "symbol")
            return "symbol";
          if (type === "function") {
            return isGeneratorFn(val) ? "generatorfunction" : "function";
          }
          if (isArray(val))
            return "array";
          if (isBuffer(val))
            return "buffer";
          if (isArguments(val))
            return "arguments";
          if (isDate(val))
            return "date";
          if (isError(val))
            return "error";
          if (isRegexp(val))
            return "regexp";
          switch (ctorName(val)) {
            case "Symbol":
              return "symbol";
            case "Promise":
              return "promise";
            case "WeakMap":
              return "weakmap";
            case "WeakSet":
              return "weakset";
            case "Map":
              return "map";
            case "Set":
              return "set";
            case "Int8Array":
              return "int8array";
            case "Uint8Array":
              return "uint8array";
            case "Uint8ClampedArray":
              return "uint8clampedarray";
            case "Int16Array":
              return "int16array";
            case "Uint16Array":
              return "uint16array";
            case "Int32Array":
              return "int32array";
            case "Uint32Array":
              return "uint32array";
            case "Float32Array":
              return "float32array";
            case "Float64Array":
              return "float64array";
          }
          if (isGeneratorObj(val)) {
            return "generator";
          }
          type = toString.call(val);
          switch (type) {
            case "[object Object]":
              return "object";
            case "[object Map Iterator]":
              return "mapiterator";
            case "[object Set Iterator]":
              return "setiterator";
            case "[object String Iterator]":
              return "stringiterator";
            case "[object Array Iterator]":
              return "arrayiterator";
          }
          return type.slice(8, -1).toLowerCase().replace(/\s/g, "");
        };
        function ctorName(val) {
          return typeof val.constructor === "function" ? val.constructor.name : null;
        }
        function isArray(val) {
          if (Array.isArray)
            return Array.isArray(val);
          return val instanceof Array;
        }
        function isError(val) {
          return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
        }
        function isDate(val) {
          if (val instanceof Date)
            return true;
          return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
        }
        function isRegexp(val) {
          if (val instanceof RegExp)
            return true;
          return typeof val.flags === "string" && typeof val.ignoreCase === "boolean" && typeof val.multiline === "boolean" && typeof val.global === "boolean";
        }
        function isGeneratorFn(name, val) {
          return ctorName(name) === "GeneratorFunction";
        }
        function isGeneratorObj(val) {
          return typeof val.throw === "function" && typeof val.return === "function" && typeof val.next === "function";
        }
        function isArguments(val) {
          try {
            if (typeof val.length === "number" && typeof val.callee === "function") {
              return true;
            }
          } catch (err) {
            if (err.message.indexOf("callee") !== -1) {
              return true;
            }
          }
          return false;
        }
        function isBuffer(val) {
          if (val.constructor && typeof val.constructor.isBuffer === "function") {
            return val.constructor.isBuffer(val);
          }
          return false;
        }
      }
    });
    
    // node_modules/.pnpm/is-extendable@0.1.1/node_modules/is-extendable/index.js
    var require_is_extendable = __commonJS({
      "node_modules/.pnpm/is-extendable@0.1.1/node_modules/is-extendable/index.js"(exports2, module2) {
        "use strict";
        module2.exports = function isExtendable(val) {
          return typeof val !== "undefined" && val !== null && (typeof val === "object" || typeof val === "function");
        };
      }
    });
    
    // node_modules/.pnpm/extend-shallow@2.0.1/node_modules/extend-shallow/index.js
    var require_extend_shallow = __commonJS({
      "node_modules/.pnpm/extend-shallow@2.0.1/node_modules/extend-shallow/index.js"(exports2, module2) {
        "use strict";
        var isObject = require_is_extendable();
        module2.exports = function extend(o) {
          if (!isObject(o)) {
            o = {};
          }
          var len = arguments.length;
          for (var i = 1; i < len; i++) {
            var obj = arguments[i];
            if (isObject(obj)) {
              assign(o, obj);
            }
          }
          return o;
        };
        function assign(a, b) {
          for (var key in b) {
            if (hasOwn(b, key)) {
              a[key] = b[key];
            }
          }
        }
        function hasOwn(obj, key) {
          return Object.prototype.hasOwnProperty.call(obj, key);
        }
      }
    });
    
    // node_modules/.pnpm/section-matter@1.0.0/node_modules/section-matter/index.js
    var require_section_matter = __commonJS({
      "node_modules/.pnpm/section-matter@1.0.0/node_modules/section-matter/index.js"(exports2, module2) {
        "use strict";
        var typeOf = require_kind_of();
        var extend = require_extend_shallow();
        module2.exports = function(input, options2) {
          if (typeof options2 === "function") {
            options2 = { parse: options2 };
          }
          var file = toObject(input);
          var defaults = { section_delimiter: "---", parse: identity };
          var opts = extend({}, defaults, options2);
          var delim = opts.section_delimiter;
          var lines = file.content.split(/\r?\n/);
          var sections = null;
          var section = createSection();
          var content = [];
          var stack = [];
          function initSections(val) {
            file.content = val;
            sections = [];
            content = [];
          }
          function closeSection(val) {
            if (stack.length) {
              section.key = getKey(stack[0], delim);
              section.content = val;
              opts.parse(section, sections);
              sections.push(section);
              section = createSection();
              content = [];
              stack = [];
            }
          }
          for (var i = 0; i < lines.length; i++) {
            var line = lines[i];
            var len = stack.length;
            var ln = line.trim();
            if (isDelimiter(ln, delim)) {
              if (ln.length === 3 && i !== 0) {
                if (len === 0 || len === 2) {
                  content.push(line);
                  continue;
                }
                stack.push(ln);
                section.data = content.join("\n");
                content = [];
                continue;
              }
              if (sections === null) {
                initSections(content.join("\n"));
              }
              if (len === 2) {
                closeSection(content.join("\n"));
              }
              stack.push(ln);
              continue;
            }
            content.push(line);
          }
          if (sections === null) {
            initSections(content.join("\n"));
          } else {
            closeSection(content.join("\n"));
          }
          file.sections = sections;
          return file;
        };
        function isDelimiter(line, delim) {
          if (line.slice(0, delim.length) !== delim) {
            return false;
          }
          if (line.charAt(delim.length + 1) === delim.slice(-1)) {
            return false;
          }
          return true;
        }
        function toObject(input) {
          if (typeOf(input) !== "object") {
            input = { content: input };
          }
          if (typeof input.content !== "string" && !isBuffer(input.content)) {
            throw new TypeError("expected a buffer or string");
          }
          input.content = input.content.toString();
          input.sections = [];
          return input;
        }
        function getKey(val, delim) {
          return val ? val.slice(delim.length).trim() : "";
        }
        function createSection() {
          return { key: "", data: "", content: "" };
        }
        function identity(val) {
          return val;
        }
        function isBuffer(val) {
          if (val && val.constructor && typeof val.constructor.isBuffer === "function") {
            return val.constructor.isBuffer(val);
          }
          return false;
        }
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/common.js
    var require_common = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/common.js"(exports2, module2) {
        "use strict";
        function isNothing(subject) {
          return typeof subject === "undefined" || subject === null;
        }
        function isObject(subject) {
          return typeof subject === "object" && subject !== null;
        }
        function toArray(sequence) {
          if (Array.isArray(sequence))
            return sequence;
          else if (isNothing(sequence))
            return [];
          return [sequence];
        }
        function extend(target, source) {
          var index, length, key, sourceKeys;
          if (source) {
            sourceKeys = Object.keys(source);
            for (index = 0, length = sourceKeys.length; index < length; index += 1) {
              key = sourceKeys[index];
              target[key] = source[key];
            }
          }
          return target;
        }
        function repeat(string, count) {
          var result = "", cycle;
          for (cycle = 0; cycle < count; cycle += 1) {
            result += string;
          }
          return result;
        }
        function isNegativeZero(number) {
          return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
        }
        module2.exports.isNothing = isNothing;
        module2.exports.isObject = isObject;
        module2.exports.toArray = toArray;
        module2.exports.repeat = repeat;
        module2.exports.isNegativeZero = isNegativeZero;
        module2.exports.extend = extend;
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/exception.js
    var require_exception = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/exception.js"(exports2, module2) {
        "use strict";
        function YAMLException(reason, mark) {
          Error.call(this);
          this.name = "YAMLException";
          this.reason = reason;
          this.mark = mark;
          this.message = (this.reason || "(unknown reason)") + (this.mark ? " " + this.mark.toString() : "");
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, this.constructor);
          } else {
            this.stack = new Error().stack || "";
          }
        }
        YAMLException.prototype = Object.create(Error.prototype);
        YAMLException.prototype.constructor = YAMLException;
        YAMLException.prototype.toString = function toString(compact) {
          var result = this.name + ": ";
          result += this.reason || "(unknown reason)";
          if (!compact && this.mark) {
            result += " " + this.mark.toString();
          }
          return result;
        };
        module2.exports = YAMLException;
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/mark.js
    var require_mark = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/mark.js"(exports2, module2) {
        "use strict";
        var common = require_common();
        function Mark(name, buffer, position, line, column) {
          this.name = name;
          this.buffer = buffer;
          this.position = position;
          this.line = line;
          this.column = column;
        }
        Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
          var head, start, tail, end, snippet;
          if (!this.buffer)
            return null;
          indent = indent || 4;
          maxLength = maxLength || 75;
          head = "";
          start = this.position;
          while (start > 0 && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(start - 1)) === -1) {
            start -= 1;
            if (this.position - start > maxLength / 2 - 1) {
              head = " ... ";
              start += 5;
              break;
            }
          }
          tail = "";
          end = this.position;
          while (end < this.buffer.length && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(end)) === -1) {
            end += 1;
            if (end - this.position > maxLength / 2 - 1) {
              tail = " ... ";
              end -= 5;
              break;
            }
          }
          snippet = this.buffer.slice(start, end);
          return common.repeat(" ", indent) + head + snippet + tail + "\n" + common.repeat(" ", indent + this.position - start + head.length) + "^";
        };
        Mark.prototype.toString = function toString(compact) {
          var snippet, where = "";
          if (this.name) {
            where += 'in "' + this.name + '" ';
          }
          where += "at line " + (this.line + 1) + ", column " + (this.column + 1);
          if (!compact) {
            snippet = this.getSnippet();
            if (snippet) {
              where += ":\n" + snippet;
            }
          }
          return where;
        };
        module2.exports = Mark;
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type.js
    var require_type = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type.js"(exports2, module2) {
        "use strict";
        var YAMLException = require_exception();
        var TYPE_CONSTRUCTOR_OPTIONS = [
          "kind",
          "resolve",
          "construct",
          "instanceOf",
          "predicate",
          "represent",
          "defaultStyle",
          "styleAliases"
        ];
        var YAML_NODE_KINDS = [
          "scalar",
          "sequence",
          "mapping"
        ];
        function compileStyleAliases(map) {
          var result = {};
          if (map !== null) {
            Object.keys(map).forEach(function(style) {
              map[style].forEach(function(alias) {
                result[String(alias)] = style;
              });
            });
          }
          return result;
        }
        function Type(tag, options2) {
          options2 = options2 || {};
          Object.keys(options2).forEach(function(name) {
            if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
              throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
            }
          });
          this.tag = tag;
          this.kind = options2["kind"] || null;
          this.resolve = options2["resolve"] || function() {
            return true;
          };
          this.construct = options2["construct"] || function(data) {
            return data;
          };
          this.instanceOf = options2["instanceOf"] || null;
          this.predicate = options2["predicate"] || null;
          this.represent = options2["represent"] || null;
          this.defaultStyle = options2["defaultStyle"] || null;
          this.styleAliases = compileStyleAliases(options2["styleAliases"] || null);
          if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
            throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
          }
        }
        module2.exports = Type;
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema.js
    var require_schema = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema.js"(exports2, module2) {
        "use strict";
        var common = require_common();
        var YAMLException = require_exception();
        var Type = require_type();
        function compileList(schema, name, result) {
          var exclude = [];
          schema.include.forEach(function(includedSchema) {
            result = compileList(includedSchema, name, result);
          });
          schema[name].forEach(function(currentType) {
            result.forEach(function(previousType, previousIndex) {
              if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
                exclude.push(previousIndex);
              }
            });
            result.push(currentType);
          });
          return result.filter(function(type, index) {
            return exclude.indexOf(index) === -1;
          });
        }
        function compileMap() {
          var result = {
            scalar: {},
            sequence: {},
            mapping: {},
            fallback: {}
          }, index, length;
          function collectType(type) {
            result[type.kind][type.tag] = result["fallback"][type.tag] = type;
          }
          for (index = 0, length = arguments.length; index < length; index += 1) {
            arguments[index].forEach(collectType);
          }
          return result;
        }
        function Schema(definition) {
          this.include = definition.include || [];
          this.implicit = definition.implicit || [];
          this.explicit = definition.explicit || [];
          this.implicit.forEach(function(type) {
            if (type.loadKind && type.loadKind !== "scalar") {
              throw new YAMLException("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
            }
          });
          this.compiledImplicit = compileList(this, "implicit", []);
          this.compiledExplicit = compileList(this, "explicit", []);
          this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
        }
        Schema.DEFAULT = null;
        Schema.create = function createSchema() {
          var schemas, types;
          switch (arguments.length) {
            case 1:
              schemas = Schema.DEFAULT;
              types = arguments[0];
              break;
            case 2:
              schemas = arguments[0];
              types = arguments[1];
              break;
            default:
              throw new YAMLException("Wrong number of arguments for Schema.create function");
          }
          schemas = common.toArray(schemas);
          types = common.toArray(types);
          if (!schemas.every(function(schema) {
            return schema instanceof Schema;
          })) {
            throw new YAMLException("Specified list of super schemas (or a single Schema object) contains a non-Schema object.");
          }
          if (!types.every(function(type) {
            return type instanceof Type;
          })) {
            throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
          }
          return new Schema({
            include: schemas,
            explicit: types
          });
        };
        module2.exports = Schema;
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/str.js
    var require_str = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/str.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        module2.exports = new Type("tag:yaml.org,2002:str", {
          kind: "scalar",
          construct: function(data) {
            return data !== null ? data : "";
          }
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/seq.js
    var require_seq = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/seq.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        module2.exports = new Type("tag:yaml.org,2002:seq", {
          kind: "sequence",
          construct: function(data) {
            return data !== null ? data : [];
          }
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/map.js
    var require_map = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/map.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        module2.exports = new Type("tag:yaml.org,2002:map", {
          kind: "mapping",
          construct: function(data) {
            return data !== null ? data : {};
          }
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js
    var require_failsafe = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js"(exports2, module2) {
        "use strict";
        var Schema = require_schema();
        module2.exports = new Schema({
          explicit: [
            require_str(),
            require_seq(),
            require_map()
          ]
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/null.js
    var require_null = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/null.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        function resolveYamlNull(data) {
          if (data === null)
            return true;
          var max = data.length;
          return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
        }
        function constructYamlNull() {
          return null;
        }
        function isNull(object) {
          return object === null;
        }
        module2.exports = new Type("tag:yaml.org,2002:null", {
          kind: "scalar",
          resolve: resolveYamlNull,
          construct: constructYamlNull,
          predicate: isNull,
          represent: {
            canonical: function() {
              return "~";
            },
            lowercase: function() {
              return "null";
            },
            uppercase: function() {
              return "NULL";
            },
            camelcase: function() {
              return "Null";
            }
          },
          defaultStyle: "lowercase"
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/bool.js
    var require_bool = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/bool.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        function resolveYamlBoolean(data) {
          if (data === null)
            return false;
          var max = data.length;
          return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
        }
        function constructYamlBoolean(data) {
          return data === "true" || data === "True" || data === "TRUE";
        }
        function isBoolean(object) {
          return Object.prototype.toString.call(object) === "[object Boolean]";
        }
        module2.exports = new Type("tag:yaml.org,2002:bool", {
          kind: "scalar",
          resolve: resolveYamlBoolean,
          construct: constructYamlBoolean,
          predicate: isBoolean,
          represent: {
            lowercase: function(object) {
              return object ? "true" : "false";
            },
            uppercase: function(object) {
              return object ? "TRUE" : "FALSE";
            },
            camelcase: function(object) {
              return object ? "True" : "False";
            }
          },
          defaultStyle: "lowercase"
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/int.js
    var require_int = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/int.js"(exports2, module2) {
        "use strict";
        var common = require_common();
        var Type = require_type();
        function isHexCode(c) {
          return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
        }
        function isOctCode(c) {
          return 48 <= c && c <= 55;
        }
        function isDecCode(c) {
          return 48 <= c && c <= 57;
        }
        function resolveYamlInteger(data) {
          if (data === null)
            return false;
          var max = data.length, index = 0, hasDigits = false, ch;
          if (!max)
            return false;
          ch = data[index];
          if (ch === "-" || ch === "+") {
            ch = data[++index];
          }
          if (ch === "0") {
            if (index + 1 === max)
              return true;
            ch = data[++index];
            if (ch === "b") {
              index++;
              for (; index < max; index++) {
                ch = data[index];
                if (ch === "_")
                  continue;
                if (ch !== "0" && ch !== "1")
                  return false;
                hasDigits = true;
              }
              return hasDigits && ch !== "_";
            }
            if (ch === "x") {
              index++;
              for (; index < max; index++) {
                ch = data[index];
                if (ch === "_")
                  continue;
                if (!isHexCode(data.charCodeAt(index)))
                  return false;
                hasDigits = true;
              }
              return hasDigits && ch !== "_";
            }
            for (; index < max; index++) {
              ch = data[index];
              if (ch === "_")
                continue;
              if (!isOctCode(data.charCodeAt(index)))
                return false;
              hasDigits = true;
            }
            return hasDigits && ch !== "_";
          }
          if (ch === "_")
            return false;
          for (; index < max; index++) {
            ch = data[index];
            if (ch === "_")
              continue;
            if (ch === ":")
              break;
            if (!isDecCode(data.charCodeAt(index))) {
              return false;
            }
            hasDigits = true;
          }
          if (!hasDigits || ch === "_")
            return false;
          if (ch !== ":")
            return true;
          return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
        }
        function constructYamlInteger(data) {
          var value = data, sign = 1, ch, base, digits = [];
          if (value.indexOf("_") !== -1) {
            value = value.replace(/_/g, "");
          }
          ch = value[0];
          if (ch === "-" || ch === "+") {
            if (ch === "-")
              sign = -1;
            value = value.slice(1);
            ch = value[0];
          }
          if (value === "0")
            return 0;
          if (ch === "0") {
            if (value[1] === "b")
              return sign * parseInt(value.slice(2), 2);
            if (value[1] === "x")
              return sign * parseInt(value, 16);
            return sign * parseInt(value, 8);
          }
          if (value.indexOf(":") !== -1) {
            value.split(":").forEach(function(v) {
              digits.unshift(parseInt(v, 10));
            });
            value = 0;
            base = 1;
            digits.forEach(function(d) {
              value += d * base;
              base *= 60;
            });
            return sign * value;
          }
          return sign * parseInt(value, 10);
        }
        function isInteger(object) {
          return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object));
        }
        module2.exports = new Type("tag:yaml.org,2002:int", {
          kind: "scalar",
          resolve: resolveYamlInteger,
          construct: constructYamlInteger,
          predicate: isInteger,
          represent: {
            binary: function(obj) {
              return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
            },
            octal: function(obj) {
              return obj >= 0 ? "0" + obj.toString(8) : "-0" + obj.toString(8).slice(1);
            },
            decimal: function(obj) {
              return obj.toString(10);
            },
            /* eslint-disable max-len */
            hexadecimal: function(obj) {
              return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
            }
          },
          defaultStyle: "decimal",
          styleAliases: {
            binary: [2, "bin"],
            octal: [8, "oct"],
            decimal: [10, "dec"],
            hexadecimal: [16, "hex"]
          }
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/float.js
    var require_float = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/float.js"(exports2, module2) {
        "use strict";
        var common = require_common();
        var Type = require_type();
        var YAML_FLOAT_PATTERN = new RegExp(
          // 2.5e4, 2.5 and integers
          "^(?:[-+]?(?: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))$"
        );
        function resolveYamlFloat(data) {
          if (data === null)
            return false;
          if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_`
          // Probably should update regexp & check speed
          data[data.length - 1] === "_") {
            return false;
          }
          return true;
        }
        function constructYamlFloat(data) {
          var value, sign, base, digits;
          value = data.replace(/_/g, "").toLowerCase();
          sign = value[0] === "-" ? -1 : 1;
          digits = [];
          if ("+-".indexOf(value[0]) >= 0) {
            value = value.slice(1);
          }
          if (value === ".inf") {
            return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
          } else if (value === ".nan") {
            return NaN;
          } else if (value.indexOf(":") >= 0) {
            value.split(":").forEach(function(v) {
              digits.unshift(parseFloat(v, 10));
            });
            value = 0;
            base = 1;
            digits.forEach(function(d) {
              value += d * base;
              base *= 60;
            });
            return sign * value;
          }
          return sign * parseFloat(value, 10);
        }
        var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
        function representYamlFloat(object, style) {
          var res;
          if (isNaN(object)) {
            switch (style) {
              case "lowercase":
                return ".nan";
              case "uppercase":
                return ".NAN";
              case "camelcase":
                return ".NaN";
            }
          } else if (Number.POSITIVE_INFINITY === object) {
            switch (style) {
              case "lowercase":
                return ".inf";
              case "uppercase":
                return ".INF";
              case "camelcase":
                return ".Inf";
            }
          } else if (Number.NEGATIVE_INFINITY === object) {
            switch (style) {
              case "lowercase":
                return "-.inf";
              case "uppercase":
                return "-.INF";
              case "camelcase":
                return "-.Inf";
            }
          } else if (common.isNegativeZero(object)) {
            return "-0.0";
          }
          res = object.toString(10);
          return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
        }
        function isFloat(object) {
          return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
        }
        module2.exports = new Type("tag:yaml.org,2002:float", {
          kind: "scalar",
          resolve: resolveYamlFloat,
          construct: constructYamlFloat,
          predicate: isFloat,
          represent: representYamlFloat,
          defaultStyle: "lowercase"
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/json.js
    var require_json = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/json.js"(exports2, module2) {
        "use strict";
        var Schema = require_schema();
        module2.exports = new Schema({
          include: [
            require_failsafe()
          ],
          implicit: [
            require_null(),
            require_bool(),
            require_int(),
            require_float()
          ]
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/core.js
    var require_core = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/core.js"(exports2, module2) {
        "use strict";
        var Schema = require_schema();
        module2.exports = new Schema({
          include: [
            require_json()
          ]
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/timestamp.js
    var require_timestamp = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/timestamp.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        var YAML_DATE_REGEXP = new RegExp(
          "^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"
        );
        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]))?))?$"
        );
        function resolveYamlTimestamp(data) {
          if (data === null)
            return false;
          if (YAML_DATE_REGEXP.exec(data) !== null)
            return true;
          if (YAML_TIMESTAMP_REGEXP.exec(data) !== null)
            return true;
          return false;
        }
        function constructYamlTimestamp(data) {
          var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
          match = YAML_DATE_REGEXP.exec(data);
          if (match === null)
            match = YAML_TIMESTAMP_REGEXP.exec(data);
          if (match === null)
            throw new Error("Date resolve error");
          year = +match[1];
          month = +match[2] - 1;
          day = +match[3];
          if (!match[4]) {
            return new Date(Date.UTC(year, month, day));
          }
          hour = +match[4];
          minute = +match[5];
          second = +match[6];
          if (match[7]) {
            fraction = match[7].slice(0, 3);
            while (fraction.length < 3) {
              fraction += "0";
            }
            fraction = +fraction;
          }
          if (match[9]) {
            tz_hour = +match[10];
            tz_minute = +(match[11] || 0);
            delta = (tz_hour * 60 + tz_minute) * 6e4;
            if (match[9] === "-")
              delta = -delta;
          }
          date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
          if (delta)
            date.setTime(date.getTime() - delta);
          return date;
        }
        function representYamlTimestamp(object) {
          return object.toISOString();
        }
        module2.exports = new Type("tag:yaml.org,2002:timestamp", {
          kind: "scalar",
          resolve: resolveYamlTimestamp,
          construct: constructYamlTimestamp,
          instanceOf: Date,
          represent: representYamlTimestamp
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/merge.js
    var require_merge = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/merge.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        function resolveYamlMerge(data) {
          return data === "<<" || data === null;
        }
        module2.exports = new Type("tag:yaml.org,2002:merge", {
          kind: "scalar",
          resolve: resolveYamlMerge
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/binary.js
    var require_binary = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/binary.js"(exports2, module2) {
        "use strict";
        var NodeBuffer;
        try {
          _require = require;
          NodeBuffer = _require("buffer").Buffer;
        } catch (__) {
        }
        var _require;
        var Type = require_type();
        var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
        function resolveYamlBinary(data) {
          if (data === null)
            return false;
          var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
          for (idx = 0; idx < max; idx++) {
            code = map.indexOf(data.charAt(idx));
            if (code > 64)
              continue;
            if (code < 0)
              return false;
            bitlen += 6;
          }
          return bitlen % 8 === 0;
        }
        function constructYamlBinary(data) {
          var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map = BASE64_MAP, bits = 0, result = [];
          for (idx = 0; idx < max; idx++) {
            if (idx % 4 === 0 && idx) {
              result.push(bits >> 16 & 255);
              result.push(bits >> 8 & 255);
              result.push(bits & 255);
            }
            bits = bits << 6 | map.indexOf(input.charAt(idx));
          }
          tailbits = max % 4 * 6;
          if (tailbits === 0) {
            result.push(bits >> 16 & 255);
            result.push(bits >> 8 & 255);
            result.push(bits & 255);
          } else if (tailbits === 18) {
            result.push(bits >> 10 & 255);
            result.push(bits >> 2 & 255);
          } else if (tailbits === 12) {
            result.push(bits >> 4 & 255);
          }
          if (NodeBuffer) {
            return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
          }
          return result;
        }
        function representYamlBinary(object) {
          var result = "", bits = 0, idx, tail, max = object.length, map = BASE64_MAP;
          for (idx = 0; idx < max; idx++) {
            if (idx % 3 === 0 && idx) {
              result += map[bits >> 18 & 63];
              result += map[bits >> 12 & 63];
              result += map[bits >> 6 & 63];
              result += map[bits & 63];
            }
            bits = (bits << 8) + object[idx];
          }
          tail = max % 3;
          if (tail === 0) {
            result += map[bits >> 18 & 63];
            result += map[bits >> 12 & 63];
            result += map[bits >> 6 & 63];
            result += map[bits & 63];
          } else if (tail === 2) {
            result += map[bits >> 10 & 63];
            result += map[bits >> 4 & 63];
            result += map[bits << 2 & 63];
            result += map[64];
          } else if (tail === 1) {
            result += map[bits >> 2 & 63];
            result += map[bits << 4 & 63];
            result += map[64];
            result += map[64];
          }
          return result;
        }
        function isBinary(object) {
          return NodeBuffer && NodeBuffer.isBuffer(object);
        }
        module2.exports = new Type("tag:yaml.org,2002:binary", {
          kind: "scalar",
          resolve: resolveYamlBinary,
          construct: constructYamlBinary,
          predicate: isBinary,
          represent: representYamlBinary
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/omap.js
    var require_omap = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/omap.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        var _hasOwnProperty = Object.prototype.hasOwnProperty;
        var _toString = Object.prototype.toString;
        function resolveYamlOmap(data) {
          if (data === null)
            return true;
          var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data;
          for (index = 0, length = object.length; index < length; index += 1) {
            pair = object[index];
            pairHasKey = false;
            if (_toString.call(pair) !== "[object Object]")
              return false;
            for (pairKey in pair) {
              if (_hasOwnProperty.call(pair, pairKey)) {
                if (!pairHasKey)
                  pairHasKey = true;
                else
                  return false;
              }
            }
            if (!pairHasKey)
              return false;
            if (objectKeys.indexOf(pairKey) === -1)
              objectKeys.push(pairKey);
            else
              return false;
          }
          return true;
        }
        function constructYamlOmap(data) {
          return data !== null ? data : [];
        }
        module2.exports = new Type("tag:yaml.org,2002:omap", {
          kind: "sequence",
          resolve: resolveYamlOmap,
          construct: constructYamlOmap
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/pairs.js
    var require_pairs = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/pairs.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        var _toString = Object.prototype.toString;
        function resolveYamlPairs(data) {
          if (data === null)
            return true;
          var index, length, pair, keys, result, object = data;
          result = new Array(object.length);
          for (index = 0, length = object.length; index < length; index += 1) {
            pair = object[index];
            if (_toString.call(pair) !== "[object Object]")
              return false;
            keys = Object.keys(pair);
            if (keys.length !== 1)
              return false;
            result[index] = [keys[0], pair[keys[0]]];
          }
          return true;
        }
        function constructYamlPairs(data) {
          if (data === null)
            return [];
          var index, length, pair, keys, result, object = data;
          result = new Array(object.length);
          for (index = 0, length = object.length; index < length; index += 1) {
            pair = object[index];
            keys = Object.keys(pair);
            result[index] = [keys[0], pair[keys[0]]];
          }
          return result;
        }
        module2.exports = new Type("tag:yaml.org,2002:pairs", {
          kind: "sequence",
          resolve: resolveYamlPairs,
          construct: constructYamlPairs
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/set.js
    var require_set = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/set.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        var _hasOwnProperty = Object.prototype.hasOwnProperty;
        function resolveYamlSet(data) {
          if (data === null)
            return true;
          var key, object = data;
          for (key in object) {
            if (_hasOwnProperty.call(object, key)) {
              if (object[key] !== null)
                return false;
            }
          }
          return true;
        }
        function constructYamlSet(data) {
          return data !== null ? data : {};
        }
        module2.exports = new Type("tag:yaml.org,2002:set", {
          kind: "mapping",
          resolve: resolveYamlSet,
          construct: constructYamlSet
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js
    var require_default_safe = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js"(exports2, module2) {
        "use strict";
        var Schema = require_schema();
        module2.exports = new Schema({
          include: [
            require_core()
          ],
          implicit: [
            require_timestamp(),
            require_merge()
          ],
          explicit: [
            require_binary(),
            require_omap(),
            require_pairs(),
            require_set()
          ]
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js
    var require_undefined = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        function resolveJavascriptUndefined() {
          return true;
        }
        function constructJavascriptUndefined() {
          return void 0;
        }
        function representJavascriptUndefined() {
          return "";
        }
        function isUndefined(object) {
          return typeof object === "undefined";
        }
        module2.exports = new Type("tag:yaml.org,2002:js/undefined", {
          kind: "scalar",
          resolve: resolveJavascriptUndefined,
          construct: constructJavascriptUndefined,
          predicate: isUndefined,
          represent: representJavascriptUndefined
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js
    var require_regexp = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js"(exports2, module2) {
        "use strict";
        var Type = require_type();
        function resolveJavascriptRegExp(data) {
          if (data === null)
            return false;
          if (data.length === 0)
            return false;
          var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = "";
          if (regexp[0] === "/") {
            if (tail)
              modifiers = tail[1];
            if (modifiers.length > 3)
              return false;
            if (regexp[regexp.length - modifiers.length - 1] !== "/")
              return false;
          }
          return true;
        }
        function constructJavascriptRegExp(data) {
          var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = "";
          if (regexp[0] === "/") {
            if (tail)
              modifiers = tail[1];
            regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
          }
          return new RegExp(regexp, modifiers);
        }
        function representJavascriptRegExp(object) {
          var result = "/" + object.source + "/";
          if (object.global)
            result += "g";
          if (object.multiline)
            result += "m";
          if (object.ignoreCase)
            result += "i";
          return result;
        }
        function isRegExp(object) {
          return Object.prototype.toString.call(object) === "[object RegExp]";
        }
        module2.exports = new Type("tag:yaml.org,2002:js/regexp", {
          kind: "scalar",
          resolve: resolveJavascriptRegExp,
          construct: constructJavascriptRegExp,
          predicate: isRegExp,
          represent: representJavascriptRegExp
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/function.js
    var require_function = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/type/js/function.js"(exports2, module2) {
        "use strict";
        var esprima;
        try {
          _require = require;
          esprima = _require("esprima");
        } catch (_) {
          if (typeof window !== "undefined")
            esprima = window.esprima;
        }
        var _require;
        var Type = require_type();
        function resolveJavascriptFunction(data) {
          if (data === null)
            return false;
          try {
            var source = "(" + data + ")", ast = esprima.parse(source, { range: true });
            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") {
              return false;
            }
            return true;
          } catch (err) {
            return false;
          }
        }
        function constructJavascriptFunction(data) {
          var source = "(" + data + ")", ast = esprima.parse(source, { range: true }), params = [], body;
          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") {
            throw new Error("Failed to resolve function");
          }
          ast.body[0].expression.params.forEach(function(param) {
            params.push(param.name);
          });
          body = ast.body[0].expression.body.range;
          if (ast.body[0].expression.body.type === "BlockStatement") {
            return new Function(params, source.slice(body[0] + 1, body[1] - 1));
          }
          return new Function(params, "return " + source.slice(body[0], body[1]));
        }
        function representJavascriptFunction(object) {
          return object.toString();
        }
        function isFunction(object) {
          return Object.prototype.toString.call(object) === "[object Function]";
        }
        module2.exports = new Type("tag:yaml.org,2002:js/function", {
          kind: "scalar",
          resolve: resolveJavascriptFunction,
          construct: constructJavascriptFunction,
          predicate: isFunction,
          represent: representJavascriptFunction
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_full.js
    var require_default_full = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/schema/default_full.js"(exports2, module2) {
        "use strict";
        var Schema = require_schema();
        module2.exports = Schema.DEFAULT = new Schema({
          include: [
            require_default_safe()
          ],
          explicit: [
            require_undefined(),
            require_regexp(),
            require_function()
          ]
        });
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/loader.js
    var require_loader = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/loader.js"(exports2, module2) {
        "use strict";
        var common = require_common();
        var YAMLException = require_exception();
        var Mark = require_mark();
        var DEFAULT_SAFE_SCHEMA = require_default_safe();
        var DEFAULT_FULL_SCHEMA = require_default_full();
        var _hasOwnProperty = Object.prototype.hasOwnProperty;
        var CONTEXT_FLOW_IN = 1;
        var CONTEXT_FLOW_OUT = 2;
        var CONTEXT_BLOCK_IN = 3;
        var CONTEXT_BLOCK_OUT = 4;
        var CHOMPING_CLIP = 1;
        var CHOMPING_STRIP = 2;
        var CHOMPING_KEEP = 3;
        var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
        var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
        var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
        var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
        var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
        function _class(obj) {
          return Object.prototype.toString.call(obj);
        }
        function is_EOL(c) {
          return c === 10 || c === 13;
        }
        function is_WHITE_SPACE(c) {
          return c === 9 || c === 32;
        }
        function is_WS_OR_EOL(c) {
          return c === 9 || c === 32 || c === 10 || c === 13;
        }
        function is_FLOW_INDICATOR(c) {
          return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
        }
        function fromHexCode(c) {
          var lc;
          if (48 <= c && c <= 57) {
            return c - 48;
          }
          lc = c | 32;
          if (97 <= lc && lc <= 102) {
            return lc - 97 + 10;
          }
          return -1;
        }
        function escapedHexLen(c) {
          if (c === 120) {
            return 2;
          }
          if (c === 117) {
            return 4;
          }
          if (c === 85) {
            return 8;
          }
          return 0;
        }
        function fromDecimalCode(c) {
          if (48 <= c && c <= 57) {
            return c - 48;
          }
          return -1;
        }
        function simpleEscapeSequence(c) {
          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 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "\x85" : c === 95 ? "\xA0" : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
        }
        function charFromCodepoint(c) {
          if (c <= 65535) {
            return String.fromCharCode(c);
          }
          return String.fromCharCode(
            (c - 65536 >> 10) + 55296,
            (c - 65536 & 1023) + 56320
          );
        }
        var simpleEscapeCheck = new Array(256);
        var simpleEscapeMap = new Array(256);
        for (i = 0; i < 256; i++) {
          simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
          simpleEscapeMap[i] = simpleEscapeSequence(i);
        }
        var i;
        function State(input, options2) {
          this.input = input;
          this.filename = options2["filename"] || null;
          this.schema = options2["schema"] || DEFAULT_FULL_SCHEMA;
          this.onWarning = options2["onWarning"] || null;
          this.legacy = options2["legacy"] || false;
          this.json = options2["json"] || false;
          this.listener = options2["listener"] || null;
          this.implicitTypes = this.schema.compiledImplicit;
          this.typeMap = this.schema.compiledTypeMap;
          this.length = input.length;
          this.position = 0;
          this.line = 0;
          this.lineStart = 0;
          this.lineIndent = 0;
          this.documents = [];
        }
        function generateError(state, message) {
          return new YAMLException(
            message,
            new Mark(state.filename, state.input, state.position, state.line, state.position - state.lineStart)
          );
        }
        function throwError(state, message) {
          throw generateError(state, message);
        }
        function throwWarning(state, message) {
          if (state.onWarning) {
            state.onWarning.call(null, generateError(state, message));
          }
        }
        var directiveHandlers = {
          YAML: function handleYamlDirective(state, name, args) {
            var match, major, minor;
            if (state.version !== null) {
              throwError(state, "duplication of %YAML directive");
            }
            if (args.length !== 1) {
              throwError(state, "YAML directive accepts exactly one argument");
            }
            match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
            if (match === null) {
              throwError(state, "ill-formed argument of the YAML directive");
            }
            major = parseInt(match[1], 10);
            minor = parseInt(match[2], 10);
            if (major !== 1) {
              throwError(state, "unacceptable YAML version of the document");
            }
            state.version = args[0];
            state.checkLineBreaks = minor < 2;
            if (minor !== 1 && minor !== 2) {
              throwWarning(state, "unsupported YAML version of the document");
            }
          },
          TAG: function handleTagDirective(state, name, args) {
            var handle, prefix;
            if (args.length !== 2) {
              throwError(state, "TAG directive accepts exactly two arguments");
            }
            handle = args[0];
            prefix = args[1];
            if (!PATTERN_TAG_HANDLE.test(handle)) {
              throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
            }
            if (_hasOwnProperty.call(state.tagMap, handle)) {
              throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
            }
            if (!PATTERN_TAG_URI.test(prefix)) {
              throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
            }
            state.tagMap[handle] = prefix;
          }
        };
        function captureSegment(state, start, end, checkJson) {
          var _position, _length, _character, _result;
          if (start < end) {
            _result = state.input.slice(start, end);
            if (checkJson) {
              for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
                _character = _result.charCodeAt(_position);
                if (!(_character === 9 || 32 <= _character && _character <= 1114111)) {
                  throwError(state, "expected valid JSON character");
                }
              }
            } else if (PATTERN_NON_PRINTABLE.test(_result)) {
              throwError(state, "the stream contains non-printable characters");
            }
            state.result += _result;
          }
        }
        function mergeMappings(state, destination, source, overridableKeys) {
          var sourceKeys, key, index, quantity;
          if (!common.isObject(source)) {
            throwError(state, "cannot merge mappings; the provided source object is unacceptable");
          }
          sourceKeys = Object.keys(source);
          for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
            key = sourceKeys[index];
            if (!_hasOwnProperty.call(destination, key)) {
              destination[key] = source[key];
              overridableKeys[key] = true;
            }
          }
        }
        function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
          var index, quantity;
          if (Array.isArray(keyNode)) {
            keyNode = Array.prototype.slice.call(keyNode);
            for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
              if (Array.isArray(keyNode[index])) {
                throwError(state, "nested arrays are not supported inside keys");
              }
              if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") {
                keyNode[index] = "[object Object]";
              }
            }
          }
          if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") {
            keyNode = "[object Object]";
          }
          keyNode = String(keyNode);
          if (_result === null) {
            _result = {};
          }
          if (keyTag === "tag:yaml.org,2002:merge") {
            if (Array.isArray(valueNode)) {
              for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
                mergeMappings(state, _result, valueNode[index], overridableKeys);
              }
            } else {
              mergeMappings(state, _result, valueNode, overridableKeys);
            }
          } else {
            if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
              state.line = startLine || state.line;
              state.position = startPos || state.position;
              throwError(state, "duplicated mapping key");
            }
            _result[keyNode] = valueNode;
            delete overridableKeys[keyNode];
          }
          return _result;
        }
        function readLineBreak(state) {
          var ch;
          ch = state.input.charCodeAt(state.position);
          if (ch === 10) {
            state.position++;
          } else if (ch === 13) {
            state.position++;
            if (state.input.charCodeAt(state.position) === 10) {
              state.position++;
            }
          } else {
            throwError(state, "a line break is expected");
          }
          state.line += 1;
          state.lineStart = state.position;
        }
        function skipSeparationSpace(state, allowComments, checkIndent) {
          var lineBreaks = 0, ch = state.input.charCodeAt(state.position);
          while (ch !== 0) {
            while (is_WHITE_SPACE(ch)) {
              ch = state.input.charCodeAt(++state.position);
            }
            if (allowComments && ch === 35) {
              do {
                ch = state.input.charCodeAt(++state.position);
              } while (ch !== 10 && ch !== 13 && ch !== 0);
            }
            if (is_EOL(ch)) {
              readLineBreak(state);
              ch = state.input.charCodeAt(state.position);
              lineBreaks++;
              state.lineIndent = 0;
              while (ch === 32) {
                state.lineIndent++;
                ch = state.input.charCodeAt(++state.position);
              }
            } else {
              break;
            }
          }
          if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
            throwWarning(state, "deficient indentation");
          }
          return lineBreaks;
        }
        function testDocumentSeparator(state) {
          var _position = state.position, ch;
          ch = state.input.charCodeAt(_position);
          if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
            _position += 3;
            ch = state.input.charCodeAt(_position);
            if (ch === 0 || is_WS_OR_EOL(ch)) {
              return true;
            }
          }
          return false;
        }
        function writeFoldedLines(state, count) {
          if (count === 1) {
            state.result += " ";
          } else if (count > 1) {
            state.result += common.repeat("\n", count - 1);
          }
        }
        function readPlainScalar(state, nodeIndent, withinFlowCollection) {
          var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch;
          ch = state.input.charCodeAt(state.position);
          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) {
            return false;
          }
          if (ch === 63 || ch === 45) {
            following = state.input.charCodeAt(state.position + 1);
            if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
              return false;
            }
          }
          state.kind = "scalar";
          state.result = "";
          captureStart = captureEnd = state.position;
          hasPendingContent = false;
          while (ch !== 0) {
            if (ch === 58) {
              following = state.input.charCodeAt(state.position + 1);
              if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
                break;
              }
            } else if (ch === 35) {
              preceding = state.input.charCodeAt(state.position - 1);
              if (is_WS_OR_EOL(preceding)) {
                break;
              }
            } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) {
              break;
            } else if (is_EOL(ch)) {
              _line = state.line;
              _lineStart = state.lineStart;
              _lineIndent = state.lineIndent;
              skipSeparationSpace(state, false, -1);
              if (state.lineIndent >= nodeIndent) {
                hasPendingContent = true;
                ch = state.input.charCodeAt(state.position);
                continue;
              } else {
                state.position = captureEnd;
                state.line = _line;
                state.lineStart = _lineStart;
                state.lineIndent = _lineIndent;
                break;
              }
            }
            if (hasPendingContent) {
              captureSegment(state, captureStart, captureEnd, false);
              writeFoldedLines(state, state.line - _line);
              captureStart = captureEnd = state.position;
              hasPendingContent = false;
            }
            if (!is_WHITE_SPACE(ch)) {
              captureEnd = state.position + 1;
            }
            ch = state.input.charCodeAt(++state.position);
          }
          captureSegment(state, captureStart, captureEnd, false);
          if (state.result) {
            return true;
          }
          state.kind = _kind;
          state.result = _result;
          return false;
        }
        function readSingleQuotedScalar(state, nodeIndent) {
          var ch, captureStart, captureEnd;
          ch = state.input.charCodeAt(state.position);
          if (ch !== 39) {
            return false;
          }
          state.kind = "scalar";
          state.result = "";
          state.position++;
          captureStart = captureEnd = state.position;
          while ((ch = state.input.charCodeAt(state.position)) !== 0) {
            if (ch === 39) {
              captureSegment(state, captureStart, state.position, true);
              ch = state.input.charCodeAt(++state.position);
              if (ch === 39) {
                captureStart = state.position;
                state.position++;
                captureEnd = state.position;
              } else {
                return true;
              }
            } else if (is_EOL(ch)) {
              captureSegment(state, captureStart, captureEnd, true);
              writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
              captureStart = captureEnd = state.position;
            } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
              throwError(state, "unexpected end of the document within a single quoted scalar");
            } else {
              state.position++;
              captureEnd = state.position;
            }
          }
          throwError(state, "unexpected end of the stream within a single quoted scalar");
        }
        function readDoubleQuotedScalar(state, nodeIndent) {
          var captureStart, captureEnd, hexLength, hexResult, tmp, ch;
          ch = state.input.charCodeAt(state.position);
          if (ch !== 34) {
            return false;
          }
          state.kind = "scalar";
          state.result = "";
          state.position++;
          captureStart = captureEnd = state.position;
          while ((ch = state.input.charCodeAt(state.position)) !== 0) {
            if (ch === 34) {
              captureSegment(state, captureStart, state.position, true);
              state.position++;
              return true;
            } else if (ch === 92) {
              captureSegment(state, captureStart, state.position, true);
              ch = state.input.charCodeAt(++state.position);
              if (is_EOL(ch)) {
                skipSeparationSpace(state, false, nodeIndent);
              } else if (ch < 256 && simpleEscapeCheck[ch]) {
                state.result += simpleEscapeMap[ch];
                state.position++;
              } else if ((tmp = escapedHexLen(ch)) > 0) {
                hexLength = tmp;
                hexResult = 0;
                for (; hexLength > 0; hexLength--) {
                  ch = state.input.charCodeAt(++state.position);
                  if ((tmp = fromHexCode(ch)) >= 0) {
                    hexResult = (hexResult << 4) + tmp;
                  } else {
                    throwError(state, "expected hexadecimal character");
                  }
                }
                state.result += charFromCodepoint(hexResult);
                state.position++;
              } else {
                throwError(state, "unknown escape sequence");
              }
              captureStart = captureEnd = state.position;
            } else if (is_EOL(ch)) {
              captureSegment(state, captureStart, captureEnd, true);
              writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
              captureStart = captureEnd = state.position;
            } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
              throwError(state, "unexpected end of the document within a double quoted scalar");
            } else {
              state.position++;
              captureEnd = state.position;
            }
          }
          throwError(state, "unexpected end of the stream within a double quoted scalar");
        }
        function readFlowCollection(state, nodeIndent) {
          var readNext = true, _line, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = {}, keyNode, keyTag, valueNode, ch;
          ch = state.input.charCodeAt(state.position);
          if (ch === 91) {
            terminator = 93;
            isMapping = false;
            _result = [];
          } else if (ch === 123) {
            terminator = 125;
            isMapping = true;
            _result = {};
          } else {
            return false;
          }
          if (state.anchor !== null) {
            state.anchorMap[state.anchor] = _result;
          }
          ch = state.input.charCodeAt(++state.position);
          while (ch !== 0) {
            skipSeparationSpace(state, true, nodeIndent);
            ch = state.input.charCodeAt(state.position);
            if (ch === terminator) {
              state.position++;
              state.tag = _tag;
              state.anchor = _anchor;
              state.kind = isMapping ? "mapping" : "sequence";
              state.result = _result;
              return true;
            } else if (!readNext) {
              throwError(state, "missed comma between flow collection entries");
            }
            keyTag = keyNode = valueNode = null;
            isPair = isExplicitPair = false;
            if (ch === 63) {
              following = state.input.charCodeAt(state.position + 1);
              if (is_WS_OR_EOL(following)) {
                isPair = isExplicitPair = true;
                state.position++;
                skipSeparationSpace(state, true, nodeIndent);
              }
            }
            _line = state.line;
            composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
            keyTag = state.tag;
            keyNode = state.result;
            skipSeparationSpace(state, true, nodeIndent);
            ch = state.input.charCodeAt(state.position);
            if ((isExplicitPair || state.line === _line) && ch === 58) {
              isPair = true;
              ch = state.input.charCodeAt(++state.position);
              skipSeparationSpace(state, true, nodeIndent);
              composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
              valueNode = state.result;
            }
            if (isMapping) {
              storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
            } else if (isPair) {
              _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
            } else {
              _result.push(keyNode);
            }
            skipSeparationSpace(state, true, nodeIndent);
            ch = state.input.charCodeAt(state.position);
            if (ch === 44) {
              readNext = true;
              ch = state.input.charCodeAt(++state.position);
            } else {
              readNext = false;
            }
          }
          throwError(state, "unexpected end of the stream within a flow collection");
        }
        function readBlockScalar(state, nodeIndent) {
          var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch;
          ch = state.input.charCodeAt(state.position);
          if (ch === 124) {
            folding = false;
          } else if (ch === 62) {
            folding = true;
          } else {
            return false;
          }
          state.kind = "scalar";
          state.result = "";
          while (ch !== 0) {
            ch = state.input.charCodeAt(++state.position);
            if (ch === 43 || ch === 45) {
              if (CHOMPING_CLIP === chomping) {
                chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
              } else {
                throwError(state, "repeat of a chomping mode identifier");
              }
            } else if ((tmp = fromDecimalCode(ch)) >= 0) {
              if (tmp === 0) {
                throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
              } else if (!detectedIndent) {
                textIndent = nodeIndent + tmp - 1;
                detectedIndent = true;
              } else {
                throwError(state, "repeat of an indentation width identifier");
              }
            } else {
              break;
            }
          }
          if (is_WHITE_SPACE(ch)) {
            do {
              ch = state.input.charCodeAt(++state.position);
            } while (is_WHITE_SPACE(ch));
            if (ch === 35) {
              do {
                ch = state.input.charCodeAt(++state.position);
              } while (!is_EOL(ch) && ch !== 0);
            }
          }
          while (ch !== 0) {
            readLineBreak(state);
            state.lineIndent = 0;
            ch = state.input.charCodeAt(state.position);
            while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
              state.lineIndent++;
              ch = state.input.charCodeAt(++state.position);
            }
            if (!detectedIndent && state.lineIndent > textIndent) {
              textIndent = state.lineIndent;
            }
            if (is_EOL(ch)) {
              emptyLines++;
              continue;
            }
            if (state.lineIndent < textIndent) {
              if (chomping === CHOMPING_KEEP) {
                state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
              } else if (chomping === CHOMPING_CLIP) {
                if (didReadContent) {
                  state.result += "\n";
                }
              }
              break;
            }
            if (folding) {
              if (is_WHITE_SPACE(ch)) {
                atMoreIndented = true;
                state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
              } else if (atMoreIndented) {
                atMoreIndented = false;
                state.result += common.repeat("\n", emptyLines + 1);
              } else if (emptyLines === 0) {
                if (didReadContent) {
                  state.result += " ";
                }
              } else {
                state.result += common.repeat("\n", emptyLines);
              }
            } else {
              state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
            }
            didReadContent = true;
            detectedIndent = true;
            emptyLines = 0;
            captureStart = state.position;
            while (!is_EOL(ch) && ch !== 0) {
              ch = state.input.charCodeAt(++state.position);
            }
            captureSegment(state, captureStart, state.position, false);
          }
          return true;
        }
        function readBlockSequence(state, nodeIndent) {
          var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch;
          if (state.anchor !== null) {
            state.anchorMap[state.anchor] = _result;
          }
          ch = state.input.charCodeAt(state.position);
          while (ch !== 0) {
            if (ch !== 45) {
              break;
            }
            following = state.input.charCodeAt(state.position + 1);
            if (!is_WS_OR_EOL(following)) {
              break;
            }
            detected = true;
            state.position++;
            if (skipSeparationSpace(state, true, -1)) {
              if (state.lineIndent <= nodeIndent) {
                _result.push(null);
                ch = state.input.charCodeAt(state.position);
                continue;
              }
            }
            _line = state.line;
            composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
            _result.push(state.result);
            skipSeparationSpace(state, true, -1);
            ch = state.input.charCodeAt(state.position);
            if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
              throwError(state, "bad indentation of a sequence entry");
            } else if (state.lineIndent < nodeIndent) {
              break;
            }
          }
          if (detected) {
            state.tag = _tag;
            state.anchor = _anchor;
            state.kind = "sequence";
            state.result = _result;
            return true;
          }
          return false;
        }
        function readBlockMapping(state, nodeIndent, flowIndent) {
          var following, allowCompact, _line, _pos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = {}, keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
          if (state.anchor !== null) {
            state.anchorMap[state.anchor] = _result;
          }
          ch = state.input.charCodeAt(state.position);
          while (ch !== 0) {
            following = state.input.charCodeAt(state.position + 1);
            _line = state.line;
            _pos = state.position;
            if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) {
              if (ch === 63) {
                if (atExplicitKey) {
                  storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
                  keyTag = keyNode = valueNode = null;
                }
                detected = true;
                atExplicitKey = true;
                allowCompact = true;
              } else if (atExplicitKey) {
                atExplicitKey = false;
                allowCompact = true;
              } else {
                throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
              }
              state.position += 1;
              ch = following;
            } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
              if (state.line === _line) {
                ch = state.input.charCodeAt(state.position);
                while (is_WHITE_SPACE(ch)) {
                  ch = state.input.charCodeAt(++state.position);
                }
                if (ch === 58) {
                  ch = state.input.charCodeAt(++state.position);
                  if (!is_WS_OR_EOL(ch)) {
                    throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
                  }
                  if (atExplicitKey) {
                    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
                    keyTag = keyNode = valueNode = null;
                  }
                  detected = true;
                  atExplicitKey = false;
                  allowCompact = false;
                  keyTag = state.tag;
                  keyNode = state.result;
                } else if (detected) {
                  throwError(state, "can not read an implicit mapping pair; a colon is missed");
                } else {
                  state.tag = _tag;
                  state.anchor = _anchor;
                  return true;
                }
              } else if (detected) {
                throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
              } else {
                state.tag = _tag;
                state.anchor = _anchor;
                return true;
              }
            } else {
              break;
            }
            if (state.line === _line || state.lineIndent > nodeIndent) {
              if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
                if (atExplicitKey) {
                  keyNode = state.result;
                } else {
                  valueNode = state.result;
                }
              }
              if (!atExplicitKey) {
                storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
                keyTag = keyNode = valueNode = null;
              }
              skipSeparationSpace(state, true, -1);
              ch = state.input.charCodeAt(state.position);
            }
            if (state.lineIndent > nodeIndent && ch !== 0) {
              throwError(state, "bad indentation of a mapping entry");
            } else if (state.lineIndent < nodeIndent) {
              break;
            }
          }
          if (atExplicitKey) {
            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
          }
          if (detected) {
            state.tag = _tag;
            state.anchor = _anchor;
            state.kind = "mapping";
            state.result = _result;
          }
          return detected;
        }
        function readTagProperty(state) {
          var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch;
          ch = state.input.charCodeAt(state.position);
          if (ch !== 33)
            return false;
          if (state.tag !== null) {
            throwError(state, "duplication of a tag property");
          }
          ch = state.input.charCodeAt(++state.position);
          if (ch === 60) {
            isVerbatim = true;
            ch = state.input.charCodeAt(++state.position);
          } else if (ch === 33) {
            isNamed = true;
            tagHandle = "!!";
            ch = state.input.charCodeAt(++state.position);
          } else {
            tagHandle = "!";
          }
          _position = state.position;
          if (isVerbatim) {
            do {
              ch = state.input.charCodeAt(++state.position);
            } while (ch !== 0 && ch !== 62);
            if (state.position < state.length) {
              tagName = state.input.slice(_position, state.position);
              ch = state.input.charCodeAt(++state.position);
            } else {
              throwError(state, "unexpected end of the stream within a verbatim tag");
            }
          } else {
            while (ch !== 0 && !is_WS_OR_EOL(ch)) {
              if (ch === 33) {
                if (!isNamed) {
                  tagHandle = state.input.slice(_position - 1, state.position + 1);
                  if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
                    throwError(state, "named tag handle cannot contain such characters");
                  }
                  isNamed = true;
                  _position = state.position + 1;
                } else {
                  throwError(state, "tag suffix cannot contain exclamation marks");
                }
              }
              ch = state.input.charCodeAt(++state.position);
            }
            tagName = state.input.slice(_position, state.position);
            if (PATTERN_FLOW_INDICATORS.test(tagName)) {
              throwError(state, "tag suffix cannot contain flow indicator characters");
            }
          }
          if (tagName && !PATTERN_TAG_URI.test(tagName)) {
            throwError(state, "tag name cannot contain such characters: " + tagName);
          }
          if (isVerbatim) {
            state.tag = tagName;
          } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
            state.tag = state.tagMap[tagHandle] + tagName;
          } else if (tagHandle === "!") {
            state.tag = "!" + tagName;
          } else if (tagHandle === "!!") {
            state.tag = "tag:yaml.org,2002:" + tagName;
          } else {
            throwError(state, 'undeclared tag handle "' + tagHandle + '"');
          }
          return true;
        }
        function readAnchorProperty(state) {
          var _position, ch;
          ch = state.input.charCodeAt(state.position);
          if (ch !== 38)
            return false;
          if (state.anchor !== null) {
            throwError(state, "duplication of an anchor property");
          }
          ch = state.input.charCodeAt(++state.position);
          _position = state.position;
          while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
            ch = state.input.charCodeAt(++state.position);
          }
          if (state.position === _position) {
            throwError(state, "name of an anchor node must contain at least one character");
          }
          state.anchor = state.input.slice(_position, state.position);
          return true;
        }
        function readAlias(state) {
          var _position, alias, ch;
          ch = state.input.charCodeAt(state.position);
          if (ch !== 42)
            return false;
          ch = state.input.charCodeAt(++state.position);
          _position = state.position;
          while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
            ch = state.input.charCodeAt(++state.position);
          }
          if (state.position === _position) {
            throwError(state, "name of an alias node must contain at least one character");
          }
          alias = state.input.slice(_position, state.position);
          if (!_hasOwnProperty.call(state.anchorMap, alias)) {
            throwError(state, 'unidentified alias "' + alias + '"');
          }
          state.result = state.anchorMap[alias];
          skipSeparationSpace(state, true, -1);
          return true;
        }
        function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
          var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, type, flowIndent, blockIndent;
          if (state.listener !== null) {
            state.listener("open", state);
          }
          state.tag = null;
          state.anchor = null;
          state.kind = null;
          state.result = null;
          allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
          if (allowToSeek) {
            if (skipSeparationSpace(state, true, -1)) {
              atNewLine = true;
              if (state.lineIndent > parentIndent) {
                indentStatus = 1;
              } else if (state.lineIndent === parentIndent) {
                indentStatus = 0;
              } else if (state.lineIndent < parentIndent) {
                indentStatus = -1;
              }
            }
          }
          if (indentStatus === 1) {
            while (readTagProperty(state) || readAnchorProperty(state)) {
              if (skipSeparationSpace(state, true, -1)) {
                atNewLine = true;
                allowBlockCollections = allowBlockStyles;
                if (state.lineIndent > parentIndent) {
                  indentStatus = 1;
                } else if (state.lineIndent === parentIndent) {
                  indentStatus = 0;
                } else if (state.lineIndent < parentIndent) {
                  indentStatus = -1;
                }
              } else {
                allowBlockCollections = false;
              }
            }
          }
          if (allowBlockCollections) {
            allowBlockCollections = atNewLine || allowCompact;
          }
          if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
            if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
              flowIndent = parentIndent;
            } else {
              flowIndent = parentIndent + 1;
            }
            blockIndent = state.position - state.lineStart;
            if (indentStatus === 1) {
              if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) {
                hasContent = true;
              } else {
                if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) {
                  hasContent = true;
                } else if (readAlias(state)) {
                  hasContent = true;
                  if (state.tag !== null || state.anchor !== null) {
                    throwError(state, "alias node should not have any properties");
                  }
                } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
                  hasContent = true;
                  if (state.tag === null) {
                    state.tag = "?";
                  }
                }
                if (state.anchor !== null) {
                  state.anchorMap[state.anchor] = state.result;
                }
              }
            } else if (indentStatus === 0) {
              hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
            }
          }
          if (state.tag !== null && state.tag !== "!") {
            if (state.tag === "?") {
              if (state.result !== null && state.kind !== "scalar") {
                throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
              }
              for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
                type = state.implicitTypes[typeIndex];
                if (type.resolve(state.result)) {
                  state.result = type.construct(state.result);
                  state.tag = type.tag;
                  if (state.anchor !== null) {
                    state.anchorMap[state.anchor] = state.result;
                  }
                  break;
                }
              }
            } else if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) {
              type = state.typeMap[state.kind || "fallback"][state.tag];
              if (state.result !== null && type.kind !== state.kind) {
                throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
              }
              if (!type.resolve(state.result)) {
                throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
              } else {
                state.result = type.construct(state.result);
                if (state.anchor !== null) {
                  state.anchorMap[state.anchor] = state.result;
                }
              }
            } else {
              throwError(state, "unknown tag !<" + state.tag + ">");
            }
          }
          if (state.listener !== null) {
            state.listener("close", state);
          }
          return state.tag !== null || state.anchor !== null || hasContent;
        }
        function readDocument(state) {
          var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch;
          state.version = null;
          state.checkLineBreaks = state.legacy;
          state.tagMap = {};
          state.anchorMap = {};
          while ((ch = state.input.charCodeAt(state.position)) !== 0) {
            skipSeparationSpace(state, true, -1);
            ch = state.input.charCodeAt(state.position);
            if (state.lineIndent > 0 || ch !== 37) {
              break;
            }
            hasDirectives = true;
            ch = state.input.charCodeAt(++state.position);
            _position = state.position;
            while (ch !== 0 && !is_WS_OR_EOL(ch)) {
              ch = state.input.charCodeAt(++state.position);
            }
            directiveName = state.input.slice(_position, state.position);
            directiveArgs = [];
            if (directiveName.length < 1) {
              throwError(state, "directive name must not be less than one character in length");
            }
            while (ch !== 0) {
              while (is_WHITE_SPACE(ch)) {
                ch = state.input.charCodeAt(++state.position);
              }
              if (ch === 35) {
                do {
                  ch = state.input.charCodeAt(++state.position);
                } while (ch !== 0 && !is_EOL(ch));
                break;
              }
              if (is_EOL(ch))
                break;
              _position = state.position;
              while (ch !== 0 && !is_WS_OR_EOL(ch)) {
                ch = state.input.charCodeAt(++state.position);
              }
              directiveArgs.push(state.input.slice(_position, state.position));
            }
            if (ch !== 0)
              readLineBreak(state);
            if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
              directiveHandlers[directiveName](state, directiveName, directiveArgs);
            } else {
              throwWarning(state, 'unknown document directive "' + directiveName + '"');
            }
          }
          skipSeparationSpace(state, true, -1);
          if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
            state.position += 3;
            skipSeparationSpace(state, true, -1);
          } else if (hasDirectives) {
            throwError(state, "directives end mark is expected");
          }
          composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
          skipSeparationSpace(state, true, -1);
          if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
            throwWarning(state, "non-ASCII line breaks are interpreted as content");
          }
          state.documents.push(state.result);
          if (state.position === state.lineStart && testDocumentSeparator(state)) {
            if (state.input.charCodeAt(state.position) === 46) {
              state.position += 3;
              skipSeparationSpace(state, true, -1);
            }
            return;
          }
          if (state.position < state.length - 1) {
            throwError(state, "end of the stream or a document separator is expected");
          } else {
            return;
          }
        }
        function loadDocuments(input, options2) {
          input = String(input);
          options2 = options2 || {};
          if (input.length !== 0) {
            if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) {
              input += "\n";
            }
            if (input.charCodeAt(0) === 65279) {
              input = input.slice(1);
            }
          }
          var state = new State(input, options2);
          var nullpos = input.indexOf("\0");
          if (nullpos !== -1) {
            state.position = nullpos;
            throwError(state, "null byte is not allowed in input");
          }
          state.input += "\0";
          while (state.input.charCodeAt(state.position) === 32) {
            state.lineIndent += 1;
            state.position += 1;
          }
          while (state.position < state.length - 1) {
            readDocument(state);
          }
          return state.documents;
        }
        function loadAll(input, iterator, options2) {
          if (iterator !== null && typeof iterator === "object" && typeof options2 === "undefined") {
            options2 = iterator;
            iterator = null;
          }
          var documents = loadDocuments(input, options2);
          if (typeof iterator !== "function") {
            return documents;
          }
          for (var index = 0, length = documents.length; index < length; index += 1) {
            iterator(documents[index]);
          }
        }
        function load(input, options2) {
          var documents = loadDocuments(input, options2);
          if (documents.length === 0) {
            return void 0;
          } else if (documents.length === 1) {
            return documents[0];
          }
          throw new YAMLException("expected a single document in the stream, but found more");
        }
        function safeLoadAll(input, iterator, options2) {
          if (typeof iterator === "object" && iterator !== null && typeof options2 === "undefined") {
            options2 = iterator;
            iterator = null;
          }
          return loadAll(input, iterator, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options2));
        }
        function safeLoad(input, options2) {
          return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options2));
        }
        module2.exports.loadAll = loadAll;
        module2.exports.load = load;
        module2.exports.safeLoadAll = safeLoadAll;
        module2.exports.safeLoad = safeLoad;
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/dumper.js
    var require_dumper = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml/dumper.js"(exports2, module2) {
        "use strict";
        var common = require_common();
        var YAMLException = require_exception();
        var DEFAULT_FULL_SCHEMA = require_default_full();
        var DEFAULT_SAFE_SCHEMA = require_default_safe();
        var _toString = Object.prototype.toString;
        var _hasOwnProperty = Object.prototype.hasOwnProperty;
        var CHAR_TAB = 9;
        var CHAR_LINE_FEED = 10;
        var CHAR_CARRIAGE_RETURN = 13;
        var CHAR_SPACE = 32;
        var CHAR_EXCLAMATION = 33;
        var CHAR_DOUBLE_QUOTE = 34;
        var CHAR_SHARP = 35;
        var CHAR_PERCENT = 37;
        var CHAR_AMPERSAND = 38;
        var CHAR_SINGLE_QUOTE = 39;
        var CHAR_ASTERISK = 42;
        var CHAR_COMMA = 44;
        var CHAR_MINUS = 45;
        var CHAR_COLON = 58;
        var CHAR_EQUALS = 61;
        var CHAR_GREATER_THAN = 62;
        var CHAR_QUESTION = 63;
        var CHAR_COMMERCIAL_AT = 64;
        var CHAR_LEFT_SQUARE_BRACKET = 91;
        var CHAR_RIGHT_SQUARE_BRACKET = 93;
        var CHAR_GRAVE_ACCENT = 96;
        var CHAR_LEFT_CURLY_BRACKET = 123;
        var CHAR_VERTICAL_LINE = 124;
        var CHAR_RIGHT_CURLY_BRACKET = 125;
        var ESCAPE_SEQUENCES = {};
        ESCAPE_SEQUENCES[0] = "\\0";
        ESCAPE_SEQUENCES[7] = "\\a";
        ESCAPE_SEQUENCES[8] = "\\b";
        ESCAPE_SEQUENCES[9] = "\\t";
        ESCAPE_SEQUENCES[10] = "\\n";
        ESCAPE_SEQUENCES[11] = "\\v";
        ESCAPE_SEQUENCES[12] = "\\f";
        ESCAPE_SEQUENCES[13] = "\\r";
        ESCAPE_SEQUENCES[27] = "\\e";
        ESCAPE_SEQUENCES[34] = '\\"';
        ESCAPE_SEQUENCES[92] = "\\\\";
        ESCAPE_SEQUENCES[133] = "\\N";
        ESCAPE_SEQUENCES[160] = "\\_";
        ESCAPE_SEQUENCES[8232] = "\\L";
        ESCAPE_SEQUENCES[8233] = "\\P";
        var DEPRECATED_BOOLEANS_SYNTAX = [
          "y",
          "Y",
          "yes",
          "Yes",
          "YES",
          "on",
          "On",
          "ON",
          "n",
          "N",
          "no",
          "No",
          "NO",
          "off",
          "Off",
          "OFF"
        ];
        function compileStyleMap(schema, map) {
          var result, keys, index, length, tag, style, type;
          if (map === null)
            return {};
          result = {};
          keys = Object.keys(map);
          for (index = 0, length = keys.length; index < length; index += 1) {
            tag = keys[index];
            style = String(map[tag]);
            if (tag.slice(0, 2) === "!!") {
              tag = "tag:yaml.org,2002:" + tag.slice(2);
            }
            type = schema.compiledTypeMap["fallback"][tag];
            if (type && _hasOwnProperty.call(type.styleAliases, style)) {
              style = type.styleAliases[style];
            }
            result[tag] = style;
          }
          return result;
        }
        function encodeHex(character) {
          var string, handle, length;
          string = character.toString(16).toUpperCase();
          if (character <= 255) {
            handle = "x";
            length = 2;
          } else if (character <= 65535) {
            handle = "u";
            length = 4;
          } else if (character <= 4294967295) {
            handle = "U";
            length = 8;
          } else {
            throw new YAMLException("code point within a string may not be greater than 0xFFFFFFFF");
          }
          return "\\" + handle + common.repeat("0", length - string.length) + string;
        }
        function State(options2) {
          this.schema = options2["schema"] || DEFAULT_FULL_SCHEMA;
          this.indent = Math.max(1, options2["indent"] || 2);
          this.noArrayIndent = options2["noArrayIndent"] || false;
          this.skipInvalid = options2["skipInvalid"] || false;
          this.flowLevel = common.isNothing(options2["flowLevel"]) ? -1 : options2["flowLevel"];
          this.styleMap = compileStyleMap(this.schema, options2["styles"] || null);
          this.sortKeys = options2["sortKeys"] || false;
          this.lineWidth = options2["lineWidth"] || 80;
          this.noRefs = options2["noRefs"] || false;
          this.noCompatMode = options2["noCompatMode"] || false;
          this.condenseFlow = options2["condenseFlow"] || false;
          this.implicitTypes = this.schema.compiledImplicit;
          this.explicitTypes = this.schema.compiledExplicit;
          this.tag = null;
          this.result = "";
          this.duplicates = [];
          this.usedDuplicates = null;
        }
        function indentString(string, spaces) {
          var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string.length;
          while (position < length) {
            next = string.indexOf("\n", position);
            if (next === -1) {
              line = string.slice(position);
              position = length;
            } else {
              line = string.slice(position, next + 1);
              position = next + 1;
            }
            if (line.length && line !== "\n")
              result += ind;
            result += line;
          }
          return result;
        }
        function generateNextLine(state, level) {
          return "\n" + common.repeat(" ", state.indent * level);
        }
        function testImplicitResolving(state, str2) {
          var index, length, type;
          for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
            type = state.implicitTypes[index];
            if (type.resolve(str2)) {
              return true;
            }
          }
          return false;
        }
        function isWhitespace(c) {
          return c === CHAR_SPACE || c === CHAR_TAB;
        }
        function isPrintable(c) {
          return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== 65279 || 65536 <= c && c <= 1114111;
        }
        function isNsChar(c) {
          return isPrintable(c) && !isWhitespace(c) && c !== 65279 && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
        }
        function isPlainSafe(c, prev) {
          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));
        }
        function isPlainSafeFirst(c) {
          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;
        }
        function needIndentIndicator(string) {
          var leadingSpaceRe = /^\n* /;
          return leadingSpaceRe.test(string);
        }
        var STYLE_PLAIN = 1;
        var STYLE_SINGLE = 2;
        var STYLE_LITERAL = 3;
        var STYLE_FOLDED = 4;
        var STYLE_DOUBLE = 5;
        function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
          var i;
          var char, prev_char;
          var hasLineBreak = false;
          var hasFoldableLine = false;
          var shouldTrackWidth = lineWidth !== -1;
          var previousLineBreak = -1;
          var plain = isPlainSafeFirst(string.charCodeAt(0)) && !isWhitespace(string.charCodeAt(string.length - 1));
          if (singleLineOnly) {
            for (i = 0; i < string.length; i++) {
              char = string.charCodeAt(i);
              if (!isPrintable(char)) {
                return STYLE_DOUBLE;
              }
              prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
              plain = plain && isPlainSafe(char, prev_char);
            }
          } else {
            for (i = 0; i < string.length; i++) {
              char = string.charCodeAt(i);
              if (char === CHAR_LINE_FEED) {
                hasLineBreak = true;
                if (shouldTrackWidth) {
                  hasFoldableLine = hasFoldableLine || // Foldable line = too long, and not more-indented.
                  i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
                  previousLineBreak = i;
                }
              } else if (!isPrintable(char)) {
                return STYLE_DOUBLE;
              }
              prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
              plain = plain && isPlainSafe(char, prev_char);
            }
            hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ");
          }
          if (!hasLineBreak && !hasFoldableLine) {
            return plain && !testAmbiguousType(string) ? STYLE_PLAIN : STYLE_SINGLE;
          }
          if (indentPerLevel > 9 && needIndentIndicator(string)) {
            return STYLE_DOUBLE;
          }
          return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
        }
        function writeScalar(state, string, level, iskey) {
          state.dump = function() {
            if (string.length === 0) {
              return "''";
            }
            if (!state.noCompatMode && DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
              return "'" + string + "'";
            }
            var indent = state.indent * Math.max(1, level);
            var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
            var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
            function testAmbiguity(string2) {
              return testImplicitResolving(state, string2);
            }
            switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
              case STYLE_PLAIN:
                return string;
              case STYLE_SINGLE:
                return "'" + string.replace(/'/g, "''") + "'";
              case STYLE_LITERAL:
                return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
              case STYLE_FOLDED:
                return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
              case STYLE_DOUBLE:
                return '"' + escapeString(string, lineWidth) + '"';
              default:
                throw new YAMLException("impossible error: invalid scalar style");
            }
          }();
        }
        function blockHeader(string, indentPerLevel) {
          var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
          var clip = string[string.length - 1] === "\n";
          var keep = clip && (string[string.length - 2] === "\n" || string === "\n");
          var chomp = keep ? "+" : clip ? "" : "-";
          return indentIndicator + chomp + "\n";
        }
        function dropEndingNewline(string) {
          return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
        }
        function foldString(string, width) {
          var lineRe = /(\n+)([^\n]*)/g;
          var result = function() {
            var nextLF = string.indexOf("\n");
            nextLF = nextLF !== -1 ? nextLF : string.length;
            lineRe.lastIndex = nextLF;
            return foldLine(string.slice(0, nextLF), width);
          }();
          var prevMoreIndented = string[0] === "\n" || string[0] === " ";
          var moreIndented;
          var match;
          while (match = lineRe.exec(string)) {
            var prefix = match[1], line = match[2];
            moreIndented = line[0] === " ";
            result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
            prevMoreIndented = moreIndented;
          }
          return result;
        }
        function foldLine(line, width) {
          if (line === "" || line[0] === " ")
            return line;
          var breakRe = / [^ ]/g;
          var match;
          var start = 0, end, curr = 0, next = 0;
          var result = "";
          while (match = breakRe.exec(line)) {
            next = match.index;
            if (next - start > width) {
              end = curr > start ? curr : next;
              result += "\n" + line.slice(start, end);
              start = end + 1;
            }
            curr = next;
          }
          result += "\n";
          if (line.length - start > width && curr > start) {
            result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
          } else {
            result += line.slice(start);
          }
          return result.slice(1);
        }
        function escapeString(string) {
          var result = "";
          var char, nextChar;
          var escapeSeq;
          for (var i = 0; i < string.length; i++) {
            char = string.charCodeAt(i);
            if (char >= 55296 && char <= 56319) {
              nextChar = string.charCodeAt(i + 1);
              if (nextChar >= 56320 && nextChar <= 57343) {
                result += encodeHex((char - 55296) * 1024 + nextChar - 56320 + 65536);
                i++;
                continue;
              }
            }
            escapeSeq = ESCAPE_SEQUENCES[char];
            result += !escapeSeq && isPrintable(char) ? string[i] : escapeSeq || encodeHex(char);
          }
          return result;
        }
        function writeFlowSequence(state, level, object) {
          var _result = "", _tag = state.tag, index, length;
          for (index = 0, length = object.length; index < length; index += 1) {
            if (writeNode(state, level, object[index], false, false)) {
              if (index !== 0)
                _result += "," + (!state.condenseFlow ? " " : "");
              _result += state.dump;
            }
          }
          state.tag = _tag;
          state.dump = "[" + _result + "]";
        }
        function writeBlockSequence(state, level, object, compact) {
          var _result = "", _tag = state.tag, index, length;
          for (index = 0, length = object.length; index < length; index += 1) {
            if (writeNode(state, level + 1, object[index], true, true)) {
              if (!compact || index !== 0) {
                _result += generateNextLine(state, level);
              }
              if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
                _result += "-";
              } else {
                _result += "- ";
              }
              _result += state.dump;
            }
          }
          state.tag = _tag;
          state.dump = _result || "[]";
        }
        function writeFlowMapping(state, level, object) {
          var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, pairBuffer;
          for (index = 0, length = objectKeyList.length; index < length; index += 1) {
            pairBuffer = "";
            if (index !== 0)
              pairBuffer += ", ";
            if (state.condenseFlow)
              pairBuffer += '"';
            objectKey = objectKeyList[index];
            objectValue = object[objectKey];
            if (!writeNode(state, level, objectKey, false, false)) {
              continue;
            }
            if (state.dump.length > 1024)
              pairBuffer += "? ";
            pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
            if (!writeNode(state, level, objectValue, false, false)) {
              continue;
            }
            pairBuffer += state.dump;
            _result += pairBuffer;
          }
          state.tag = _tag;
          state.dump = "{" + _result + "}";
        }
        function writeBlockMapping(state, level, object, compact) {
          var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
          if (state.sortKeys === true) {
            objectKeyList.sort();
          } else if (typeof state.sortKeys === "function") {
            objectKeyList.sort(state.sortKeys);
          } else if (state.sortKeys) {
            throw new YAMLException("sortKeys must be a boolean or a function");
          }
          for (index = 0, length = objectKeyList.length; index < length; index += 1) {
            pairBuffer = "";
            if (!compact || index !== 0) {
              pairBuffer += generateNextLine(state, level);
            }
            objectKey = objectKeyList[index];
            objectValue = object[objectKey];
            if (!writeNode(state, level + 1, objectKey, true, true, true)) {
              continue;
            }
            explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
            if (explicitPair) {
              if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
                pairBuffer += "?";
              } else {
                pairBuffer += "? ";
              }
            }
            pairBuffer += state.dump;
            if (explicitPair) {
              pairBuffer += generateNextLine(state, level);
            }
            if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
              continue;
            }
            if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
              pairBuffer += ":";
            } else {
              pairBuffer += ": ";
            }
            pairBuffer += state.dump;
            _result += pairBuffer;
          }
          state.tag = _tag;
          state.dump = _result || "{}";
        }
        function detectType(state, object, explicit) {
          var _result, typeList, index, length, type, style;
          typeList = explicit ? state.explicitTypes : state.implicitTypes;
          for (index = 0, length = typeList.length; index < length; index += 1) {
            type = typeList[index];
            if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
              state.tag = explicit ? type.tag : "?";
              if (type.represent) {
                style = state.styleMap[type.tag] || type.defaultStyle;
                if (_toString.call(type.represent) === "[object Function]") {
                  _result = type.represent(object, style);
                } else if (_hasOwnProperty.call(type.represent, style)) {
                  _result = type.represent[style](object, style);
                } else {
                  throw new YAMLException("!<" + type.tag + '> tag resolver accepts not "' + style + '" style');
                }
                state.dump = _result;
              }
              return true;
            }
          }
          return false;
        }
        function writeNode(state, level, object, block, compact, iskey) {
          state.tag = null;
          state.dump = object;
          if (!detectType(state, object, false)) {
            detectType(state, object, true);
          }
          var type = _toString.call(state.dump);
          if (block) {
            block = state.flowLevel < 0 || state.flowLevel > level;
          }
          var objectOrArray = type === "[object Object]" || type === "[object Array]", duplicateIndex, duplicate;
          if (objectOrArray) {
            duplicateIndex = state.duplicates.indexOf(object);
            duplicate = duplicateIndex !== -1;
          }
          if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
            compact = false;
          }
          if (duplicate && state.usedDuplicates[duplicateIndex]) {
            state.dump = "*ref_" + duplicateIndex;
          } else {
            if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
              state.usedDuplicates[duplicateIndex] = true;
            }
            if (type === "[object Object]") {
              if (block && Object.keys(state.dump).length !== 0) {
                writeBlockMapping(state, level, state.dump, compact);
                if (duplicate) {
                  state.dump = "&ref_" + duplicateIndex + state.dump;
                }
              } else {
                writeFlowMapping(state, level, state.dump);
                if (duplicate) {
                  state.dump = "&ref_" + duplicateIndex + " " + state.dump;
                }
              }
            } else if (type === "[object Array]") {
              var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level;
              if (block && state.dump.length !== 0) {
                writeBlockSequence(state, arrayLevel, state.dump, compact);
                if (duplicate) {
                  state.dump = "&ref_" + duplicateIndex + state.dump;
                }
              } else {
                writeFlowSequence(state, arrayLevel, state.dump);
                if (duplicate) {
                  state.dump = "&ref_" + duplicateIndex + " " + state.dump;
                }
              }
            } else if (type === "[object String]") {
              if (state.tag !== "?") {
                writeScalar(state, state.dump, level, iskey);
              }
            } else {
              if (state.skipInvalid)
                return false;
              throw new YAMLException("unacceptable kind of an object to dump " + type);
            }
            if (state.tag !== null && state.tag !== "?") {
              state.dump = "!<" + state.tag + "> " + state.dump;
            }
          }
          return true;
        }
        function getDuplicateReferences(object, state) {
          var objects = [], duplicatesIndexes = [], index, length;
          inspectNode(object, objects, duplicatesIndexes);
          for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
            state.duplicates.push(objects[duplicatesIndexes[index]]);
          }
          state.usedDuplicates = new Array(length);
        }
        function inspectNode(object, objects, duplicatesIndexes) {
          var objectKeyList, index, length;
          if (object !== null && typeof object === "object") {
            index = objects.indexOf(object);
            if (index !== -1) {
              if (duplicatesIndexes.indexOf(index) === -1) {
                duplicatesIndexes.push(index);
              }
            } else {
              objects.push(object);
              if (Array.isArray(object)) {
                for (index = 0, length = object.length; index < length; index += 1) {
                  inspectNode(object[index], objects, duplicatesIndexes);
                }
              } else {
                objectKeyList = Object.keys(object);
                for (index = 0, length = objectKeyList.length; index < length; index += 1) {
                  inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
                }
              }
            }
          }
        }
        function dump(input, options2) {
          options2 = options2 || {};
          var state = new State(options2);
          if (!state.noRefs)
            getDuplicateReferences(input, state);
          if (writeNode(state, 0, input, true, true))
            return state.dump + "\n";
          return "";
        }
        function safeDump(input, options2) {
          return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options2));
        }
        module2.exports.dump = dump;
        module2.exports.safeDump = safeDump;
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml.js
    var require_js_yaml = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/lib/js-yaml.js"(exports2, module2) {
        "use strict";
        var loader = require_loader();
        var dumper = require_dumper();
        function deprecated(name) {
          return function() {
            throw new Error("Function " + name + " is deprecated and cannot be used.");
          };
        }
        module2.exports.Type = require_type();
        module2.exports.Schema = require_schema();
        module2.exports.FAILSAFE_SCHEMA = require_failsafe();
        module2.exports.JSON_SCHEMA = require_json();
        module2.exports.CORE_SCHEMA = require_core();
        module2.exports.DEFAULT_SAFE_SCHEMA = require_default_safe();
        module2.exports.DEFAULT_FULL_SCHEMA = require_default_full();
        module2.exports.load = loader.load;
        module2.exports.loadAll = loader.loadAll;
        module2.exports.safeLoad = loader.safeLoad;
        module2.exports.safeLoadAll = loader.safeLoadAll;
        module2.exports.dump = dumper.dump;
        module2.exports.safeDump = dumper.safeDump;
        module2.exports.YAMLException = require_exception();
        module2.exports.MINIMAL_SCHEMA = require_failsafe();
        module2.exports.SAFE_SCHEMA = require_default_safe();
        module2.exports.DEFAULT_SCHEMA = require_default_full();
        module2.exports.scan = deprecated("scan");
        module2.exports.parse = deprecated("parse");
        module2.exports.compose = deprecated("compose");
        module2.exports.addConstructor = deprecated("addConstructor");
      }
    });
    
    // node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/index.js
    var require_js_yaml2 = __commonJS({
      "node_modules/.pnpm/js-yaml@3.14.1/node_modules/js-yaml/index.js"(exports2, module2) {
        "use strict";
        var yaml2 = require_js_yaml();
        module2.exports = yaml2;
      }
    });
    
    // node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js
    var require_engines = __commonJS({
      "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js"(exports, module) {
        "use strict";
        var yaml = require_js_yaml2();
        var engines = exports = module.exports;
        engines.yaml = {
          parse: yaml.safeLoad.bind(yaml),
          stringify: yaml.safeDump.bind(yaml)
        };
        engines.json = {
          parse: JSON.parse.bind(JSON),
          stringify: function(obj, options2) {
            const opts = Object.assign({ replacer: null, space: 2 }, options2);
            return JSON.stringify(obj, opts.replacer, opts.space);
          }
        };
        engines.javascript = {
          parse: function parse(str, options, wrap) {
            try {
              if (wrap !== false) {
                str = "(function() {\nreturn " + str.trim() + ";\n}());";
              }
              return eval(str) || {};
            } catch (err) {
              if (wrap !== false && /(unexpected|identifier)/i.test(err.message)) {
                return parse(str, options, false);
              }
              throw new SyntaxError(err);
            }
          },
          stringify: function() {
            throw new Error("stringifying JavaScript is not supported");
          }
        };
      }
    });
    
    // node_modules/.pnpm/strip-bom-string@1.0.0/node_modules/strip-bom-string/index.js
    var require_strip_bom_string = __commonJS({
      "node_modules/.pnpm/strip-bom-string@1.0.0/node_modules/strip-bom-string/index.js"(exports2, module2) {
        "use strict";
        module2.exports = function(str2) {
          if (typeof str2 === "string" && str2.charAt(0) === "\uFEFF") {
            return str2.slice(1);
          }
          return str2;
        };
      }
    });
    
    // node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js
    var require_utils = __commonJS({
      "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js"(exports2) {
        "use strict";
        var stripBom = require_strip_bom_string();
        var typeOf = require_kind_of();
        exports2.define = function(obj, key, val) {
          Reflect.defineProperty(obj, key, {
            enumerable: false,
            configurable: true,
            writable: true,
            value: val
          });
        };
        exports2.isBuffer = function(val) {
          return typeOf(val) === "buffer";
        };
        exports2.isObject = function(val) {
          return typeOf(val) === "object";
        };
        exports2.toBuffer = function(input) {
          return typeof input === "string" ? Buffer.from(input) : input;
        };
        exports2.toString = function(input) {
          if (exports2.isBuffer(input))
            return stripBom(String(input));
          if (typeof input !== "string") {
            throw new TypeError("expected input to be a string or buffer");
          }
          return stripBom(input);
        };
        exports2.arrayify = function(val) {
          return val ? Array.isArray(val) ? val : [val] : [];
        };
        exports2.startsWith = function(str2, substr, len) {
          if (typeof len !== "number")
            len = substr.length;
          return str2.slice(0, len) === substr;
        };
      }
    });
    
    // node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js
    var require_defaults = __commonJS({
      "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js"(exports2, module2) {
        "use strict";
        var engines2 = require_engines();
        var utils = require_utils();
        module2.exports = function(options2) {
          const opts = Object.assign({}, options2);
          opts.delimiters = utils.arrayify(opts.delims || opts.delimiters || "---");
          if (opts.delimiters.length === 1) {
            opts.delimiters.push(opts.delimiters[0]);
          }
          opts.language = (opts.language || opts.lang || "yaml").toLowerCase();
          opts.engines = Object.assign({}, engines2, opts.parsers, opts.engines);
          return opts;
        };
      }
    });
    
    // node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js
    var require_engine = __commonJS({
      "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js"(exports2, module2) {
        "use strict";
        module2.exports = function(name, options2) {
          let engine = options2.engines[name] || options2.engines[aliase(name)];
          if (typeof engine === "undefined") {
            throw new Error('gray-matter engine "' + name + '" is not registered');
          }
          if (typeof engine === "function") {
            engine = { parse: engine };
          }
          return engine;
        };
        function aliase(name) {
          switch (name.toLowerCase()) {
            case "js":
            case "javascript":
              return "javascript";
            case "coffee":
            case "coffeescript":
            case "cson":
              return "coffee";
            case "yaml":
            case "yml":
              return "yaml";
            default: {
              return name;
            }
          }
        }
      }
    });
    
    // node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js
    var require_stringify = __commonJS({
      "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js"(exports2, module2) {
        "use strict";
        var typeOf = require_kind_of();
        var getEngine = require_engine();
        var defaults = require_defaults();
        module2.exports = function(file, data, options2) {
          if (data == null && options2 == null) {
            switch (typeOf(file)) {
              case "object":
                data = file.data;
                options2 = {};
                break;
              case "string":
                return file;
              default: {
                throw new TypeError("expected file to be a string or object");
              }
            }
          }
          const str2 = file.content;
          const opts = defaults(options2);
          if (data == null) {
            if (!opts.data)
              return file;
            data = opts.data;
          }
          const language = file.language || opts.language;
          const engine = getEngine(language, opts);
          if (typeof engine.stringify !== "function") {
            throw new TypeError('expected "' + language + '.stringify" to be a function');
          }
          data = Object.assign({}, file.data, data);
          const open = opts.delimiters[0];
          const close = opts.delimiters[1];
          const matter2 = engine.stringify(data, options2).trim();
          let buf = "";
          if (matter2 !== "{}") {
            buf = newline(open) + newline(matter2) + newline(close);
          }
          if (typeof file.excerpt === "string" && file.excerpt !== "") {
            if (str2.indexOf(file.excerpt.trim()) === -1) {
              buf += newline(file.excerpt) + newline(close);
            }
          }
          return buf + newline(str2);
        };
        function newline(str2) {
          return str2.slice(-1) !== "\n" ? str2 + "\n" : str2;
        }
      }
    });
    
    // node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/excerpt.js
    var require_excerpt = __commonJS({
      "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/excerpt.js"(exports2, module2) {
        "use strict";
        var defaults = require_defaults();
        module2.exports = function(file, options2) {
          const opts = defaults(options2);
          if (file.data == null) {
            file.data = {};
          }
          if (typeof opts.excerpt === "function") {
            return opts.excerpt(file, opts);
          }
          const sep = file.data.excerpt_separator || opts.excerpt_separator;
          if (sep == null && (opts.excerpt === false || opts.excerpt == null)) {
            return file;
          }
          const delimiter = typeof opts.excerpt === "string" ? opts.excerpt : sep || opts.delimiters[0];
          const idx = file.content.indexOf(delimiter);
          if (idx !== -1) {
            file.excerpt = file.content.slice(0, idx);
          }
          return file;
        };
      }
    });
    
    // node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/to-file.js
    var require_to_file = __commonJS({
      "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/to-file.js"(exports2, module2) {
        "use strict";
        var typeOf = require_kind_of();
        var stringify = require_stringify();
        var utils = require_utils();
        module2.exports = function(file) {
          if (typeOf(file) !== "object") {
            file = { content: file };
          }
          if (typeOf(file.data) !== "object") {
            file.data = {};
          }
          if (file.contents && file.content == null) {
            file.content = file.contents;
          }
          utils.define(file, "orig", utils.toBuffer(file.content));
          utils.define(file, "language", file.language || "");
          utils.define(file, "matter", file.matter || "");
          utils.define(file, "stringify", function(data, options2) {
            if (options2 && options2.language) {
              file.language = options2.language;
            }
            return stringify(file, data, options2);
          });
          file.content = utils.toString(file.content);
          file.isEmpty = false;
          file.excerpt = "";
          return file;
        };
      }
    });
    
    // node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/parse.js
    var require_parse = __commonJS({
      "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/parse.js"(exports2, module2) {
        "use strict";
        var getEngine = require_engine();
        var defaults = require_defaults();
        module2.exports = function(language, str2, options2) {
          const opts = defaults(options2);
          const engine = getEngine(language, opts);
          if (typeof engine.parse !== "function") {
            throw new TypeError('expected "' + language + '.parse" to be a function');
          }
          return engine.parse(str2, opts);
        };
      }
    });
    
    // node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js
    var require_gray_matter = __commonJS({
      "node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js"(exports2, module2) {
        "use strict";
        var fs2 = require("fs");
        var sections = require_section_matter();
        var defaults = require_defaults();
        var stringify = require_stringify();
        var excerpt = require_excerpt();
        var engines2 = require_engines();
        var toFile = require_to_file();
        var parse3 = require_parse();
        var utils = require_utils();
        function matter2(input, options2) {
          if (input === "") {
            return { data: {}, content: input, excerpt: "", orig: input };
          }
          let file = toFile(input);
          const cached = matter2.cache[file.content];
          if (!options2) {
            if (cached) {
              file = Object.assign({}, cached);
              file.orig = cached.orig;
              return file;
            }
            matter2.cache[file.content] = file;
          }
          return parseMatter(file, options2);
        }
        function parseMatter(file, options2) {
          const opts = defaults(options2);
          const open = opts.delimiters[0];
          const close = "\n" + opts.delimiters[1];
          let str2 = file.content;
          if (opts.language) {
            file.language = opts.language;
          }
          const openLen = open.length;
          if (!utils.startsWith(str2, open, openLen)) {
            excerpt(file, opts);
            return file;
          }
          if (str2.charAt(openLen) === open.slice(-1)) {
            return file;
          }
          str2 = str2.slice(openLen);
          const len = str2.length;
          const language = matter2.language(str2, opts);
          if (language.name) {
            file.language = language.name;
            str2 = str2.slice(language.raw.length);
          }
          let closeIndex = str2.indexOf(close);
          if (closeIndex === -1) {
            closeIndex = len;
          }
          file.matter = str2.slice(0, closeIndex);
          const block = file.matter.replace(/^\s*#[^\n]+/gm, "").trim();
          if (block === "") {
            file.isEmpty = true;
            file.empty = file.content;
            file.data = {};
          } else {
            file.data = parse3(file.language, file.matter, opts);
          }
          if (closeIndex === len) {
            file.content = "";
          } else {
            file.content = str2.slice(closeIndex + close.length);
            if (file.content[0] === "\r") {
              file.content = file.content.slice(1);
            }
            if (file.content[0] === "\n") {
              file.content = file.content.slice(1);
            }
          }
          excerpt(file, opts);
          if (opts.sections === true || typeof opts.section === "function") {
            sections(file, opts.section);
          }
          return file;
        }
        matter2.engines = engines2;
        matter2.stringify = function(file, data, options2) {
          if (typeof file === "string")
            file = matter2(file, options2);
          return stringify(file, data, options2);
        };
        matter2.read = function(filepath, options2) {
          const str2 = fs2.readFileSync(filepath, "utf8");
          const file = matter2(str2, options2);
          file.path = filepath;
          return file;
        };
        matter2.test = function(str2, options2) {
          return utils.startsWith(str2, defaults(options2).delimiters[0]);
        };
        matter2.language = function(str2, options2) {
          const opts = defaults(options2);
          const open = opts.delimiters[0];
          if (matter2.test(str2)) {
            str2 = str2.slice(open.length);
          }
          const language = str2.slice(0, str2.search(/\r?\n/));
          return {
            raw: language,
            name: language ? language.trim() : ""
          };
        };
        matter2.cache = {};
        matter2.clearCache = function() {
          matter2.cache = {};
        };
        module2.exports = matter2;
      }
    });
    
    // node_modules/.pnpm/entities@3.0.1/node_modules/entities/lib/maps/entities.json
    var require_entities = __commonJS({
      "node_modules/.pnpm/entities@3.0.1/node_modules/entities/lib/maps/entities.json"(exports2, module2) {
        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" };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/common/entities.js
    var require_entities2 = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/common/entities.js"(exports2, module2) {
        "use strict";
        module2.exports = require_entities();
      }
    });
    
    // node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/categories/P/regex.js
    var require_regex = __commonJS({
      "node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/categories/P/regex.js"(exports2, module2) {
        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]/;
      }
    });
    
    // node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/encode.js
    var require_encode = __commonJS({
      "node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/encode.js"(exports2, module2) {
        "use strict";
        var encodeCache = {};
        function getEncodeCache(exclude) {
          var i, ch, cache = encodeCache[exclude];
          if (cache) {
            return cache;
          }
          cache = encodeCache[exclude] = [];
          for (i = 0; i < 128; i++) {
            ch = String.fromCharCode(i);
            if (/^[0-9a-z]$/i.test(ch)) {
              cache.push(ch);
            } else {
              cache.push("%" + ("0" + i.toString(16).toUpperCase()).slice(-2));
            }
          }
          for (i = 0; i < exclude.length; i++) {
            cache[exclude.charCodeAt(i)] = exclude[i];
          }
          return cache;
        }
        function encode(string, exclude, keepEscaped) {
          var i, l, code, nextCode, cache, result = "";
          if (typeof exclude !== "string") {
            keepEscaped = exclude;
            exclude = encode.defaultChars;
          }
          if (typeof keepEscaped === "undefined") {
            keepEscaped = true;
          }
          cache = getEncodeCache(exclude);
          for (i = 0, l = string.length; i < l; i++) {
            code = string.charCodeAt(i);
            if (keepEscaped && code === 37 && i + 2 < l) {
              if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
                result += string.slice(i, i + 3);
                i += 2;
                continue;
              }
            }
            if (code < 128) {
              result += cache[code];
              continue;
            }
            if (code >= 55296 && code <= 57343) {
              if (code >= 55296 && code <= 56319 && i + 1 < l) {
                nextCode = string.charCodeAt(i + 1);
                if (nextCode >= 56320 && nextCode <= 57343) {
                  result += encodeURIComponent(string[i] + string[i + 1]);
                  i++;
                  continue;
                }
              }
              result += "%EF%BF%BD";
              continue;
            }
            result += encodeURIComponent(string[i]);
          }
          return result;
        }
        encode.defaultChars = ";/?:@&=+$,-_.!~*'()#";
        encode.componentChars = "-_.!~*'()";
        module2.exports = encode;
      }
    });
    
    // node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/decode.js
    var require_decode = __commonJS({
      "node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/decode.js"(exports2, module2) {
        "use strict";
        var decodeCache = {};
        function getDecodeCache(exclude) {
          var i, ch, cache = decodeCache[exclude];
          if (cache) {
            return cache;
          }
          cache = decodeCache[exclude] = [];
          for (i = 0; i < 128; i++) {
            ch = String.fromCharCode(i);
            cache.push(ch);
          }
          for (i = 0; i < exclude.length; i++) {
            ch = exclude.charCodeAt(i);
            cache[ch] = "%" + ("0" + ch.toString(16).toUpperCase()).slice(-2);
          }
          return cache;
        }
        function decode(string, exclude) {
          var cache;
          if (typeof exclude !== "string") {
            exclude = decode.defaultChars;
          }
          cache = getDecodeCache(exclude);
          return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {
            var i, l, b1, b2, b3, b4, chr, result = "";
            for (i = 0, l = seq.length; i < l; i += 3) {
              b1 = parseInt(seq.slice(i + 1, i + 3), 16);
              if (b1 < 128) {
                result += cache[b1];
                continue;
              }
              if ((b1 & 224) === 192 && i + 3 < l) {
                b2 = parseInt(seq.slice(i + 4, i + 6), 16);
                if ((b2 & 192) === 128) {
                  chr = b1 << 6 & 1984 | b2 & 63;
                  if (chr < 128) {
                    result += "\uFFFD\uFFFD";
                  } else {
                    result += String.fromCharCode(chr);
                  }
                  i += 3;
                  continue;
                }
              }
              if ((b1 & 240) === 224 && i + 6 < l) {
                b2 = parseInt(seq.slice(i + 4, i + 6), 16);
                b3 = parseInt(seq.slice(i + 7, i + 9), 16);
                if ((b2 & 192) === 128 && (b3 & 192) === 128) {
                  chr = b1 << 12 & 61440 | b2 << 6 & 4032 | b3 & 63;
                  if (chr < 2048 || chr >= 55296 && chr <= 57343) {
                    result += "\uFFFD\uFFFD\uFFFD";
                  } else {
                    result += String.fromCharCode(chr);
                  }
                  i += 6;
                  continue;
                }
              }
              if ((b1 & 248) === 240 && i + 9 < l) {
                b2 = parseInt(seq.slice(i + 4, i + 6), 16);
                b3 = parseInt(seq.slice(i + 7, i + 9), 16);
                b4 = parseInt(seq.slice(i + 10, i + 12), 16);
                if ((b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128) {
                  chr = b1 << 18 & 1835008 | b2 << 12 & 258048 | b3 << 6 & 4032 | b4 & 63;
                  if (chr < 65536 || chr > 1114111) {
                    result += "\uFFFD\uFFFD\uFFFD\uFFFD";
                  } else {
                    chr -= 65536;
                    result += String.fromCharCode(55296 + (chr >> 10), 56320 + (chr & 1023));
                  }
                  i += 9;
                  continue;
                }
              }
              result += "\uFFFD";
            }
            return result;
          });
        }
        decode.defaultChars = ";/?:@&=+$,#";
        decode.componentChars = "";
        module2.exports = decode;
      }
    });
    
    // node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/format.js
    var require_format = __commonJS({
      "node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/format.js"(exports2, module2) {
        "use strict";
        module2.exports = function format(url) {
          var result = "";
          result += url.protocol || "";
          result += url.slashes ? "//" : "";
          result += url.auth ? url.auth + "@" : "";
          if (url.hostname && url.hostname.indexOf(":") !== -1) {
            result += "[" + url.hostname + "]";
          } else {
            result += url.hostname || "";
          }
          result += url.port ? ":" + url.port : "";
          result += url.pathname || "";
          result += url.search || "";
          result += url.hash || "";
          return result;
        };
      }
    });
    
    // node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/parse.js
    var require_parse2 = __commonJS({
      "node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/parse.js"(exports2, module2) {
        "use strict";
        function Url() {
          this.protocol = null;
          this.slashes = null;
          this.auth = null;
          this.port = null;
          this.hostname = null;
          this.hash = null;
          this.search = null;
          this.pathname = null;
        }
        var protocolPattern = /^([a-z0-9.+-]+:)/i;
        var portPattern = /:[0-9]*$/;
        var simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
        var delims = ["<", ">", '"', "`", " ", "\r", "\n", "	"];
        var unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims);
        var autoEscape = ["'"].concat(unwise);
        var nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape);
        var hostEndingChars = ["/", "?", "#"];
        var hostnameMaxLen = 255;
        var hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
        var hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
        var hostlessProtocol = {
          "javascript": true,
          "javascript:": true
        };
        var slashedProtocol = {
          "http": true,
          "https": true,
          "ftp": true,
          "gopher": true,
          "file": true,
          "http:": true,
          "https:": true,
          "ftp:": true,
          "gopher:": true,
          "file:": true
        };
        function urlParse(url, slashesDenoteHost) {
          if (url && url instanceof Url) {
            return url;
          }
          var u = new Url();
          u.parse(url, slashesDenoteHost);
          return u;
        }
        Url.prototype.parse = function(url, slashesDenoteHost) {
          var i, l, lowerProto, hec, slashes, rest = url;
          rest = rest.trim();
          if (!slashesDenoteHost && url.split("#").length === 1) {
            var simplePath = simplePathPattern.exec(rest);
            if (simplePath) {
              this.pathname = simplePath[1];
              if (simplePath[2]) {
                this.search = simplePath[2];
              }
              return this;
            }
          }
          var proto = protocolPattern.exec(rest);
          if (proto) {
            proto = proto[0];
            lowerProto = proto.toLowerCase();
            this.protocol = proto;
            rest = rest.substr(proto.length);
          }
          if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
            slashes = rest.substr(0, 2) === "//";
            if (slashes && !(proto && hostlessProtocol[proto])) {
              rest = rest.substr(2);
              this.slashes = true;
            }
          }
          if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
            var hostEnd = -1;
            for (i = 0; i < hostEndingChars.length; i++) {
              hec = rest.indexOf(hostEndingChars[i]);
              if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
                hostEnd = hec;
              }
            }
            var auth, atSign;
            if (hostEnd === -1) {
              atSign = rest.lastIndexOf("@");
            } else {
              atSign = rest.lastIndexOf("@", hostEnd);
            }
            if (atSign !== -1) {
              auth = rest.slice(0, atSign);
              rest = rest.slice(atSign + 1);
              this.auth = auth;
            }
            hostEnd = -1;
            for (i = 0; i < nonHostChars.length; i++) {
              hec = rest.indexOf(nonHostChars[i]);
              if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
                hostEnd = hec;
              }
            }
            if (hostEnd === -1) {
              hostEnd = rest.length;
            }
            if (rest[hostEnd - 1] === ":") {
              hostEnd--;
            }
            var host = rest.slice(0, hostEnd);
            rest = rest.slice(hostEnd);
            this.parseHost(host);
            this.hostname = this.hostname || "";
            var ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
            if (!ipv6Hostname) {
              var hostparts = this.hostname.split(/\./);
              for (i = 0, l = hostparts.length; i < l; i++) {
                var part = hostparts[i];
                if (!part) {
                  continue;
                }
                if (!part.match(hostnamePartPattern)) {
                  var newpart = "";
                  for (var j = 0, k = part.length; j < k; j++) {
                    if (part.charCodeAt(j) > 127) {
                      newpart += "x";
                    } else {
                      newpart += part[j];
                    }
                  }
                  if (!newpart.match(hostnamePartPattern)) {
                    var validParts = hostparts.slice(0, i);
                    var notHost = hostparts.slice(i + 1);
                    var bit = part.match(hostnamePartStart);
                    if (bit) {
                      validParts.push(bit[1]);
                      notHost.unshift(bit[2]);
                    }
                    if (notHost.length) {
                      rest = notHost.join(".") + rest;
                    }
                    this.hostname = validParts.join(".");
                    break;
                  }
                }
              }
            }
            if (this.hostname.length > hostnameMaxLen) {
              this.hostname = "";
            }
            if (ipv6Hostname) {
              this.hostname = this.hostname.substr(1, this.hostname.length - 2);
            }
          }
          var hash = rest.indexOf("#");
          if (hash !== -1) {
            this.hash = rest.substr(hash);
            rest = rest.slice(0, hash);
          }
          var qm = rest.indexOf("?");
          if (qm !== -1) {
            this.search = rest.substr(qm);
            rest = rest.slice(0, qm);
          }
          if (rest) {
            this.pathname = rest;
          }
          if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
            this.pathname = "";
          }
          return this;
        };
        Url.prototype.parseHost = function(host) {
          var port = portPattern.exec(host);
          if (port) {
            port = port[0];
            if (port !== ":") {
              this.port = port.substr(1);
            }
            host = host.substr(0, host.length - port.length);
          }
          if (host) {
            this.hostname = host;
          }
        };
        module2.exports = urlParse;
      }
    });
    
    // node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/index.js
    var require_mdurl = __commonJS({
      "node_modules/.pnpm/mdurl@1.0.1/node_modules/mdurl/index.js"(exports2, module2) {
        "use strict";
        module2.exports.encode = require_encode();
        module2.exports.decode = require_decode();
        module2.exports.format = require_format();
        module2.exports.parse = require_parse2();
      }
    });
    
    // node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/properties/Any/regex.js
    var require_regex2 = __commonJS({
      "node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/properties/Any/regex.js"(exports2, module2) {
        module2.exports = /[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
      }
    });
    
    // node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/categories/Cc/regex.js
    var require_regex3 = __commonJS({
      "node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/categories/Cc/regex.js"(exports2, module2) {
        module2.exports = /[\0-\x1F\x7F-\x9F]/;
      }
    });
    
    // node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/categories/Cf/regex.js
    var require_regex4 = __commonJS({
      "node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/categories/Cf/regex.js"(exports2, module2) {
        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]/;
      }
    });
    
    // node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/categories/Z/regex.js
    var require_regex5 = __commonJS({
      "node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/categories/Z/regex.js"(exports2, module2) {
        module2.exports = /[ \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
      }
    });
    
    // node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/index.js
    var require_uc = __commonJS({
      "node_modules/.pnpm/uc.micro@1.0.6/node_modules/uc.micro/index.js"(exports2) {
        "use strict";
        exports2.Any = require_regex2();
        exports2.Cc = require_regex3();
        exports2.Cf = require_regex4();
        exports2.P = require_regex();
        exports2.Z = require_regex5();
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/common/utils.js
    var require_utils2 = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/common/utils.js"(exports2) {
        "use strict";
        function _class(obj) {
          return Object.prototype.toString.call(obj);
        }
        function isString(obj) {
          return _class(obj) === "[object String]";
        }
        var _hasOwnProperty = Object.prototype.hasOwnProperty;
        function has(object, key) {
          return _hasOwnProperty.call(object, key);
        }
        function assign(obj) {
          var sources = Array.prototype.slice.call(arguments, 1);
          sources.forEach(function(source) {
            if (!source) {
              return;
            }
            if (typeof source !== "object") {
              throw new TypeError(source + "must be object");
            }
            Object.keys(source).forEach(function(key) {
              obj[key] = source[key];
            });
          });
          return obj;
        }
        function arrayReplaceAt(src, pos, newElements) {
          return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
        }
        function isValidEntityCode(c) {
          if (c >= 55296 && c <= 57343) {
            return false;
          }
          if (c >= 64976 && c <= 65007) {
            return false;
          }
          if ((c & 65535) === 65535 || (c & 65535) === 65534) {
            return false;
          }
          if (c >= 0 && c <= 8) {
            return false;
          }
          if (c === 11) {
            return false;
          }
          if (c >= 14 && c <= 31) {
            return false;
          }
          if (c >= 127 && c <= 159) {
            return false;
          }
          if (c > 1114111) {
            return false;
          }
          return true;
        }
        function fromCodePoint(c) {
          if (c > 65535) {
            c -= 65536;
            var surrogate1 = 55296 + (c >> 10), surrogate2 = 56320 + (c & 1023);
            return String.fromCharCode(surrogate1, surrogate2);
          }
          return String.fromCharCode(c);
        }
        var UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])/g;
        var ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
        var UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + "|" + ENTITY_RE.source, "gi");
        var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;
        var entities = require_entities2();
        function replaceEntityPattern(match, name) {
          var code = 0;
          if (has(entities, name)) {
            return entities[name];
          }
          if (name.charCodeAt(0) === 35 && DIGITAL_ENTITY_TEST_RE.test(name)) {
            code = name[1].toLowerCase() === "x" ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
            if (isValidEntityCode(code)) {
              return fromCodePoint(code);
            }
          }
          return match;
        }
        function unescapeMd(str2) {
          if (str2.indexOf("\\") < 0) {
            return str2;
          }
          return str2.replace(UNESCAPE_MD_RE, "$1");
        }
        function unescapeAll(str2) {
          if (str2.indexOf("\\") < 0 && str2.indexOf("&") < 0) {
            return str2;
          }
          return str2.replace(UNESCAPE_ALL_RE, function(match, escaped, entity) {
            if (escaped) {
              return escaped;
            }
            return replaceEntityPattern(match, entity);
          });
        }
        var HTML_ESCAPE_TEST_RE = /[&<>"]/;
        var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
        var HTML_REPLACEMENTS = {
          "&": "&amp;",
          "<": "&lt;",
          ">": "&gt;",
          '"': "&quot;"
        };
        function replaceUnsafeChar(ch) {
          return HTML_REPLACEMENTS[ch];
        }
        function escapeHtml(str2) {
          if (HTML_ESCAPE_TEST_RE.test(str2)) {
            return str2.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
          }
          return str2;
        }
        var REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;
        function escapeRE(str2) {
          return str2.replace(REGEXP_ESCAPE_RE, "\\$&");
        }
        function isSpace(code) {
          switch (code) {
            case 9:
            case 32:
              return true;
          }
          return false;
        }
        function isWhiteSpace(code) {
          if (code >= 8192 && code <= 8202) {
            return true;
          }
          switch (code) {
            case 9:
            case 10:
            case 11:
            case 12:
            case 13:
            case 32:
            case 160:
            case 5760:
            case 8239:
            case 8287:
            case 12288:
              return true;
          }
          return false;
        }
        var UNICODE_PUNCT_RE = require_regex();
        function isPunctChar(ch) {
          return UNICODE_PUNCT_RE.test(ch);
        }
        function isMdAsciiPunct(ch) {
          switch (ch) {
            case 33:
            case 34:
            case 35:
            case 36:
            case 37:
            case 38:
            case 39:
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 58:
            case 59:
            case 60:
            case 61:
            case 62:
            case 63:
            case 64:
            case 91:
            case 92:
            case 93:
            case 94:
            case 95:
            case 96:
            case 123:
            case 124:
            case 125:
            case 126:
              return true;
            default:
              return false;
          }
        }
        function normalizeReference(str2) {
          str2 = str2.trim().replace(/\s+/g, " ");
          if ("\u1E9E".toLowerCase() === "\u1E7E") {
            str2 = str2.replace(/ẞ/g, "\xDF");
          }
          return str2.toLowerCase().toUpperCase();
        }
        exports2.lib = {};
        exports2.lib.mdurl = require_mdurl();
        exports2.lib.ucmicro = require_uc();
        exports2.assign = assign;
        exports2.isString = isString;
        exports2.has = has;
        exports2.unescapeMd = unescapeMd;
        exports2.unescapeAll = unescapeAll;
        exports2.isValidEntityCode = isValidEntityCode;
        exports2.fromCodePoint = fromCodePoint;
        exports2.escapeHtml = escapeHtml;
        exports2.arrayReplaceAt = arrayReplaceAt;
        exports2.isSpace = isSpace;
        exports2.isWhiteSpace = isWhiteSpace;
        exports2.isMdAsciiPunct = isMdAsciiPunct;
        exports2.isPunctChar = isPunctChar;
        exports2.escapeRE = escapeRE;
        exports2.normalizeReference = normalizeReference;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/helpers/parse_link_label.js
    var require_parse_link_label = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/helpers/parse_link_label.js"(exports2, module2) {
        "use strict";
        module2.exports = function parseLinkLabel(state, start, disableNested) {
          var level, found, marker, prevPos, labelEnd = -1, max = state.posMax, oldPos = state.pos;
          state.pos = start + 1;
          level = 1;
          while (state.pos < max) {
            marker = state.src.charCodeAt(state.pos);
            if (marker === 93) {
              level--;
              if (level === 0) {
                found = true;
                break;
              }
            }
            prevPos = state.pos;
            state.md.inline.skipToken(state);
            if (marker === 91) {
              if (prevPos === state.pos - 1) {
                level++;
              } else if (disableNested) {
                state.pos = oldPos;
                return -1;
              }
            }
          }
          if (found) {
            labelEnd = state.pos;
          }
          state.pos = oldPos;
          return labelEnd;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/helpers/parse_link_destination.js
    var require_parse_link_destination = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/helpers/parse_link_destination.js"(exports2, module2) {
        "use strict";
        var unescapeAll = require_utils2().unescapeAll;
        module2.exports = function parseLinkDestination(str2, pos, max) {
          var code, level, lines = 0, start = pos, result = {
            ok: false,
            pos: 0,
            lines: 0,
            str: ""
          };
          if (str2.charCodeAt(pos) === 60) {
            pos++;
            while (pos < max) {
              code = str2.charCodeAt(pos);
              if (code === 10) {
                return result;
              }
              if (code === 60) {
                return result;
              }
              if (code === 62) {
                result.pos = pos + 1;
                result.str = unescapeAll(str2.slice(start + 1, pos));
                result.ok = true;
                return result;
              }
              if (code === 92 && pos + 1 < max) {
                pos += 2;
                continue;
              }
              pos++;
            }
            return result;
          }
          level = 0;
          while (pos < max) {
            code = str2.charCodeAt(pos);
            if (code === 32) {
              break;
            }
            if (code < 32 || code === 127) {
              break;
            }
            if (code === 92 && pos + 1 < max) {
              if (str2.charCodeAt(pos + 1) === 32) {
                break;
              }
              pos += 2;
              continue;
            }
            if (code === 40) {
              level++;
              if (level > 32) {
                return result;
              }
            }
            if (code === 41) {
              if (level === 0) {
                break;
              }
              level--;
            }
            pos++;
          }
          if (start === pos) {
            return result;
          }
          if (level !== 0) {
            return result;
          }
          result.str = unescapeAll(str2.slice(start, pos));
          result.lines = lines;
          result.pos = pos;
          result.ok = true;
          return result;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/helpers/parse_link_title.js
    var require_parse_link_title = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/helpers/parse_link_title.js"(exports2, module2) {
        "use strict";
        var unescapeAll = require_utils2().unescapeAll;
        module2.exports = function parseLinkTitle(str2, pos, max) {
          var code, marker, lines = 0, start = pos, result = {
            ok: false,
            pos: 0,
            lines: 0,
            str: ""
          };
          if (pos >= max) {
            return result;
          }
          marker = str2.charCodeAt(pos);
          if (marker !== 34 && marker !== 39 && marker !== 40) {
            return result;
          }
          pos++;
          if (marker === 40) {
            marker = 41;
          }
          while (pos < max) {
            code = str2.charCodeAt(pos);
            if (code === marker) {
              result.pos = pos + 1;
              result.lines = lines;
              result.str = unescapeAll(str2.slice(start + 1, pos));
              result.ok = true;
              return result;
            } else if (code === 40 && marker === 41) {
              return result;
            } else if (code === 10) {
              lines++;
            } else if (code === 92 && pos + 1 < max) {
              pos++;
              if (str2.charCodeAt(pos) === 10) {
                lines++;
              }
            }
            pos++;
          }
          return result;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/helpers/index.js
    var require_helpers = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/helpers/index.js"(exports2) {
        "use strict";
        exports2.parseLinkLabel = require_parse_link_label();
        exports2.parseLinkDestination = require_parse_link_destination();
        exports2.parseLinkTitle = require_parse_link_title();
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/renderer.js
    var require_renderer = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/renderer.js"(exports2, module2) {
        "use strict";
        var assign = require_utils2().assign;
        var unescapeAll = require_utils2().unescapeAll;
        var escapeHtml = require_utils2().escapeHtml;
        var default_rules = {};
        default_rules.code_inline = function(tokens, idx, options2, env, slf) {
          var token = tokens[idx];
          return "<code" + slf.renderAttrs(token) + ">" + escapeHtml(tokens[idx].content) + "</code>";
        };
        default_rules.code_block = function(tokens, idx, options2, env, slf) {
          var token = tokens[idx];
          return "<pre" + slf.renderAttrs(token) + "><code>" + escapeHtml(tokens[idx].content) + "</code></pre>\n";
        };
        default_rules.fence = function(tokens, idx, options2, env, slf) {
          var token = tokens[idx], info = token.info ? unescapeAll(token.info).trim() : "", langName = "", langAttrs = "", highlighted, i, arr, tmpAttrs, tmpToken;
          if (info) {
            arr = info.split(/(\s+)/g);
            langName = arr[0];
            langAttrs = arr.slice(2).join("");
          }
          if (options2.highlight) {
            highlighted = options2.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);
          } else {
            highlighted = escapeHtml(token.content);
          }
          if (highlighted.indexOf("<pre") === 0) {
            return highlighted + "\n";
          }
          if (info) {
            i = token.attrIndex("class");
            tmpAttrs = token.attrs ? token.attrs.slice() : [];
            if (i < 0) {
              tmpAttrs.push(["class", options2.langPrefix + langName]);
            } else {
              tmpAttrs[i] = tmpAttrs[i].slice();
              tmpAttrs[i][1] += " " + options2.langPrefix + langName;
            }
            tmpToken = {
              attrs: tmpAttrs
            };
            return "<pre><code" + slf.renderAttrs(tmpToken) + ">" + highlighted + "</code></pre>\n";
          }
          return "<pre><code" + slf.renderAttrs(token) + ">" + highlighted + "</code></pre>\n";
        };
        default_rules.image = function(tokens, idx, options2, env, slf) {
          var token = tokens[idx];
          token.attrs[token.attrIndex("alt")][1] = slf.renderInlineAsText(token.children, options2, env);
          return slf.renderToken(tokens, idx, options2);
        };
        default_rules.hardbreak = function(tokens, idx, options2) {
          return options2.xhtmlOut ? "<br />\n" : "<br>\n";
        };
        default_rules.softbreak = function(tokens, idx, options2) {
          return options2.breaks ? options2.xhtmlOut ? "<br />\n" : "<br>\n" : "\n";
        };
        default_rules.text = function(tokens, idx) {
          return escapeHtml(tokens[idx].content);
        };
        default_rules.html_block = function(tokens, idx) {
          return tokens[idx].content;
        };
        default_rules.html_inline = function(tokens, idx) {
          return tokens[idx].content;
        };
        function Renderer() {
          this.rules = assign({}, default_rules);
        }
        Renderer.prototype.renderAttrs = function renderAttrs(token) {
          var i, l, result;
          if (!token.attrs) {
            return "";
          }
          result = "";
          for (i = 0, l = token.attrs.length; i < l; i++) {
            result += " " + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
          }
          return result;
        };
        Renderer.prototype.renderToken = function renderToken(tokens, idx, options2) {
          var nextToken, result = "", needLf = false, token = tokens[idx];
          if (token.hidden) {
            return "";
          }
          if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
            result += "\n";
          }
          result += (token.nesting === -1 ? "</" : "<") + token.tag;
          result += this.renderAttrs(token);
          if (token.nesting === 0 && options2.xhtmlOut) {
            result += " /";
          }
          if (token.block) {
            needLf = true;
            if (token.nesting === 1) {
              if (idx + 1 < tokens.length) {
                nextToken = tokens[idx + 1];
                if (nextToken.type === "inline" || nextToken.hidden) {
                  needLf = false;
                } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
                  needLf = false;
                }
              }
            }
          }
          result += needLf ? ">\n" : ">";
          return result;
        };
        Renderer.prototype.renderInline = function(tokens, options2, env) {
          var type, result = "", rules = this.rules;
          for (var i = 0, len = tokens.length; i < len; i++) {
            type = tokens[i].type;
            if (typeof rules[type] !== "undefined") {
              result += rules[type](tokens, i, options2, env, this);
            } else {
              result += this.renderToken(tokens, i, options2);
            }
          }
          return result;
        };
        Renderer.prototype.renderInlineAsText = function(tokens, options2, env) {
          var result = "";
          for (var i = 0, len = tokens.length; i < len; i++) {
            if (tokens[i].type === "text") {
              result += tokens[i].content;
            } else if (tokens[i].type === "image") {
              result += this.renderInlineAsText(tokens[i].children, options2, env);
            } else if (tokens[i].type === "softbreak") {
              result += "\n";
            }
          }
          return result;
        };
        Renderer.prototype.render = function(tokens, options2, env) {
          var i, len, type, result = "", rules = this.rules;
          for (i = 0, len = tokens.length; i < len; i++) {
            type = tokens[i].type;
            if (type === "inline") {
              result += this.renderInline(tokens[i].children, options2, env);
            } else if (typeof rules[type] !== "undefined") {
              result += rules[tokens[i].type](tokens, i, options2, env, this);
            } else {
              result += this.renderToken(tokens, i, options2, env);
            }
          }
          return result;
        };
        module2.exports = Renderer;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/ruler.js
    var require_ruler = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/ruler.js"(exports2, module2) {
        "use strict";
        function Ruler() {
          this.__rules__ = [];
          this.__cache__ = null;
        }
        Ruler.prototype.__find__ = function(name) {
          for (var i = 0; i < this.__rules__.length; i++) {
            if (this.__rules__[i].name === name) {
              return i;
            }
          }
          return -1;
        };
        Ruler.prototype.__compile__ = function() {
          var self = this;
          var chains = [""];
          self.__rules__.forEach(function(rule) {
            if (!rule.enabled) {
              return;
            }
            rule.alt.forEach(function(altName) {
              if (chains.indexOf(altName) < 0) {
                chains.push(altName);
              }
            });
          });
          self.__cache__ = {};
          chains.forEach(function(chain) {
            self.__cache__[chain] = [];
            self.__rules__.forEach(function(rule) {
              if (!rule.enabled) {
                return;
              }
              if (chain && rule.alt.indexOf(chain) < 0) {
                return;
              }
              self.__cache__[chain].push(rule.fn);
            });
          });
        };
        Ruler.prototype.at = function(name, fn, options2) {
          var index = this.__find__(name);
          var opt = options2 || {};
          if (index === -1) {
            throw new Error("Parser rule not found: " + name);
          }
          this.__rules__[index].fn = fn;
          this.__rules__[index].alt = opt.alt || [];
          this.__cache__ = null;
        };
        Ruler.prototype.before = function(beforeName, ruleName, fn, options2) {
          var index = this.__find__(beforeName);
          var opt = options2 || {};
          if (index === -1) {
            throw new Error("Parser rule not found: " + beforeName);
          }
          this.__rules__.splice(index, 0, {
            name: ruleName,
            enabled: true,
            fn,
            alt: opt.alt || []
          });
          this.__cache__ = null;
        };
        Ruler.prototype.after = function(afterName, ruleName, fn, options2) {
          var index = this.__find__(afterName);
          var opt = options2 || {};
          if (index === -1) {
            throw new Error("Parser rule not found: " + afterName);
          }
          this.__rules__.splice(index + 1, 0, {
            name: ruleName,
            enabled: true,
            fn,
            alt: opt.alt || []
          });
          this.__cache__ = null;
        };
        Ruler.prototype.push = function(ruleName, fn, options2) {
          var opt = options2 || {};
          this.__rules__.push({
            name: ruleName,
            enabled: true,
            fn,
            alt: opt.alt || []
          });
          this.__cache__ = null;
        };
        Ruler.prototype.enable = function(list, ignoreInvalid) {
          if (!Array.isArray(list)) {
            list = [list];
          }
          var result = [];
          list.forEach(function(name) {
            var idx = this.__find__(name);
            if (idx < 0) {
              if (ignoreInvalid) {
                return;
              }
              throw new Error("Rules manager: invalid rule name " + name);
            }
            this.__rules__[idx].enabled = true;
            result.push(name);
          }, this);
          this.__cache__ = null;
          return result;
        };
        Ruler.prototype.enableOnly = function(list, ignoreInvalid) {
          if (!Array.isArray(list)) {
            list = [list];
          }
          this.__rules__.forEach(function(rule) {
            rule.enabled = false;
          });
          this.enable(list, ignoreInvalid);
        };
        Ruler.prototype.disable = function(list, ignoreInvalid) {
          if (!Array.isArray(list)) {
            list = [list];
          }
          var result = [];
          list.forEach(function(name) {
            var idx = this.__find__(name);
            if (idx < 0) {
              if (ignoreInvalid) {
                return;
              }
              throw new Error("Rules manager: invalid rule name " + name);
            }
            this.__rules__[idx].enabled = false;
            result.push(name);
          }, this);
          this.__cache__ = null;
          return result;
        };
        Ruler.prototype.getRules = function(chainName) {
          if (this.__cache__ === null) {
            this.__compile__();
          }
          return this.__cache__[chainName] || [];
        };
        module2.exports = Ruler;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/normalize.js
    var require_normalize = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/normalize.js"(exports2, module2) {
        "use strict";
        var NEWLINES_RE = /\r\n?|\n/g;
        var NULL_RE = /\0/g;
        module2.exports = function normalize(state) {
          var str2;
          str2 = state.src.replace(NEWLINES_RE, "\n");
          str2 = str2.replace(NULL_RE, "\uFFFD");
          state.src = str2;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/block.js
    var require_block = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/block.js"(exports2, module2) {
        "use strict";
        module2.exports = function block(state) {
          var token;
          if (state.inlineMode) {
            token = new state.Token("inline", "", 0);
            token.content = state.src;
            token.map = [0, 1];
            token.children = [];
            state.tokens.push(token);
          } else {
            state.md.block.parse(state.src, state.md, state.env, state.tokens);
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/inline.js
    var require_inline = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/inline.js"(exports2, module2) {
        "use strict";
        module2.exports = function inline(state) {
          var tokens = state.tokens, tok, i, l;
          for (i = 0, l = tokens.length; i < l; i++) {
            tok = tokens[i];
            if (tok.type === "inline") {
              state.md.inline.parse(tok.content, state.md, state.env, tok.children);
            }
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/linkify.js
    var require_linkify = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/linkify.js"(exports2, module2) {
        "use strict";
        var arrayReplaceAt = require_utils2().arrayReplaceAt;
        function isLinkOpen(str2) {
          return /^<a[>\s]/i.test(str2);
        }
        function isLinkClose(str2) {
          return /^<\/a\s*>/i.test(str2);
        }
        module2.exports = function linkify(state) {
          var i, j, l, tokens, token, currentToken, nodes, ln, text, pos, lastPos, level, htmlLinkLevel, url, fullUrl, urlText, blockTokens = state.tokens, links;
          if (!state.md.options.linkify) {
            return;
          }
          for (j = 0, l = blockTokens.length; j < l; j++) {
            if (blockTokens[j].type !== "inline" || !state.md.linkify.pretest(blockTokens[j].content)) {
              continue;
            }
            tokens = blockTokens[j].children;
            htmlLinkLevel = 0;
            for (i = tokens.length - 1; i >= 0; i--) {
              currentToken = tokens[i];
              if (currentToken.type === "link_close") {
                i--;
                while (tokens[i].level !== currentToken.level && tokens[i].type !== "link_open") {
                  i--;
                }
                continue;
              }
              if (currentToken.type === "html_inline") {
                if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
                  htmlLinkLevel--;
                }
                if (isLinkClose(currentToken.content)) {
                  htmlLinkLevel++;
                }
              }
              if (htmlLinkLevel > 0) {
                continue;
              }
              if (currentToken.type === "text" && state.md.linkify.test(currentToken.content)) {
                text = currentToken.content;
                links = state.md.linkify.match(text);
                nodes = [];
                level = currentToken.level;
                lastPos = 0;
                if (links.length > 0 && links[0].index === 0 && i > 0 && tokens[i - 1].type === "text_special") {
                  links = links.slice(1);
                }
                for (ln = 0; ln < links.length; ln++) {
                  url = links[ln].url;
                  fullUrl = state.md.normalizeLink(url);
                  if (!state.md.validateLink(fullUrl)) {
                    continue;
                  }
                  urlText = links[ln].text;
                  if (!links[ln].schema) {
                    urlText = state.md.normalizeLinkText("http://" + urlText).replace(/^http:\/\//, "");
                  } else if (links[ln].schema === "mailto:" && !/^mailto:/i.test(urlText)) {
                    urlText = state.md.normalizeLinkText("mailto:" + urlText).replace(/^mailto:/, "");
                  } else {
                    urlText = state.md.normalizeLinkText(urlText);
                  }
                  pos = links[ln].index;
                  if (pos > lastPos) {
                    token = new state.Token("text", "", 0);
                    token.content = text.slice(lastPos, pos);
                    token.level = level;
                    nodes.push(token);
                  }
                  token = new state.Token("link_open", "a", 1);
                  token.attrs = [["href", fullUrl]];
                  token.level = level++;
                  token.markup = "linkify";
                  token.info = "auto";
                  nodes.push(token);
                  token = new state.Token("text", "", 0);
                  token.content = urlText;
                  token.level = level;
                  nodes.push(token);
                  token = new state.Token("link_close", "a", -1);
                  token.level = --level;
                  token.markup = "linkify";
                  token.info = "auto";
                  nodes.push(token);
                  lastPos = links[ln].lastIndex;
                }
                if (lastPos < text.length) {
                  token = new state.Token("text", "", 0);
                  token.content = text.slice(lastPos);
                  token.level = level;
                  nodes.push(token);
                }
                blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
              }
            }
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/replacements.js
    var require_replacements = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/replacements.js"(exports2, module2) {
        "use strict";
        var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
        var SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i;
        var SCOPED_ABBR_RE = /\((c|tm|r)\)/ig;
        var SCOPED_ABBR = {
          c: "\xA9",
          r: "\xAE",
          tm: "\u2122"
        };
        function replaceFn(match, name) {
          return SCOPED_ABBR[name.toLowerCase()];
        }
        function replace_scoped(inlineTokens) {
          var i, token, inside_autolink = 0;
          for (i = inlineTokens.length - 1; i >= 0; i--) {
            token = inlineTokens[i];
            if (token.type === "text" && !inside_autolink) {
              token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
            }
            if (token.type === "link_open" && token.info === "auto") {
              inside_autolink--;
            }
            if (token.type === "link_close" && token.info === "auto") {
              inside_autolink++;
            }
          }
        }
        function replace_rare(inlineTokens) {
          var i, token, inside_autolink = 0;
          for (i = inlineTokens.length - 1; i >= 0; i--) {
            token = inlineTokens[i];
            if (token.type === "text" && !inside_autolink) {
              if (RARE_RE.test(token.content)) {
                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");
              }
            }
            if (token.type === "link_open" && token.info === "auto") {
              inside_autolink--;
            }
            if (token.type === "link_close" && token.info === "auto") {
              inside_autolink++;
            }
          }
        }
        module2.exports = function replace(state) {
          var blkIdx;
          if (!state.md.options.typographer) {
            return;
          }
          for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
            if (state.tokens[blkIdx].type !== "inline") {
              continue;
            }
            if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
              replace_scoped(state.tokens[blkIdx].children);
            }
            if (RARE_RE.test(state.tokens[blkIdx].content)) {
              replace_rare(state.tokens[blkIdx].children);
            }
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/smartquotes.js
    var require_smartquotes = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/smartquotes.js"(exports2, module2) {
        "use strict";
        var isWhiteSpace = require_utils2().isWhiteSpace;
        var isPunctChar = require_utils2().isPunctChar;
        var isMdAsciiPunct = require_utils2().isMdAsciiPunct;
        var QUOTE_TEST_RE = /['"]/;
        var QUOTE_RE = /['"]/g;
        var APOSTROPHE = "\u2019";
        function replaceAt(str2, index, ch) {
          return str2.slice(0, index) + ch + str2.slice(index + 1);
        }
        function process_inlines(tokens, state) {
          var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar, isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace, canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;
          stack = [];
          for (i = 0; i < tokens.length; i++) {
            token = tokens[i];
            thisLevel = tokens[i].level;
            for (j = stack.length - 1; j >= 0; j--) {
              if (stack[j].level <= thisLevel) {
                break;
              }
            }
            stack.length = j + 1;
            if (token.type !== "text") {
              continue;
            }
            text = token.content;
            pos = 0;
            max = text.length;
            OUTER:
              while (pos < max) {
                QUOTE_RE.lastIndex = pos;
                t = QUOTE_RE.exec(text);
                if (!t) {
                  break;
                }
                canOpen = canClose = true;
                pos = t.index + 1;
                isSingle = t[0] === "'";
                lastChar = 32;
                if (t.index - 1 >= 0) {
                  lastChar = text.charCodeAt(t.index - 1);
                } else {
                  for (j = i - 1; j >= 0; j--) {
                    if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak")
                      break;
                    if (!tokens[j].content)
                      continue;
                    lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);
                    break;
                  }
                }
                nextChar = 32;
                if (pos < max) {
                  nextChar = text.charCodeAt(pos);
                } else {
                  for (j = i + 1; j < tokens.length; j++) {
                    if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak")
                      break;
                    if (!tokens[j].content)
                      continue;
                    nextChar = tokens[j].content.charCodeAt(0);
                    break;
                  }
                }
                isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
                isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
                isLastWhiteSpace = isWhiteSpace(lastChar);
                isNextWhiteSpace = isWhiteSpace(nextChar);
                if (isNextWhiteSpace) {
                  canOpen = false;
                } else if (isNextPunctChar) {
                  if (!(isLastWhiteSpace || isLastPunctChar)) {
                    canOpen = false;
                  }
                }
                if (isLastWhiteSpace) {
                  canClose = false;
                } else if (isLastPunctChar) {
                  if (!(isNextWhiteSpace || isNextPunctChar)) {
                    canClose = false;
                  }
                }
                if (nextChar === 34 && t[0] === '"') {
                  if (lastChar >= 48 && lastChar <= 57) {
                    canClose = canOpen = false;
                  }
                }
                if (canOpen && canClose) {
                  canOpen = isLastPunctChar;
                  canClose = isNextPunctChar;
                }
                if (!canOpen && !canClose) {
                  if (isSingle) {
                    token.content = replaceAt(token.content, t.index, APOSTROPHE);
                  }
                  continue;
                }
                if (canClose) {
                  for (j = stack.length - 1; j >= 0; j--) {
                    item = stack[j];
                    if (stack[j].level < thisLevel) {
                      break;
                    }
                    if (item.single === isSingle && stack[j].level === thisLevel) {
                      item = stack[j];
                      if (isSingle) {
                        openQuote = state.md.options.quotes[2];
                        closeQuote = state.md.options.quotes[3];
                      } else {
                        openQuote = state.md.options.quotes[0];
                        closeQuote = state.md.options.quotes[1];
                      }
                      token.content = replaceAt(token.content, t.index, closeQuote);
                      tokens[item.token].content = replaceAt(
                        tokens[item.token].content,
                        item.pos,
                        openQuote
                      );
                      pos += closeQuote.length - 1;
                      if (item.token === i) {
                        pos += openQuote.length - 1;
                      }
                      text = token.content;
                      max = text.length;
                      stack.length = j;
                      continue OUTER;
                    }
                  }
                }
                if (canOpen) {
                  stack.push({
                    token: i,
                    pos: t.index,
                    single: isSingle,
                    level: thisLevel
                  });
                } else if (canClose && isSingle) {
                  token.content = replaceAt(token.content, t.index, APOSTROPHE);
                }
              }
          }
        }
        module2.exports = function smartquotes(state) {
          var blkIdx;
          if (!state.md.options.typographer) {
            return;
          }
          for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
            if (state.tokens[blkIdx].type !== "inline" || !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
              continue;
            }
            process_inlines(state.tokens[blkIdx].children, state);
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/text_join.js
    var require_text_join = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/text_join.js"(exports2, module2) {
        "use strict";
        module2.exports = function text_join(state) {
          var j, l, tokens, curr, max, last, blockTokens = state.tokens;
          for (j = 0, l = blockTokens.length; j < l; j++) {
            if (blockTokens[j].type !== "inline")
              continue;
            tokens = blockTokens[j].children;
            max = tokens.length;
            for (curr = 0; curr < max; curr++) {
              if (tokens[curr].type === "text_special") {
                tokens[curr].type = "text";
              }
            }
            for (curr = last = 0; curr < max; curr++) {
              if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") {
                tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
              } else {
                if (curr !== last) {
                  tokens[last] = tokens[curr];
                }
                last++;
              }
            }
            if (curr !== last) {
              tokens.length = last;
            }
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/token.js
    var require_token = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/token.js"(exports2, module2) {
        "use strict";
        function Token2(type, tag, nesting) {
          this.type = type;
          this.tag = tag;
          this.attrs = null;
          this.map = null;
          this.nesting = nesting;
          this.level = 0;
          this.children = null;
          this.content = "";
          this.markup = "";
          this.info = "";
          this.meta = null;
          this.block = false;
          this.hidden = false;
        }
        Token2.prototype.attrIndex = function attrIndex(name) {
          var attrs, i, len;
          if (!this.attrs) {
            return -1;
          }
          attrs = this.attrs;
          for (i = 0, len = attrs.length; i < len; i++) {
            if (attrs[i][0] === name) {
              return i;
            }
          }
          return -1;
        };
        Token2.prototype.attrPush = function attrPush(attrData) {
          if (this.attrs) {
            this.attrs.push(attrData);
          } else {
            this.attrs = [attrData];
          }
        };
        Token2.prototype.attrSet = function attrSet(name, value) {
          var idx = this.attrIndex(name), attrData = [name, value];
          if (idx < 0) {
            this.attrPush(attrData);
          } else {
            this.attrs[idx] = attrData;
          }
        };
        Token2.prototype.attrGet = function attrGet(name) {
          var idx = this.attrIndex(name), value = null;
          if (idx >= 0) {
            value = this.attrs[idx][1];
          }
          return value;
        };
        Token2.prototype.attrJoin = function attrJoin(name, value) {
          var idx = this.attrIndex(name);
          if (idx < 0) {
            this.attrPush([name, value]);
          } else {
            this.attrs[idx][1] = this.attrs[idx][1] + " " + value;
          }
        };
        module2.exports = Token2;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/state_core.js
    var require_state_core = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_core/state_core.js"(exports2, module2) {
        "use strict";
        var Token2 = require_token();
        function StateCore(src, md2, env) {
          this.src = src;
          this.env = env;
          this.tokens = [];
          this.inlineMode = false;
          this.md = md2;
        }
        StateCore.prototype.Token = Token2;
        module2.exports = StateCore;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/parser_core.js
    var require_parser_core = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/parser_core.js"(exports2, module2) {
        "use strict";
        var Ruler = require_ruler();
        var _rules = [
          ["normalize", require_normalize()],
          ["block", require_block()],
          ["inline", require_inline()],
          ["linkify", require_linkify()],
          ["replacements", require_replacements()],
          ["smartquotes", require_smartquotes()],
          // `text_join` finds `text_special` tokens (for escape sequences)
          // and joins them with the rest of the text
          ["text_join", require_text_join()]
        ];
        function Core() {
          this.ruler = new Ruler();
          for (var i = 0; i < _rules.length; i++) {
            this.ruler.push(_rules[i][0], _rules[i][1]);
          }
        }
        Core.prototype.process = function(state) {
          var i, l, rules;
          rules = this.ruler.getRules("");
          for (i = 0, l = rules.length; i < l; i++) {
            rules[i](state);
          }
        };
        Core.prototype.State = require_state_core();
        module2.exports = Core;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/table.js
    var require_table = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/table.js"(exports2, module2) {
        "use strict";
        var isSpace = require_utils2().isSpace;
        function getLine(state, line) {
          var pos = state.bMarks[line] + state.tShift[line], max = state.eMarks[line];
          return state.src.slice(pos, max);
        }
        function escapedSplit(str2) {
          var result = [], pos = 0, max = str2.length, ch, isEscaped = false, lastPos = 0, current = "";
          ch = str2.charCodeAt(pos);
          while (pos < max) {
            if (ch === 124) {
              if (!isEscaped) {
                result.push(current + str2.substring(lastPos, pos));
                current = "";
                lastPos = pos + 1;
              } else {
                current += str2.substring(lastPos, pos - 1);
                lastPos = pos;
              }
            }
            isEscaped = ch === 92;
            pos++;
            ch = str2.charCodeAt(pos);
          }
          result.push(current + str2.substring(lastPos));
          return result;
        }
        module2.exports = function table(state, startLine, endLine, silent) {
          var ch, lineText, pos, i, l, nextLine, columns, columnCount, token, aligns, t, tableLines, tbodyLines, oldParentType, terminate, terminatorRules, firstCh, secondCh;
          if (startLine + 2 > endLine) {
            return false;
          }
          nextLine = startLine + 1;
          if (state.sCount[nextLine] < state.blkIndent) {
            return false;
          }
          if (state.sCount[nextLine] - state.blkIndent >= 4) {
            return false;
          }
          pos = state.bMarks[nextLine] + state.tShift[nextLine];
          if (pos >= state.eMarks[nextLine]) {
            return false;
          }
          firstCh = state.src.charCodeAt(pos++);
          if (firstCh !== 124 && firstCh !== 45 && firstCh !== 58) {
            return false;
          }
          if (pos >= state.eMarks[nextLine]) {
            return false;
          }
          secondCh = state.src.charCodeAt(pos++);
          if (secondCh !== 124 && secondCh !== 45 && secondCh !== 58 && !isSpace(secondCh)) {
            return false;
          }
          if (firstCh === 45 && isSpace(secondCh)) {
            return false;
          }
          while (pos < state.eMarks[nextLine]) {
            ch = state.src.charCodeAt(pos);
            if (ch !== 124 && ch !== 45 && ch !== 58 && !isSpace(ch)) {
              return false;
            }
            pos++;
          }
          lineText = getLine(state, startLine + 1);
          columns = lineText.split("|");
          aligns = [];
          for (i = 0; i < columns.length; i++) {
            t = columns[i].trim();
            if (!t) {
              if (i === 0 || i === columns.length - 1) {
                continue;
              } else {
                return false;
              }
            }
            if (!/^:?-+:?$/.test(t)) {
              return false;
            }
            if (t.charCodeAt(t.length - 1) === 58) {
              aligns.push(t.charCodeAt(0) === 58 ? "center" : "right");
            } else if (t.charCodeAt(0) === 58) {
              aligns.push("left");
            } else {
              aligns.push("");
            }
          }
          lineText = getLine(state, startLine).trim();
          if (lineText.indexOf("|") === -1) {
            return false;
          }
          if (state.sCount[startLine] - state.blkIndent >= 4) {
            return false;
          }
          columns = escapedSplit(lineText);
          if (columns.length && columns[0] === "")
            columns.shift();
          if (columns.length && columns[columns.length - 1] === "")
            columns.pop();
          columnCount = columns.length;
          if (columnCount === 0 || columnCount !== aligns.length) {
            return false;
          }
          if (silent) {
            return true;
          }
          oldParentType = state.parentType;
          state.parentType = "table";
          terminatorRules = state.md.block.ruler.getRules("blockquote");
          token = state.push("table_open", "table", 1);
          token.map = tableLines = [startLine, 0];
          token = state.push("thead_open", "thead", 1);
          token.map = [startLine, startLine + 1];
          token = state.push("tr_open", "tr", 1);
          token.map = [startLine, startLine + 1];
          for (i = 0; i < columns.length; i++) {
            token = state.push("th_open", "th", 1);
            if (aligns[i]) {
              token.attrs = [["style", "text-align:" + aligns[i]]];
            }
            token = state.push("inline", "", 0);
            token.content = columns[i].trim();
            token.children = [];
            token = state.push("th_close", "th", -1);
          }
          token = state.push("tr_close", "tr", -1);
          token = state.push("thead_close", "thead", -1);
          for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
            if (state.sCount[nextLine] < state.blkIndent) {
              break;
            }
            terminate = false;
            for (i = 0, l = terminatorRules.length; i < l; i++) {
              if (terminatorRules[i](state, nextLine, endLine, true)) {
                terminate = true;
                break;
              }
            }
            if (terminate) {
              break;
            }
            lineText = getLine(state, nextLine).trim();
            if (!lineText) {
              break;
            }
            if (state.sCount[nextLine] - state.blkIndent >= 4) {
              break;
            }
            columns = escapedSplit(lineText);
            if (columns.length && columns[0] === "")
              columns.shift();
            if (columns.length && columns[columns.length - 1] === "")
              columns.pop();
            if (nextLine === startLine + 2) {
              token = state.push("tbody_open", "tbody", 1);
              token.map = tbodyLines = [startLine + 2, 0];
            }
            token = state.push("tr_open", "tr", 1);
            token.map = [nextLine, nextLine + 1];
            for (i = 0; i < columnCount; i++) {
              token = state.push("td_open", "td", 1);
              if (aligns[i]) {
                token.attrs = [["style", "text-align:" + aligns[i]]];
              }
              token = state.push("inline", "", 0);
              token.content = columns[i] ? columns[i].trim() : "";
              token.children = [];
              token = state.push("td_close", "td", -1);
            }
            token = state.push("tr_close", "tr", -1);
          }
          if (tbodyLines) {
            token = state.push("tbody_close", "tbody", -1);
            tbodyLines[1] = nextLine;
          }
          token = state.push("table_close", "table", -1);
          tableLines[1] = nextLine;
          state.parentType = oldParentType;
          state.line = nextLine;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/code.js
    var require_code = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/code.js"(exports2, module2) {
        "use strict";
        module2.exports = function code(state, startLine, endLine) {
          var nextLine, last, token;
          if (state.sCount[startLine] - state.blkIndent < 4) {
            return false;
          }
          last = nextLine = startLine + 1;
          while (nextLine < endLine) {
            if (state.isEmpty(nextLine)) {
              nextLine++;
              continue;
            }
            if (state.sCount[nextLine] - state.blkIndent >= 4) {
              nextLine++;
              last = nextLine;
              continue;
            }
            break;
          }
          state.line = last;
          token = state.push("code_block", "code", 0);
          token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + "\n";
          token.map = [startLine, state.line];
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/fence.js
    var require_fence = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/fence.js"(exports2, module2) {
        "use strict";
        module2.exports = function fence(state, startLine, endLine, silent) {
          var marker, len, params, nextLine, mem, token, markup, haveEndMarker = false, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
          if (state.sCount[startLine] - state.blkIndent >= 4) {
            return false;
          }
          if (pos + 3 > max) {
            return false;
          }
          marker = state.src.charCodeAt(pos);
          if (marker !== 126 && marker !== 96) {
            return false;
          }
          mem = pos;
          pos = state.skipChars(pos, marker);
          len = pos - mem;
          if (len < 3) {
            return false;
          }
          markup = state.src.slice(mem, pos);
          params = state.src.slice(pos, max);
          if (marker === 96) {
            if (params.indexOf(String.fromCharCode(marker)) >= 0) {
              return false;
            }
          }
          if (silent) {
            return true;
          }
          nextLine = startLine;
          for (; ; ) {
            nextLine++;
            if (nextLine >= endLine) {
              break;
            }
            pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
            max = state.eMarks[nextLine];
            if (pos < max && state.sCount[nextLine] < state.blkIndent) {
              break;
            }
            if (state.src.charCodeAt(pos) !== marker) {
              continue;
            }
            if (state.sCount[nextLine] - state.blkIndent >= 4) {
              continue;
            }
            pos = state.skipChars(pos, marker);
            if (pos - mem < len) {
              continue;
            }
            pos = state.skipSpaces(pos);
            if (pos < max) {
              continue;
            }
            haveEndMarker = true;
            break;
          }
          len = state.sCount[startLine];
          state.line = nextLine + (haveEndMarker ? 1 : 0);
          token = state.push("fence", "code", 0);
          token.info = params;
          token.content = state.getLines(startLine + 1, nextLine, len, true);
          token.markup = markup;
          token.map = [startLine, state.line];
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/blockquote.js
    var require_blockquote = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/blockquote.js"(exports2, module2) {
        "use strict";
        var isSpace = require_utils2().isSpace;
        module2.exports = function blockquote(state, startLine, endLine, silent) {
          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];
          if (state.sCount[startLine] - state.blkIndent >= 4) {
            return false;
          }
          if (state.src.charCodeAt(pos++) !== 62) {
            return false;
          }
          if (silent) {
            return true;
          }
          initial = offset = state.sCount[startLine] + 1;
          if (state.src.charCodeAt(pos) === 32) {
            pos++;
            initial++;
            offset++;
            adjustTab = false;
            spaceAfterMarker = true;
          } else if (state.src.charCodeAt(pos) === 9) {
            spaceAfterMarker = true;
            if ((state.bsCount[startLine] + offset) % 4 === 3) {
              pos++;
              initial++;
              offset++;
              adjustTab = false;
            } else {
              adjustTab = true;
            }
          } else {
            spaceAfterMarker = false;
          }
          oldBMarks = [state.bMarks[startLine]];
          state.bMarks[startLine] = pos;
          while (pos < max) {
            ch = state.src.charCodeAt(pos);
            if (isSpace(ch)) {
              if (ch === 9) {
                offset += 4 - (offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4;
              } else {
                offset++;
              }
            } else {
              break;
            }
            pos++;
          }
          oldBSCount = [state.bsCount[startLine]];
          state.bsCount[startLine] = state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0);
          lastLineEmpty = pos >= max;
          oldSCount = [state.sCount[startLine]];
          state.sCount[startLine] = offset - initial;
          oldTShift = [state.tShift[startLine]];
          state.tShift[startLine] = pos - state.bMarks[startLine];
          terminatorRules = state.md.block.ruler.getRules("blockquote");
          oldParentType = state.parentType;
          state.parentType = "blockquote";
          for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
            isOutdented = state.sCount[nextLine] < state.blkIndent;
            pos = state.bMarks[nextLine] + state.tShift[nextLine];
            max = state.eMarks[nextLine];
            if (pos >= max) {
              break;
            }
            if (state.src.charCodeAt(pos++) === 62 && !isOutdented) {
              initial = offset = state.sCount[nextLine] + 1;
              if (state.src.charCodeAt(pos) === 32) {
                pos++;
                initial++;
                offset++;
                adjustTab = false;
                spaceAfterMarker = true;
              } else if (state.src.charCodeAt(pos) === 9) {
                spaceAfterMarker = true;
                if ((state.bsCount[nextLine] + offset) % 4 === 3) {
                  pos++;
                  initial++;
                  offset++;
                  adjustTab = false;
                } else {
                  adjustTab = true;
                }
              } else {
                spaceAfterMarker = false;
              }
              oldBMarks.push(state.bMarks[nextLine]);
              state.bMarks[nextLine] = pos;
              while (pos < max) {
                ch = state.src.charCodeAt(pos);
                if (isSpace(ch)) {
                  if (ch === 9) {
                    offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
                  } else {
                    offset++;
                  }
                } else {
                  break;
                }
                pos++;
              }
              lastLineEmpty = pos >= max;
              oldBSCount.push(state.bsCount[nextLine]);
              state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);
              oldSCount.push(state.sCount[nextLine]);
              state.sCount[nextLine] = offset - initial;
              oldTShift.push(state.tShift[nextLine]);
              state.tShift[nextLine] = pos - state.bMarks[nextLine];
              continue;
            }
            if (lastLineEmpty) {
              break;
            }
            terminate = false;
            for (i = 0, l = terminatorRules.length; i < l; i++) {
              if (terminatorRules[i](state, nextLine, endLine, true)) {
                terminate = true;
                break;
              }
            }
            if (terminate) {
              state.lineMax = nextLine;
              if (state.blkIndent !== 0) {
                oldBMarks.push(state.bMarks[nextLine]);
                oldBSCount.push(state.bsCount[nextLine]);
                oldTShift.push(state.tShift[nextLine]);
                oldSCount.push(state.sCount[nextLine]);
                state.sCount[nextLine] -= state.blkIndent;
              }
              break;
            }
            oldBMarks.push(state.bMarks[nextLine]);
            oldBSCount.push(state.bsCount[nextLine]);
            oldTShift.push(state.tShift[nextLine]);
            oldSCount.push(state.sCount[nextLine]);
            state.sCount[nextLine] = -1;
          }
          oldIndent = state.blkIndent;
          state.blkIndent = 0;
          token = state.push("blockquote_open", "blockquote", 1);
          token.markup = ">";
          token.map = lines = [startLine, 0];
          state.md.block.tokenize(state, startLine, nextLine);
          token = state.push("blockquote_close", "blockquote", -1);
          token.markup = ">";
          state.lineMax = oldLineMax;
          state.parentType = oldParentType;
          lines[1] = state.line;
          for (i = 0; i < oldTShift.length; i++) {
            state.bMarks[i + startLine] = oldBMarks[i];
            state.tShift[i + startLine] = oldTShift[i];
            state.sCount[i + startLine] = oldSCount[i];
            state.bsCount[i + startLine] = oldBSCount[i];
          }
          state.blkIndent = oldIndent;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/hr.js
    var require_hr = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/hr.js"(exports2, module2) {
        "use strict";
        var isSpace = require_utils2().isSpace;
        module2.exports = function hr(state, startLine, endLine, silent) {
          var marker, cnt, ch, token, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
          if (state.sCount[startLine] - state.blkIndent >= 4) {
            return false;
          }
          marker = state.src.charCodeAt(pos++);
          if (marker !== 42 && marker !== 45 && marker !== 95) {
            return false;
          }
          cnt = 1;
          while (pos < max) {
            ch = state.src.charCodeAt(pos++);
            if (ch !== marker && !isSpace(ch)) {
              return false;
            }
            if (ch === marker) {
              cnt++;
            }
          }
          if (cnt < 3) {
            return false;
          }
          if (silent) {
            return true;
          }
          state.line = startLine + 1;
          token = state.push("hr", "hr", 0);
          token.map = [startLine, state.line];
          token.markup = Array(cnt + 1).join(String.fromCharCode(marker));
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/list.js
    var require_list = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/list.js"(exports2, module2) {
        "use strict";
        var isSpace = require_utils2().isSpace;
        function skipBulletListMarker(state, startLine) {
          var marker, pos, max, ch;
          pos = state.bMarks[startLine] + state.tShift[startLine];
          max = state.eMarks[startLine];
          marker = state.src.charCodeAt(pos++);
          if (marker !== 42 && marker !== 45 && marker !== 43) {
            return -1;
          }
          if (pos < max) {
            ch = state.src.charCodeAt(pos);
            if (!isSpace(ch)) {
              return -1;
            }
          }
          return pos;
        }
        function skipOrderedListMarker(state, startLine) {
          var ch, start = state.bMarks[startLine] + state.tShift[startLine], pos = start, max = state.eMarks[startLine];
          if (pos + 1 >= max) {
            return -1;
          }
          ch = state.src.charCodeAt(pos++);
          if (ch < 48 || ch > 57) {
            return -1;
          }
          for (; ; ) {
            if (pos >= max) {
              return -1;
            }
            ch = state.src.charCodeAt(pos++);
            if (ch >= 48 && ch <= 57) {
              if (pos - start >= 10) {
                return -1;
              }
              continue;
            }
            if (ch === 41 || ch === 46) {
              break;
            }
            return -1;
          }
          if (pos < max) {
            ch = state.src.charCodeAt(pos);
            if (!isSpace(ch)) {
              return -1;
            }
          }
          return pos;
        }
        function markTightParagraphs(state, idx) {
          var i, l, level = state.level + 2;
          for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
            if (state.tokens[i].level === level && state.tokens[i].type === "paragraph_open") {
              state.tokens[i + 2].hidden = true;
              state.tokens[i].hidden = true;
              i += 2;
            }
          }
        }
        module2.exports = function list(state, startLine, endLine, silent) {
          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;
          if (state.sCount[startLine] - state.blkIndent >= 4) {
            return false;
          }
          if (state.listIndent >= 0 && state.sCount[startLine] - state.listIndent >= 4 && state.sCount[startLine] < state.blkIndent) {
            return false;
          }
          if (silent && state.parentType === "paragraph") {
            if (state.sCount[startLine] >= state.blkIndent) {
              isTerminatingParagraph = true;
            }
          }
          if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {
            isOrdered = true;
            start = state.bMarks[startLine] + state.tShift[startLine];
            markerValue = Number(state.src.slice(start, posAfterMarker - 1));
            if (isTerminatingParagraph && markerValue !== 1)
              return false;
          } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {
            isOrdered = false;
          } else {
            return false;
          }
          if (isTerminatingParagraph) {
            if (state.skipSpaces(posAfterMarker) >= state.eMarks[startLine])
              return false;
          }
          markerCharCode = state.src.charCodeAt(posAfterMarker - 1);
          if (silent) {
            return true;
          }
          listTokIdx = state.tokens.length;
          if (isOrdered) {
            token = state.push("ordered_list_open", "ol", 1);
            if (markerValue !== 1) {
              token.attrs = [["start", markerValue]];
            }
          } else {
            token = state.push("bullet_list_open", "ul", 1);
          }
          token.map = listLines = [startLine, 0];
          token.markup = String.fromCharCode(markerCharCode);
          nextLine = startLine;
          prevEmptyEnd = false;
          terminatorRules = state.md.block.ruler.getRules("list");
          oldParentType = state.parentType;
          state.parentType = "list";
          while (nextLine < endLine) {
            pos = posAfterMarker;
            max = state.eMarks[nextLine];
            initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine]);
            while (pos < max) {
              ch = state.src.charCodeAt(pos);
              if (ch === 9) {
                offset += 4 - (offset + state.bsCount[nextLine]) % 4;
              } else if (ch === 32) {
                offset++;
              } else {
                break;
              }
              pos++;
            }
            contentStart = pos;
            if (contentStart >= max) {
              indentAfterMarker = 1;
            } else {
              indentAfterMarker = offset - initial;
            }
            if (indentAfterMarker > 4) {
              indentAfterMarker = 1;
            }
            indent = initial + indentAfterMarker;
            token = state.push("list_item_open", "li", 1);
            token.markup = String.fromCharCode(markerCharCode);
            token.map = itemLines = [startLine, 0];
            if (isOrdered) {
              token.info = state.src.slice(start, posAfterMarker - 1);
            }
            oldTight = state.tight;
            oldTShift = state.tShift[startLine];
            oldSCount = state.sCount[startLine];
            oldListIndent = state.listIndent;
            state.listIndent = state.blkIndent;
            state.blkIndent = indent;
            state.tight = true;
            state.tShift[startLine] = contentStart - state.bMarks[startLine];
            state.sCount[startLine] = offset;
            if (contentStart >= max && state.isEmpty(startLine + 1)) {
              state.line = Math.min(state.line + 2, endLine);
            } else {
              state.md.block.tokenize(state, startLine, endLine, true);
            }
            if (!state.tight || prevEmptyEnd) {
              tight = false;
            }
            prevEmptyEnd = state.line - startLine > 1 && state.isEmpty(state.line - 1);
            state.blkIndent = state.listIndent;
            state.listIndent = oldListIndent;
            state.tShift[startLine] = oldTShift;
            state.sCount[startLine] = oldSCount;
            state.tight = oldTight;
            token = state.push("list_item_close", "li", -1);
            token.markup = String.fromCharCode(markerCharCode);
            nextLine = startLine = state.line;
            itemLines[1] = nextLine;
            contentStart = state.bMarks[startLine];
            if (nextLine >= endLine) {
              break;
            }
            if (state.sCount[nextLine] < state.blkIndent) {
              break;
            }
            if (state.sCount[startLine] - state.blkIndent >= 4) {
              break;
            }
            terminate = false;
            for (i = 0, l = terminatorRules.length; i < l; i++) {
              if (terminatorRules[i](state, nextLine, endLine, true)) {
                terminate = true;
                break;
              }
            }
            if (terminate) {
              break;
            }
            if (isOrdered) {
              posAfterMarker = skipOrderedListMarker(state, nextLine);
              if (posAfterMarker < 0) {
                break;
              }
              start = state.bMarks[nextLine] + state.tShift[nextLine];
            } else {
              posAfterMarker = skipBulletListMarker(state, nextLine);
              if (posAfterMarker < 0) {
                break;
              }
            }
            if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {
              break;
            }
          }
          if (isOrdered) {
            token = state.push("ordered_list_close", "ol", -1);
          } else {
            token = state.push("bullet_list_close", "ul", -1);
          }
          token.markup = String.fromCharCode(markerCharCode);
          listLines[1] = nextLine;
          state.line = nextLine;
          state.parentType = oldParentType;
          if (tight) {
            markTightParagraphs(state, listTokIdx);
          }
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/reference.js
    var require_reference = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/reference.js"(exports2, module2) {
        "use strict";
        var normalizeReference = require_utils2().normalizeReference;
        var isSpace = require_utils2().isSpace;
        module2.exports = function reference(state, startLine, _endLine, silent) {
          var ch, destEndPos, destEndLineNo, endLine, href, i, l, label, labelEnd, oldParentType, res, start, str2, terminate, terminatorRules, title, lines = 0, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine], nextLine = startLine + 1;
          if (state.sCount[startLine] - state.blkIndent >= 4) {
            return false;
          }
          if (state.src.charCodeAt(pos) !== 91) {
            return false;
          }
          while (++pos < max) {
            if (state.src.charCodeAt(pos) === 93 && state.src.charCodeAt(pos - 1) !== 92) {
              if (pos + 1 === max) {
                return false;
              }
              if (state.src.charCodeAt(pos + 1) !== 58) {
                return false;
              }
              break;
            }
          }
          endLine = state.lineMax;
          terminatorRules = state.md.block.ruler.getRules("reference");
          oldParentType = state.parentType;
          state.parentType = "reference";
          for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
            if (state.sCount[nextLine] - state.blkIndent > 3) {
              continue;
            }
            if (state.sCount[nextLine] < 0) {
              continue;
            }
            terminate = false;
            for (i = 0, l = terminatorRules.length; i < l; i++) {
              if (terminatorRules[i](state, nextLine, endLine, true)) {
                terminate = true;
                break;
              }
            }
            if (terminate) {
              break;
            }
          }
          str2 = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
          max = str2.length;
          for (pos = 1; pos < max; pos++) {
            ch = str2.charCodeAt(pos);
            if (ch === 91) {
              return false;
            } else if (ch === 93) {
              labelEnd = pos;
              break;
            } else if (ch === 10) {
              lines++;
            } else if (ch === 92) {
              pos++;
              if (pos < max && str2.charCodeAt(pos) === 10) {
                lines++;
              }
            }
          }
          if (labelEnd < 0 || str2.charCodeAt(labelEnd + 1) !== 58) {
            return false;
          }
          for (pos = labelEnd + 2; pos < max; pos++) {
            ch = str2.charCodeAt(pos);
            if (ch === 10) {
              lines++;
            } else if (isSpace(ch)) {
            } else {
              break;
            }
          }
          res = state.md.helpers.parseLinkDestination(str2, pos, max);
          if (!res.ok) {
            return false;
          }
          href = state.md.normalizeLink(res.str);
          if (!state.md.validateLink(href)) {
            return false;
          }
          pos = res.pos;
          lines += res.lines;
          destEndPos = pos;
          destEndLineNo = lines;
          start = pos;
          for (; pos < max; pos++) {
            ch = str2.charCodeAt(pos);
            if (ch === 10) {
              lines++;
            } else if (isSpace(ch)) {
            } else {
              break;
            }
          }
          res = state.md.helpers.parseLinkTitle(str2, pos, max);
          if (pos < max && start !== pos && res.ok) {
            title = res.str;
            pos = res.pos;
            lines += res.lines;
          } else {
            title = "";
            pos = destEndPos;
            lines = destEndLineNo;
          }
          while (pos < max) {
            ch = str2.charCodeAt(pos);
            if (!isSpace(ch)) {
              break;
            }
            pos++;
          }
          if (pos < max && str2.charCodeAt(pos) !== 10) {
            if (title) {
              title = "";
              pos = destEndPos;
              lines = destEndLineNo;
              while (pos < max) {
                ch = str2.charCodeAt(pos);
                if (!isSpace(ch)) {
                  break;
                }
                pos++;
              }
            }
          }
          if (pos < max && str2.charCodeAt(pos) !== 10) {
            return false;
          }
          label = normalizeReference(str2.slice(1, labelEnd));
          if (!label) {
            return false;
          }
          if (silent) {
            return true;
          }
          if (typeof state.env.references === "undefined") {
            state.env.references = {};
          }
          if (typeof state.env.references[label] === "undefined") {
            state.env.references[label] = { title, href };
          }
          state.parentType = oldParentType;
          state.line = startLine + lines + 1;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/common/html_blocks.js
    var require_html_blocks = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/common/html_blocks.js"(exports2, module2) {
        "use strict";
        module2.exports = [
          "address",
          "article",
          "aside",
          "base",
          "basefont",
          "blockquote",
          "body",
          "caption",
          "center",
          "col",
          "colgroup",
          "dd",
          "details",
          "dialog",
          "dir",
          "div",
          "dl",
          "dt",
          "fieldset",
          "figcaption",
          "figure",
          "footer",
          "form",
          "frame",
          "frameset",
          "h1",
          "h2",
          "h3",
          "h4",
          "h5",
          "h6",
          "head",
          "header",
          "hr",
          "html",
          "iframe",
          "legend",
          "li",
          "link",
          "main",
          "menu",
          "menuitem",
          "nav",
          "noframes",
          "ol",
          "optgroup",
          "option",
          "p",
          "param",
          "section",
          "source",
          "summary",
          "table",
          "tbody",
          "td",
          "tfoot",
          "th",
          "thead",
          "title",
          "tr",
          "track",
          "ul"
        ];
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/common/html_re.js
    var require_html_re = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/common/html_re.js"(exports2, module2) {
        "use strict";
        var attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*";
        var unquoted = "[^\"'=<>`\\x00-\\x20]+";
        var single_quoted = "'[^']*'";
        var double_quoted = '"[^"]*"';
        var attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")";
        var attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)";
        var open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>";
        var close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
        var comment = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->";
        var processing = "<[?][\\s\\S]*?[?]>";
        var declaration = "<![A-Z]+\\s+[^>]*>";
        var cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
        var HTML_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + "|" + comment + "|" + processing + "|" + declaration + "|" + cdata + ")");
        var HTML_OPEN_CLOSE_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + ")");
        module2.exports.HTML_TAG_RE = HTML_TAG_RE;
        module2.exports.HTML_OPEN_CLOSE_TAG_RE = HTML_OPEN_CLOSE_TAG_RE;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/html_block.js
    var require_html_block = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/html_block.js"(exports2, module2) {
        "use strict";
        var block_names = require_html_blocks();
        var HTML_OPEN_CLOSE_TAG_RE = require_html_re().HTML_OPEN_CLOSE_TAG_RE;
        var HTML_SEQUENCES = [
          [/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true],
          [/^<!--/, /-->/, true],
          [/^<\?/, /\?>/, true],
          [/^<![A-Z]/, />/, true],
          [/^<!\[CDATA\[/, /\]\]>/, true],
          [new RegExp("^</?(" + block_names.join("|") + ")(?=(\\s|/?>|$))", "i"), /^$/, true],
          [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + "\\s*$"), /^$/, false]
        ];
        module2.exports = function html_block(state, startLine, endLine, silent) {
          var i, nextLine, token, lineText, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
          if (state.sCount[startLine] - state.blkIndent >= 4) {
            return false;
          }
          if (!state.md.options.html) {
            return false;
          }
          if (state.src.charCodeAt(pos) !== 60) {
            return false;
          }
          lineText = state.src.slice(pos, max);
          for (i = 0; i < HTML_SEQUENCES.length; i++) {
            if (HTML_SEQUENCES[i][0].test(lineText)) {
              break;
            }
          }
          if (i === HTML_SEQUENCES.length) {
            return false;
          }
          if (silent) {
            return HTML_SEQUENCES[i][2];
          }
          nextLine = startLine + 1;
          if (!HTML_SEQUENCES[i][1].test(lineText)) {
            for (; nextLine < endLine; nextLine++) {
              if (state.sCount[nextLine] < state.blkIndent) {
                break;
              }
              pos = state.bMarks[nextLine] + state.tShift[nextLine];
              max = state.eMarks[nextLine];
              lineText = state.src.slice(pos, max);
              if (HTML_SEQUENCES[i][1].test(lineText)) {
                if (lineText.length !== 0) {
                  nextLine++;
                }
                break;
              }
            }
          }
          state.line = nextLine;
          token = state.push("html_block", "", 0);
          token.map = [startLine, nextLine];
          token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/heading.js
    var require_heading = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/heading.js"(exports2, module2) {
        "use strict";
        var isSpace = require_utils2().isSpace;
        module2.exports = function heading(state, startLine, endLine, silent) {
          var ch, level, tmp, token, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
          if (state.sCount[startLine] - state.blkIndent >= 4) {
            return false;
          }
          ch = state.src.charCodeAt(pos);
          if (ch !== 35 || pos >= max) {
            return false;
          }
          level = 1;
          ch = state.src.charCodeAt(++pos);
          while (ch === 35 && pos < max && level <= 6) {
            level++;
            ch = state.src.charCodeAt(++pos);
          }
          if (level > 6 || pos < max && !isSpace(ch)) {
            return false;
          }
          if (silent) {
            return true;
          }
          max = state.skipSpacesBack(max, pos);
          tmp = state.skipCharsBack(max, 35, pos);
          if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
            max = tmp;
          }
          state.line = startLine + 1;
          token = state.push("heading_open", "h" + String(level), 1);
          token.markup = "########".slice(0, level);
          token.map = [startLine, state.line];
          token = state.push("inline", "", 0);
          token.content = state.src.slice(pos, max).trim();
          token.map = [startLine, state.line];
          token.children = [];
          token = state.push("heading_close", "h" + String(level), -1);
          token.markup = "########".slice(0, level);
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/lheading.js
    var require_lheading = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/lheading.js"(exports2, module2) {
        "use strict";
        module2.exports = function lheading(state, startLine, endLine) {
          var content, terminate, i, l, token, pos, max, level, marker, nextLine = startLine + 1, oldParentType, terminatorRules = state.md.block.ruler.getRules("paragraph");
          if (state.sCount[startLine] - state.blkIndent >= 4) {
            return false;
          }
          oldParentType = state.parentType;
          state.parentType = "paragraph";
          for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
            if (state.sCount[nextLine] - state.blkIndent > 3) {
              continue;
            }
            if (state.sCount[nextLine] >= state.blkIndent) {
              pos = state.bMarks[nextLine] + state.tShift[nextLine];
              max = state.eMarks[nextLine];
              if (pos < max) {
                marker = state.src.charCodeAt(pos);
                if (marker === 45 || marker === 61) {
                  pos = state.skipChars(pos, marker);
                  pos = state.skipSpaces(pos);
                  if (pos >= max) {
                    level = marker === 61 ? 1 : 2;
                    break;
                  }
                }
              }
            }
            if (state.sCount[nextLine] < 0) {
              continue;
            }
            terminate = false;
            for (i = 0, l = terminatorRules.length; i < l; i++) {
              if (terminatorRules[i](state, nextLine, endLine, true)) {
                terminate = true;
                break;
              }
            }
            if (terminate) {
              break;
            }
          }
          if (!level) {
            return false;
          }
          content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
          state.line = nextLine + 1;
          token = state.push("heading_open", "h" + String(level), 1);
          token.markup = String.fromCharCode(marker);
          token.map = [startLine, state.line];
          token = state.push("inline", "", 0);
          token.content = content;
          token.map = [startLine, state.line - 1];
          token.children = [];
          token = state.push("heading_close", "h" + String(level), -1);
          token.markup = String.fromCharCode(marker);
          state.parentType = oldParentType;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/paragraph.js
    var require_paragraph = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/paragraph.js"(exports2, module2) {
        "use strict";
        module2.exports = function paragraph(state, startLine) {
          var content, terminate, i, l, token, oldParentType, nextLine = startLine + 1, terminatorRules = state.md.block.ruler.getRules("paragraph"), endLine = state.lineMax;
          oldParentType = state.parentType;
          state.parentType = "paragraph";
          for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
            if (state.sCount[nextLine] - state.blkIndent > 3) {
              continue;
            }
            if (state.sCount[nextLine] < 0) {
              continue;
            }
            terminate = false;
            for (i = 0, l = terminatorRules.length; i < l; i++) {
              if (terminatorRules[i](state, nextLine, endLine, true)) {
                terminate = true;
                break;
              }
            }
            if (terminate) {
              break;
            }
          }
          content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
          state.line = nextLine;
          token = state.push("paragraph_open", "p", 1);
          token.map = [startLine, state.line];
          token = state.push("inline", "", 0);
          token.content = content;
          token.map = [startLine, state.line];
          token.children = [];
          token = state.push("paragraph_close", "p", -1);
          state.parentType = oldParentType;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/state_block.js
    var require_state_block = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_block/state_block.js"(exports2, module2) {
        "use strict";
        var Token2 = require_token();
        var isSpace = require_utils2().isSpace;
        function StateBlock(src, md2, env, tokens) {
          var ch, s, start, pos, len, indent, offset, indent_found;
          this.src = src;
          this.md = md2;
          this.env = env;
          this.tokens = tokens;
          this.bMarks = [];
          this.eMarks = [];
          this.tShift = [];
          this.sCount = [];
          this.bsCount = [];
          this.blkIndent = 0;
          this.line = 0;
          this.lineMax = 0;
          this.tight = false;
          this.ddIndent = -1;
          this.listIndent = -1;
          this.parentType = "root";
          this.level = 0;
          this.result = "";
          s = this.src;
          indent_found = false;
          for (start = pos = indent = offset = 0, len = s.length; pos < len; pos++) {
            ch = s.charCodeAt(pos);
            if (!indent_found) {
              if (isSpace(ch)) {
                indent++;
                if (ch === 9) {
                  offset += 4 - offset % 4;
                } else {
                  offset++;
                }
                continue;
              } else {
                indent_found = true;
              }
            }
            if (ch === 10 || pos === len - 1) {
              if (ch !== 10) {
                pos++;
              }
              this.bMarks.push(start);
              this.eMarks.push(pos);
              this.tShift.push(indent);
              this.sCount.push(offset);
              this.bsCount.push(0);
              indent_found = false;
              indent = 0;
              offset = 0;
              start = pos + 1;
            }
          }
          this.bMarks.push(s.length);
          this.eMarks.push(s.length);
          this.tShift.push(0);
          this.sCount.push(0);
          this.bsCount.push(0);
          this.lineMax = this.bMarks.length - 1;
        }
        StateBlock.prototype.push = function(type, tag, nesting) {
          var token = new Token2(type, tag, nesting);
          token.block = true;
          if (nesting < 0)
            this.level--;
          token.level = this.level;
          if (nesting > 0)
            this.level++;
          this.tokens.push(token);
          return token;
        };
        StateBlock.prototype.isEmpty = function isEmpty(line) {
          return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
        };
        StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
          for (var max = this.lineMax; from < max; from++) {
            if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
              break;
            }
          }
          return from;
        };
        StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
          var ch;
          for (var max = this.src.length; pos < max; pos++) {
            ch = this.src.charCodeAt(pos);
            if (!isSpace(ch)) {
              break;
            }
          }
          return pos;
        };
        StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
          if (pos <= min) {
            return pos;
          }
          while (pos > min) {
            if (!isSpace(this.src.charCodeAt(--pos))) {
              return pos + 1;
            }
          }
          return pos;
        };
        StateBlock.prototype.skipChars = function skipChars(pos, code) {
          for (var max = this.src.length; pos < max; pos++) {
            if (this.src.charCodeAt(pos) !== code) {
              break;
            }
          }
          return pos;
        };
        StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {
          if (pos <= min) {
            return pos;
          }
          while (pos > min) {
            if (code !== this.src.charCodeAt(--pos)) {
              return pos + 1;
            }
          }
          return pos;
        };
        StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {
          var i, lineIndent, ch, first, last, queue, lineStart, line = begin;
          if (begin >= end) {
            return "";
          }
          queue = new Array(end - begin);
          for (i = 0; line < end; line++, i++) {
            lineIndent = 0;
            lineStart = first = this.bMarks[line];
            if (line + 1 < end || keepLastLF) {
              last = this.eMarks[line] + 1;
            } else {
              last = this.eMarks[line];
            }
            while (first < last && lineIndent < indent) {
              ch = this.src.charCodeAt(first);
              if (isSpace(ch)) {
                if (ch === 9) {
                  lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
                } else {
                  lineIndent++;
                }
              } else if (first - lineStart < this.tShift[line]) {
                lineIndent++;
              } else {
                break;
              }
              first++;
            }
            if (lineIndent > indent) {
              queue[i] = new Array(lineIndent - indent + 1).join(" ") + this.src.slice(first, last);
            } else {
              queue[i] = this.src.slice(first, last);
            }
          }
          return queue.join("");
        };
        StateBlock.prototype.Token = Token2;
        module2.exports = StateBlock;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/parser_block.js
    var require_parser_block = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/parser_block.js"(exports2, module2) {
        "use strict";
        var Ruler = require_ruler();
        var _rules = [
          // First 2 params - rule name & source. Secondary array - list of rules,
          // which can be terminated by this one.
          ["table", require_table(), ["paragraph", "reference"]],
          ["code", require_code()],
          ["fence", require_fence(), ["paragraph", "reference", "blockquote", "list"]],
          ["blockquote", require_blockquote(), ["paragraph", "reference", "blockquote", "list"]],
          ["hr", require_hr(), ["paragraph", "reference", "blockquote", "list"]],
          ["list", require_list(), ["paragraph", "reference", "blockquote"]],
          ["reference", require_reference()],
          ["html_block", require_html_block(), ["paragraph", "reference", "blockquote"]],
          ["heading", require_heading(), ["paragraph", "reference", "blockquote"]],
          ["lheading", require_lheading()],
          ["paragraph", require_paragraph()]
        ];
        function ParserBlock() {
          this.ruler = new Ruler();
          for (var i = 0; i < _rules.length; i++) {
            this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });
          }
        }
        ParserBlock.prototype.tokenize = function(state, startLine, endLine) {
          var ok, i, rules = this.ruler.getRules(""), len = rules.length, line = startLine, hasEmptyLines = false, maxNesting = state.md.options.maxNesting;
          while (line < endLine) {
            state.line = line = state.skipEmptyLines(line);
            if (line >= endLine) {
              break;
            }
            if (state.sCount[line] < state.blkIndent) {
              break;
            }
            if (state.level >= maxNesting) {
              state.line = endLine;
              break;
            }
            for (i = 0; i < len; i++) {
              ok = rules[i](state, line, endLine, false);
              if (ok) {
                break;
              }
            }
            state.tight = !hasEmptyLines;
            if (state.isEmpty(state.line - 1)) {
              hasEmptyLines = true;
            }
            line = state.line;
            if (line < endLine && state.isEmpty(line)) {
              hasEmptyLines = true;
              line++;
              state.line = line;
            }
          }
        };
        ParserBlock.prototype.parse = function(src, md2, env, outTokens) {
          var state;
          if (!src) {
            return;
          }
          state = new this.State(src, md2, env, outTokens);
          this.tokenize(state, state.line, state.lineMax);
        };
        ParserBlock.prototype.State = require_state_block();
        module2.exports = ParserBlock;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/text.js
    var require_text = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/text.js"(exports2, module2) {
        "use strict";
        function isTerminatorChar(ch) {
          switch (ch) {
            case 10:
            case 33:
            case 35:
            case 36:
            case 37:
            case 38:
            case 42:
            case 43:
            case 45:
            case 58:
            case 60:
            case 61:
            case 62:
            case 64:
            case 91:
            case 92:
            case 93:
            case 94:
            case 95:
            case 96:
            case 123:
            case 125:
            case 126:
              return true;
            default:
              return false;
          }
        }
        module2.exports = function text(state, silent) {
          var pos = state.pos;
          while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
            pos++;
          }
          if (pos === state.pos) {
            return false;
          }
          if (!silent) {
            state.pending += state.src.slice(state.pos, pos);
          }
          state.pos = pos;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/linkify.js
    var require_linkify2 = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/linkify.js"(exports2, module2) {
        "use strict";
        var SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;
        module2.exports = function linkify(state, silent) {
          var pos, max, match, proto, link, url, fullUrl, token;
          if (!state.md.options.linkify)
            return false;
          if (state.linkLevel > 0)
            return false;
          pos = state.pos;
          max = state.posMax;
          if (pos + 3 > max)
            return false;
          if (state.src.charCodeAt(pos) !== 58)
            return false;
          if (state.src.charCodeAt(pos + 1) !== 47)
            return false;
          if (state.src.charCodeAt(pos + 2) !== 47)
            return false;
          match = state.pending.match(SCHEME_RE);
          if (!match)
            return false;
          proto = match[1];
          link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));
          if (!link)
            return false;
          url = link.url;
          url = url.replace(/\*+$/, "");
          fullUrl = state.md.normalizeLink(url);
          if (!state.md.validateLink(fullUrl))
            return false;
          if (!silent) {
            state.pending = state.pending.slice(0, -proto.length);
            token = state.push("link_open", "a", 1);
            token.attrs = [["href", fullUrl]];
            token.markup = "linkify";
            token.info = "auto";
            token = state.push("text", "", 0);
            token.content = state.md.normalizeLinkText(url);
            token = state.push("link_close", "a", -1);
            token.markup = "linkify";
            token.info = "auto";
          }
          state.pos += url.length - proto.length;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/newline.js
    var require_newline = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/newline.js"(exports2, module2) {
        "use strict";
        var isSpace = require_utils2().isSpace;
        module2.exports = function newline(state, silent) {
          var pmax, max, ws, pos = state.pos;
          if (state.src.charCodeAt(pos) !== 10) {
            return false;
          }
          pmax = state.pending.length - 1;
          max = state.posMax;
          if (!silent) {
            if (pmax >= 0 && state.pending.charCodeAt(pmax) === 32) {
              if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 32) {
                ws = pmax - 1;
                while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 32)
                  ws--;
                state.pending = state.pending.slice(0, ws);
                state.push("hardbreak", "br", 0);
              } else {
                state.pending = state.pending.slice(0, -1);
                state.push("softbreak", "br", 0);
              }
            } else {
              state.push("softbreak", "br", 0);
            }
          }
          pos++;
          while (pos < max && isSpace(state.src.charCodeAt(pos))) {
            pos++;
          }
          state.pos = pos;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/escape.js
    var require_escape = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/escape.js"(exports2, module2) {
        "use strict";
        var isSpace = require_utils2().isSpace;
        var ESCAPED = [];
        for (i = 0; i < 256; i++) {
          ESCAPED.push(0);
        }
        var i;
        "\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-".split("").forEach(function(ch) {
          ESCAPED[ch.charCodeAt(0)] = 1;
        });
        module2.exports = function escape(state, silent) {
          var ch1, ch2, origStr, escapedStr, token, pos = state.pos, max = state.posMax;
          if (state.src.charCodeAt(pos) !== 92)
            return false;
          pos++;
          if (pos >= max)
            return false;
          ch1 = state.src.charCodeAt(pos);
          if (ch1 === 10) {
            if (!silent) {
              state.push("hardbreak", "br", 0);
            }
            pos++;
            while (pos < max) {
              ch1 = state.src.charCodeAt(pos);
              if (!isSpace(ch1))
                break;
              pos++;
            }
            state.pos = pos;
            return true;
          }
          escapedStr = state.src[pos];
          if (ch1 >= 55296 && ch1 <= 56319 && pos + 1 < max) {
            ch2 = state.src.charCodeAt(pos + 1);
            if (ch2 >= 56320 && ch2 <= 57343) {
              escapedStr += state.src[pos + 1];
              pos++;
            }
          }
          origStr = "\\" + escapedStr;
          if (!silent) {
            token = state.push("text_special", "", 0);
            if (ch1 < 256 && ESCAPED[ch1] !== 0) {
              token.content = escapedStr;
            } else {
              token.content = origStr;
            }
            token.markup = origStr;
            token.info = "escape";
          }
          state.pos = pos + 1;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/backticks.js
    var require_backticks = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/backticks.js"(exports2, module2) {
        "use strict";
        module2.exports = function backtick(state, silent) {
          var start, max, marker, token, matchStart, matchEnd, openerLength, closerLength, pos = state.pos, ch = state.src.charCodeAt(pos);
          if (ch !== 96) {
            return false;
          }
          start = pos;
          pos++;
          max = state.posMax;
          while (pos < max && state.src.charCodeAt(pos) === 96) {
            pos++;
          }
          marker = state.src.slice(start, pos);
          openerLength = marker.length;
          if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
            if (!silent)
              state.pending += marker;
            state.pos += openerLength;
            return true;
          }
          matchStart = matchEnd = pos;
          while ((matchStart = state.src.indexOf("`", matchEnd)) !== -1) {
            matchEnd = matchStart + 1;
            while (matchEnd < max && state.src.charCodeAt(matchEnd) === 96) {
              matchEnd++;
            }
            closerLength = matchEnd - matchStart;
            if (closerLength === openerLength) {
              if (!silent) {
                token = state.push("code_inline", "code", 0);
                token.markup = marker;
                token.content = state.src.slice(pos, matchStart).replace(/\n/g, " ").replace(/^ (.+) $/, "$1");
              }
              state.pos = matchEnd;
              return true;
            }
            state.backticks[closerLength] = matchStart;
          }
          state.backticksScanned = true;
          if (!silent)
            state.pending += marker;
          state.pos += openerLength;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/strikethrough.js
    var require_strikethrough = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/strikethrough.js"(exports2, module2) {
        "use strict";
        module2.exports.tokenize = function strikethrough(state, silent) {
          var i, scanned, token, len, ch, start = state.pos, marker = state.src.charCodeAt(start);
          if (silent) {
            return false;
          }
          if (marker !== 126) {
            return false;
          }
          scanned = state.scanDelims(state.pos, true);
          len = scanned.length;
          ch = String.fromCharCode(marker);
          if (len < 2) {
            return false;
          }
          if (len % 2) {
            token = state.push("text", "", 0);
            token.content = ch;
            len--;
          }
          for (i = 0; i < len; i += 2) {
            token = state.push("text", "", 0);
            token.content = ch + ch;
            state.delimiters.push({
              marker,
              length: 0,
              // disable "rule of 3" length checks meant for emphasis
              token: state.tokens.length - 1,
              end: -1,
              open: scanned.can_open,
              close: scanned.can_close
            });
          }
          state.pos += scanned.length;
          return true;
        };
        function postProcess(state, delimiters) {
          var i, j, startDelim, endDelim, token, loneMarkers = [], max = delimiters.length;
          for (i = 0; i < max; i++) {
            startDelim = delimiters[i];
            if (startDelim.marker !== 126) {
              continue;
            }
            if (startDelim.end === -1) {
              continue;
            }
            endDelim = delimiters[startDelim.end];
            token = state.tokens[startDelim.token];
            token.type = "s_open";
            token.tag = "s";
            token.nesting = 1;
            token.markup = "~~";
            token.content = "";
            token = state.tokens[endDelim.token];
            token.type = "s_close";
            token.tag = "s";
            token.nesting = -1;
            token.markup = "~~";
            token.content = "";
            if (state.tokens[endDelim.token - 1].type === "text" && state.tokens[endDelim.token - 1].content === "~") {
              loneMarkers.push(endDelim.token - 1);
            }
          }
          while (loneMarkers.length) {
            i = loneMarkers.pop();
            j = i + 1;
            while (j < state.tokens.length && state.tokens[j].type === "s_close") {
              j++;
            }
            j--;
            if (i !== j) {
              token = state.tokens[j];
              state.tokens[j] = state.tokens[i];
              state.tokens[i] = token;
            }
          }
        }
        module2.exports.postProcess = function strikethrough(state) {
          var curr, tokens_meta = state.tokens_meta, max = state.tokens_meta.length;
          postProcess(state, state.delimiters);
          for (curr = 0; curr < max; curr++) {
            if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
              postProcess(state, tokens_meta[curr].delimiters);
            }
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/emphasis.js
    var require_emphasis = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/emphasis.js"(exports2, module2) {
        "use strict";
        module2.exports.tokenize = function emphasis(state, silent) {
          var i, scanned, token, start = state.pos, marker = state.src.charCodeAt(start);
          if (silent) {
            return false;
          }
          if (marker !== 95 && marker !== 42) {
            return false;
          }
          scanned = state.scanDelims(state.pos, marker === 42);
          for (i = 0; i < scanned.length; i++) {
            token = state.push("text", "", 0);
            token.content = String.fromCharCode(marker);
            state.delimiters.push({
              // Char code of the starting marker (number).
              //
              marker,
              // Total length of these series of delimiters.
              //
              length: scanned.length,
              // A position of the token this delimiter corresponds to.
              //
              token: state.tokens.length - 1,
              // If this delimiter is matched as a valid opener, `end` will be
              // equal to its position, otherwise it's `-1`.
              //
              end: -1,
              // Boolean flags that determine if this delimiter could open or close
              // an emphasis.
              //
              open: scanned.can_open,
              close: scanned.can_close
            });
          }
          state.pos += scanned.length;
          return true;
        };
        function postProcess(state, delimiters) {
          var i, startDelim, endDelim, token, ch, isStrong, max = delimiters.length;
          for (i = max - 1; i >= 0; i--) {
            startDelim = delimiters[i];
            if (startDelim.marker !== 95 && startDelim.marker !== 42) {
              continue;
            }
            if (startDelim.end === -1) {
              continue;
            }
            endDelim = delimiters[startDelim.end];
            isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 && // check that first two markers match and adjacent
            delimiters[i - 1].marker === startDelim.marker && delimiters[i - 1].token === startDelim.token - 1 && // check that last two markers are adjacent (we can safely assume they match)
            delimiters[startDelim.end + 1].token === endDelim.token + 1;
            ch = String.fromCharCode(startDelim.marker);
            token = state.tokens[startDelim.token];
            token.type = isStrong ? "strong_open" : "em_open";
            token.tag = isStrong ? "strong" : "em";
            token.nesting = 1;
            token.markup = isStrong ? ch + ch : ch;
            token.content = "";
            token = state.tokens[endDelim.token];
            token.type = isStrong ? "strong_close" : "em_close";
            token.tag = isStrong ? "strong" : "em";
            token.nesting = -1;
            token.markup = isStrong ? ch + ch : ch;
            token.content = "";
            if (isStrong) {
              state.tokens[delimiters[i - 1].token].content = "";
              state.tokens[delimiters[startDelim.end + 1].token].content = "";
              i--;
            }
          }
        }
        module2.exports.postProcess = function emphasis(state) {
          var curr, tokens_meta = state.tokens_meta, max = state.tokens_meta.length;
          postProcess(state, state.delimiters);
          for (curr = 0; curr < max; curr++) {
            if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
              postProcess(state, tokens_meta[curr].delimiters);
            }
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/link.js
    var require_link = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/link.js"(exports2, module2) {
        "use strict";
        var normalizeReference = require_utils2().normalizeReference;
        var isSpace = require_utils2().isSpace;
        module2.exports = function link(state, silent) {
          var attrs, code, label, labelEnd, labelStart, pos, res, ref, token, href = "", title = "", oldPos = state.pos, max = state.posMax, start = state.pos, parseReference = true;
          if (state.src.charCodeAt(state.pos) !== 91) {
            return false;
          }
          labelStart = state.pos + 1;
          labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
          if (labelEnd < 0) {
            return false;
          }
          pos = labelEnd + 1;
          if (pos < max && state.src.charCodeAt(pos) === 40) {
            parseReference = false;
            pos++;
            for (; pos < max; pos++) {
              code = state.src.charCodeAt(pos);
              if (!isSpace(code) && code !== 10) {
                break;
              }
            }
            if (pos >= max) {
              return false;
            }
            start = pos;
            res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
            if (res.ok) {
              href = state.md.normalizeLink(res.str);
              if (state.md.validateLink(href)) {
                pos = res.pos;
              } else {
                href = "";
              }
              start = pos;
              for (; pos < max; pos++) {
                code = state.src.charCodeAt(pos);
                if (!isSpace(code) && code !== 10) {
                  break;
                }
              }
              res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
              if (pos < max && start !== pos && res.ok) {
                title = res.str;
                pos = res.pos;
                for (; pos < max; pos++) {
                  code = state.src.charCodeAt(pos);
                  if (!isSpace(code) && code !== 10) {
                    break;
                  }
                }
              }
            }
            if (pos >= max || state.src.charCodeAt(pos) !== 41) {
              parseReference = true;
            }
            pos++;
          }
          if (parseReference) {
            if (typeof state.env.references === "undefined") {
              return false;
            }
            if (pos < max && state.src.charCodeAt(pos) === 91) {
              start = pos + 1;
              pos = state.md.helpers.parseLinkLabel(state, pos);
              if (pos >= 0) {
                label = state.src.slice(start, pos++);
              } else {
                pos = labelEnd + 1;
              }
            } else {
              pos = labelEnd + 1;
            }
            if (!label) {
              label = state.src.slice(labelStart, labelEnd);
            }
            ref = state.env.references[normalizeReference(label)];
            if (!ref) {
              state.pos = oldPos;
              return false;
            }
            href = ref.href;
            title = ref.title;
          }
          if (!silent) {
            state.pos = labelStart;
            state.posMax = labelEnd;
            token = state.push("link_open", "a", 1);
            token.attrs = attrs = [["href", href]];
            if (title) {
              attrs.push(["title", title]);
            }
            state.linkLevel++;
            state.md.inline.tokenize(state);
            state.linkLevel--;
            token = state.push("link_close", "a", -1);
          }
          state.pos = pos;
          state.posMax = max;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/image.js
    var require_image = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/image.js"(exports2, module2) {
        "use strict";
        var normalizeReference = require_utils2().normalizeReference;
        var isSpace = require_utils2().isSpace;
        module2.exports = function image(state, silent) {
          var attrs, code, content, label, labelEnd, labelStart, pos, ref, res, title, token, tokens, start, href = "", oldPos = state.pos, max = state.posMax;
          if (state.src.charCodeAt(state.pos) !== 33) {
            return false;
          }
          if (state.src.charCodeAt(state.pos + 1) !== 91) {
            return false;
          }
          labelStart = state.pos + 2;
          labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);
          if (labelEnd < 0) {
            return false;
          }
          pos = labelEnd + 1;
          if (pos < max && state.src.charCodeAt(pos) === 40) {
            pos++;
            for (; pos < max; pos++) {
              code = state.src.charCodeAt(pos);
              if (!isSpace(code) && code !== 10) {
                break;
              }
            }
            if (pos >= max) {
              return false;
            }
            start = pos;
            res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
            if (res.ok) {
              href = state.md.normalizeLink(res.str);
              if (state.md.validateLink(href)) {
                pos = res.pos;
              } else {
                href = "";
              }
            }
            start = pos;
            for (; pos < max; pos++) {
              code = state.src.charCodeAt(pos);
              if (!isSpace(code) && code !== 10) {
                break;
              }
            }
            res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
            if (pos < max && start !== pos && res.ok) {
              title = res.str;
              pos = res.pos;
              for (; pos < max; pos++) {
                code = state.src.charCodeAt(pos);
                if (!isSpace(code) && code !== 10) {
                  break;
                }
              }
            } else {
              title = "";
            }
            if (pos >= max || state.src.charCodeAt(pos) !== 41) {
              state.pos = oldPos;
              return false;
            }
            pos++;
          } else {
            if (typeof state.env.references === "undefined") {
              return false;
            }
            if (pos < max && state.src.charCodeAt(pos) === 91) {
              start = pos + 1;
              pos = state.md.helpers.parseLinkLabel(state, pos);
              if (pos >= 0) {
                label = state.src.slice(start, pos++);
              } else {
                pos = labelEnd + 1;
              }
            } else {
              pos = labelEnd + 1;
            }
            if (!label) {
              label = state.src.slice(labelStart, labelEnd);
            }
            ref = state.env.references[normalizeReference(label)];
            if (!ref) {
              state.pos = oldPos;
              return false;
            }
            href = ref.href;
            title = ref.title;
          }
          if (!silent) {
            content = state.src.slice(labelStart, labelEnd);
            state.md.inline.parse(
              content,
              state.md,
              state.env,
              tokens = []
            );
            token = state.push("image", "img", 0);
            token.attrs = attrs = [["src", href], ["alt", ""]];
            token.children = tokens;
            token.content = content;
            if (title) {
              attrs.push(["title", title]);
            }
          }
          state.pos = pos;
          state.posMax = max;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/autolink.js
    var require_autolink = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/autolink.js"(exports2, module2) {
        "use strict";
        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])?)*)$/;
        var AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)$/;
        module2.exports = function autolink(state, silent) {
          var url, fullUrl, token, ch, start, max, pos = state.pos;
          if (state.src.charCodeAt(pos) !== 60) {
            return false;
          }
          start = state.pos;
          max = state.posMax;
          for (; ; ) {
            if (++pos >= max)
              return false;
            ch = state.src.charCodeAt(pos);
            if (ch === 60)
              return false;
            if (ch === 62)
              break;
          }
          url = state.src.slice(start + 1, pos);
          if (AUTOLINK_RE.test(url)) {
            fullUrl = state.md.normalizeLink(url);
            if (!state.md.validateLink(fullUrl)) {
              return false;
            }
            if (!silent) {
              token = state.push("link_open", "a", 1);
              token.attrs = [["href", fullUrl]];
              token.markup = "autolink";
              token.info = "auto";
              token = state.push("text", "", 0);
              token.content = state.md.normalizeLinkText(url);
              token = state.push("link_close", "a", -1);
              token.markup = "autolink";
              token.info = "auto";
            }
            state.pos += url.length + 2;
            return true;
          }
          if (EMAIL_RE.test(url)) {
            fullUrl = state.md.normalizeLink("mailto:" + url);
            if (!state.md.validateLink(fullUrl)) {
              return false;
            }
            if (!silent) {
              token = state.push("link_open", "a", 1);
              token.attrs = [["href", fullUrl]];
              token.markup = "autolink";
              token.info = "auto";
              token = state.push("text", "", 0);
              token.content = state.md.normalizeLinkText(url);
              token = state.push("link_close", "a", -1);
              token.markup = "autolink";
              token.info = "auto";
            }
            state.pos += url.length + 2;
            return true;
          }
          return false;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/html_inline.js
    var require_html_inline = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/html_inline.js"(exports2, module2) {
        "use strict";
        var HTML_TAG_RE = require_html_re().HTML_TAG_RE;
        function isLinkOpen(str2) {
          return /^<a[>\s]/i.test(str2);
        }
        function isLinkClose(str2) {
          return /^<\/a\s*>/i.test(str2);
        }
        function isLetter(ch) {
          var lc = ch | 32;
          return lc >= 97 && lc <= 122;
        }
        module2.exports = function html_inline(state, silent) {
          var ch, match, max, token, pos = state.pos;
          if (!state.md.options.html) {
            return false;
          }
          max = state.posMax;
          if (state.src.charCodeAt(pos) !== 60 || pos + 2 >= max) {
            return false;
          }
          ch = state.src.charCodeAt(pos + 1);
          if (ch !== 33 && ch !== 63 && ch !== 47 && !isLetter(ch)) {
            return false;
          }
          match = state.src.slice(pos).match(HTML_TAG_RE);
          if (!match) {
            return false;
          }
          if (!silent) {
            token = state.push("html_inline", "", 0);
            token.content = state.src.slice(pos, pos + match[0].length);
            if (isLinkOpen(token.content))
              state.linkLevel++;
            if (isLinkClose(token.content))
              state.linkLevel--;
          }
          state.pos += match[0].length;
          return true;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/entity.js
    var require_entity = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/entity.js"(exports2, module2) {
        "use strict";
        var entities = require_entities2();
        var has = require_utils2().has;
        var isValidEntityCode = require_utils2().isValidEntityCode;
        var fromCodePoint = require_utils2().fromCodePoint;
        var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
        var NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;
        module2.exports = function entity(state, silent) {
          var ch, code, match, token, pos = state.pos, max = state.posMax;
          if (state.src.charCodeAt(pos) !== 38)
            return false;
          if (pos + 1 >= max)
            return false;
          ch = state.src.charCodeAt(pos + 1);
          if (ch === 35) {
            match = state.src.slice(pos).match(DIGITAL_RE);
            if (match) {
              if (!silent) {
                code = match[1][0].toLowerCase() === "x" ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);
                token = state.push("text_special", "", 0);
                token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(65533);
                token.markup = match[0];
                token.info = "entity";
              }
              state.pos += match[0].length;
              return true;
            }
          } else {
            match = state.src.slice(pos).match(NAMED_RE);
            if (match) {
              if (has(entities, match[1])) {
                if (!silent) {
                  token = state.push("text_special", "", 0);
                  token.content = entities[match[1]];
                  token.markup = match[0];
                  token.info = "entity";
                }
                state.pos += match[0].length;
                return true;
              }
            }
          }
          return false;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/balance_pairs.js
    var require_balance_pairs = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/balance_pairs.js"(exports2, module2) {
        "use strict";
        function processDelimiters(state, delimiters) {
          var closerIdx, openerIdx, closer, opener, minOpenerIdx, newMinOpenerIdx, isOddMatch, lastJump, openersBottom = {}, max = delimiters.length;
          if (!max)
            return;
          var headerIdx = 0;
          var lastTokenIdx = -2;
          var jumps = [];
          for (closerIdx = 0; closerIdx < max; closerIdx++) {
            closer = delimiters[closerIdx];
            jumps.push(0);
            if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {
              headerIdx = closerIdx;
            }
            lastTokenIdx = closer.token;
            closer.length = closer.length || 0;
            if (!closer.close)
              continue;
            if (!openersBottom.hasOwnProperty(closer.marker)) {
              openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1];
            }
            minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + closer.length % 3];
            openerIdx = headerIdx - jumps[headerIdx] - 1;
            newMinOpenerIdx = openerIdx;
            for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
              opener = delimiters[openerIdx];
              if (opener.marker !== closer.marker)
                continue;
              if (opener.open && opener.end < 0) {
                isOddMatch = false;
                if (opener.close || closer.open) {
                  if ((opener.length + closer.length) % 3 === 0) {
                    if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
                      isOddMatch = true;
                    }
                  }
                }
                if (!isOddMatch) {
                  lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ? jumps[openerIdx - 1] + 1 : 0;
                  jumps[closerIdx] = closerIdx - openerIdx + lastJump;
                  jumps[openerIdx] = lastJump;
                  closer.open = false;
                  opener.end = closerIdx;
                  opener.close = false;
                  newMinOpenerIdx = -1;
                  lastTokenIdx = -2;
                  break;
                }
              }
            }
            if (newMinOpenerIdx !== -1) {
              openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length || 0) % 3] = newMinOpenerIdx;
            }
          }
        }
        module2.exports = function link_pairs(state) {
          var curr, tokens_meta = state.tokens_meta, max = state.tokens_meta.length;
          processDelimiters(state, state.delimiters);
          for (curr = 0; curr < max; curr++) {
            if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
              processDelimiters(state, tokens_meta[curr].delimiters);
            }
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/fragments_join.js
    var require_fragments_join = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/fragments_join.js"(exports2, module2) {
        "use strict";
        module2.exports = function fragments_join(state) {
          var curr, last, level = 0, tokens = state.tokens, max = state.tokens.length;
          for (curr = last = 0; curr < max; curr++) {
            if (tokens[curr].nesting < 0)
              level--;
            tokens[curr].level = level;
            if (tokens[curr].nesting > 0)
              level++;
            if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") {
              tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
            } else {
              if (curr !== last) {
                tokens[last] = tokens[curr];
              }
              last++;
            }
          }
          if (curr !== last) {
            tokens.length = last;
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/state_inline.js
    var require_state_inline = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/rules_inline/state_inline.js"(exports2, module2) {
        "use strict";
        var Token2 = require_token();
        var isWhiteSpace = require_utils2().isWhiteSpace;
        var isPunctChar = require_utils2().isPunctChar;
        var isMdAsciiPunct = require_utils2().isMdAsciiPunct;
        function StateInline(src, md2, env, outTokens) {
          this.src = src;
          this.env = env;
          this.md = md2;
          this.tokens = outTokens;
          this.tokens_meta = Array(outTokens.length);
          this.pos = 0;
          this.posMax = this.src.length;
          this.level = 0;
          this.pending = "";
          this.pendingLevel = 0;
          this.cache = {};
          this.delimiters = [];
          this._prev_delimiters = [];
          this.backticks = {};
          this.backticksScanned = false;
          this.linkLevel = 0;
        }
        StateInline.prototype.pushPending = function() {
          var token = new Token2("text", "", 0);
          token.content = this.pending;
          token.level = this.pendingLevel;
          this.tokens.push(token);
          this.pending = "";
          return token;
        };
        StateInline.prototype.push = function(type, tag, nesting) {
          if (this.pending) {
            this.pushPending();
          }
          var token = new Token2(type, tag, nesting);
          var token_meta = null;
          if (nesting < 0) {
            this.level--;
            this.delimiters = this._prev_delimiters.pop();
          }
          token.level = this.level;
          if (nesting > 0) {
            this.level++;
            this._prev_delimiters.push(this.delimiters);
            this.delimiters = [];
            token_meta = { delimiters: this.delimiters };
          }
          this.pendingLevel = this.level;
          this.tokens.push(token);
          this.tokens_meta.push(token_meta);
          return token;
        };
        StateInline.prototype.scanDelims = function(start, canSplitWord) {
          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);
          lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 32;
          while (pos < max && this.src.charCodeAt(pos) === marker) {
            pos++;
          }
          count = pos - start;
          nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
          isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
          isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
          isLastWhiteSpace = isWhiteSpace(lastChar);
          isNextWhiteSpace = isWhiteSpace(nextChar);
          if (isNextWhiteSpace) {
            left_flanking = false;
          } else if (isNextPunctChar) {
            if (!(isLastWhiteSpace || isLastPunctChar)) {
              left_flanking = false;
            }
          }
          if (isLastWhiteSpace) {
            right_flanking = false;
          } else if (isLastPunctChar) {
            if (!(isNextWhiteSpace || isNextPunctChar)) {
              right_flanking = false;
            }
          }
          if (!canSplitWord) {
            can_open = left_flanking && (!right_flanking || isLastPunctChar);
            can_close = right_flanking && (!left_flanking || isNextPunctChar);
          } else {
            can_open = left_flanking;
            can_close = right_flanking;
          }
          return {
            can_open,
            can_close,
            length: count
          };
        };
        StateInline.prototype.Token = Token2;
        module2.exports = StateInline;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/parser_inline.js
    var require_parser_inline = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/parser_inline.js"(exports2, module2) {
        "use strict";
        var Ruler = require_ruler();
        var _rules = [
          ["text", require_text()],
          ["linkify", require_linkify2()],
          ["newline", require_newline()],
          ["escape", require_escape()],
          ["backticks", require_backticks()],
          ["strikethrough", require_strikethrough().tokenize],
          ["emphasis", require_emphasis().tokenize],
          ["link", require_link()],
          ["image", require_image()],
          ["autolink", require_autolink()],
          ["html_inline", require_html_inline()],
          ["entity", require_entity()]
        ];
        var _rules2 = [
          ["balance_pairs", require_balance_pairs()],
          ["strikethrough", require_strikethrough().postProcess],
          ["emphasis", require_emphasis().postProcess],
          // rules for pairs separate '**' into its own text tokens, which may be left unused,
          // rule below merges unused segments back with the rest of the text
          ["fragments_join", require_fragments_join()]
        ];
        function ParserInline() {
          var i;
          this.ruler = new Ruler();
          for (i = 0; i < _rules.length; i++) {
            this.ruler.push(_rules[i][0], _rules[i][1]);
          }
          this.ruler2 = new Ruler();
          for (i = 0; i < _rules2.length; i++) {
            this.ruler2.push(_rules2[i][0], _rules2[i][1]);
          }
        }
        ParserInline.prototype.skipToken = function(state) {
          var ok, i, pos = state.pos, rules = this.ruler.getRules(""), len = rules.length, maxNesting = state.md.options.maxNesting, cache = state.cache;
          if (typeof cache[pos] !== "undefined") {
            state.pos = cache[pos];
            return;
          }
          if (state.level < maxNesting) {
            for (i = 0; i < len; i++) {
              state.level++;
              ok = rules[i](state, true);
              state.level--;
              if (ok) {
                break;
              }
            }
          } else {
            state.pos = state.posMax;
          }
          if (!ok) {
            state.pos++;
          }
          cache[pos] = state.pos;
        };
        ParserInline.prototype.tokenize = function(state) {
          var ok, i, rules = this.ruler.getRules(""), len = rules.length, end = state.posMax, maxNesting = state.md.options.maxNesting;
          while (state.pos < end) {
            if (state.level < maxNesting) {
              for (i = 0; i < len; i++) {
                ok = rules[i](state, false);
                if (ok) {
                  break;
                }
              }
            }
            if (ok) {
              if (state.pos >= end) {
                break;
              }
              continue;
            }
            state.pending += state.src[state.pos++];
          }
          if (state.pending) {
            state.pushPending();
          }
        };
        ParserInline.prototype.parse = function(str2, md2, env, outTokens) {
          var i, rules, len;
          var state = new this.State(str2, md2, env, outTokens);
          this.tokenize(state);
          rules = this.ruler2.getRules("");
          len = rules.length;
          for (i = 0; i < len; i++) {
            rules[i](state);
          }
        };
        ParserInline.prototype.State = require_state_inline();
        module2.exports = ParserInline;
      }
    });
    
    // node_modules/.pnpm/linkify-it@4.0.1/node_modules/linkify-it/lib/re.js
    var require_re = __commonJS({
      "node_modules/.pnpm/linkify-it@4.0.1/node_modules/linkify-it/lib/re.js"(exports2, module2) {
        "use strict";
        module2.exports = function(opts) {
          var re = {};
          opts = opts || {};
          re.src_Any = require_regex2().source;
          re.src_Cc = require_regex3().source;
          re.src_Z = require_regex5().source;
          re.src_P = require_regex().source;
          re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join("|");
          re.src_ZCc = [re.src_Z, re.src_Cc].join("|");
          var text_separators = "[><\uFF5C]";
          re.src_pseudo_letter = "(?:(?!" + text_separators + "|" + re.src_ZPCc + ")" + re.src_Any + ")";
          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]?)";
          re.src_auth = "(?:(?:(?!" + re.src_ZCc + "|[@/\\[\\]()]).)+@)?";
          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}))?";
          re.src_host_terminator = "(?=$|" + text_separators + "|" + re.src_ZPCc + ")(?!" + (opts["---"] ? "-(?!--)|" : "-|") + "_|:\\d|\\.-|\\.(?!$|" + re.src_ZPCc + "))";
          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["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + ",(?!" + re.src_ZCc + "|$)|;(?!" + re.src_ZCc + "|$)|\\!+(?!" + re.src_ZCc + "|[!]|$)|\\?(?!" + re.src_ZCc + "|[?]|$))+|\\/)?";
          re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
          re.src_xn = "xn--[a-z0-9\\-]{1,59}";
          re.src_domain_root = // Allow letters & digits (http://test1)
          "(?:" + re.src_xn + "|" + re.src_pseudo_letter + "{1,63})";
          re.src_domain = "(?:" + re.src_xn + "|(?:" + re.src_pseudo_letter + ")|(?:" + re.src_pseudo_letter + "(?:-|" + re.src_pseudo_letter + "){0,61}" + re.src_pseudo_letter + "))";
          re.src_host = "(?:(?:(?:(?:" + re.src_domain + ")\\.)*" + re.src_domain + "))";
          re.tpl_host_fuzzy = "(?:" + re.src_ip4 + "|(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%)))";
          re.tpl_host_no_ip_fuzzy = "(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%))";
          re.src_host_strict = re.src_host + re.src_host_terminator;
          re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
          re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
          re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
          re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
          re.tpl_host_fuzzy_test = "localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:" + re.src_ZPCc + "|>|$))";
          re.tpl_email_fuzzy = "(^|" + text_separators + '|"|\\(|' + re.src_ZCc + ")(" + re.src_email_name + "@" + re.tpl_host_fuzzy_strict + ")";
          re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
          // but can start with > (markdown blockquote)
          "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_fuzzy_strict + re.src_path + ")";
          re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
          // but can start with > (markdown blockquote)
          "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ")";
          return re;
        };
      }
    });
    
    // node_modules/.pnpm/linkify-it@4.0.1/node_modules/linkify-it/index.js
    var require_linkify_it = __commonJS({
      "node_modules/.pnpm/linkify-it@4.0.1/node_modules/linkify-it/index.js"(exports2, module2) {
        "use strict";
        function assign(obj) {
          var sources = Array.prototype.slice.call(arguments, 1);
          sources.forEach(function(source) {
            if (!source) {
              return;
            }
            Object.keys(source).forEach(function(key) {
              obj[key] = source[key];
            });
          });
          return obj;
        }
        function _class(obj) {
          return Object.prototype.toString.call(obj);
        }
        function isString(obj) {
          return _class(obj) === "[object String]";
        }
        function isObject(obj) {
          return _class(obj) === "[object Object]";
        }
        function isRegExp(obj) {
          return _class(obj) === "[object RegExp]";
        }
        function isFunction(obj) {
          return _class(obj) === "[object Function]";
        }
        function escapeRE(str2) {
          return str2.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
        }
        var defaultOptions = {
          fuzzyLink: true,
          fuzzyEmail: true,
          fuzzyIP: false
        };
        function isOptionsObj(obj) {
          return Object.keys(obj || {}).reduce(function(acc, k) {
            return acc || defaultOptions.hasOwnProperty(k);
          }, false);
        }
        var defaultSchemas = {
          "http:": {
            validate: function(text, pos, self) {
              var tail = text.slice(pos);
              if (!self.re.http) {
                self.re.http = new RegExp(
                  "^\\/\\/" + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path,
                  "i"
                );
              }
              if (self.re.http.test(tail)) {
                return tail.match(self.re.http)[0].length;
              }
              return 0;
            }
          },
          "https:": "http:",
          "ftp:": "http:",
          "//": {
            validate: function(text, pos, self) {
              var tail = text.slice(pos);
              if (!self.re.no_http) {
                self.re.no_http = new RegExp(
                  "^" + self.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
                  // with code comments
                  "(?:localhost|(?:(?:" + self.re.src_domain + ")\\.)+" + self.re.src_domain_root + ")" + self.re.src_port + self.re.src_host_terminator + self.re.src_path,
                  "i"
                );
              }
              if (self.re.no_http.test(tail)) {
                if (pos >= 3 && text[pos - 3] === ":") {
                  return 0;
                }
                if (pos >= 3 && text[pos - 3] === "/") {
                  return 0;
                }
                return tail.match(self.re.no_http)[0].length;
              }
              return 0;
            }
          },
          "mailto:": {
            validate: function(text, pos, self) {
              var tail = text.slice(pos);
              if (!self.re.mailto) {
                self.re.mailto = new RegExp(
                  "^" + self.re.src_email_name + "@" + self.re.src_host_strict,
                  "i"
                );
              }
              if (self.re.mailto.test(tail)) {
                return tail.match(self.re.mailto)[0].length;
              }
              return 0;
            }
          }
        };
        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]";
        var tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|\u0440\u0444".split("|");
        function resetScanCache(self) {
          self.__index__ = -1;
          self.__text_cache__ = "";
        }
        function createValidator(re) {
          return function(text, pos) {
            var tail = text.slice(pos);
            if (re.test(tail)) {
              return tail.match(re)[0].length;
            }
            return 0;
          };
        }
        function createNormalizer() {
          return function(match, self) {
            self.normalize(match);
          };
        }
        function compile(self) {
          var re = self.re = require_re()(self.__opts__);
          var tlds = self.__tlds__.slice();
          self.onCompile();
          if (!self.__tlds_replaced__) {
            tlds.push(tlds_2ch_src_re);
          }
          tlds.push(re.src_xn);
          re.src_tlds = tlds.join("|");
          function untpl(tpl) {
            return tpl.replace("%TLDS%", re.src_tlds);
          }
          re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), "i");
          re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), "i");
          re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
          re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
          var aliases = [];
          self.__compiled__ = {};
          function schemaError(name, val) {
            throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
          }
          Object.keys(self.__schemas__).forEach(function(name) {
            var val = self.__schemas__[name];
            if (val === null) {
              return;
            }
            var compiled = { validate: null, link: null };
            self.__compiled__[name] = compiled;
            if (isObject(val)) {
              if (isRegExp(val.validate)) {
                compiled.validate = createValidator(val.validate);
              } else if (isFunction(val.validate)) {
                compiled.validate = val.validate;
              } else {
                schemaError(name, val);
              }
              if (isFunction(val.normalize)) {
                compiled.normalize = val.normalize;
              } else if (!val.normalize) {
                compiled.normalize = createNormalizer();
              } else {
                schemaError(name, val);
              }
              return;
            }
            if (isString(val)) {
              aliases.push(name);
              return;
            }
            schemaError(name, val);
          });
          aliases.forEach(function(alias) {
            if (!self.__compiled__[self.__schemas__[alias]]) {
              return;
            }
            self.__compiled__[alias].validate = self.__compiled__[self.__schemas__[alias]].validate;
            self.__compiled__[alias].normalize = self.__compiled__[self.__schemas__[alias]].normalize;
          });
          self.__compiled__[""] = { validate: null, normalize: createNormalizer() };
          var slist = Object.keys(self.__compiled__).filter(function(name) {
            return name.length > 0 && self.__compiled__[name];
          }).map(escapeRE).join("|");
          self.re.schema_test = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "i");
          self.re.schema_search = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
          self.re.schema_at_start = RegExp("^" + self.re.schema_search.source, "i");
          self.re.pretest = RegExp(
            "(" + self.re.schema_test.source + ")|(" + self.re.host_fuzzy_test.source + ")|@",
            "i"
          );
          resetScanCache(self);
        }
        function Match(self, shift) {
          var start = self.__index__, end = self.__last_index__, text = self.__text_cache__.slice(start, end);
          this.schema = self.__schema__.toLowerCase();
          this.index = start + shift;
          this.lastIndex = end + shift;
          this.raw = text;
          this.text = text;
          this.url = text;
        }
        function createMatch(self, shift) {
          var match = new Match(self, shift);
          self.__compiled__[match.schema].normalize(match, self);
          return match;
        }
        function LinkifyIt(schemas, options2) {
          if (!(this instanceof LinkifyIt)) {
            return new LinkifyIt(schemas, options2);
          }
          if (!options2) {
            if (isOptionsObj(schemas)) {
              options2 = schemas;
              schemas = {};
            }
          }
          this.__opts__ = assign({}, defaultOptions, options2);
          this.__index__ = -1;
          this.__last_index__ = -1;
          this.__schema__ = "";
          this.__text_cache__ = "";
          this.__schemas__ = assign({}, defaultSchemas, schemas);
          this.__compiled__ = {};
          this.__tlds__ = tlds_default;
          this.__tlds_replaced__ = false;
          this.re = {};
          compile(this);
        }
        LinkifyIt.prototype.add = function add(schema, definition) {
          this.__schemas__[schema] = definition;
          compile(this);
          return this;
        };
        LinkifyIt.prototype.set = function set(options2) {
          this.__opts__ = assign(this.__opts__, options2);
          return this;
        };
        LinkifyIt.prototype.test = function test(text) {
          this.__text_cache__ = text;
          this.__index__ = -1;
          if (!text.length) {
            return false;
          }
          var m, ml, me, len, shift, next, re, tld_pos, at_pos;
          if (this.re.schema_test.test(text)) {
            re = this.re.schema_search;
            re.lastIndex = 0;
            while ((m = re.exec(text)) !== null) {
              len = this.testSchemaAt(text, m[2], re.lastIndex);
              if (len) {
                this.__schema__ = m[2];
                this.__index__ = m.index + m[1].length;
                this.__last_index__ = m.index + m[0].length + len;
                break;
              }
            }
          }
          if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
            tld_pos = text.search(this.re.host_fuzzy_test);
            if (tld_pos >= 0) {
              if (this.__index__ < 0 || tld_pos < this.__index__) {
                if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
                  shift = ml.index + ml[1].length;
                  if (this.__index__ < 0 || shift < this.__index__) {
                    this.__schema__ = "";
                    this.__index__ = shift;
                    this.__last_index__ = ml.index + ml[0].length;
                  }
                }
              }
            }
          }
          if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
            at_pos = text.indexOf("@");
            if (at_pos >= 0) {
              if ((me = text.match(this.re.email_fuzzy)) !== null) {
                shift = me.index + me[1].length;
                next = me.index + me[0].length;
                if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {
                  this.__schema__ = "mailto:";
                  this.__index__ = shift;
                  this.__last_index__ = next;
                }
              }
            }
          }
          return this.__index__ >= 0;
        };
        LinkifyIt.prototype.pretest = function pretest(text) {
          return this.re.pretest.test(text);
        };
        LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
          if (!this.__compiled__[schema.toLowerCase()]) {
            return 0;
          }
          return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
        };
        LinkifyIt.prototype.match = function match(text) {
          var shift = 0, result = [];
          if (this.__index__ >= 0 && this.__text_cache__ === text) {
            result.push(createMatch(this, shift));
            shift = this.__last_index__;
          }
          var tail = shift ? text.slice(shift) : text;
          while (this.test(tail)) {
            result.push(createMatch(this, shift));
            tail = tail.slice(this.__last_index__);
            shift += this.__last_index__;
          }
          if (result.length) {
            return result;
          }
          return null;
        };
        LinkifyIt.prototype.matchAtStart = function matchAtStart(text) {
          this.__text_cache__ = text;
          this.__index__ = -1;
          if (!text.length)
            return null;
          var m = this.re.schema_at_start.exec(text);
          if (!m)
            return null;
          var len = this.testSchemaAt(text, m[2], m[0].length);
          if (!len)
            return null;
          this.__schema__ = m[2];
          this.__index__ = m.index + m[1].length;
          this.__last_index__ = m.index + m[0].length + len;
          return createMatch(this, 0);
        };
        LinkifyIt.prototype.tlds = function tlds(list, keepOld) {
          list = Array.isArray(list) ? list : [list];
          if (!keepOld) {
            this.__tlds__ = list.slice();
            this.__tlds_replaced__ = true;
            compile(this);
            return this;
          }
          this.__tlds__ = this.__tlds__.concat(list).sort().filter(function(el, idx, arr) {
            return el !== arr[idx - 1];
          }).reverse();
          compile(this);
          return this;
        };
        LinkifyIt.prototype.normalize = function normalize(match) {
          if (!match.schema) {
            match.url = "http://" + match.url;
          }
          if (match.schema === "mailto:" && !/^mailto:/i.test(match.url)) {
            match.url = "mailto:" + match.url;
          }
        };
        LinkifyIt.prototype.onCompile = function onCompile() {
        };
        module2.exports = LinkifyIt;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/presets/default.js
    var require_default = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/presets/default.js"(exports2, module2) {
        "use strict";
        module2.exports = {
          options: {
            html: false,
            // Enable HTML tags in source
            xhtmlOut: false,
            // Use '/' to close single tags (<br />)
            breaks: false,
            // Convert '\n' in paragraphs into <br>
            langPrefix: "language-",
            // CSS language prefix for fenced blocks
            linkify: false,
            // autoconvert URL-like texts to links
            // Enable some language-neutral replacements + quotes beautification
            typographer: false,
            // Double + single quotes replacement pairs, when typographer enabled,
            // and smartquotes on. Could be either a String or an Array.
            //
            // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
            // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
            quotes: "\u201C\u201D\u2018\u2019",
            /* “”‘’ */
            // Highlighter function. Should return escaped HTML,
            // or '' if the source string is not changed and should be escaped externaly.
            // If result starts with <pre... internal wrapper is skipped.
            //
            // function (/*str, lang*/) { return ''; }
            //
            highlight: null,
            maxNesting: 100
            // Internal protection, recursion limit
          },
          components: {
            core: {},
            block: {},
            inline: {}
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/presets/zero.js
    var require_zero = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/presets/zero.js"(exports2, module2) {
        "use strict";
        module2.exports = {
          options: {
            html: false,
            // Enable HTML tags in source
            xhtmlOut: false,
            // Use '/' to close single tags (<br />)
            breaks: false,
            // Convert '\n' in paragraphs into <br>
            langPrefix: "language-",
            // CSS language prefix for fenced blocks
            linkify: false,
            // autoconvert URL-like texts to links
            // Enable some language-neutral replacements + quotes beautification
            typographer: false,
            // Double + single quotes replacement pairs, when typographer enabled,
            // and smartquotes on. Could be either a String or an Array.
            //
            // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
            // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
            quotes: "\u201C\u201D\u2018\u2019",
            /* “”‘’ */
            // Highlighter function. Should return escaped HTML,
            // or '' if the source string is not changed and should be escaped externaly.
            // If result starts with <pre... internal wrapper is skipped.
            //
            // function (/*str, lang*/) { return ''; }
            //
            highlight: null,
            maxNesting: 20
            // Internal protection, recursion limit
          },
          components: {
            core: {
              rules: [
                "normalize",
                "block",
                "inline",
                "text_join"
              ]
            },
            block: {
              rules: [
                "paragraph"
              ]
            },
            inline: {
              rules: [
                "text"
              ],
              rules2: [
                "balance_pairs",
                "fragments_join"
              ]
            }
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/presets/commonmark.js
    var require_commonmark = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/presets/commonmark.js"(exports2, module2) {
        "use strict";
        module2.exports = {
          options: {
            html: true,
            // Enable HTML tags in source
            xhtmlOut: true,
            // Use '/' to close single tags (<br />)
            breaks: false,
            // Convert '\n' in paragraphs into <br>
            langPrefix: "language-",
            // CSS language prefix for fenced blocks
            linkify: false,
            // autoconvert URL-like texts to links
            // Enable some language-neutral replacements + quotes beautification
            typographer: false,
            // Double + single quotes replacement pairs, when typographer enabled,
            // and smartquotes on. Could be either a String or an Array.
            //
            // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
            // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
            quotes: "\u201C\u201D\u2018\u2019",
            /* “”‘’ */
            // Highlighter function. Should return escaped HTML,
            // or '' if the source string is not changed and should be escaped externaly.
            // If result starts with <pre... internal wrapper is skipped.
            //
            // function (/*str, lang*/) { return ''; }
            //
            highlight: null,
            maxNesting: 20
            // Internal protection, recursion limit
          },
          components: {
            core: {
              rules: [
                "normalize",
                "block",
                "inline",
                "text_join"
              ]
            },
            block: {
              rules: [
                "blockquote",
                "code",
                "fence",
                "heading",
                "hr",
                "html_block",
                "lheading",
                "list",
                "reference",
                "paragraph"
              ]
            },
            inline: {
              rules: [
                "autolink",
                "backticks",
                "emphasis",
                "entity",
                "escape",
                "html_inline",
                "image",
                "link",
                "newline",
                "text"
              ],
              rules2: [
                "balance_pairs",
                "emphasis",
                "fragments_join"
              ]
            }
          }
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/index.js
    var require_lib = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/index.js"(exports2, module2) {
        "use strict";
        var utils = require_utils2();
        var helpers = require_helpers();
        var Renderer = require_renderer();
        var ParserCore = require_parser_core();
        var ParserBlock = require_parser_block();
        var ParserInline = require_parser_inline();
        var LinkifyIt = require_linkify_it();
        var mdurl = require_mdurl();
        var punycode = require("punycode");
        var config = {
          default: require_default(),
          zero: require_zero(),
          commonmark: require_commonmark()
        };
        var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
        var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
        function validateLink(url) {
          var str2 = url.trim().toLowerCase();
          return BAD_PROTO_RE.test(str2) ? GOOD_DATA_RE.test(str2) ? true : false : true;
        }
        var RECODE_HOSTNAME_FOR = ["http:", "https:", "mailto:"];
        function normalizeLink(url) {
          var parsed = mdurl.parse(url, true);
          if (parsed.hostname) {
            if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
              try {
                parsed.hostname = punycode.toASCII(parsed.hostname);
              } catch (er) {
              }
            }
          }
          return mdurl.encode(mdurl.format(parsed));
        }
        function normalizeLinkText(url) {
          var parsed = mdurl.parse(url, true);
          if (parsed.hostname) {
            if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
              try {
                parsed.hostname = punycode.toUnicode(parsed.hostname);
              } catch (er) {
              }
            }
          }
          return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + "%");
        }
        function MarkdownIt(presetName, options2) {
          if (!(this instanceof MarkdownIt)) {
            return new MarkdownIt(presetName, options2);
          }
          if (!options2) {
            if (!utils.isString(presetName)) {
              options2 = presetName || {};
              presetName = "default";
            }
          }
          this.inline = new ParserInline();
          this.block = new ParserBlock();
          this.core = new ParserCore();
          this.renderer = new Renderer();
          this.linkify = new LinkifyIt();
          this.validateLink = validateLink;
          this.normalizeLink = normalizeLink;
          this.normalizeLinkText = normalizeLinkText;
          this.utils = utils;
          this.helpers = utils.assign({}, helpers);
          this.options = {};
          this.configure(presetName);
          if (options2) {
            this.set(options2);
          }
        }
        MarkdownIt.prototype.set = function(options2) {
          utils.assign(this.options, options2);
          return this;
        };
        MarkdownIt.prototype.configure = function(presets) {
          var self = this, presetName;
          if (utils.isString(presets)) {
            presetName = presets;
            presets = config[presetName];
            if (!presets) {
              throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name');
            }
          }
          if (!presets) {
            throw new Error("Wrong `markdown-it` preset, can't be empty");
          }
          if (presets.options) {
            self.set(presets.options);
          }
          if (presets.components) {
            Object.keys(presets.components).forEach(function(name) {
              if (presets.components[name].rules) {
                self[name].ruler.enableOnly(presets.components[name].rules);
              }
              if (presets.components[name].rules2) {
                self[name].ruler2.enableOnly(presets.components[name].rules2);
              }
            });
          }
          return this;
        };
        MarkdownIt.prototype.enable = function(list, ignoreInvalid) {
          var result = [];
          if (!Array.isArray(list)) {
            list = [list];
          }
          ["core", "block", "inline"].forEach(function(chain) {
            result = result.concat(this[chain].ruler.enable(list, true));
          }, this);
          result = result.concat(this.inline.ruler2.enable(list, true));
          var missed = list.filter(function(name) {
            return result.indexOf(name) < 0;
          });
          if (missed.length && !ignoreInvalid) {
            throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + missed);
          }
          return this;
        };
        MarkdownIt.prototype.disable = function(list, ignoreInvalid) {
          var result = [];
          if (!Array.isArray(list)) {
            list = [list];
          }
          ["core", "block", "inline"].forEach(function(chain) {
            result = result.concat(this[chain].ruler.disable(list, true));
          }, this);
          result = result.concat(this.inline.ruler2.disable(list, true));
          var missed = list.filter(function(name) {
            return result.indexOf(name) < 0;
          });
          if (missed.length && !ignoreInvalid) {
            throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + missed);
          }
          return this;
        };
        MarkdownIt.prototype.use = function(plugin) {
          var args = [this].concat(Array.prototype.slice.call(arguments, 1));
          plugin.apply(plugin, args);
          return this;
        };
        MarkdownIt.prototype.parse = function(src, env) {
          if (typeof src !== "string") {
            throw new Error("Input data should be a String");
          }
          var state = new this.core.State(src, this, env);
          this.core.process(state);
          return state.tokens;
        };
        MarkdownIt.prototype.render = function(src, env) {
          env = env || {};
          return this.renderer.render(this.parse(src, env), this.options, env);
        };
        MarkdownIt.prototype.parseInline = function(src, env) {
          var state = new this.core.State(src, this, env);
          state.inlineMode = true;
          this.core.process(state);
          return state.tokens;
        };
        MarkdownIt.prototype.renderInline = function(src, env) {
          env = env || {};
          return this.renderer.render(this.parseInline(src, env), this.options, env);
        };
        module2.exports = MarkdownIt;
      }
    });
    
    // node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/index.js
    var require_markdown_it = __commonJS({
      "node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/index.js"(exports2, module2) {
        "use strict";
        module2.exports = require_lib();
      }
    });
    
    // node_modules/.pnpm/markdown-it-bracketed-spans@1.0.1/node_modules/markdown-it-bracketed-spans/index.js
    var require_markdown_it_bracketed_spans = __commonJS({
      "node_modules/.pnpm/markdown-it-bracketed-spans@1.0.1/node_modules/markdown-it-bracketed-spans/index.js"(exports2, module2) {
        "use strict";
        module2.exports = function bracketed_spans_plugin2(md2) {
          function span(state) {
            var max = state.posMax;
            if (state.src.charCodeAt(state.pos) !== 91) {
              return false;
            }
            var labelStart = state.pos + 1;
            var labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
            if (labelEnd < 0) {
              return false;
            }
            var pos = labelEnd + 1;
            if (pos < max && state.src.charCodeAt(pos) === 123) {
              state.pos = labelStart;
              state.posMax = labelEnd;
              state.push("span_open", "span", 1);
              state.md.inline.tokenize(state);
              state.push("span_close", "span", -1);
              state.pos = pos;
              state.posMax = max;
              return true;
            } else {
              return false;
            }
          }
          ;
          md2.inline.ruler.push("bracketed-spans", span);
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-attrs@4.1.6_markdown-it@13.0.1/node_modules/markdown-it-attrs/utils.js
    var require_utils3 = __commonJS({
      "node_modules/.pnpm/markdown-it-attrs@4.1.6_markdown-it@13.0.1/node_modules/markdown-it-attrs/utils.js"(exports2) {
        exports2.getAttrs = function(str2, start, options2) {
          const allowedKeyChars = /[^\t\n\f />"'=]/;
          const pairSeparator = " ";
          const keySeparator = "=";
          const classChar = ".";
          const idChar = "#";
          const attrs = [];
          let key = "";
          let value = "";
          let parsingKey = true;
          let valueInsideQuotes = false;
          for (let i = start + options2.leftDelimiter.length; i < str2.length; i++) {
            if (str2.slice(i, i + options2.rightDelimiter.length) === options2.rightDelimiter) {
              if (key !== "") {
                attrs.push([key, value]);
              }
              break;
            }
            const char_ = str2.charAt(i);
            if (char_ === keySeparator && parsingKey) {
              parsingKey = false;
              continue;
            }
            if (char_ === classChar && key === "") {
              if (str2.charAt(i + 1) === classChar) {
                key = "css-module";
                i += 1;
              } else {
                key = "class";
              }
              parsingKey = false;
              continue;
            }
            if (char_ === idChar && key === "") {
              key = "id";
              parsingKey = false;
              continue;
            }
            if (char_ === '"' && value === "" && !valueInsideQuotes) {
              valueInsideQuotes = true;
              continue;
            }
            if (char_ === '"' && valueInsideQuotes) {
              valueInsideQuotes = false;
              continue;
            }
            if (char_ === pairSeparator && !valueInsideQuotes) {
              if (key === "") {
                continue;
              }
              attrs.push([key, value]);
              key = "";
              value = "";
              parsingKey = true;
              continue;
            }
            if (parsingKey && char_.search(allowedKeyChars) === -1) {
              continue;
            }
            if (parsingKey) {
              key += char_;
              continue;
            }
            value += char_;
          }
          if (options2.allowedAttributes && options2.allowedAttributes.length) {
            const allowedAttributes = options2.allowedAttributes;
            return attrs.filter(function(attrPair) {
              const attr = attrPair[0];
              function isAllowedAttribute(allowedAttribute) {
                return attr === allowedAttribute || allowedAttribute instanceof RegExp && allowedAttribute.test(attr);
              }
              return allowedAttributes.some(isAllowedAttribute);
            });
          }
          return attrs;
        };
        exports2.addAttrs = function(attrs, token) {
          for (let j = 0, l = attrs.length; j < l; ++j) {
            const key = attrs[j][0];
            if (key === "class") {
              token.attrJoin("class", attrs[j][1]);
            } else if (key === "css-module") {
              token.attrJoin("css-module", attrs[j][1]);
            } else {
              token.attrPush(attrs[j]);
            }
          }
          return token;
        };
        exports2.hasDelimiters = function(where, options2) {
          if (!where) {
            throw new Error('Parameter `where` not passed. Should be "start", "end" or "only".');
          }
          return function(str2) {
            const minCurlyLength = options2.leftDelimiter.length + 1 + options2.rightDelimiter.length;
            if (!str2 || typeof str2 !== "string" || str2.length < minCurlyLength) {
              return false;
            }
            function validCurlyLength(curly) {
              const isClass = curly.charAt(options2.leftDelimiter.length) === ".";
              const isId = curly.charAt(options2.leftDelimiter.length) === "#";
              return isClass || isId ? curly.length >= minCurlyLength + 1 : curly.length >= minCurlyLength;
            }
            let start, end, slice, nextChar;
            const rightDelimiterMinimumShift = minCurlyLength - options2.rightDelimiter.length;
            switch (where) {
              case "start":
                slice = str2.slice(0, options2.leftDelimiter.length);
                start = slice === options2.leftDelimiter ? 0 : -1;
                end = start === -1 ? -1 : str2.indexOf(options2.rightDelimiter, rightDelimiterMinimumShift);
                nextChar = str2.charAt(end + options2.rightDelimiter.length);
                if (nextChar && options2.rightDelimiter.indexOf(nextChar) !== -1) {
                  end = -1;
                }
                break;
              case "end":
                start = str2.lastIndexOf(options2.leftDelimiter);
                end = start === -1 ? -1 : str2.indexOf(options2.rightDelimiter, start + rightDelimiterMinimumShift);
                end = end === str2.length - options2.rightDelimiter.length ? end : -1;
                break;
              case "only":
                slice = str2.slice(0, options2.leftDelimiter.length);
                start = slice === options2.leftDelimiter ? 0 : -1;
                slice = str2.slice(str2.length - options2.rightDelimiter.length);
                end = slice === options2.rightDelimiter ? str2.length - options2.rightDelimiter.length : -1;
                break;
              default:
                throw new Error(`Unexpected case ${where}, expected 'start', 'end' or 'only'`);
            }
            return start !== -1 && end !== -1 && validCurlyLength(str2.substring(start, end + options2.rightDelimiter.length));
          };
        };
        exports2.removeDelimiter = function(str2, options2) {
          const start = escapeRegExp(options2.leftDelimiter);
          const end = escapeRegExp(options2.rightDelimiter);
          const curly = new RegExp(
            "[ \\n]?" + start + "[^" + start + end + "]+" + end + "$"
          );
          const pos = str2.search(curly);
          return pos !== -1 ? str2.slice(0, pos) : str2;
        };
        function escapeRegExp(s) {
          return s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
        }
        exports2.escapeRegExp = escapeRegExp;
        exports2.getMatchingOpeningToken = function(tokens, i) {
          if (tokens[i].type === "softbreak") {
            return false;
          }
          if (tokens[i].nesting === 0) {
            return tokens[i];
          }
          const level = tokens[i].level;
          const type = tokens[i].type.replace("_close", "_open");
          for (; i >= 0; --i) {
            if (tokens[i].type === type && tokens[i].level === level) {
              return tokens[i];
            }
          }
          return false;
        };
        var HTML_ESCAPE_TEST_RE = /[&<>"]/;
        var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
        var HTML_REPLACEMENTS = {
          "&": "&amp;",
          "<": "&lt;",
          ">": "&gt;",
          '"': "&quot;"
        };
        function replaceUnsafeChar(ch) {
          return HTML_REPLACEMENTS[ch];
        }
        exports2.escapeHtml = function(str2) {
          if (HTML_ESCAPE_TEST_RE.test(str2)) {
            return str2.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
          }
          return str2;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-attrs@4.1.6_markdown-it@13.0.1/node_modules/markdown-it-attrs/patterns.js
    var require_patterns = __commonJS({
      "node_modules/.pnpm/markdown-it-attrs@4.1.6_markdown-it@13.0.1/node_modules/markdown-it-attrs/patterns.js"(exports2, module2) {
        "use strict";
        var utils = require_utils3();
        module2.exports = (options2) => {
          const __hr = new RegExp("^ {0,3}[-*_]{3,} ?" + utils.escapeRegExp(options2.leftDelimiter) + "[^" + utils.escapeRegExp(options2.rightDelimiter) + "]");
          return [
            {
              /**
               * ```python {.cls}
               * for i in range(10):
               *     print(i)
               * ```
               */
              name: "fenced code blocks",
              tests: [
                {
                  shift: 0,
                  block: true,
                  info: utils.hasDelimiters("end", options2)
                }
              ],
              transform: (tokens, i) => {
                const token = tokens[i];
                const start = token.info.lastIndexOf(options2.leftDelimiter);
                const attrs = utils.getAttrs(token.info, start, options2);
                utils.addAttrs(attrs, token);
                token.info = utils.removeDelimiter(token.info, options2);
              }
            },
            {
              /**
               * bla `click()`{.c} ![](img.png){.d}
               *
               * differs from 'inline attributes' as it does
               * not have a closing tag (nesting: -1)
               */
              name: "inline nesting 0",
              tests: [
                {
                  shift: 0,
                  type: "inline",
                  children: [
                    {
                      shift: -1,
                      type: (str2) => str2 === "image" || str2 === "code_inline"
                    },
                    {
                      shift: 0,
                      type: "text",
                      content: utils.hasDelimiters("start", options2)
                    }
                  ]
                }
              ],
              transform: (tokens, i, j) => {
                const token = tokens[i].children[j];
                const endChar = token.content.indexOf(options2.rightDelimiter);
                const attrToken = tokens[i].children[j - 1];
                const attrs = utils.getAttrs(token.content, 0, options2);
                utils.addAttrs(attrs, attrToken);
                if (token.content.length === endChar + options2.rightDelimiter.length) {
                  tokens[i].children.splice(j, 1);
                } else {
                  token.content = token.content.slice(endChar + options2.rightDelimiter.length);
                }
              }
            },
            {
              /**
               * | h1 |
               * | -- |
               * | c1 |
               *
               * {.c}
               */
              name: "tables",
              tests: [
                {
                  // let this token be i, such that for-loop continues at
                  // next token after tokens.splice
                  shift: 0,
                  type: "table_close"
                },
                {
                  shift: 1,
                  type: "paragraph_open"
                },
                {
                  shift: 2,
                  type: "inline",
                  content: utils.hasDelimiters("only", options2)
                }
              ],
              transform: (tokens, i) => {
                const token = tokens[i + 2];
                const tableOpen = utils.getMatchingOpeningToken(tokens, i);
                const attrs = utils.getAttrs(token.content, 0, options2);
                utils.addAttrs(attrs, tableOpen);
                tokens.splice(i + 1, 3);
              }
            },
            {
              /**
               * *emphasis*{.with attrs=1}
               */
              name: "inline attributes",
              tests: [
                {
                  shift: 0,
                  type: "inline",
                  children: [
                    {
                      shift: -1,
                      nesting: -1
                      // closing inline tag, </em>{.a}
                    },
                    {
                      shift: 0,
                      type: "text",
                      content: utils.hasDelimiters("start", options2)
                    }
                  ]
                }
              ],
              transform: (tokens, i, j) => {
                const token = tokens[i].children[j];
                const content = token.content;
                const attrs = utils.getAttrs(content, 0, options2);
                const openingToken = utils.getMatchingOpeningToken(tokens[i].children, j - 1);
                utils.addAttrs(attrs, openingToken);
                token.content = content.slice(content.indexOf(options2.rightDelimiter) + options2.rightDelimiter.length);
              }
            },
            {
              /**
               * - item
               * {.a}
               */
              name: "list softbreak",
              tests: [
                {
                  shift: -2,
                  type: "list_item_open"
                },
                {
                  shift: 0,
                  type: "inline",
                  children: [
                    {
                      position: -2,
                      type: "softbreak"
                    },
                    {
                      position: -1,
                      type: "text",
                      content: utils.hasDelimiters("only", options2)
                    }
                  ]
                }
              ],
              transform: (tokens, i, j) => {
                const token = tokens[i].children[j];
                const content = token.content;
                const attrs = utils.getAttrs(content, 0, options2);
                let ii = i - 2;
                while (tokens[ii - 1] && tokens[ii - 1].type !== "ordered_list_open" && tokens[ii - 1].type !== "bullet_list_open") {
                  ii--;
                }
                utils.addAttrs(attrs, tokens[ii - 1]);
                tokens[i].children = tokens[i].children.slice(0, -2);
              }
            },
            {
              /**
               * - nested list
               *   - with double \n
               *   {.a} <-- apply to nested ul
               *
               * {.b} <-- apply to root <ul>
               */
              name: "list double softbreak",
              tests: [
                {
                  // let this token be i = 0 so that we can erase
                  // the <p>{.a}</p> tokens below
                  shift: 0,
                  type: (str2) => str2 === "bullet_list_close" || str2 === "ordered_list_close"
                },
                {
                  shift: 1,
                  type: "paragraph_open"
                },
                {
                  shift: 2,
                  type: "inline",
                  content: utils.hasDelimiters("only", options2),
                  children: (arr) => arr.length === 1
                },
                {
                  shift: 3,
                  type: "paragraph_close"
                }
              ],
              transform: (tokens, i) => {
                const token = tokens[i + 2];
                const content = token.content;
                const attrs = utils.getAttrs(content, 0, options2);
                const openingToken = utils.getMatchingOpeningToken(tokens, i);
                utils.addAttrs(attrs, openingToken);
                tokens.splice(i + 1, 3);
              }
            },
            {
              /**
               * - end of {.list-item}
               */
              name: "list item end",
              tests: [
                {
                  shift: -2,
                  type: "list_item_open"
                },
                {
                  shift: 0,
                  type: "inline",
                  children: [
                    {
                      position: -1,
                      type: "text",
                      content: utils.hasDelimiters("end", options2)
                    }
                  ]
                }
              ],
              transform: (tokens, i, j) => {
                const token = tokens[i].children[j];
                const content = token.content;
                const attrs = utils.getAttrs(content, content.lastIndexOf(options2.leftDelimiter), options2);
                utils.addAttrs(attrs, tokens[i - 2]);
                const trimmed = content.slice(0, content.lastIndexOf(options2.leftDelimiter));
                token.content = last(trimmed) !== " " ? trimmed : trimmed.slice(0, -1);
              }
            },
            {
              /**
               * something with softbreak
               * {.cls}
               */
              name: "\n{.a} softbreak then curly in start",
              tests: [
                {
                  shift: 0,
                  type: "inline",
                  children: [
                    {
                      position: -2,
                      type: "softbreak"
                    },
                    {
                      position: -1,
                      type: "text",
                      content: utils.hasDelimiters("only", options2)
                    }
                  ]
                }
              ],
              transform: (tokens, i, j) => {
                const token = tokens[i].children[j];
                const attrs = utils.getAttrs(token.content, 0, options2);
                let ii = i + 1;
                while (tokens[ii + 1] && tokens[ii + 1].nesting === -1) {
                  ii++;
                }
                const openingToken = utils.getMatchingOpeningToken(tokens, ii);
                utils.addAttrs(attrs, openingToken);
                tokens[i].children = tokens[i].children.slice(0, -2);
              }
            },
            {
              /**
               * horizontal rule --- {#id}
               */
              name: "horizontal rule",
              tests: [
                {
                  shift: 0,
                  type: "paragraph_open"
                },
                {
                  shift: 1,
                  type: "inline",
                  children: (arr) => arr.length === 1,
                  content: (str2) => str2.match(__hr) !== null
                },
                {
                  shift: 2,
                  type: "paragraph_close"
                }
              ],
              transform: (tokens, i) => {
                const token = tokens[i];
                token.type = "hr";
                token.tag = "hr";
                token.nesting = 0;
                const content = tokens[i + 1].content;
                const start = content.lastIndexOf(options2.leftDelimiter);
                const attrs = utils.getAttrs(content, start, options2);
                utils.addAttrs(attrs, token);
                token.markup = content;
                tokens.splice(i + 1, 2);
              }
            },
            {
              /**
               * end of {.block}
               */
              name: "end of block",
              tests: [
                {
                  shift: 0,
                  type: "inline",
                  children: [
                    {
                      position: -1,
                      content: utils.hasDelimiters("end", options2),
                      type: (t) => t !== "code_inline" && t !== "math_inline"
                    }
                  ]
                }
              ],
              transform: (tokens, i, j) => {
                const token = tokens[i].children[j];
                const content = token.content;
                const attrs = utils.getAttrs(content, content.lastIndexOf(options2.leftDelimiter), options2);
                let ii = i + 1;
                while (tokens[ii + 1] && tokens[ii + 1].nesting === -1) {
                  ii++;
                }
                const openingToken = utils.getMatchingOpeningToken(tokens, ii);
                utils.addAttrs(attrs, openingToken);
                const trimmed = content.slice(0, content.lastIndexOf(options2.leftDelimiter));
                token.content = last(trimmed) !== " " ? trimmed : trimmed.slice(0, -1);
              }
            }
          ];
        };
        function last(arr) {
          return arr.slice(-1)[0];
        }
      }
    });
    
    // node_modules/.pnpm/markdown-it-attrs@4.1.6_markdown-it@13.0.1/node_modules/markdown-it-attrs/index.js
    var require_markdown_it_attrs = __commonJS({
      "node_modules/.pnpm/markdown-it-attrs@4.1.6_markdown-it@13.0.1/node_modules/markdown-it-attrs/index.js"(exports2, module2) {
        "use strict";
        var patternsConfig = require_patterns();
        var defaultOptions = {
          leftDelimiter: "{",
          rightDelimiter: "}",
          allowedAttributes: []
        };
        module2.exports = function attributes2(md2, options_) {
          let options2 = Object.assign({}, defaultOptions);
          options2 = Object.assign(options2, options_);
          const patterns = patternsConfig(options2);
          function curlyAttrs(state) {
            const tokens = state.tokens;
            for (let i = 0; i < tokens.length; i++) {
              for (let p = 0; p < patterns.length; p++) {
                const pattern = patterns[p];
                let j = null;
                const match = pattern.tests.every((t) => {
                  const res = test(tokens, i, t);
                  if (res.j !== null) {
                    j = res.j;
                  }
                  return res.match;
                });
                if (match) {
                  pattern.transform(tokens, i, j);
                  if (pattern.name === "inline attributes" || pattern.name === "inline nesting 0") {
                    p--;
                  }
                }
              }
            }
          }
          md2.core.ruler.before("linkify", "curly_attributes", curlyAttrs);
        };
        function test(tokens, i, t) {
          const res = {
            match: false,
            j: null
            // position of child
          };
          const ii = t.shift !== void 0 ? i + t.shift : t.position;
          if (t.shift !== void 0 && ii < 0) {
            return res;
          }
          const token = get(tokens, ii);
          if (token === void 0) {
            return res;
          }
          for (const key of Object.keys(t)) {
            if (key === "shift" || key === "position") {
              continue;
            }
            if (token[key] === void 0) {
              return res;
            }
            if (key === "children" && isArrayOfObjects(t.children)) {
              if (token.children.length === 0) {
                return res;
              }
              let match;
              const childTests = t.children;
              const children = token.children;
              if (childTests.every((tt) => tt.position !== void 0)) {
                match = childTests.every((tt) => test(children, tt.position, tt).match);
                if (match) {
                  const j = last(childTests).position;
                  res.j = j >= 0 ? j : children.length + j;
                }
              } else {
                for (let j = 0; j < children.length; j++) {
                  match = childTests.every((tt) => test(children, j, tt).match);
                  if (match) {
                    res.j = j;
                    break;
                  }
                }
              }
              if (match === false) {
                return res;
              }
              continue;
            }
            switch (typeof t[key]) {
              case "boolean":
              case "number":
              case "string":
                if (token[key] !== t[key]) {
                  return res;
                }
                break;
              case "function":
                if (!t[key](token[key])) {
                  return res;
                }
                break;
              case "object":
                if (isArrayOfFunctions(t[key])) {
                  const r = t[key].every((tt) => tt(token[key]));
                  if (r === false) {
                    return res;
                  }
                  break;
                }
              default:
                throw new Error(`Unknown type of pattern test (key: ${key}). Test should be of type boolean, number, string, function or array of functions.`);
            }
          }
          res.match = true;
          return res;
        }
        function isArrayOfObjects(arr) {
          return Array.isArray(arr) && arr.length && arr.every((i) => typeof i === "object");
        }
        function isArrayOfFunctions(arr) {
          return Array.isArray(arr) && arr.length && arr.every((i) => typeof i === "function");
        }
        function get(arr, n) {
          return n >= 0 ? arr[n] : arr[arr.length + n];
        }
        function last(arr) {
          return arr.slice(-1)[0] || {};
        }
      }
    });
    
    // node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/data/full.json
    var require_full = __commonJS({
      "node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/data/full.json"(exports2, module2) {
        module2.exports = {
          "100": "\u{1F4AF}",
          "1234": "\u{1F522}",
          grinning: "\u{1F600}",
          smiley: "\u{1F603}",
          smile: "\u{1F604}",
          grin: "\u{1F601}",
          laughing: "\u{1F606}",
          satisfied: "\u{1F606}",
          sweat_smile: "\u{1F605}",
          rofl: "\u{1F923}",
          joy: "\u{1F602}",
          slightly_smiling_face: "\u{1F642}",
          upside_down_face: "\u{1F643}",
          wink: "\u{1F609}",
          blush: "\u{1F60A}",
          innocent: "\u{1F607}",
          smiling_face_with_three_hearts: "\u{1F970}",
          heart_eyes: "\u{1F60D}",
          star_struck: "\u{1F929}",
          kissing_heart: "\u{1F618}",
          kissing: "\u{1F617}",
          relaxed: "\u263A\uFE0F",
          kissing_closed_eyes: "\u{1F61A}",
          kissing_smiling_eyes: "\u{1F619}",
          smiling_face_with_tear: "\u{1F972}",
          yum: "\u{1F60B}",
          stuck_out_tongue: "\u{1F61B}",
          stuck_out_tongue_winking_eye: "\u{1F61C}",
          zany_face: "\u{1F92A}",
          stuck_out_tongue_closed_eyes: "\u{1F61D}",
          money_mouth_face: "\u{1F911}",
          hugs: "\u{1F917}",
          hand_over_mouth: "\u{1F92D}",
          shushing_face: "\u{1F92B}",
          thinking: "\u{1F914}",
          zipper_mouth_face: "\u{1F910}",
          raised_eyebrow: "\u{1F928}",
          neutral_face: "\u{1F610}",
          expressionless: "\u{1F611}",
          no_mouth: "\u{1F636}",
          smirk: "\u{1F60F}",
          unamused: "\u{1F612}",
          roll_eyes: "\u{1F644}",
          grimacing: "\u{1F62C}",
          lying_face: "\u{1F925}",
          relieved: "\u{1F60C}",
          pensive: "\u{1F614}",
          sleepy: "\u{1F62A}",
          drooling_face: "\u{1F924}",
          sleeping: "\u{1F634}",
          mask: "\u{1F637}",
          face_with_thermometer: "\u{1F912}",
          face_with_head_bandage: "\u{1F915}",
          nauseated_face: "\u{1F922}",
          vomiting_face: "\u{1F92E}",
          sneezing_face: "\u{1F927}",
          hot_face: "\u{1F975}",
          cold_face: "\u{1F976}",
          woozy_face: "\u{1F974}",
          dizzy_face: "\u{1F635}",
          exploding_head: "\u{1F92F}",
          cowboy_hat_face: "\u{1F920}",
          partying_face: "\u{1F973}",
          disguised_face: "\u{1F978}",
          sunglasses: "\u{1F60E}",
          nerd_face: "\u{1F913}",
          monocle_face: "\u{1F9D0}",
          confused: "\u{1F615}",
          worried: "\u{1F61F}",
          slightly_frowning_face: "\u{1F641}",
          frowning_face: "\u2639\uFE0F",
          open_mouth: "\u{1F62E}",
          hushed: "\u{1F62F}",
          astonished: "\u{1F632}",
          flushed: "\u{1F633}",
          pleading_face: "\u{1F97A}",
          frowning: "\u{1F626}",
          anguished: "\u{1F627}",
          fearful: "\u{1F628}",
          cold_sweat: "\u{1F630}",
          disappointed_relieved: "\u{1F625}",
          cry: "\u{1F622}",
          sob: "\u{1F62D}",
          scream: "\u{1F631}",
          confounded: "\u{1F616}",
          persevere: "\u{1F623}",
          disappointed: "\u{1F61E}",
          sweat: "\u{1F613}",
          weary: "\u{1F629}",
          tired_face: "\u{1F62B}",
          yawning_face: "\u{1F971}",
          triumph: "\u{1F624}",
          rage: "\u{1F621}",
          pout: "\u{1F621}",
          angry: "\u{1F620}",
          cursing_face: "\u{1F92C}",
          smiling_imp: "\u{1F608}",
          imp: "\u{1F47F}",
          skull: "\u{1F480}",
          skull_and_crossbones: "\u2620\uFE0F",
          hankey: "\u{1F4A9}",
          poop: "\u{1F4A9}",
          shit: "\u{1F4A9}",
          clown_face: "\u{1F921}",
          japanese_ogre: "\u{1F479}",
          japanese_goblin: "\u{1F47A}",
          ghost: "\u{1F47B}",
          alien: "\u{1F47D}",
          space_invader: "\u{1F47E}",
          robot: "\u{1F916}",
          smiley_cat: "\u{1F63A}",
          smile_cat: "\u{1F638}",
          joy_cat: "\u{1F639}",
          heart_eyes_cat: "\u{1F63B}",
          smirk_cat: "\u{1F63C}",
          kissing_cat: "\u{1F63D}",
          scream_cat: "\u{1F640}",
          crying_cat_face: "\u{1F63F}",
          pouting_cat: "\u{1F63E}",
          see_no_evil: "\u{1F648}",
          hear_no_evil: "\u{1F649}",
          speak_no_evil: "\u{1F64A}",
          kiss: "\u{1F48B}",
          love_letter: "\u{1F48C}",
          cupid: "\u{1F498}",
          gift_heart: "\u{1F49D}",
          sparkling_heart: "\u{1F496}",
          heartpulse: "\u{1F497}",
          heartbeat: "\u{1F493}",
          revolving_hearts: "\u{1F49E}",
          two_hearts: "\u{1F495}",
          heart_decoration: "\u{1F49F}",
          heavy_heart_exclamation: "\u2763\uFE0F",
          broken_heart: "\u{1F494}",
          heart: "\u2764\uFE0F",
          orange_heart: "\u{1F9E1}",
          yellow_heart: "\u{1F49B}",
          green_heart: "\u{1F49A}",
          blue_heart: "\u{1F499}",
          purple_heart: "\u{1F49C}",
          brown_heart: "\u{1F90E}",
          black_heart: "\u{1F5A4}",
          white_heart: "\u{1F90D}",
          anger: "\u{1F4A2}",
          boom: "\u{1F4A5}",
          collision: "\u{1F4A5}",
          dizzy: "\u{1F4AB}",
          sweat_drops: "\u{1F4A6}",
          dash: "\u{1F4A8}",
          hole: "\u{1F573}\uFE0F",
          bomb: "\u{1F4A3}",
          speech_balloon: "\u{1F4AC}",
          eye_speech_bubble: "\u{1F441}\uFE0F\u200D\u{1F5E8}\uFE0F",
          left_speech_bubble: "\u{1F5E8}\uFE0F",
          right_anger_bubble: "\u{1F5EF}\uFE0F",
          thought_balloon: "\u{1F4AD}",
          zzz: "\u{1F4A4}",
          wave: "\u{1F44B}",
          raised_back_of_hand: "\u{1F91A}",
          raised_hand_with_fingers_splayed: "\u{1F590}\uFE0F",
          hand: "\u270B",
          raised_hand: "\u270B",
          vulcan_salute: "\u{1F596}",
          ok_hand: "\u{1F44C}",
          pinched_fingers: "\u{1F90C}",
          pinching_hand: "\u{1F90F}",
          v: "\u270C\uFE0F",
          crossed_fingers: "\u{1F91E}",
          love_you_gesture: "\u{1F91F}",
          metal: "\u{1F918}",
          call_me_hand: "\u{1F919}",
          point_left: "\u{1F448}",
          point_right: "\u{1F449}",
          point_up_2: "\u{1F446}",
          middle_finger: "\u{1F595}",
          fu: "\u{1F595}",
          point_down: "\u{1F447}",
          point_up: "\u261D\uFE0F",
          "+1": "\u{1F44D}",
          thumbsup: "\u{1F44D}",
          "-1": "\u{1F44E}",
          thumbsdown: "\u{1F44E}",
          fist_raised: "\u270A",
          fist: "\u270A",
          fist_oncoming: "\u{1F44A}",
          facepunch: "\u{1F44A}",
          punch: "\u{1F44A}",
          fist_left: "\u{1F91B}",
          fist_right: "\u{1F91C}",
          clap: "\u{1F44F}",
          raised_hands: "\u{1F64C}",
          open_hands: "\u{1F450}",
          palms_up_together: "\u{1F932}",
          handshake: "\u{1F91D}",
          pray: "\u{1F64F}",
          writing_hand: "\u270D\uFE0F",
          nail_care: "\u{1F485}",
          selfie: "\u{1F933}",
          muscle: "\u{1F4AA}",
          mechanical_arm: "\u{1F9BE}",
          mechanical_leg: "\u{1F9BF}",
          leg: "\u{1F9B5}",
          foot: "\u{1F9B6}",
          ear: "\u{1F442}",
          ear_with_hearing_aid: "\u{1F9BB}",
          nose: "\u{1F443}",
          brain: "\u{1F9E0}",
          anatomical_heart: "\u{1FAC0}",
          lungs: "\u{1FAC1}",
          tooth: "\u{1F9B7}",
          bone: "\u{1F9B4}",
          eyes: "\u{1F440}",
          eye: "\u{1F441}\uFE0F",
          tongue: "\u{1F445}",
          lips: "\u{1F444}",
          baby: "\u{1F476}",
          child: "\u{1F9D2}",
          boy: "\u{1F466}",
          girl: "\u{1F467}",
          adult: "\u{1F9D1}",
          blond_haired_person: "\u{1F471}",
          man: "\u{1F468}",
          bearded_person: "\u{1F9D4}",
          red_haired_man: "\u{1F468}\u200D\u{1F9B0}",
          curly_haired_man: "\u{1F468}\u200D\u{1F9B1}",
          white_haired_man: "\u{1F468}\u200D\u{1F9B3}",
          bald_man: "\u{1F468}\u200D\u{1F9B2}",
          woman: "\u{1F469}",
          red_haired_woman: "\u{1F469}\u200D\u{1F9B0}",
          person_red_hair: "\u{1F9D1}\u200D\u{1F9B0}",
          curly_haired_woman: "\u{1F469}\u200D\u{1F9B1}",
          person_curly_hair: "\u{1F9D1}\u200D\u{1F9B1}",
          white_haired_woman: "\u{1F469}\u200D\u{1F9B3}",
          person_white_hair: "\u{1F9D1}\u200D\u{1F9B3}",
          bald_woman: "\u{1F469}\u200D\u{1F9B2}",
          person_bald: "\u{1F9D1}\u200D\u{1F9B2}",
          blond_haired_woman: "\u{1F471}\u200D\u2640\uFE0F",
          blonde_woman: "\u{1F471}\u200D\u2640\uFE0F",
          blond_haired_man: "\u{1F471}\u200D\u2642\uFE0F",
          older_adult: "\u{1F9D3}",
          older_man: "\u{1F474}",
          older_woman: "\u{1F475}",
          frowning_person: "\u{1F64D}",
          frowning_man: "\u{1F64D}\u200D\u2642\uFE0F",
          frowning_woman: "\u{1F64D}\u200D\u2640\uFE0F",
          pouting_face: "\u{1F64E}",
          pouting_man: "\u{1F64E}\u200D\u2642\uFE0F",
          pouting_woman: "\u{1F64E}\u200D\u2640\uFE0F",
          no_good: "\u{1F645}",
          no_good_man: "\u{1F645}\u200D\u2642\uFE0F",
          ng_man: "\u{1F645}\u200D\u2642\uFE0F",
          no_good_woman: "\u{1F645}\u200D\u2640\uFE0F",
          ng_woman: "\u{1F645}\u200D\u2640\uFE0F",
          ok_person: "\u{1F646}",
          ok_man: "\u{1F646}\u200D\u2642\uFE0F",
          ok_woman: "\u{1F646}\u200D\u2640\uFE0F",
          tipping_hand_person: "\u{1F481}",
          information_desk_person: "\u{1F481}",
          tipping_hand_man: "\u{1F481}\u200D\u2642\uFE0F",
          sassy_man: "\u{1F481}\u200D\u2642\uFE0F",
          tipping_hand_woman: "\u{1F481}\u200D\u2640\uFE0F",
          sassy_woman: "\u{1F481}\u200D\u2640\uFE0F",
          raising_hand: "\u{1F64B}",
          raising_hand_man: "\u{1F64B}\u200D\u2642\uFE0F",
          raising_hand_woman: "\u{1F64B}\u200D\u2640\uFE0F",
          deaf_person: "\u{1F9CF}",
          deaf_man: "\u{1F9CF}\u200D\u2642\uFE0F",
          deaf_woman: "\u{1F9CF}\u200D\u2640\uFE0F",
          bow: "\u{1F647}",
          bowing_man: "\u{1F647}\u200D\u2642\uFE0F",
          bowing_woman: "\u{1F647}\u200D\u2640\uFE0F",
          facepalm: "\u{1F926}",
          man_facepalming: "\u{1F926}\u200D\u2642\uFE0F",
          woman_facepalming: "\u{1F926}\u200D\u2640\uFE0F",
          shrug: "\u{1F937}",
          man_shrugging: "\u{1F937}\u200D\u2642\uFE0F",
          woman_shrugging: "\u{1F937}\u200D\u2640\uFE0F",
          health_worker: "\u{1F9D1}\u200D\u2695\uFE0F",
          man_health_worker: "\u{1F468}\u200D\u2695\uFE0F",
          woman_health_worker: "\u{1F469}\u200D\u2695\uFE0F",
          student: "\u{1F9D1}\u200D\u{1F393}",
          man_student: "\u{1F468}\u200D\u{1F393}",
          woman_student: "\u{1F469}\u200D\u{1F393}",
          teacher: "\u{1F9D1}\u200D\u{1F3EB}",
          man_teacher: "\u{1F468}\u200D\u{1F3EB}",
          woman_teacher: "\u{1F469}\u200D\u{1F3EB}",
          judge: "\u{1F9D1}\u200D\u2696\uFE0F",
          man_judge: "\u{1F468}\u200D\u2696\uFE0F",
          woman_judge: "\u{1F469}\u200D\u2696\uFE0F",
          farmer: "\u{1F9D1}\u200D\u{1F33E}",
          man_farmer: "\u{1F468}\u200D\u{1F33E}",
          woman_farmer: "\u{1F469}\u200D\u{1F33E}",
          cook: "\u{1F9D1}\u200D\u{1F373}",
          man_cook: "\u{1F468}\u200D\u{1F373}",
          woman_cook: "\u{1F469}\u200D\u{1F373}",
          mechanic: "\u{1F9D1}\u200D\u{1F527}",
          man_mechanic: "\u{1F468}\u200D\u{1F527}",
          woman_mechanic: "\u{1F469}\u200D\u{1F527}",
          factory_worker: "\u{1F9D1}\u200D\u{1F3ED}",
          man_factory_worker: "\u{1F468}\u200D\u{1F3ED}",
          woman_factory_worker: "\u{1F469}\u200D\u{1F3ED}",
          office_worker: "\u{1F9D1}\u200D\u{1F4BC}",
          man_office_worker: "\u{1F468}\u200D\u{1F4BC}",
          woman_office_worker: "\u{1F469}\u200D\u{1F4BC}",
          scientist: "\u{1F9D1}\u200D\u{1F52C}",
          man_scientist: "\u{1F468}\u200D\u{1F52C}",
          woman_scientist: "\u{1F469}\u200D\u{1F52C}",
          technologist: "\u{1F9D1}\u200D\u{1F4BB}",
          man_technologist: "\u{1F468}\u200D\u{1F4BB}",
          woman_technologist: "\u{1F469}\u200D\u{1F4BB}",
          singer: "\u{1F9D1}\u200D\u{1F3A4}",
          man_singer: "\u{1F468}\u200D\u{1F3A4}",
          woman_singer: "\u{1F469}\u200D\u{1F3A4}",
          artist: "\u{1F9D1}\u200D\u{1F3A8}",
          man_artist: "\u{1F468}\u200D\u{1F3A8}",
          woman_artist: "\u{1F469}\u200D\u{1F3A8}",
          pilot: "\u{1F9D1}\u200D\u2708\uFE0F",
          man_pilot: "\u{1F468}\u200D\u2708\uFE0F",
          woman_pilot: "\u{1F469}\u200D\u2708\uFE0F",
          astronaut: "\u{1F9D1}\u200D\u{1F680}",
          man_astronaut: "\u{1F468}\u200D\u{1F680}",
          woman_astronaut: "\u{1F469}\u200D\u{1F680}",
          firefighter: "\u{1F9D1}\u200D\u{1F692}",
          man_firefighter: "\u{1F468}\u200D\u{1F692}",
          woman_firefighter: "\u{1F469}\u200D\u{1F692}",
          police_officer: "\u{1F46E}",
          cop: "\u{1F46E}",
          policeman: "\u{1F46E}\u200D\u2642\uFE0F",
          policewoman: "\u{1F46E}\u200D\u2640\uFE0F",
          detective: "\u{1F575}\uFE0F",
          male_detective: "\u{1F575}\uFE0F\u200D\u2642\uFE0F",
          female_detective: "\u{1F575}\uFE0F\u200D\u2640\uFE0F",
          guard: "\u{1F482}",
          guardsman: "\u{1F482}\u200D\u2642\uFE0F",
          guardswoman: "\u{1F482}\u200D\u2640\uFE0F",
          ninja: "\u{1F977}",
          construction_worker: "\u{1F477}",
          construction_worker_man: "\u{1F477}\u200D\u2642\uFE0F",
          construction_worker_woman: "\u{1F477}\u200D\u2640\uFE0F",
          prince: "\u{1F934}",
          princess: "\u{1F478}",
          person_with_turban: "\u{1F473}",
          man_with_turban: "\u{1F473}\u200D\u2642\uFE0F",
          woman_with_turban: "\u{1F473}\u200D\u2640\uFE0F",
          man_with_gua_pi_mao: "\u{1F472}",
          woman_with_headscarf: "\u{1F9D5}",
          person_in_tuxedo: "\u{1F935}",
          man_in_tuxedo: "\u{1F935}\u200D\u2642\uFE0F",
          woman_in_tuxedo: "\u{1F935}\u200D\u2640\uFE0F",
          person_with_veil: "\u{1F470}",
          man_with_veil: "\u{1F470}\u200D\u2642\uFE0F",
          woman_with_veil: "\u{1F470}\u200D\u2640\uFE0F",
          bride_with_veil: "\u{1F470}\u200D\u2640\uFE0F",
          pregnant_woman: "\u{1F930}",
          breast_feeding: "\u{1F931}",
          woman_feeding_baby: "\u{1F469}\u200D\u{1F37C}",
          man_feeding_baby: "\u{1F468}\u200D\u{1F37C}",
          person_feeding_baby: "\u{1F9D1}\u200D\u{1F37C}",
          angel: "\u{1F47C}",
          santa: "\u{1F385}",
          mrs_claus: "\u{1F936}",
          mx_claus: "\u{1F9D1}\u200D\u{1F384}",
          superhero: "\u{1F9B8}",
          superhero_man: "\u{1F9B8}\u200D\u2642\uFE0F",
          superhero_woman: "\u{1F9B8}\u200D\u2640\uFE0F",
          supervillain: "\u{1F9B9}",
          supervillain_man: "\u{1F9B9}\u200D\u2642\uFE0F",
          supervillain_woman: "\u{1F9B9}\u200D\u2640\uFE0F",
          mage: "\u{1F9D9}",
          mage_man: "\u{1F9D9}\u200D\u2642\uFE0F",
          mage_woman: "\u{1F9D9}\u200D\u2640\uFE0F",
          fairy: "\u{1F9DA}",
          fairy_man: "\u{1F9DA}\u200D\u2642\uFE0F",
          fairy_woman: "\u{1F9DA}\u200D\u2640\uFE0F",
          vampire: "\u{1F9DB}",
          vampire_man: "\u{1F9DB}\u200D\u2642\uFE0F",
          vampire_woman: "\u{1F9DB}\u200D\u2640\uFE0F",
          merperson: "\u{1F9DC}",
          merman: "\u{1F9DC}\u200D\u2642\uFE0F",
          mermaid: "\u{1F9DC}\u200D\u2640\uFE0F",
          elf: "\u{1F9DD}",
          elf_man: "\u{1F9DD}\u200D\u2642\uFE0F",
          elf_woman: "\u{1F9DD}\u200D\u2640\uFE0F",
          genie: "\u{1F9DE}",
          genie_man: "\u{1F9DE}\u200D\u2642\uFE0F",
          genie_woman: "\u{1F9DE}\u200D\u2640\uFE0F",
          zombie: "\u{1F9DF}",
          zombie_man: "\u{1F9DF}\u200D\u2642\uFE0F",
          zombie_woman: "\u{1F9DF}\u200D\u2640\uFE0F",
          massage: "\u{1F486}",
          massage_man: "\u{1F486}\u200D\u2642\uFE0F",
          massage_woman: "\u{1F486}\u200D\u2640\uFE0F",
          haircut: "\u{1F487}",
          haircut_man: "\u{1F487}\u200D\u2642\uFE0F",
          haircut_woman: "\u{1F487}\u200D\u2640\uFE0F",
          walking: "\u{1F6B6}",
          walking_man: "\u{1F6B6}\u200D\u2642\uFE0F",
          walking_woman: "\u{1F6B6}\u200D\u2640\uFE0F",
          standing_person: "\u{1F9CD}",
          standing_man: "\u{1F9CD}\u200D\u2642\uFE0F",
          standing_woman: "\u{1F9CD}\u200D\u2640\uFE0F",
          kneeling_person: "\u{1F9CE}",
          kneeling_man: "\u{1F9CE}\u200D\u2642\uFE0F",
          kneeling_woman: "\u{1F9CE}\u200D\u2640\uFE0F",
          person_with_probing_cane: "\u{1F9D1}\u200D\u{1F9AF}",
          man_with_probing_cane: "\u{1F468}\u200D\u{1F9AF}",
          woman_with_probing_cane: "\u{1F469}\u200D\u{1F9AF}",
          person_in_motorized_wheelchair: "\u{1F9D1}\u200D\u{1F9BC}",
          man_in_motorized_wheelchair: "\u{1F468}\u200D\u{1F9BC}",
          woman_in_motorized_wheelchair: "\u{1F469}\u200D\u{1F9BC}",
          person_in_manual_wheelchair: "\u{1F9D1}\u200D\u{1F9BD}",
          man_in_manual_wheelchair: "\u{1F468}\u200D\u{1F9BD}",
          woman_in_manual_wheelchair: "\u{1F469}\u200D\u{1F9BD}",
          runner: "\u{1F3C3}",
          running: "\u{1F3C3}",
          running_man: "\u{1F3C3}\u200D\u2642\uFE0F",
          running_woman: "\u{1F3C3}\u200D\u2640\uFE0F",
          woman_dancing: "\u{1F483}",
          dancer: "\u{1F483}",
          man_dancing: "\u{1F57A}",
          business_suit_levitating: "\u{1F574}\uFE0F",
          dancers: "\u{1F46F}",
          dancing_men: "\u{1F46F}\u200D\u2642\uFE0F",
          dancing_women: "\u{1F46F}\u200D\u2640\uFE0F",
          sauna_person: "\u{1F9D6}",
          sauna_man: "\u{1F9D6}\u200D\u2642\uFE0F",
          sauna_woman: "\u{1F9D6}\u200D\u2640\uFE0F",
          climbing: "\u{1F9D7}",
          climbing_man: "\u{1F9D7}\u200D\u2642\uFE0F",
          climbing_woman: "\u{1F9D7}\u200D\u2640\uFE0F",
          person_fencing: "\u{1F93A}",
          horse_racing: "\u{1F3C7}",
          skier: "\u26F7\uFE0F",
          snowboarder: "\u{1F3C2}",
          golfing: "\u{1F3CC}\uFE0F",
          golfing_man: "\u{1F3CC}\uFE0F\u200D\u2642\uFE0F",
          golfing_woman: "\u{1F3CC}\uFE0F\u200D\u2640\uFE0F",
          surfer: "\u{1F3C4}",
          surfing_man: "\u{1F3C4}\u200D\u2642\uFE0F",
          surfing_woman: "\u{1F3C4}\u200D\u2640\uFE0F",
          rowboat: "\u{1F6A3}",
          rowing_man: "\u{1F6A3}\u200D\u2642\uFE0F",
          rowing_woman: "\u{1F6A3}\u200D\u2640\uFE0F",
          swimmer: "\u{1F3CA}",
          swimming_man: "\u{1F3CA}\u200D\u2642\uFE0F",
          swimming_woman: "\u{1F3CA}\u200D\u2640\uFE0F",
          bouncing_ball_person: "\u26F9\uFE0F",
          bouncing_ball_man: "\u26F9\uFE0F\u200D\u2642\uFE0F",
          basketball_man: "\u26F9\uFE0F\u200D\u2642\uFE0F",
          bouncing_ball_woman: "\u26F9\uFE0F\u200D\u2640\uFE0F",
          basketball_woman: "\u26F9\uFE0F\u200D\u2640\uFE0F",
          weight_lifting: "\u{1F3CB}\uFE0F",
          weight_lifting_man: "\u{1F3CB}\uFE0F\u200D\u2642\uFE0F",
          weight_lifting_woman: "\u{1F3CB}\uFE0F\u200D\u2640\uFE0F",
          bicyclist: "\u{1F6B4}",
          biking_man: "\u{1F6B4}\u200D\u2642\uFE0F",
          biking_woman: "\u{1F6B4}\u200D\u2640\uFE0F",
          mountain_bicyclist: "\u{1F6B5}",
          mountain_biking_man: "\u{1F6B5}\u200D\u2642\uFE0F",
          mountain_biking_woman: "\u{1F6B5}\u200D\u2640\uFE0F",
          cartwheeling: "\u{1F938}",
          man_cartwheeling: "\u{1F938}\u200D\u2642\uFE0F",
          woman_cartwheeling: "\u{1F938}\u200D\u2640\uFE0F",
          wrestling: "\u{1F93C}",
          men_wrestling: "\u{1F93C}\u200D\u2642\uFE0F",
          women_wrestling: "\u{1F93C}\u200D\u2640\uFE0F",
          water_polo: "\u{1F93D}",
          man_playing_water_polo: "\u{1F93D}\u200D\u2642\uFE0F",
          woman_playing_water_polo: "\u{1F93D}\u200D\u2640\uFE0F",
          handball_person: "\u{1F93E}",
          man_playing_handball: "\u{1F93E}\u200D\u2642\uFE0F",
          woman_playing_handball: "\u{1F93E}\u200D\u2640\uFE0F",
          juggling_person: "\u{1F939}",
          man_juggling: "\u{1F939}\u200D\u2642\uFE0F",
          woman_juggling: "\u{1F939}\u200D\u2640\uFE0F",
          lotus_position: "\u{1F9D8}",
          lotus_position_man: "\u{1F9D8}\u200D\u2642\uFE0F",
          lotus_position_woman: "\u{1F9D8}\u200D\u2640\uFE0F",
          bath: "\u{1F6C0}",
          sleeping_bed: "\u{1F6CC}",
          people_holding_hands: "\u{1F9D1}\u200D\u{1F91D}\u200D\u{1F9D1}",
          two_women_holding_hands: "\u{1F46D}",
          couple: "\u{1F46B}",
          two_men_holding_hands: "\u{1F46C}",
          couplekiss: "\u{1F48F}",
          couplekiss_man_woman: "\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}",
          couplekiss_man_man: "\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}",
          couplekiss_woman_woman: "\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}",
          couple_with_heart: "\u{1F491}",
          couple_with_heart_woman_man: "\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F468}",
          couple_with_heart_man_man: "\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F468}",
          couple_with_heart_woman_woman: "\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F469}",
          family: "\u{1F46A}",
          family_man_woman_boy: "\u{1F468}\u200D\u{1F469}\u200D\u{1F466}",
          family_man_woman_girl: "\u{1F468}\u200D\u{1F469}\u200D\u{1F467}",
          family_man_woman_girl_boy: "\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}",
          family_man_woman_boy_boy: "\u{1F468}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}",
          family_man_woman_girl_girl: "\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}",
          family_man_man_boy: "\u{1F468}\u200D\u{1F468}\u200D\u{1F466}",
          family_man_man_girl: "\u{1F468}\u200D\u{1F468}\u200D\u{1F467}",
          family_man_man_girl_boy: "\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F466}",
          family_man_man_boy_boy: "\u{1F468}\u200D\u{1F468}\u200D\u{1F466}\u200D\u{1F466}",
          family_man_man_girl_girl: "\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F467}",
          family_woman_woman_boy: "\u{1F469}\u200D\u{1F469}\u200D\u{1F466}",
          family_woman_woman_girl: "\u{1F469}\u200D\u{1F469}\u200D\u{1F467}",
          family_woman_woman_girl_boy: "\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}",
          family_woman_woman_boy_boy: "\u{1F469}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}",
          family_woman_woman_girl_girl: "\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}",
          family_man_boy: "\u{1F468}\u200D\u{1F466}",
          family_man_boy_boy: "\u{1F468}\u200D\u{1F466}\u200D\u{1F466}",
          family_man_girl: "\u{1F468}\u200D\u{1F467}",
          family_man_girl_boy: "\u{1F468}\u200D\u{1F467}\u200D\u{1F466}",
          family_man_girl_girl: "\u{1F468}\u200D\u{1F467}\u200D\u{1F467}",
          family_woman_boy: "\u{1F469}\u200D\u{1F466}",
          family_woman_boy_boy: "\u{1F469}\u200D\u{1F466}\u200D\u{1F466}",
          family_woman_girl: "\u{1F469}\u200D\u{1F467}",
          family_woman_girl_boy: "\u{1F469}\u200D\u{1F467}\u200D\u{1F466}",
          family_woman_girl_girl: "\u{1F469}\u200D\u{1F467}\u200D\u{1F467}",
          speaking_head: "\u{1F5E3}\uFE0F",
          bust_in_silhouette: "\u{1F464}",
          busts_in_silhouette: "\u{1F465}",
          people_hugging: "\u{1FAC2}",
          footprints: "\u{1F463}",
          monkey_face: "\u{1F435}",
          monkey: "\u{1F412}",
          gorilla: "\u{1F98D}",
          orangutan: "\u{1F9A7}",
          dog: "\u{1F436}",
          dog2: "\u{1F415}",
          guide_dog: "\u{1F9AE}",
          service_dog: "\u{1F415}\u200D\u{1F9BA}",
          poodle: "\u{1F429}",
          wolf: "\u{1F43A}",
          fox_face: "\u{1F98A}",
          raccoon: "\u{1F99D}",
          cat: "\u{1F431}",
          cat2: "\u{1F408}",
          black_cat: "\u{1F408}\u200D\u2B1B",
          lion: "\u{1F981}",
          tiger: "\u{1F42F}",
          tiger2: "\u{1F405}",
          leopard: "\u{1F406}",
          horse: "\u{1F434}",
          racehorse: "\u{1F40E}",
          unicorn: "\u{1F984}",
          zebra: "\u{1F993}",
          deer: "\u{1F98C}",
          bison: "\u{1F9AC}",
          cow: "\u{1F42E}",
          ox: "\u{1F402}",
          water_buffalo: "\u{1F403}",
          cow2: "\u{1F404}",
          pig: "\u{1F437}",
          pig2: "\u{1F416}",
          boar: "\u{1F417}",
          pig_nose: "\u{1F43D}",
          ram: "\u{1F40F}",
          sheep: "\u{1F411}",
          goat: "\u{1F410}",
          dromedary_camel: "\u{1F42A}",
          camel: "\u{1F42B}",
          llama: "\u{1F999}",
          giraffe: "\u{1F992}",
          elephant: "\u{1F418}",
          mammoth: "\u{1F9A3}",
          rhinoceros: "\u{1F98F}",
          hippopotamus: "\u{1F99B}",
          mouse: "\u{1F42D}",
          mouse2: "\u{1F401}",
          rat: "\u{1F400}",
          hamster: "\u{1F439}",
          rabbit: "\u{1F430}",
          rabbit2: "\u{1F407}",
          chipmunk: "\u{1F43F}\uFE0F",
          beaver: "\u{1F9AB}",
          hedgehog: "\u{1F994}",
          bat: "\u{1F987}",
          bear: "\u{1F43B}",
          polar_bear: "\u{1F43B}\u200D\u2744\uFE0F",
          koala: "\u{1F428}",
          panda_face: "\u{1F43C}",
          sloth: "\u{1F9A5}",
          otter: "\u{1F9A6}",
          skunk: "\u{1F9A8}",
          kangaroo: "\u{1F998}",
          badger: "\u{1F9A1}",
          feet: "\u{1F43E}",
          paw_prints: "\u{1F43E}",
          turkey: "\u{1F983}",
          chicken: "\u{1F414}",
          rooster: "\u{1F413}",
          hatching_chick: "\u{1F423}",
          baby_chick: "\u{1F424}",
          hatched_chick: "\u{1F425}",
          bird: "\u{1F426}",
          penguin: "\u{1F427}",
          dove: "\u{1F54A}\uFE0F",
          eagle: "\u{1F985}",
          duck: "\u{1F986}",
          swan: "\u{1F9A2}",
          owl: "\u{1F989}",
          dodo: "\u{1F9A4}",
          feather: "\u{1FAB6}",
          flamingo: "\u{1F9A9}",
          peacock: "\u{1F99A}",
          parrot: "\u{1F99C}",
          frog: "\u{1F438}",
          crocodile: "\u{1F40A}",
          turtle: "\u{1F422}",
          lizard: "\u{1F98E}",
          snake: "\u{1F40D}",
          dragon_face: "\u{1F432}",
          dragon: "\u{1F409}",
          sauropod: "\u{1F995}",
          "t-rex": "\u{1F996}",
          whale: "\u{1F433}",
          whale2: "\u{1F40B}",
          dolphin: "\u{1F42C}",
          flipper: "\u{1F42C}",
          seal: "\u{1F9AD}",
          fish: "\u{1F41F}",
          tropical_fish: "\u{1F420}",
          blowfish: "\u{1F421}",
          shark: "\u{1F988}",
          octopus: "\u{1F419}",
          shell: "\u{1F41A}",
          snail: "\u{1F40C}",
          butterfly: "\u{1F98B}",
          bug: "\u{1F41B}",
          ant: "\u{1F41C}",
          bee: "\u{1F41D}",
          honeybee: "\u{1F41D}",
          beetle: "\u{1FAB2}",
          lady_beetle: "\u{1F41E}",
          cricket: "\u{1F997}",
          cockroach: "\u{1FAB3}",
          spider: "\u{1F577}\uFE0F",
          spider_web: "\u{1F578}\uFE0F",
          scorpion: "\u{1F982}",
          mosquito: "\u{1F99F}",
          fly: "\u{1FAB0}",
          worm: "\u{1FAB1}",
          microbe: "\u{1F9A0}",
          bouquet: "\u{1F490}",
          cherry_blossom: "\u{1F338}",
          white_flower: "\u{1F4AE}",
          rosette: "\u{1F3F5}\uFE0F",
          rose: "\u{1F339}",
          wilted_flower: "\u{1F940}",
          hibiscus: "\u{1F33A}",
          sunflower: "\u{1F33B}",
          blossom: "\u{1F33C}",
          tulip: "\u{1F337}",
          seedling: "\u{1F331}",
          potted_plant: "\u{1FAB4}",
          evergreen_tree: "\u{1F332}",
          deciduous_tree: "\u{1F333}",
          palm_tree: "\u{1F334}",
          cactus: "\u{1F335}",
          ear_of_rice: "\u{1F33E}",
          herb: "\u{1F33F}",
          shamrock: "\u2618\uFE0F",
          four_leaf_clover: "\u{1F340}",
          maple_leaf: "\u{1F341}",
          fallen_leaf: "\u{1F342}",
          leaves: "\u{1F343}",
          grapes: "\u{1F347}",
          melon: "\u{1F348}",
          watermelon: "\u{1F349}",
          tangerine: "\u{1F34A}",
          orange: "\u{1F34A}",
          mandarin: "\u{1F34A}",
          lemon: "\u{1F34B}",
          banana: "\u{1F34C}",
          pineapple: "\u{1F34D}",
          mango: "\u{1F96D}",
          apple: "\u{1F34E}",
          green_apple: "\u{1F34F}",
          pear: "\u{1F350}",
          peach: "\u{1F351}",
          cherries: "\u{1F352}",
          strawberry: "\u{1F353}",
          blueberries: "\u{1FAD0}",
          kiwi_fruit: "\u{1F95D}",
          tomato: "\u{1F345}",
          olive: "\u{1FAD2}",
          coconut: "\u{1F965}",
          avocado: "\u{1F951}",
          eggplant: "\u{1F346}",
          potato: "\u{1F954}",
          carrot: "\u{1F955}",
          corn: "\u{1F33D}",
          hot_pepper: "\u{1F336}\uFE0F",
          bell_pepper: "\u{1FAD1}",
          cucumber: "\u{1F952}",
          leafy_green: "\u{1F96C}",
          broccoli: "\u{1F966}",
          garlic: "\u{1F9C4}",
          onion: "\u{1F9C5}",
          mushroom: "\u{1F344}",
          peanuts: "\u{1F95C}",
          chestnut: "\u{1F330}",
          bread: "\u{1F35E}",
          croissant: "\u{1F950}",
          baguette_bread: "\u{1F956}",
          flatbread: "\u{1FAD3}",
          pretzel: "\u{1F968}",
          bagel: "\u{1F96F}",
          pancakes: "\u{1F95E}",
          waffle: "\u{1F9C7}",
          cheese: "\u{1F9C0}",
          meat_on_bone: "\u{1F356}",
          poultry_leg: "\u{1F357}",
          cut_of_meat: "\u{1F969}",
          bacon: "\u{1F953}",
          hamburger: "\u{1F354}",
          fries: "\u{1F35F}",
          pizza: "\u{1F355}",
          hotdog: "\u{1F32D}",
          sandwich: "\u{1F96A}",
          taco: "\u{1F32E}",
          burrito: "\u{1F32F}",
          tamale: "\u{1FAD4}",
          stuffed_flatbread: "\u{1F959}",
          falafel: "\u{1F9C6}",
          egg: "\u{1F95A}",
          fried_egg: "\u{1F373}",
          shallow_pan_of_food: "\u{1F958}",
          stew: "\u{1F372}",
          fondue: "\u{1FAD5}",
          bowl_with_spoon: "\u{1F963}",
          green_salad: "\u{1F957}",
          popcorn: "\u{1F37F}",
          butter: "\u{1F9C8}",
          salt: "\u{1F9C2}",
          canned_food: "\u{1F96B}",
          bento: "\u{1F371}",
          rice_cracker: "\u{1F358}",
          rice_ball: "\u{1F359}",
          rice: "\u{1F35A}",
          curry: "\u{1F35B}",
          ramen: "\u{1F35C}",
          spaghetti: "\u{1F35D}",
          sweet_potato: "\u{1F360}",
          oden: "\u{1F362}",
          sushi: "\u{1F363}",
          fried_shrimp: "\u{1F364}",
          fish_cake: "\u{1F365}",
          moon_cake: "\u{1F96E}",
          dango: "\u{1F361}",
          dumpling: "\u{1F95F}",
          fortune_cookie: "\u{1F960}",
          takeout_box: "\u{1F961}",
          crab: "\u{1F980}",
          lobster: "\u{1F99E}",
          shrimp: "\u{1F990}",
          squid: "\u{1F991}",
          oyster: "\u{1F9AA}",
          icecream: "\u{1F366}",
          shaved_ice: "\u{1F367}",
          ice_cream: "\u{1F368}",
          doughnut: "\u{1F369}",
          cookie: "\u{1F36A}",
          birthday: "\u{1F382}",
          cake: "\u{1F370}",
          cupcake: "\u{1F9C1}",
          pie: "\u{1F967}",
          chocolate_bar: "\u{1F36B}",
          candy: "\u{1F36C}",
          lollipop: "\u{1F36D}",
          custard: "\u{1F36E}",
          honey_pot: "\u{1F36F}",
          baby_bottle: "\u{1F37C}",
          milk_glass: "\u{1F95B}",
          coffee: "\u2615",
          teapot: "\u{1FAD6}",
          tea: "\u{1F375}",
          sake: "\u{1F376}",
          champagne: "\u{1F37E}",
          wine_glass: "\u{1F377}",
          cocktail: "\u{1F378}",
          tropical_drink: "\u{1F379}",
          beer: "\u{1F37A}",
          beers: "\u{1F37B}",
          clinking_glasses: "\u{1F942}",
          tumbler_glass: "\u{1F943}",
          cup_with_straw: "\u{1F964}",
          bubble_tea: "\u{1F9CB}",
          beverage_box: "\u{1F9C3}",
          mate: "\u{1F9C9}",
          ice_cube: "\u{1F9CA}",
          chopsticks: "\u{1F962}",
          plate_with_cutlery: "\u{1F37D}\uFE0F",
          fork_and_knife: "\u{1F374}",
          spoon: "\u{1F944}",
          hocho: "\u{1F52A}",
          knife: "\u{1F52A}",
          amphora: "\u{1F3FA}",
          earth_africa: "\u{1F30D}",
          earth_americas: "\u{1F30E}",
          earth_asia: "\u{1F30F}",
          globe_with_meridians: "\u{1F310}",
          world_map: "\u{1F5FA}\uFE0F",
          japan: "\u{1F5FE}",
          compass: "\u{1F9ED}",
          mountain_snow: "\u{1F3D4}\uFE0F",
          mountain: "\u26F0\uFE0F",
          volcano: "\u{1F30B}",
          mount_fuji: "\u{1F5FB}",
          camping: "\u{1F3D5}\uFE0F",
          beach_umbrella: "\u{1F3D6}\uFE0F",
          desert: "\u{1F3DC}\uFE0F",
          desert_island: "\u{1F3DD}\uFE0F",
          national_park: "\u{1F3DE}\uFE0F",
          stadium: "\u{1F3DF}\uFE0F",
          classical_building: "\u{1F3DB}\uFE0F",
          building_construction: "\u{1F3D7}\uFE0F",
          bricks: "\u{1F9F1}",
          rock: "\u{1FAA8}",
          wood: "\u{1FAB5}",
          hut: "\u{1F6D6}",
          houses: "\u{1F3D8}\uFE0F",
          derelict_house: "\u{1F3DA}\uFE0F",
          house: "\u{1F3E0}",
          house_with_garden: "\u{1F3E1}",
          office: "\u{1F3E2}",
          post_office: "\u{1F3E3}",
          european_post_office: "\u{1F3E4}",
          hospital: "\u{1F3E5}",
          bank: "\u{1F3E6}",
          hotel: "\u{1F3E8}",
          love_hotel: "\u{1F3E9}",
          convenience_store: "\u{1F3EA}",
          school: "\u{1F3EB}",
          department_store: "\u{1F3EC}",
          factory: "\u{1F3ED}",
          japanese_castle: "\u{1F3EF}",
          european_castle: "\u{1F3F0}",
          wedding: "\u{1F492}",
          tokyo_tower: "\u{1F5FC}",
          statue_of_liberty: "\u{1F5FD}",
          church: "\u26EA",
          mosque: "\u{1F54C}",
          hindu_temple: "\u{1F6D5}",
          synagogue: "\u{1F54D}",
          shinto_shrine: "\u26E9\uFE0F",
          kaaba: "\u{1F54B}",
          fountain: "\u26F2",
          tent: "\u26FA",
          foggy: "\u{1F301}",
          night_with_stars: "\u{1F303}",
          cityscape: "\u{1F3D9}\uFE0F",
          sunrise_over_mountains: "\u{1F304}",
          sunrise: "\u{1F305}",
          city_sunset: "\u{1F306}",
          city_sunrise: "\u{1F307}",
          bridge_at_night: "\u{1F309}",
          hotsprings: "\u2668\uFE0F",
          carousel_horse: "\u{1F3A0}",
          ferris_wheel: "\u{1F3A1}",
          roller_coaster: "\u{1F3A2}",
          barber: "\u{1F488}",
          circus_tent: "\u{1F3AA}",
          steam_locomotive: "\u{1F682}",
          railway_car: "\u{1F683}",
          bullettrain_side: "\u{1F684}",
          bullettrain_front: "\u{1F685}",
          train2: "\u{1F686}",
          metro: "\u{1F687}",
          light_rail: "\u{1F688}",
          station: "\u{1F689}",
          tram: "\u{1F68A}",
          monorail: "\u{1F69D}",
          mountain_railway: "\u{1F69E}",
          train: "\u{1F68B}",
          bus: "\u{1F68C}",
          oncoming_bus: "\u{1F68D}",
          trolleybus: "\u{1F68E}",
          minibus: "\u{1F690}",
          ambulance: "\u{1F691}",
          fire_engine: "\u{1F692}",
          police_car: "\u{1F693}",
          oncoming_police_car: "\u{1F694}",
          taxi: "\u{1F695}",
          oncoming_taxi: "\u{1F696}",
          car: "\u{1F697}",
          red_car: "\u{1F697}",
          oncoming_automobile: "\u{1F698}",
          blue_car: "\u{1F699}",
          pickup_truck: "\u{1F6FB}",
          truck: "\u{1F69A}",
          articulated_lorry: "\u{1F69B}",
          tractor: "\u{1F69C}",
          racing_car: "\u{1F3CE}\uFE0F",
          motorcycle: "\u{1F3CD}\uFE0F",
          motor_scooter: "\u{1F6F5}",
          manual_wheelchair: "\u{1F9BD}",
          motorized_wheelchair: "\u{1F9BC}",
          auto_rickshaw: "\u{1F6FA}",
          bike: "\u{1F6B2}",
          kick_scooter: "\u{1F6F4}",
          skateboard: "\u{1F6F9}",
          roller_skate: "\u{1F6FC}",
          busstop: "\u{1F68F}",
          motorway: "\u{1F6E3}\uFE0F",
          railway_track: "\u{1F6E4}\uFE0F",
          oil_drum: "\u{1F6E2}\uFE0F",
          fuelpump: "\u26FD",
          rotating_light: "\u{1F6A8}",
          traffic_light: "\u{1F6A5}",
          vertical_traffic_light: "\u{1F6A6}",
          stop_sign: "\u{1F6D1}",
          construction: "\u{1F6A7}",
          anchor: "\u2693",
          boat: "\u26F5",
          sailboat: "\u26F5",
          canoe: "\u{1F6F6}",
          speedboat: "\u{1F6A4}",
          passenger_ship: "\u{1F6F3}\uFE0F",
          ferry: "\u26F4\uFE0F",
          motor_boat: "\u{1F6E5}\uFE0F",
          ship: "\u{1F6A2}",
          airplane: "\u2708\uFE0F",
          small_airplane: "\u{1F6E9}\uFE0F",
          flight_departure: "\u{1F6EB}",
          flight_arrival: "\u{1F6EC}",
          parachute: "\u{1FA82}",
          seat: "\u{1F4BA}",
          helicopter: "\u{1F681}",
          suspension_railway: "\u{1F69F}",
          mountain_cableway: "\u{1F6A0}",
          aerial_tramway: "\u{1F6A1}",
          artificial_satellite: "\u{1F6F0}\uFE0F",
          rocket: "\u{1F680}",
          flying_saucer: "\u{1F6F8}",
          bellhop_bell: "\u{1F6CE}\uFE0F",
          luggage: "\u{1F9F3}",
          hourglass: "\u231B",
          hourglass_flowing_sand: "\u23F3",
          watch: "\u231A",
          alarm_clock: "\u23F0",
          stopwatch: "\u23F1\uFE0F",
          timer_clock: "\u23F2\uFE0F",
          mantelpiece_clock: "\u{1F570}\uFE0F",
          clock12: "\u{1F55B}",
          clock1230: "\u{1F567}",
          clock1: "\u{1F550}",
          clock130: "\u{1F55C}",
          clock2: "\u{1F551}",
          clock230: "\u{1F55D}",
          clock3: "\u{1F552}",
          clock330: "\u{1F55E}",
          clock4: "\u{1F553}",
          clock430: "\u{1F55F}",
          clock5: "\u{1F554}",
          clock530: "\u{1F560}",
          clock6: "\u{1F555}",
          clock630: "\u{1F561}",
          clock7: "\u{1F556}",
          clock730: "\u{1F562}",
          clock8: "\u{1F557}",
          clock830: "\u{1F563}",
          clock9: "\u{1F558}",
          clock930: "\u{1F564}",
          clock10: "\u{1F559}",
          clock1030: "\u{1F565}",
          clock11: "\u{1F55A}",
          clock1130: "\u{1F566}",
          new_moon: "\u{1F311}",
          waxing_crescent_moon: "\u{1F312}",
          first_quarter_moon: "\u{1F313}",
          moon: "\u{1F314}",
          waxing_gibbous_moon: "\u{1F314}",
          full_moon: "\u{1F315}",
          waning_gibbous_moon: "\u{1F316}",
          last_quarter_moon: "\u{1F317}",
          waning_crescent_moon: "\u{1F318}",
          crescent_moon: "\u{1F319}",
          new_moon_with_face: "\u{1F31A}",
          first_quarter_moon_with_face: "\u{1F31B}",
          last_quarter_moon_with_face: "\u{1F31C}",
          thermometer: "\u{1F321}\uFE0F",
          sunny: "\u2600\uFE0F",
          full_moon_with_face: "\u{1F31D}",
          sun_with_face: "\u{1F31E}",
          ringed_planet: "\u{1FA90}",
          star: "\u2B50",
          star2: "\u{1F31F}",
          stars: "\u{1F320}",
          milky_way: "\u{1F30C}",
          cloud: "\u2601\uFE0F",
          partly_sunny: "\u26C5",
          cloud_with_lightning_and_rain: "\u26C8\uFE0F",
          sun_behind_small_cloud: "\u{1F324}\uFE0F",
          sun_behind_large_cloud: "\u{1F325}\uFE0F",
          sun_behind_rain_cloud: "\u{1F326}\uFE0F",
          cloud_with_rain: "\u{1F327}\uFE0F",
          cloud_with_snow: "\u{1F328}\uFE0F",
          cloud_with_lightning: "\u{1F329}\uFE0F",
          tornado: "\u{1F32A}\uFE0F",
          fog: "\u{1F32B}\uFE0F",
          wind_face: "\u{1F32C}\uFE0F",
          cyclone: "\u{1F300}",
          rainbow: "\u{1F308}",
          closed_umbrella: "\u{1F302}",
          open_umbrella: "\u2602\uFE0F",
          umbrella: "\u2614",
          parasol_on_ground: "\u26F1\uFE0F",
          zap: "\u26A1",
          snowflake: "\u2744\uFE0F",
          snowman_with_snow: "\u2603\uFE0F",
          snowman: "\u26C4",
          comet: "\u2604\uFE0F",
          fire: "\u{1F525}",
          droplet: "\u{1F4A7}",
          ocean: "\u{1F30A}",
          jack_o_lantern: "\u{1F383}",
          christmas_tree: "\u{1F384}",
          fireworks: "\u{1F386}",
          sparkler: "\u{1F387}",
          firecracker: "\u{1F9E8}",
          sparkles: "\u2728",
          balloon: "\u{1F388}",
          tada: "\u{1F389}",
          confetti_ball: "\u{1F38A}",
          tanabata_tree: "\u{1F38B}",
          bamboo: "\u{1F38D}",
          dolls: "\u{1F38E}",
          flags: "\u{1F38F}",
          wind_chime: "\u{1F390}",
          rice_scene: "\u{1F391}",
          red_envelope: "\u{1F9E7}",
          ribbon: "\u{1F380}",
          gift: "\u{1F381}",
          reminder_ribbon: "\u{1F397}\uFE0F",
          tickets: "\u{1F39F}\uFE0F",
          ticket: "\u{1F3AB}",
          medal_military: "\u{1F396}\uFE0F",
          trophy: "\u{1F3C6}",
          medal_sports: "\u{1F3C5}",
          "1st_place_medal": "\u{1F947}",
          "2nd_place_medal": "\u{1F948}",
          "3rd_place_medal": "\u{1F949}",
          soccer: "\u26BD",
          baseball: "\u26BE",
          softball: "\u{1F94E}",
          basketball: "\u{1F3C0}",
          volleyball: "\u{1F3D0}",
          football: "\u{1F3C8}",
          rugby_football: "\u{1F3C9}",
          tennis: "\u{1F3BE}",
          flying_disc: "\u{1F94F}",
          bowling: "\u{1F3B3}",
          cricket_game: "\u{1F3CF}",
          field_hockey: "\u{1F3D1}",
          ice_hockey: "\u{1F3D2}",
          lacrosse: "\u{1F94D}",
          ping_pong: "\u{1F3D3}",
          badminton: "\u{1F3F8}",
          boxing_glove: "\u{1F94A}",
          martial_arts_uniform: "\u{1F94B}",
          goal_net: "\u{1F945}",
          golf: "\u26F3",
          ice_skate: "\u26F8\uFE0F",
          fishing_pole_and_fish: "\u{1F3A3}",
          diving_mask: "\u{1F93F}",
          running_shirt_with_sash: "\u{1F3BD}",
          ski: "\u{1F3BF}",
          sled: "\u{1F6F7}",
          curling_stone: "\u{1F94C}",
          dart: "\u{1F3AF}",
          yo_yo: "\u{1FA80}",
          kite: "\u{1FA81}",
          "8ball": "\u{1F3B1}",
          crystal_ball: "\u{1F52E}",
          magic_wand: "\u{1FA84}",
          nazar_amulet: "\u{1F9FF}",
          video_game: "\u{1F3AE}",
          joystick: "\u{1F579}\uFE0F",
          slot_machine: "\u{1F3B0}",
          game_die: "\u{1F3B2}",
          jigsaw: "\u{1F9E9}",
          teddy_bear: "\u{1F9F8}",
          pinata: "\u{1FA85}",
          nesting_dolls: "\u{1FA86}",
          spades: "\u2660\uFE0F",
          hearts: "\u2665\uFE0F",
          diamonds: "\u2666\uFE0F",
          clubs: "\u2663\uFE0F",
          chess_pawn: "\u265F\uFE0F",
          black_joker: "\u{1F0CF}",
          mahjong: "\u{1F004}",
          flower_playing_cards: "\u{1F3B4}",
          performing_arts: "\u{1F3AD}",
          framed_picture: "\u{1F5BC}\uFE0F",
          art: "\u{1F3A8}",
          thread: "\u{1F9F5}",
          sewing_needle: "\u{1FAA1}",
          yarn: "\u{1F9F6}",
          knot: "\u{1FAA2}",
          eyeglasses: "\u{1F453}",
          dark_sunglasses: "\u{1F576}\uFE0F",
          goggles: "\u{1F97D}",
          lab_coat: "\u{1F97C}",
          safety_vest: "\u{1F9BA}",
          necktie: "\u{1F454}",
          shirt: "\u{1F455}",
          tshirt: "\u{1F455}",
          jeans: "\u{1F456}",
          scarf: "\u{1F9E3}",
          gloves: "\u{1F9E4}",
          coat: "\u{1F9E5}",
          socks: "\u{1F9E6}",
          dress: "\u{1F457}",
          kimono: "\u{1F458}",
          sari: "\u{1F97B}",
          one_piece_swimsuit: "\u{1FA71}",
          swim_brief: "\u{1FA72}",
          shorts: "\u{1FA73}",
          bikini: "\u{1F459}",
          womans_clothes: "\u{1F45A}",
          purse: "\u{1F45B}",
          handbag: "\u{1F45C}",
          pouch: "\u{1F45D}",
          shopping: "\u{1F6CD}\uFE0F",
          school_satchel: "\u{1F392}",
          thong_sandal: "\u{1FA74}",
          mans_shoe: "\u{1F45E}",
          shoe: "\u{1F45E}",
          athletic_shoe: "\u{1F45F}",
          hiking_boot: "\u{1F97E}",
          flat_shoe: "\u{1F97F}",
          high_heel: "\u{1F460}",
          sandal: "\u{1F461}",
          ballet_shoes: "\u{1FA70}",
          boot: "\u{1F462}",
          crown: "\u{1F451}",
          womans_hat: "\u{1F452}",
          tophat: "\u{1F3A9}",
          mortar_board: "\u{1F393}",
          billed_cap: "\u{1F9E2}",
          military_helmet: "\u{1FA96}",
          rescue_worker_helmet: "\u26D1\uFE0F",
          prayer_beads: "\u{1F4FF}",
          lipstick: "\u{1F484}",
          ring: "\u{1F48D}",
          gem: "\u{1F48E}",
          mute: "\u{1F507}",
          speaker: "\u{1F508}",
          sound: "\u{1F509}",
          loud_sound: "\u{1F50A}",
          loudspeaker: "\u{1F4E2}",
          mega: "\u{1F4E3}",
          postal_horn: "\u{1F4EF}",
          bell: "\u{1F514}",
          no_bell: "\u{1F515}",
          musical_score: "\u{1F3BC}",
          musical_note: "\u{1F3B5}",
          notes: "\u{1F3B6}",
          studio_microphone: "\u{1F399}\uFE0F",
          level_slider: "\u{1F39A}\uFE0F",
          control_knobs: "\u{1F39B}\uFE0F",
          microphone: "\u{1F3A4}",
          headphones: "\u{1F3A7}",
          radio: "\u{1F4FB}",
          saxophone: "\u{1F3B7}",
          accordion: "\u{1FA97}",
          guitar: "\u{1F3B8}",
          musical_keyboard: "\u{1F3B9}",
          trumpet: "\u{1F3BA}",
          violin: "\u{1F3BB}",
          banjo: "\u{1FA95}",
          drum: "\u{1F941}",
          long_drum: "\u{1FA98}",
          iphone: "\u{1F4F1}",
          calling: "\u{1F4F2}",
          phone: "\u260E\uFE0F",
          telephone: "\u260E\uFE0F",
          telephone_receiver: "\u{1F4DE}",
          pager: "\u{1F4DF}",
          fax: "\u{1F4E0}",
          battery: "\u{1F50B}",
          electric_plug: "\u{1F50C}",
          computer: "\u{1F4BB}",
          desktop_computer: "\u{1F5A5}\uFE0F",
          printer: "\u{1F5A8}\uFE0F",
          keyboard: "\u2328\uFE0F",
          computer_mouse: "\u{1F5B1}\uFE0F",
          trackball: "\u{1F5B2}\uFE0F",
          minidisc: "\u{1F4BD}",
          floppy_disk: "\u{1F4BE}",
          cd: "\u{1F4BF}",
          dvd: "\u{1F4C0}",
          abacus: "\u{1F9EE}",
          movie_camera: "\u{1F3A5}",
          film_strip: "\u{1F39E}\uFE0F",
          film_projector: "\u{1F4FD}\uFE0F",
          clapper: "\u{1F3AC}",
          tv: "\u{1F4FA}",
          camera: "\u{1F4F7}",
          camera_flash: "\u{1F4F8}",
          video_camera: "\u{1F4F9}",
          vhs: "\u{1F4FC}",
          mag: "\u{1F50D}",
          mag_right: "\u{1F50E}",
          candle: "\u{1F56F}\uFE0F",
          bulb: "\u{1F4A1}",
          flashlight: "\u{1F526}",
          izakaya_lantern: "\u{1F3EE}",
          lantern: "\u{1F3EE}",
          diya_lamp: "\u{1FA94}",
          notebook_with_decorative_cover: "\u{1F4D4}",
          closed_book: "\u{1F4D5}",
          book: "\u{1F4D6}",
          open_book: "\u{1F4D6}",
          green_book: "\u{1F4D7}",
          blue_book: "\u{1F4D8}",
          orange_book: "\u{1F4D9}",
          books: "\u{1F4DA}",
          notebook: "\u{1F4D3}",
          ledger: "\u{1F4D2}",
          page_with_curl: "\u{1F4C3}",
          scroll: "\u{1F4DC}",
          page_facing_up: "\u{1F4C4}",
          newspaper: "\u{1F4F0}",
          newspaper_roll: "\u{1F5DE}\uFE0F",
          bookmark_tabs: "\u{1F4D1}",
          bookmark: "\u{1F516}",
          label: "\u{1F3F7}\uFE0F",
          moneybag: "\u{1F4B0}",
          coin: "\u{1FA99}",
          yen: "\u{1F4B4}",
          dollar: "\u{1F4B5}",
          euro: "\u{1F4B6}",
          pound: "\u{1F4B7}",
          money_with_wings: "\u{1F4B8}",
          credit_card: "\u{1F4B3}",
          receipt: "\u{1F9FE}",
          chart: "\u{1F4B9}",
          envelope: "\u2709\uFE0F",
          email: "\u{1F4E7}",
          "e-mail": "\u{1F4E7}",
          incoming_envelope: "\u{1F4E8}",
          envelope_with_arrow: "\u{1F4E9}",
          outbox_tray: "\u{1F4E4}",
          inbox_tray: "\u{1F4E5}",
          package: "\u{1F4E6}",
          mailbox: "\u{1F4EB}",
          mailbox_closed: "\u{1F4EA}",
          mailbox_with_mail: "\u{1F4EC}",
          mailbox_with_no_mail: "\u{1F4ED}",
          postbox: "\u{1F4EE}",
          ballot_box: "\u{1F5F3}\uFE0F",
          pencil2: "\u270F\uFE0F",
          black_nib: "\u2712\uFE0F",
          fountain_pen: "\u{1F58B}\uFE0F",
          pen: "\u{1F58A}\uFE0F",
          paintbrush: "\u{1F58C}\uFE0F",
          crayon: "\u{1F58D}\uFE0F",
          memo: "\u{1F4DD}",
          pencil: "\u{1F4DD}",
          briefcase: "\u{1F4BC}",
          file_folder: "\u{1F4C1}",
          open_file_folder: "\u{1F4C2}",
          card_index_dividers: "\u{1F5C2}\uFE0F",
          date: "\u{1F4C5}",
          calendar: "\u{1F4C6}",
          spiral_notepad: "\u{1F5D2}\uFE0F",
          spiral_calendar: "\u{1F5D3}\uFE0F",
          card_index: "\u{1F4C7}",
          chart_with_upwards_trend: "\u{1F4C8}",
          chart_with_downwards_trend: "\u{1F4C9}",
          bar_chart: "\u{1F4CA}",
          clipboard: "\u{1F4CB}",
          pushpin: "\u{1F4CC}",
          round_pushpin: "\u{1F4CD}",
          paperclip: "\u{1F4CE}",
          paperclips: "\u{1F587}\uFE0F",
          straight_ruler: "\u{1F4CF}",
          triangular_ruler: "\u{1F4D0}",
          scissors: "\u2702\uFE0F",
          card_file_box: "\u{1F5C3}\uFE0F",
          file_cabinet: "\u{1F5C4}\uFE0F",
          wastebasket: "\u{1F5D1}\uFE0F",
          lock: "\u{1F512}",
          unlock: "\u{1F513}",
          lock_with_ink_pen: "\u{1F50F}",
          closed_lock_with_key: "\u{1F510}",
          key: "\u{1F511}",
          old_key: "\u{1F5DD}\uFE0F",
          hammer: "\u{1F528}",
          axe: "\u{1FA93}",
          pick: "\u26CF\uFE0F",
          hammer_and_pick: "\u2692\uFE0F",
          hammer_and_wrench: "\u{1F6E0}\uFE0F",
          dagger: "\u{1F5E1}\uFE0F",
          crossed_swords: "\u2694\uFE0F",
          gun: "\u{1F52B}",
          boomerang: "\u{1FA83}",
          bow_and_arrow: "\u{1F3F9}",
          shield: "\u{1F6E1}\uFE0F",
          carpentry_saw: "\u{1FA9A}",
          wrench: "\u{1F527}",
          screwdriver: "\u{1FA9B}",
          nut_and_bolt: "\u{1F529}",
          gear: "\u2699\uFE0F",
          clamp: "\u{1F5DC}\uFE0F",
          balance_scale: "\u2696\uFE0F",
          probing_cane: "\u{1F9AF}",
          link: "\u{1F517}",
          chains: "\u26D3\uFE0F",
          hook: "\u{1FA9D}",
          toolbox: "\u{1F9F0}",
          magnet: "\u{1F9F2}",
          ladder: "\u{1FA9C}",
          alembic: "\u2697\uFE0F",
          test_tube: "\u{1F9EA}",
          petri_dish: "\u{1F9EB}",
          dna: "\u{1F9EC}",
          microscope: "\u{1F52C}",
          telescope: "\u{1F52D}",
          satellite: "\u{1F4E1}",
          syringe: "\u{1F489}",
          drop_of_blood: "\u{1FA78}",
          pill: "\u{1F48A}",
          adhesive_bandage: "\u{1FA79}",
          stethoscope: "\u{1FA7A}",
          door: "\u{1F6AA}",
          elevator: "\u{1F6D7}",
          mirror: "\u{1FA9E}",
          window: "\u{1FA9F}",
          bed: "\u{1F6CF}\uFE0F",
          couch_and_lamp: "\u{1F6CB}\uFE0F",
          chair: "\u{1FA91}",
          toilet: "\u{1F6BD}",
          plunger: "\u{1FAA0}",
          shower: "\u{1F6BF}",
          bathtub: "\u{1F6C1}",
          mouse_trap: "\u{1FAA4}",
          razor: "\u{1FA92}",
          lotion_bottle: "\u{1F9F4}",
          safety_pin: "\u{1F9F7}",
          broom: "\u{1F9F9}",
          basket: "\u{1F9FA}",
          roll_of_paper: "\u{1F9FB}",
          bucket: "\u{1FAA3}",
          soap: "\u{1F9FC}",
          toothbrush: "\u{1FAA5}",
          sponge: "\u{1F9FD}",
          fire_extinguisher: "\u{1F9EF}",
          shopping_cart: "\u{1F6D2}",
          smoking: "\u{1F6AC}",
          coffin: "\u26B0\uFE0F",
          headstone: "\u{1FAA6}",
          funeral_urn: "\u26B1\uFE0F",
          moyai: "\u{1F5FF}",
          placard: "\u{1FAA7}",
          atm: "\u{1F3E7}",
          put_litter_in_its_place: "\u{1F6AE}",
          potable_water: "\u{1F6B0}",
          wheelchair: "\u267F",
          mens: "\u{1F6B9}",
          womens: "\u{1F6BA}",
          restroom: "\u{1F6BB}",
          baby_symbol: "\u{1F6BC}",
          wc: "\u{1F6BE}",
          passport_control: "\u{1F6C2}",
          customs: "\u{1F6C3}",
          baggage_claim: "\u{1F6C4}",
          left_luggage: "\u{1F6C5}",
          warning: "\u26A0\uFE0F",
          children_crossing: "\u{1F6B8}",
          no_entry: "\u26D4",
          no_entry_sign: "\u{1F6AB}",
          no_bicycles: "\u{1F6B3}",
          no_smoking: "\u{1F6AD}",
          do_not_litter: "\u{1F6AF}",
          "non-potable_water": "\u{1F6B1}",
          no_pedestrians: "\u{1F6B7}",
          no_mobile_phones: "\u{1F4F5}",
          underage: "\u{1F51E}",
          radioactive: "\u2622\uFE0F",
          biohazard: "\u2623\uFE0F",
          arrow_up: "\u2B06\uFE0F",
          arrow_upper_right: "\u2197\uFE0F",
          arrow_right: "\u27A1\uFE0F",
          arrow_lower_right: "\u2198\uFE0F",
          arrow_down: "\u2B07\uFE0F",
          arrow_lower_left: "\u2199\uFE0F",
          arrow_left: "\u2B05\uFE0F",
          arrow_upper_left: "\u2196\uFE0F",
          arrow_up_down: "\u2195\uFE0F",
          left_right_arrow: "\u2194\uFE0F",
          leftwards_arrow_with_hook: "\u21A9\uFE0F",
          arrow_right_hook: "\u21AA\uFE0F",
          arrow_heading_up: "\u2934\uFE0F",
          arrow_heading_down: "\u2935\uFE0F",
          arrows_clockwise: "\u{1F503}",
          arrows_counterclockwise: "\u{1F504}",
          back: "\u{1F519}",
          end: "\u{1F51A}",
          on: "\u{1F51B}",
          soon: "\u{1F51C}",
          top: "\u{1F51D}",
          place_of_worship: "\u{1F6D0}",
          atom_symbol: "\u269B\uFE0F",
          om: "\u{1F549}\uFE0F",
          star_of_david: "\u2721\uFE0F",
          wheel_of_dharma: "\u2638\uFE0F",
          yin_yang: "\u262F\uFE0F",
          latin_cross: "\u271D\uFE0F",
          orthodox_cross: "\u2626\uFE0F",
          star_and_crescent: "\u262A\uFE0F",
          peace_symbol: "\u262E\uFE0F",
          menorah: "\u{1F54E}",
          six_pointed_star: "\u{1F52F}",
          aries: "\u2648",
          taurus: "\u2649",
          gemini: "\u264A",
          cancer: "\u264B",
          leo: "\u264C",
          virgo: "\u264D",
          libra: "\u264E",
          scorpius: "\u264F",
          sagittarius: "\u2650",
          capricorn: "\u2651",
          aquarius: "\u2652",
          pisces: "\u2653",
          ophiuchus: "\u26CE",
          twisted_rightwards_arrows: "\u{1F500}",
          repeat: "\u{1F501}",
          repeat_one: "\u{1F502}",
          arrow_forward: "\u25B6\uFE0F",
          fast_forward: "\u23E9",
          next_track_button: "\u23ED\uFE0F",
          play_or_pause_button: "\u23EF\uFE0F",
          arrow_backward: "\u25C0\uFE0F",
          rewind: "\u23EA",
          previous_track_button: "\u23EE\uFE0F",
          arrow_up_small: "\u{1F53C}",
          arrow_double_up: "\u23EB",
          arrow_down_small: "\u{1F53D}",
          arrow_double_down: "\u23EC",
          pause_button: "\u23F8\uFE0F",
          stop_button: "\u23F9\uFE0F",
          record_button: "\u23FA\uFE0F",
          eject_button: "\u23CF\uFE0F",
          cinema: "\u{1F3A6}",
          low_brightness: "\u{1F505}",
          high_brightness: "\u{1F506}",
          signal_strength: "\u{1F4F6}",
          vibration_mode: "\u{1F4F3}",
          mobile_phone_off: "\u{1F4F4}",
          female_sign: "\u2640\uFE0F",
          male_sign: "\u2642\uFE0F",
          transgender_symbol: "\u26A7\uFE0F",
          heavy_multiplication_x: "\u2716\uFE0F",
          heavy_plus_sign: "\u2795",
          heavy_minus_sign: "\u2796",
          heavy_division_sign: "\u2797",
          infinity: "\u267E\uFE0F",
          bangbang: "\u203C\uFE0F",
          interrobang: "\u2049\uFE0F",
          question: "\u2753",
          grey_question: "\u2754",
          grey_exclamation: "\u2755",
          exclamation: "\u2757",
          heavy_exclamation_mark: "\u2757",
          wavy_dash: "\u3030\uFE0F",
          currency_exchange: "\u{1F4B1}",
          heavy_dollar_sign: "\u{1F4B2}",
          medical_symbol: "\u2695\uFE0F",
          recycle: "\u267B\uFE0F",
          fleur_de_lis: "\u269C\uFE0F",
          trident: "\u{1F531}",
          name_badge: "\u{1F4DB}",
          beginner: "\u{1F530}",
          o: "\u2B55",
          white_check_mark: "\u2705",
          ballot_box_with_check: "\u2611\uFE0F",
          heavy_check_mark: "\u2714\uFE0F",
          x: "\u274C",
          negative_squared_cross_mark: "\u274E",
          curly_loop: "\u27B0",
          loop: "\u27BF",
          part_alternation_mark: "\u303D\uFE0F",
          eight_spoked_asterisk: "\u2733\uFE0F",
          eight_pointed_black_star: "\u2734\uFE0F",
          sparkle: "\u2747\uFE0F",
          copyright: "\xA9\uFE0F",
          registered: "\xAE\uFE0F",
          tm: "\u2122\uFE0F",
          hash: "#\uFE0F\u20E3",
          asterisk: "*\uFE0F\u20E3",
          zero: "0\uFE0F\u20E3",
          one: "1\uFE0F\u20E3",
          two: "2\uFE0F\u20E3",
          three: "3\uFE0F\u20E3",
          four: "4\uFE0F\u20E3",
          five: "5\uFE0F\u20E3",
          six: "6\uFE0F\u20E3",
          seven: "7\uFE0F\u20E3",
          eight: "8\uFE0F\u20E3",
          nine: "9\uFE0F\u20E3",
          keycap_ten: "\u{1F51F}",
          capital_abcd: "\u{1F520}",
          abcd: "\u{1F521}",
          symbols: "\u{1F523}",
          abc: "\u{1F524}",
          a: "\u{1F170}\uFE0F",
          ab: "\u{1F18E}",
          b: "\u{1F171}\uFE0F",
          cl: "\u{1F191}",
          cool: "\u{1F192}",
          free: "\u{1F193}",
          information_source: "\u2139\uFE0F",
          id: "\u{1F194}",
          m: "\u24C2\uFE0F",
          new: "\u{1F195}",
          ng: "\u{1F196}",
          o2: "\u{1F17E}\uFE0F",
          ok: "\u{1F197}",
          parking: "\u{1F17F}\uFE0F",
          sos: "\u{1F198}",
          up: "\u{1F199}",
          vs: "\u{1F19A}",
          koko: "\u{1F201}",
          sa: "\u{1F202}\uFE0F",
          ideograph_advantage: "\u{1F250}",
          accept: "\u{1F251}",
          congratulations: "\u3297\uFE0F",
          secret: "\u3299\uFE0F",
          u6e80: "\u{1F235}",
          red_circle: "\u{1F534}",
          orange_circle: "\u{1F7E0}",
          yellow_circle: "\u{1F7E1}",
          green_circle: "\u{1F7E2}",
          large_blue_circle: "\u{1F535}",
          purple_circle: "\u{1F7E3}",
          brown_circle: "\u{1F7E4}",
          black_circle: "\u26AB",
          white_circle: "\u26AA",
          red_square: "\u{1F7E5}",
          orange_square: "\u{1F7E7}",
          yellow_square: "\u{1F7E8}",
          green_square: "\u{1F7E9}",
          blue_square: "\u{1F7E6}",
          purple_square: "\u{1F7EA}",
          brown_square: "\u{1F7EB}",
          black_large_square: "\u2B1B",
          white_large_square: "\u2B1C",
          black_medium_square: "\u25FC\uFE0F",
          white_medium_square: "\u25FB\uFE0F",
          black_medium_small_square: "\u25FE",
          white_medium_small_square: "\u25FD",
          black_small_square: "\u25AA\uFE0F",
          white_small_square: "\u25AB\uFE0F",
          large_orange_diamond: "\u{1F536}",
          large_blue_diamond: "\u{1F537}",
          small_orange_diamond: "\u{1F538}",
          small_blue_diamond: "\u{1F539}",
          small_red_triangle: "\u{1F53A}",
          small_red_triangle_down: "\u{1F53B}",
          diamond_shape_with_a_dot_inside: "\u{1F4A0}",
          radio_button: "\u{1F518}",
          white_square_button: "\u{1F533}",
          black_square_button: "\u{1F532}",
          checkered_flag: "\u{1F3C1}",
          triangular_flag_on_post: "\u{1F6A9}",
          crossed_flags: "\u{1F38C}",
          black_flag: "\u{1F3F4}",
          white_flag: "\u{1F3F3}\uFE0F",
          rainbow_flag: "\u{1F3F3}\uFE0F\u200D\u{1F308}",
          transgender_flag: "\u{1F3F3}\uFE0F\u200D\u26A7\uFE0F",
          pirate_flag: "\u{1F3F4}\u200D\u2620\uFE0F",
          ascension_island: "\u{1F1E6}\u{1F1E8}",
          andorra: "\u{1F1E6}\u{1F1E9}",
          united_arab_emirates: "\u{1F1E6}\u{1F1EA}",
          afghanistan: "\u{1F1E6}\u{1F1EB}",
          antigua_barbuda: "\u{1F1E6}\u{1F1EC}",
          anguilla: "\u{1F1E6}\u{1F1EE}",
          albania: "\u{1F1E6}\u{1F1F1}",
          armenia: "\u{1F1E6}\u{1F1F2}",
          angola: "\u{1F1E6}\u{1F1F4}",
          antarctica: "\u{1F1E6}\u{1F1F6}",
          argentina: "\u{1F1E6}\u{1F1F7}",
          american_samoa: "\u{1F1E6}\u{1F1F8}",
          austria: "\u{1F1E6}\u{1F1F9}",
          australia: "\u{1F1E6}\u{1F1FA}",
          aruba: "\u{1F1E6}\u{1F1FC}",
          aland_islands: "\u{1F1E6}\u{1F1FD}",
          azerbaijan: "\u{1F1E6}\u{1F1FF}",
          bosnia_herzegovina: "\u{1F1E7}\u{1F1E6}",
          barbados: "\u{1F1E7}\u{1F1E7}",
          bangladesh: "\u{1F1E7}\u{1F1E9}",
          belgium: "\u{1F1E7}\u{1F1EA}",
          burkina_faso: "\u{1F1E7}\u{1F1EB}",
          bulgaria: "\u{1F1E7}\u{1F1EC}",
          bahrain: "\u{1F1E7}\u{1F1ED}",
          burundi: "\u{1F1E7}\u{1F1EE}",
          benin: "\u{1F1E7}\u{1F1EF}",
          st_barthelemy: "\u{1F1E7}\u{1F1F1}",
          bermuda: "\u{1F1E7}\u{1F1F2}",
          brunei: "\u{1F1E7}\u{1F1F3}",
          bolivia: "\u{1F1E7}\u{1F1F4}",
          caribbean_netherlands: "\u{1F1E7}\u{1F1F6}",
          brazil: "\u{1F1E7}\u{1F1F7}",
          bahamas: "\u{1F1E7}\u{1F1F8}",
          bhutan: "\u{1F1E7}\u{1F1F9}",
          bouvet_island: "\u{1F1E7}\u{1F1FB}",
          botswana: "\u{1F1E7}\u{1F1FC}",
          belarus: "\u{1F1E7}\u{1F1FE}",
          belize: "\u{1F1E7}\u{1F1FF}",
          canada: "\u{1F1E8}\u{1F1E6}",
          cocos_islands: "\u{1F1E8}\u{1F1E8}",
          congo_kinshasa: "\u{1F1E8}\u{1F1E9}",
          central_african_republic: "\u{1F1E8}\u{1F1EB}",
          congo_brazzaville: "\u{1F1E8}\u{1F1EC}",
          switzerland: "\u{1F1E8}\u{1F1ED}",
          cote_divoire: "\u{1F1E8}\u{1F1EE}",
          cook_islands: "\u{1F1E8}\u{1F1F0}",
          chile: "\u{1F1E8}\u{1F1F1}",
          cameroon: "\u{1F1E8}\u{1F1F2}",
          cn: "\u{1F1E8}\u{1F1F3}",
          colombia: "\u{1F1E8}\u{1F1F4}",
          clipperton_island: "\u{1F1E8}\u{1F1F5}",
          costa_rica: "\u{1F1E8}\u{1F1F7}",
          cuba: "\u{1F1E8}\u{1F1FA}",
          cape_verde: "\u{1F1E8}\u{1F1FB}",
          curacao: "\u{1F1E8}\u{1F1FC}",
          christmas_island: "\u{1F1E8}\u{1F1FD}",
          cyprus: "\u{1F1E8}\u{1F1FE}",
          czech_republic: "\u{1F1E8}\u{1F1FF}",
          de: "\u{1F1E9}\u{1F1EA}",
          diego_garcia: "\u{1F1E9}\u{1F1EC}",
          djibouti: "\u{1F1E9}\u{1F1EF}",
          denmark: "\u{1F1E9}\u{1F1F0}",
          dominica: "\u{1F1E9}\u{1F1F2}",
          dominican_republic: "\u{1F1E9}\u{1F1F4}",
          algeria: "\u{1F1E9}\u{1F1FF}",
          ceuta_melilla: "\u{1F1EA}\u{1F1E6}",
          ecuador: "\u{1F1EA}\u{1F1E8}",
          estonia: "\u{1F1EA}\u{1F1EA}",
          egypt: "\u{1F1EA}\u{1F1EC}",
          western_sahara: "\u{1F1EA}\u{1F1ED}",
          eritrea: "\u{1F1EA}\u{1F1F7}",
          es: "\u{1F1EA}\u{1F1F8}",
          ethiopia: "\u{1F1EA}\u{1F1F9}",
          eu: "\u{1F1EA}\u{1F1FA}",
          european_union: "\u{1F1EA}\u{1F1FA}",
          finland: "\u{1F1EB}\u{1F1EE}",
          fiji: "\u{1F1EB}\u{1F1EF}",
          falkland_islands: "\u{1F1EB}\u{1F1F0}",
          micronesia: "\u{1F1EB}\u{1F1F2}",
          faroe_islands: "\u{1F1EB}\u{1F1F4}",
          fr: "\u{1F1EB}\u{1F1F7}",
          gabon: "\u{1F1EC}\u{1F1E6}",
          gb: "\u{1F1EC}\u{1F1E7}",
          uk: "\u{1F1EC}\u{1F1E7}",
          grenada: "\u{1F1EC}\u{1F1E9}",
          georgia: "\u{1F1EC}\u{1F1EA}",
          french_guiana: "\u{1F1EC}\u{1F1EB}",
          guernsey: "\u{1F1EC}\u{1F1EC}",
          ghana: "\u{1F1EC}\u{1F1ED}",
          gibraltar: "\u{1F1EC}\u{1F1EE}",
          greenland: "\u{1F1EC}\u{1F1F1}",
          gambia: "\u{1F1EC}\u{1F1F2}",
          guinea: "\u{1F1EC}\u{1F1F3}",
          guadeloupe: "\u{1F1EC}\u{1F1F5}",
          equatorial_guinea: "\u{1F1EC}\u{1F1F6}",
          greece: "\u{1F1EC}\u{1F1F7}",
          south_georgia_south_sandwich_islands: "\u{1F1EC}\u{1F1F8}",
          guatemala: "\u{1F1EC}\u{1F1F9}",
          guam: "\u{1F1EC}\u{1F1FA}",
          guinea_bissau: "\u{1F1EC}\u{1F1FC}",
          guyana: "\u{1F1EC}\u{1F1FE}",
          hong_kong: "\u{1F1ED}\u{1F1F0}",
          heard_mcdonald_islands: "\u{1F1ED}\u{1F1F2}",
          honduras: "\u{1F1ED}\u{1F1F3}",
          croatia: "\u{1F1ED}\u{1F1F7}",
          haiti: "\u{1F1ED}\u{1F1F9}",
          hungary: "\u{1F1ED}\u{1F1FA}",
          canary_islands: "\u{1F1EE}\u{1F1E8}",
          indonesia: "\u{1F1EE}\u{1F1E9}",
          ireland: "\u{1F1EE}\u{1F1EA}",
          israel: "\u{1F1EE}\u{1F1F1}",
          isle_of_man: "\u{1F1EE}\u{1F1F2}",
          india: "\u{1F1EE}\u{1F1F3}",
          british_indian_ocean_territory: "\u{1F1EE}\u{1F1F4}",
          iraq: "\u{1F1EE}\u{1F1F6}",
          iran: "\u{1F1EE}\u{1F1F7}",
          iceland: "\u{1F1EE}\u{1F1F8}",
          it: "\u{1F1EE}\u{1F1F9}",
          jersey: "\u{1F1EF}\u{1F1EA}",
          jamaica: "\u{1F1EF}\u{1F1F2}",
          jordan: "\u{1F1EF}\u{1F1F4}",
          jp: "\u{1F1EF}\u{1F1F5}",
          kenya: "\u{1F1F0}\u{1F1EA}",
          kyrgyzstan: "\u{1F1F0}\u{1F1EC}",
          cambodia: "\u{1F1F0}\u{1F1ED}",
          kiribati: "\u{1F1F0}\u{1F1EE}",
          comoros: "\u{1F1F0}\u{1F1F2}",
          st_kitts_nevis: "\u{1F1F0}\u{1F1F3}",
          north_korea: "\u{1F1F0}\u{1F1F5}",
          kr: "\u{1F1F0}\u{1F1F7}",
          kuwait: "\u{1F1F0}\u{1F1FC}",
          cayman_islands: "\u{1F1F0}\u{1F1FE}",
          kazakhstan: "\u{1F1F0}\u{1F1FF}",
          laos: "\u{1F1F1}\u{1F1E6}",
          lebanon: "\u{1F1F1}\u{1F1E7}",
          st_lucia: "\u{1F1F1}\u{1F1E8}",
          liechtenstein: "\u{1F1F1}\u{1F1EE}",
          sri_lanka: "\u{1F1F1}\u{1F1F0}",
          liberia: "\u{1F1F1}\u{1F1F7}",
          lesotho: "\u{1F1F1}\u{1F1F8}",
          lithuania: "\u{1F1F1}\u{1F1F9}",
          luxembourg: "\u{1F1F1}\u{1F1FA}",
          latvia: "\u{1F1F1}\u{1F1FB}",
          libya: "\u{1F1F1}\u{1F1FE}",
          morocco: "\u{1F1F2}\u{1F1E6}",
          monaco: "\u{1F1F2}\u{1F1E8}",
          moldova: "\u{1F1F2}\u{1F1E9}",
          montenegro: "\u{1F1F2}\u{1F1EA}",
          st_martin: "\u{1F1F2}\u{1F1EB}",
          madagascar: "\u{1F1F2}\u{1F1EC}",
          marshall_islands: "\u{1F1F2}\u{1F1ED}",
          macedonia: "\u{1F1F2}\u{1F1F0}",
          mali: "\u{1F1F2}\u{1F1F1}",
          myanmar: "\u{1F1F2}\u{1F1F2}",
          mongolia: "\u{1F1F2}\u{1F1F3}",
          macau: "\u{1F1F2}\u{1F1F4}",
          northern_mariana_islands: "\u{1F1F2}\u{1F1F5}",
          martinique: "\u{1F1F2}\u{1F1F6}",
          mauritania: "\u{1F1F2}\u{1F1F7}",
          montserrat: "\u{1F1F2}\u{1F1F8}",
          malta: "\u{1F1F2}\u{1F1F9}",
          mauritius: "\u{1F1F2}\u{1F1FA}",
          maldives: "\u{1F1F2}\u{1F1FB}",
          malawi: "\u{1F1F2}\u{1F1FC}",
          mexico: "\u{1F1F2}\u{1F1FD}",
          malaysia: "\u{1F1F2}\u{1F1FE}",
          mozambique: "\u{1F1F2}\u{1F1FF}",
          namibia: "\u{1F1F3}\u{1F1E6}",
          new_caledonia: "\u{1F1F3}\u{1F1E8}",
          niger: "\u{1F1F3}\u{1F1EA}",
          norfolk_island: "\u{1F1F3}\u{1F1EB}",
          nigeria: "\u{1F1F3}\u{1F1EC}",
          nicaragua: "\u{1F1F3}\u{1F1EE}",
          netherlands: "\u{1F1F3}\u{1F1F1}",
          norway: "\u{1F1F3}\u{1F1F4}",
          nepal: "\u{1F1F3}\u{1F1F5}",
          nauru: "\u{1F1F3}\u{1F1F7}",
          niue: "\u{1F1F3}\u{1F1FA}",
          new_zealand: "\u{1F1F3}\u{1F1FF}",
          oman: "\u{1F1F4}\u{1F1F2}",
          panama: "\u{1F1F5}\u{1F1E6}",
          peru: "\u{1F1F5}\u{1F1EA}",
          french_polynesia: "\u{1F1F5}\u{1F1EB}",
          papua_new_guinea: "\u{1F1F5}\u{1F1EC}",
          philippines: "\u{1F1F5}\u{1F1ED}",
          pakistan: "\u{1F1F5}\u{1F1F0}",
          poland: "\u{1F1F5}\u{1F1F1}",
          st_pierre_miquelon: "\u{1F1F5}\u{1F1F2}",
          pitcairn_islands: "\u{1F1F5}\u{1F1F3}",
          puerto_rico: "\u{1F1F5}\u{1F1F7}",
          palestinian_territories: "\u{1F1F5}\u{1F1F8}",
          portugal: "\u{1F1F5}\u{1F1F9}",
          palau: "\u{1F1F5}\u{1F1FC}",
          paraguay: "\u{1F1F5}\u{1F1FE}",
          qatar: "\u{1F1F6}\u{1F1E6}",
          reunion: "\u{1F1F7}\u{1F1EA}",
          romania: "\u{1F1F7}\u{1F1F4}",
          serbia: "\u{1F1F7}\u{1F1F8}",
          ru: "\u{1F1F7}\u{1F1FA}",
          rwanda: "\u{1F1F7}\u{1F1FC}",
          saudi_arabia: "\u{1F1F8}\u{1F1E6}",
          solomon_islands: "\u{1F1F8}\u{1F1E7}",
          seychelles: "\u{1F1F8}\u{1F1E8}",
          sudan: "\u{1F1F8}\u{1F1E9}",
          sweden: "\u{1F1F8}\u{1F1EA}",
          singapore: "\u{1F1F8}\u{1F1EC}",
          st_helena: "\u{1F1F8}\u{1F1ED}",
          slovenia: "\u{1F1F8}\u{1F1EE}",
          svalbard_jan_mayen: "\u{1F1F8}\u{1F1EF}",
          slovakia: "\u{1F1F8}\u{1F1F0}",
          sierra_leone: "\u{1F1F8}\u{1F1F1}",
          san_marino: "\u{1F1F8}\u{1F1F2}",
          senegal: "\u{1F1F8}\u{1F1F3}",
          somalia: "\u{1F1F8}\u{1F1F4}",
          suriname: "\u{1F1F8}\u{1F1F7}",
          south_sudan: "\u{1F1F8}\u{1F1F8}",
          sao_tome_principe: "\u{1F1F8}\u{1F1F9}",
          el_salvador: "\u{1F1F8}\u{1F1FB}",
          sint_maarten: "\u{1F1F8}\u{1F1FD}",
          syria: "\u{1F1F8}\u{1F1FE}",
          swaziland: "\u{1F1F8}\u{1F1FF}",
          tristan_da_cunha: "\u{1F1F9}\u{1F1E6}",
          turks_caicos_islands: "\u{1F1F9}\u{1F1E8}",
          chad: "\u{1F1F9}\u{1F1E9}",
          french_southern_territories: "\u{1F1F9}\u{1F1EB}",
          togo: "\u{1F1F9}\u{1F1EC}",
          thailand: "\u{1F1F9}\u{1F1ED}",
          tajikistan: "\u{1F1F9}\u{1F1EF}",
          tokelau: "\u{1F1F9}\u{1F1F0}",
          timor_leste: "\u{1F1F9}\u{1F1F1}",
          turkmenistan: "\u{1F1F9}\u{1F1F2}",
          tunisia: "\u{1F1F9}\u{1F1F3}",
          tonga: "\u{1F1F9}\u{1F1F4}",
          tr: "\u{1F1F9}\u{1F1F7}",
          trinidad_tobago: "\u{1F1F9}\u{1F1F9}",
          tuvalu: "\u{1F1F9}\u{1F1FB}",
          taiwan: "\u{1F1F9}\u{1F1FC}",
          tanzania: "\u{1F1F9}\u{1F1FF}",
          ukraine: "\u{1F1FA}\u{1F1E6}",
          uganda: "\u{1F1FA}\u{1F1EC}",
          us_outlying_islands: "\u{1F1FA}\u{1F1F2}",
          united_nations: "\u{1F1FA}\u{1F1F3}",
          us: "\u{1F1FA}\u{1F1F8}",
          uruguay: "\u{1F1FA}\u{1F1FE}",
          uzbekistan: "\u{1F1FA}\u{1F1FF}",
          vatican_city: "\u{1F1FB}\u{1F1E6}",
          st_vincent_grenadines: "\u{1F1FB}\u{1F1E8}",
          venezuela: "\u{1F1FB}\u{1F1EA}",
          british_virgin_islands: "\u{1F1FB}\u{1F1EC}",
          us_virgin_islands: "\u{1F1FB}\u{1F1EE}",
          vietnam: "\u{1F1FB}\u{1F1F3}",
          vanuatu: "\u{1F1FB}\u{1F1FA}",
          wallis_futuna: "\u{1F1FC}\u{1F1EB}",
          samoa: "\u{1F1FC}\u{1F1F8}",
          kosovo: "\u{1F1FD}\u{1F1F0}",
          yemen: "\u{1F1FE}\u{1F1EA}",
          mayotte: "\u{1F1FE}\u{1F1F9}",
          south_africa: "\u{1F1FF}\u{1F1E6}",
          zambia: "\u{1F1FF}\u{1F1F2}",
          zimbabwe: "\u{1F1FF}\u{1F1FC}",
          england: "\u{1F3F4}\u{E0067}\u{E0062}\u{E0065}\u{E006E}\u{E0067}\u{E007F}",
          scotland: "\u{1F3F4}\u{E0067}\u{E0062}\u{E0073}\u{E0063}\u{E0074}\u{E007F}",
          wales: "\u{1F3F4}\u{E0067}\u{E0062}\u{E0077}\u{E006C}\u{E0073}\u{E007F}"
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/data/shortcuts.js
    var require_shortcuts = __commonJS({
      "node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/data/shortcuts.js"(exports2, module2) {
        "use strict";
        module2.exports = {
          angry: [">:(", ">:-("],
          blush: [':")', ':-")'],
          broken_heart: ["</3", "<\\3"],
          // :\ and :-\ not used because of conflict with markdown escaping
          confused: [":/", ":-/"],
          // twemoji shows question
          cry: [":'(", ":'-(", ":,(", ":,-("],
          frowning: [":(", ":-("],
          heart: ["<3"],
          imp: ["]:(", "]:-("],
          innocent: ["o:)", "O:)", "o:-)", "O:-)", "0:)", "0:-)"],
          joy: [":')", ":'-)", ":,)", ":,-)", ":'D", ":'-D", ":,D", ":,-D"],
          kissing: [":*", ":-*"],
          laughing: ["x-)", "X-)"],
          neutral_face: [":|", ":-|"],
          open_mouth: [":o", ":-o", ":O", ":-O"],
          rage: [":@", ":-@"],
          smile: [":D", ":-D"],
          smiley: [":)", ":-)"],
          smiling_imp: ["]:)", "]:-)"],
          sob: [":,'(", ":,'-(", ";(", ";-("],
          stuck_out_tongue: [":P", ":-P"],
          sunglasses: ["8-)", "B-)"],
          sweat: [",:(", ",:-("],
          sweat_smile: [",:)", ",:-)"],
          unamused: [":s", ":-S", ":z", ":-Z", ":$", ":-$"],
          wink: [";)", ";-)"]
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/render.js
    var require_render = __commonJS({
      "node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/render.js"(exports2, module2) {
        "use strict";
        module2.exports = function emoji_html(tokens, idx) {
          return tokens[idx].content;
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/replace.js
    var require_replace = __commonJS({
      "node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/replace.js"(exports2, module2) {
        "use strict";
        module2.exports = function create_rule(md2, emojies, shortcuts, scanRE, replaceRE) {
          var arrayReplaceAt = md2.utils.arrayReplaceAt, ucm = md2.utils.lib.ucmicro, ZPCc = new RegExp([ucm.Z.source, ucm.P.source, ucm.Cc.source].join("|"));
          function splitTextToken(text, level, Token2) {
            var token, last_pos = 0, nodes = [];
            text.replace(replaceRE, function(match, offset, src) {
              var emoji_name;
              if (shortcuts.hasOwnProperty(match)) {
                emoji_name = shortcuts[match];
                if (offset > 0 && !ZPCc.test(src[offset - 1])) {
                  return;
                }
                if (offset + match.length < src.length && !ZPCc.test(src[offset + match.length])) {
                  return;
                }
              } else {
                emoji_name = match.slice(1, -1);
              }
              if (offset > last_pos) {
                token = new Token2("text", "", 0);
                token.content = text.slice(last_pos, offset);
                nodes.push(token);
              }
              token = new Token2("emoji", "", 0);
              token.markup = emoji_name;
              token.content = emojies[emoji_name];
              nodes.push(token);
              last_pos = offset + match.length;
            });
            if (last_pos < text.length) {
              token = new Token2("text", "", 0);
              token.content = text.slice(last_pos);
              nodes.push(token);
            }
            return nodes;
          }
          return function emoji_replace(state) {
            var i, j, l, tokens, token, blockTokens = state.tokens, autolinkLevel = 0;
            for (j = 0, l = blockTokens.length; j < l; j++) {
              if (blockTokens[j].type !== "inline") {
                continue;
              }
              tokens = blockTokens[j].children;
              for (i = tokens.length - 1; i >= 0; i--) {
                token = tokens[i];
                if (token.type === "link_open" || token.type === "link_close") {
                  if (token.info === "auto") {
                    autolinkLevel -= token.nesting;
                  }
                }
                if (token.type === "text" && autolinkLevel === 0 && scanRE.test(token.content)) {
                  blockTokens[j].children = tokens = arrayReplaceAt(
                    tokens,
                    i,
                    splitTextToken(token.content, token.level, state.Token)
                  );
                }
              }
            }
          };
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/normalize_opts.js
    var require_normalize_opts = __commonJS({
      "node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/lib/normalize_opts.js"(exports2, module2) {
        "use strict";
        function quoteRE(str2) {
          return str2.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
        }
        module2.exports = function normalize_opts(options2) {
          var emojies = options2.defs, shortcuts;
          if (options2.enabled.length) {
            emojies = Object.keys(emojies).reduce(function(acc, key) {
              if (options2.enabled.indexOf(key) >= 0) {
                acc[key] = emojies[key];
              }
              return acc;
            }, {});
          }
          shortcuts = Object.keys(options2.shortcuts).reduce(function(acc, key) {
            if (!emojies[key]) {
              return acc;
            }
            if (Array.isArray(options2.shortcuts[key])) {
              options2.shortcuts[key].forEach(function(alias) {
                acc[alias] = key;
              });
              return acc;
            }
            acc[options2.shortcuts[key]] = key;
            return acc;
          }, {});
          var keys = Object.keys(emojies), names;
          if (keys.length === 0) {
            names = "^$";
          } else {
            names = keys.map(function(name) {
              return ":" + name + ":";
            }).concat(Object.keys(shortcuts)).sort().reverse().map(function(name) {
              return quoteRE(name);
            }).join("|");
          }
          var scanRE = RegExp(names);
          var replaceRE = RegExp(names, "g");
          return {
            defs: emojies,
            shortcuts,
            scanRE,
            replaceRE
          };
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/bare.js
    var require_bare = __commonJS({
      "node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/bare.js"(exports2, module2) {
        "use strict";
        var emoji_html = require_render();
        var emoji_replace = require_replace();
        var normalize_opts = require_normalize_opts();
        module2.exports = function emoji_plugin2(md2, options2) {
          var defaults = {
            defs: {},
            shortcuts: {},
            enabled: []
          };
          var opts = normalize_opts(md2.utils.assign({}, defaults, options2 || {}));
          md2.renderer.rules.emoji = emoji_html;
          md2.core.ruler.after(
            "linkify",
            "emoji",
            emoji_replace(md2, opts.defs, opts.shortcuts, opts.scanRE, opts.replaceRE)
          );
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/index.js
    var require_markdown_it_emoji = __commonJS({
      "node_modules/.pnpm/markdown-it-emoji@2.0.2/node_modules/markdown-it-emoji/index.js"(exports2, module2) {
        "use strict";
        var emojies_defs = require_full();
        var emojies_shortcuts = require_shortcuts();
        var bare_emoji_plugin = require_bare();
        module2.exports = function emoji_plugin2(md2, options2) {
          var defaults = {
            defs: emojies_defs,
            shortcuts: emojies_shortcuts,
            enabled: []
          };
          var opts = md2.utils.assign({}, defaults, options2 || {});
          bare_emoji_plugin(md2, opts);
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-footnote@3.0.3/node_modules/markdown-it-footnote/index.js
    var require_markdown_it_footnote = __commonJS({
      "node_modules/.pnpm/markdown-it-footnote@3.0.3/node_modules/markdown-it-footnote/index.js"(exports2, module2) {
        "use strict";
        function render_footnote_anchor_name(tokens, idx, options2, env) {
          var n = Number(tokens[idx].meta.id + 1).toString();
          var prefix = "";
          if (typeof env.docId === "string") {
            prefix = "-" + env.docId + "-";
          }
          return prefix + n;
        }
        function render_footnote_caption(tokens, idx) {
          var n = Number(tokens[idx].meta.id + 1).toString();
          if (tokens[idx].meta.subId > 0) {
            n += ":" + tokens[idx].meta.subId;
          }
          return "[" + n + "]";
        }
        function render_footnote_ref(tokens, idx, options2, env, slf) {
          var id = slf.rules.footnote_anchor_name(tokens, idx, options2, env, slf);
          var caption = slf.rules.footnote_caption(tokens, idx, options2, env, slf);
          var refid = id;
          if (tokens[idx].meta.subId > 0) {
            refid += ":" + tokens[idx].meta.subId;
          }
          return '<sup class="footnote-ref"><a href="#fn' + id + '" id="fnref' + refid + '">' + caption + "</a></sup>";
        }
        function render_footnote_block_open(tokens, idx, options2) {
          return (options2.xhtmlOut ? '<hr class="footnotes-sep" />\n' : '<hr class="footnotes-sep">\n') + '<section class="footnotes">\n<ol class="footnotes-list">\n';
        }
        function render_footnote_block_close() {
          return "</ol>\n</section>\n";
        }
        function render_footnote_open(tokens, idx, options2, env, slf) {
          var id = slf.rules.footnote_anchor_name(tokens, idx, options2, env, slf);
          if (tokens[idx].meta.subId > 0) {
            id += ":" + tokens[idx].meta.subId;
          }
          return '<li id="fn' + id + '" class="footnote-item">';
        }
        function render_footnote_close() {
          return "</li>\n";
        }
        function render_footnote_anchor(tokens, idx, options2, env, slf) {
          var id = slf.rules.footnote_anchor_name(tokens, idx, options2, env, slf);
          if (tokens[idx].meta.subId > 0) {
            id += ":" + tokens[idx].meta.subId;
          }
          return ' <a href="#fnref' + id + '" class="footnote-backref">\u21A9\uFE0E</a>';
        }
        module2.exports = function footnote_plugin2(md2) {
          var parseLinkLabel = md2.helpers.parseLinkLabel, isSpace = md2.utils.isSpace;
          md2.renderer.rules.footnote_ref = render_footnote_ref;
          md2.renderer.rules.footnote_block_open = render_footnote_block_open;
          md2.renderer.rules.footnote_block_close = render_footnote_block_close;
          md2.renderer.rules.footnote_open = render_footnote_open;
          md2.renderer.rules.footnote_close = render_footnote_close;
          md2.renderer.rules.footnote_anchor = render_footnote_anchor;
          md2.renderer.rules.footnote_caption = render_footnote_caption;
          md2.renderer.rules.footnote_anchor_name = render_footnote_anchor_name;
          function footnote_def(state, startLine, endLine, silent) {
            var oldBMark, oldTShift, oldSCount, oldParentType, pos, label, token, initial, offset, ch, posAfterColon, start = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
            if (start + 4 > max) {
              return false;
            }
            if (state.src.charCodeAt(start) !== 91) {
              return false;
            }
            if (state.src.charCodeAt(start + 1) !== 94) {
              return false;
            }
            for (pos = start + 2; pos < max; pos++) {
              if (state.src.charCodeAt(pos) === 32) {
                return false;
              }
              if (state.src.charCodeAt(pos) === 93) {
                break;
              }
            }
            if (pos === start + 2) {
              return false;
            }
            if (pos + 1 >= max || state.src.charCodeAt(++pos) !== 58) {
              return false;
            }
            if (silent) {
              return true;
            }
            pos++;
            if (!state.env.footnotes) {
              state.env.footnotes = {};
            }
            if (!state.env.footnotes.refs) {
              state.env.footnotes.refs = {};
            }
            label = state.src.slice(start + 2, pos - 2);
            state.env.footnotes.refs[":" + label] = -1;
            token = new state.Token("footnote_reference_open", "", 1);
            token.meta = { label };
            token.level = state.level++;
            state.tokens.push(token);
            oldBMark = state.bMarks[startLine];
            oldTShift = state.tShift[startLine];
            oldSCount = state.sCount[startLine];
            oldParentType = state.parentType;
            posAfterColon = pos;
            initial = offset = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine]);
            while (pos < max) {
              ch = state.src.charCodeAt(pos);
              if (isSpace(ch)) {
                if (ch === 9) {
                  offset += 4 - offset % 4;
                } else {
                  offset++;
                }
              } else {
                break;
              }
              pos++;
            }
            state.tShift[startLine] = pos - posAfterColon;
            state.sCount[startLine] = offset - initial;
            state.bMarks[startLine] = posAfterColon;
            state.blkIndent += 4;
            state.parentType = "footnote";
            if (state.sCount[startLine] < state.blkIndent) {
              state.sCount[startLine] += state.blkIndent;
            }
            state.md.block.tokenize(state, startLine, endLine, true);
            state.parentType = oldParentType;
            state.blkIndent -= 4;
            state.tShift[startLine] = oldTShift;
            state.sCount[startLine] = oldSCount;
            state.bMarks[startLine] = oldBMark;
            token = new state.Token("footnote_reference_close", "", -1);
            token.level = --state.level;
            state.tokens.push(token);
            return true;
          }
          function footnote_inline(state, silent) {
            var labelStart, labelEnd, footnoteId, token, tokens, max = state.posMax, start = state.pos;
            if (start + 2 >= max) {
              return false;
            }
            if (state.src.charCodeAt(start) !== 94) {
              return false;
            }
            if (state.src.charCodeAt(start + 1) !== 91) {
              return false;
            }
            labelStart = start + 2;
            labelEnd = parseLinkLabel(state, start + 1);
            if (labelEnd < 0) {
              return false;
            }
            if (!silent) {
              if (!state.env.footnotes) {
                state.env.footnotes = {};
              }
              if (!state.env.footnotes.list) {
                state.env.footnotes.list = [];
              }
              footnoteId = state.env.footnotes.list.length;
              state.md.inline.parse(
                state.src.slice(labelStart, labelEnd),
                state.md,
                state.env,
                tokens = []
              );
              token = state.push("footnote_ref", "", 0);
              token.meta = { id: footnoteId };
              state.env.footnotes.list[footnoteId] = {
                content: state.src.slice(labelStart, labelEnd),
                tokens
              };
            }
            state.pos = labelEnd + 1;
            state.posMax = max;
            return true;
          }
          function footnote_ref(state, silent) {
            var label, pos, footnoteId, footnoteSubId, token, max = state.posMax, start = state.pos;
            if (start + 3 > max) {
              return false;
            }
            if (!state.env.footnotes || !state.env.footnotes.refs) {
              return false;
            }
            if (state.src.charCodeAt(start) !== 91) {
              return false;
            }
            if (state.src.charCodeAt(start + 1) !== 94) {
              return false;
            }
            for (pos = start + 2; pos < max; pos++) {
              if (state.src.charCodeAt(pos) === 32) {
                return false;
              }
              if (state.src.charCodeAt(pos) === 10) {
                return false;
              }
              if (state.src.charCodeAt(pos) === 93) {
                break;
              }
            }
            if (pos === start + 2) {
              return false;
            }
            if (pos >= max) {
              return false;
            }
            pos++;
            label = state.src.slice(start + 2, pos - 1);
            if (typeof state.env.footnotes.refs[":" + label] === "undefined") {
              return false;
            }
            if (!silent) {
              if (!state.env.footnotes.list) {
                state.env.footnotes.list = [];
              }
              if (state.env.footnotes.refs[":" + label] < 0) {
                footnoteId = state.env.footnotes.list.length;
                state.env.footnotes.list[footnoteId] = { label, count: 0 };
                state.env.footnotes.refs[":" + label] = footnoteId;
              } else {
                footnoteId = state.env.footnotes.refs[":" + label];
              }
              footnoteSubId = state.env.footnotes.list[footnoteId].count;
              state.env.footnotes.list[footnoteId].count++;
              token = state.push("footnote_ref", "", 0);
              token.meta = { id: footnoteId, subId: footnoteSubId, label };
            }
            state.pos = pos;
            state.posMax = max;
            return true;
          }
          function footnote_tail(state) {
            var i, l, j, t, lastParagraph, list, token, tokens, current, currentLabel, insideRef = false, refTokens = {};
            if (!state.env.footnotes) {
              return;
            }
            state.tokens = state.tokens.filter(function(tok) {
              if (tok.type === "footnote_reference_open") {
                insideRef = true;
                current = [];
                currentLabel = tok.meta.label;
                return false;
              }
              if (tok.type === "footnote_reference_close") {
                insideRef = false;
                refTokens[":" + currentLabel] = current;
                return false;
              }
              if (insideRef) {
                current.push(tok);
              }
              return !insideRef;
            });
            if (!state.env.footnotes.list) {
              return;
            }
            list = state.env.footnotes.list;
            token = new state.Token("footnote_block_open", "", 1);
            state.tokens.push(token);
            for (i = 0, l = list.length; i < l; i++) {
              token = new state.Token("footnote_open", "", 1);
              token.meta = { id: i, label: list[i].label };
              state.tokens.push(token);
              if (list[i].tokens) {
                tokens = [];
                token = new state.Token("paragraph_open", "p", 1);
                token.block = true;
                tokens.push(token);
                token = new state.Token("inline", "", 0);
                token.children = list[i].tokens;
                token.content = list[i].content;
                tokens.push(token);
                token = new state.Token("paragraph_close", "p", -1);
                token.block = true;
                tokens.push(token);
              } else if (list[i].label) {
                tokens = refTokens[":" + list[i].label];
              }
              if (tokens)
                state.tokens = state.tokens.concat(tokens);
              if (state.tokens[state.tokens.length - 1].type === "paragraph_close") {
                lastParagraph = state.tokens.pop();
              } else {
                lastParagraph = null;
              }
              t = list[i].count > 0 ? list[i].count : 1;
              for (j = 0; j < t; j++) {
                token = new state.Token("footnote_anchor", "", 0);
                token.meta = { id: i, subId: j, label: list[i].label };
                state.tokens.push(token);
              }
              if (lastParagraph) {
                state.tokens.push(lastParagraph);
              }
              token = new state.Token("footnote_close", "", -1);
              state.tokens.push(token);
            }
            token = new state.Token("footnote_block_close", "", -1);
            state.tokens.push(token);
          }
          md2.block.ruler.before("reference", "footnote_def", footnote_def, { alt: ["paragraph", "reference"] });
          md2.inline.ruler.after("image", "footnote_inline", footnote_inline);
          md2.inline.ruler.after("footnote_inline", "footnote_ref", footnote_ref);
          md2.core.ruler.after("inline", "footnote_tail", footnote_tail);
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-abbr@1.0.4/node_modules/markdown-it-abbr/index.js
    var require_markdown_it_abbr = __commonJS({
      "node_modules/.pnpm/markdown-it-abbr@1.0.4/node_modules/markdown-it-abbr/index.js"(exports2, module2) {
        "use strict";
        module2.exports = function sub_plugin(md2) {
          var escapeRE = md2.utils.escapeRE, arrayReplaceAt = md2.utils.arrayReplaceAt;
          var OTHER_CHARS = " \r\n$+<=>^`|~";
          var UNICODE_PUNCT_RE = md2.utils.lib.ucmicro.P.source;
          var UNICODE_SPACE_RE = md2.utils.lib.ucmicro.Z.source;
          function abbr_def(state, startLine, endLine, silent) {
            var label, title, ch, labelStart, labelEnd, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
            if (pos + 2 >= max) {
              return false;
            }
            if (state.src.charCodeAt(pos++) !== 42) {
              return false;
            }
            if (state.src.charCodeAt(pos++) !== 91) {
              return false;
            }
            labelStart = pos;
            for (; pos < max; pos++) {
              ch = state.src.charCodeAt(pos);
              if (ch === 91) {
                return false;
              } else if (ch === 93) {
                labelEnd = pos;
                break;
              } else if (ch === 92) {
                pos++;
              }
            }
            if (labelEnd < 0 || state.src.charCodeAt(labelEnd + 1) !== 58) {
              return false;
            }
            if (silent) {
              return true;
            }
            label = state.src.slice(labelStart, labelEnd).replace(/\\(.)/g, "$1");
            title = state.src.slice(labelEnd + 2, max).trim();
            if (label.length === 0) {
              return false;
            }
            if (title.length === 0) {
              return false;
            }
            if (!state.env.abbreviations) {
              state.env.abbreviations = {};
            }
            if (typeof state.env.abbreviations[":" + label] === "undefined") {
              state.env.abbreviations[":" + label] = title;
            }
            state.line = startLine + 1;
            return true;
          }
          function abbr_replace(state) {
            var i, j, l, tokens, token, text, nodes, pos, reg, m, regText, regSimple, currentToken, blockTokens = state.tokens;
            if (!state.env.abbreviations) {
              return;
            }
            regSimple = new RegExp("(?:" + Object.keys(state.env.abbreviations).map(function(x) {
              return x.substr(1);
            }).sort(function(a, b) {
              return b.length - a.length;
            }).map(escapeRE).join("|") + ")");
            regText = "(^|" + UNICODE_PUNCT_RE + "|" + UNICODE_SPACE_RE + "|[" + OTHER_CHARS.split("").map(escapeRE).join("") + "])(" + Object.keys(state.env.abbreviations).map(function(x) {
              return x.substr(1);
            }).sort(function(a, b) {
              return b.length - a.length;
            }).map(escapeRE).join("|") + ")($|" + UNICODE_PUNCT_RE + "|" + UNICODE_SPACE_RE + "|[" + OTHER_CHARS.split("").map(escapeRE).join("") + "])";
            reg = new RegExp(regText, "g");
            for (j = 0, l = blockTokens.length; j < l; j++) {
              if (blockTokens[j].type !== "inline") {
                continue;
              }
              tokens = blockTokens[j].children;
              for (i = tokens.length - 1; i >= 0; i--) {
                currentToken = tokens[i];
                if (currentToken.type !== "text") {
                  continue;
                }
                pos = 0;
                text = currentToken.content;
                reg.lastIndex = 0;
                nodes = [];
                if (!regSimple.test(text)) {
                  continue;
                }
                while (m = reg.exec(text)) {
                  if (m.index > 0 || m[1].length > 0) {
                    token = new state.Token("text", "", 0);
                    token.content = text.slice(pos, m.index + m[1].length);
                    nodes.push(token);
                  }
                  token = new state.Token("abbr_open", "abbr", 1);
                  token.attrs = [["title", state.env.abbreviations[":" + m[2]]]];
                  nodes.push(token);
                  token = new state.Token("text", "", 0);
                  token.content = m[2];
                  nodes.push(token);
                  token = new state.Token("abbr_close", "abbr", -1);
                  nodes.push(token);
                  reg.lastIndex -= m[3].length;
                  pos = reg.lastIndex;
                }
                if (!nodes.length) {
                  continue;
                }
                if (pos < text.length) {
                  token = new state.Token("text", "", 0);
                  token.content = text.slice(pos);
                  nodes.push(token);
                }
                blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
              }
            }
          }
          md2.block.ruler.before("reference", "abbr_def", abbr_def, { alt: ["paragraph", "reference"] });
          md2.core.ruler.after("linkify", "abbr_replace", abbr_replace);
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-deflist@2.1.0/node_modules/markdown-it-deflist/index.js
    var require_markdown_it_deflist = __commonJS({
      "node_modules/.pnpm/markdown-it-deflist@2.1.0/node_modules/markdown-it-deflist/index.js"(exports2, module2) {
        "use strict";
        module2.exports = function deflist_plugin(md2) {
          var isSpace = md2.utils.isSpace;
          function skipMarker(state, line) {
            var pos, marker, start = state.bMarks[line] + state.tShift[line], max = state.eMarks[line];
            if (start >= max) {
              return -1;
            }
            marker = state.src.charCodeAt(start++);
            if (marker !== 126 && marker !== 58) {
              return -1;
            }
            pos = state.skipSpaces(start);
            if (start === pos) {
              return -1;
            }
            if (pos >= max) {
              return -1;
            }
            return start;
          }
          function markTightParagraphs(state, idx) {
            var i, l, level = state.level + 2;
            for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
              if (state.tokens[i].level === level && state.tokens[i].type === "paragraph_open") {
                state.tokens[i + 2].hidden = true;
                state.tokens[i].hidden = true;
                i += 2;
              }
            }
          }
          function deflist(state, startLine, endLine, silent) {
            var ch, contentStart, ddLine, dtLine, itemLines, listLines, listTokIdx, max, nextLine, offset, oldDDIndent, oldIndent, oldParentType, oldSCount, oldTShift, oldTight, pos, prevEmptyEnd, tight, token;
            if (silent) {
              if (state.ddIndent < 0) {
                return false;
              }
              return skipMarker(state, startLine) >= 0;
            }
            nextLine = startLine + 1;
            if (nextLine >= endLine) {
              return false;
            }
            if (state.isEmpty(nextLine)) {
              nextLine++;
              if (nextLine >= endLine) {
                return false;
              }
            }
            if (state.sCount[nextLine] < state.blkIndent) {
              return false;
            }
            contentStart = skipMarker(state, nextLine);
            if (contentStart < 0) {
              return false;
            }
            listTokIdx = state.tokens.length;
            tight = true;
            token = state.push("dl_open", "dl", 1);
            token.map = listLines = [startLine, 0];
            dtLine = startLine;
            ddLine = nextLine;
            OUTER:
              for (; ; ) {
                prevEmptyEnd = false;
                token = state.push("dt_open", "dt", 1);
                token.map = [dtLine, dtLine];
                token = state.push("inline", "", 0);
                token.map = [dtLine, dtLine];
                token.content = state.getLines(dtLine, dtLine + 1, state.blkIndent, false).trim();
                token.children = [];
                token = state.push("dt_close", "dt", -1);
                for (; ; ) {
                  token = state.push("dd_open", "dd", 1);
                  token.map = itemLines = [nextLine, 0];
                  pos = contentStart;
                  max = state.eMarks[ddLine];
                  offset = state.sCount[ddLine] + contentStart - (state.bMarks[ddLine] + state.tShift[ddLine]);
                  while (pos < max) {
                    ch = state.src.charCodeAt(pos);
                    if (isSpace(ch)) {
                      if (ch === 9) {
                        offset += 4 - offset % 4;
                      } else {
                        offset++;
                      }
                    } else {
                      break;
                    }
                    pos++;
                  }
                  contentStart = pos;
                  oldTight = state.tight;
                  oldDDIndent = state.ddIndent;
                  oldIndent = state.blkIndent;
                  oldTShift = state.tShift[ddLine];
                  oldSCount = state.sCount[ddLine];
                  oldParentType = state.parentType;
                  state.blkIndent = state.ddIndent = state.sCount[ddLine] + 2;
                  state.tShift[ddLine] = contentStart - state.bMarks[ddLine];
                  state.sCount[ddLine] = offset;
                  state.tight = true;
                  state.parentType = "deflist";
                  state.md.block.tokenize(state, ddLine, endLine, true);
                  if (!state.tight || prevEmptyEnd) {
                    tight = false;
                  }
                  prevEmptyEnd = state.line - ddLine > 1 && state.isEmpty(state.line - 1);
                  state.tShift[ddLine] = oldTShift;
                  state.sCount[ddLine] = oldSCount;
                  state.tight = oldTight;
                  state.parentType = oldParentType;
                  state.blkIndent = oldIndent;
                  state.ddIndent = oldDDIndent;
                  token = state.push("dd_close", "dd", -1);
                  itemLines[1] = nextLine = state.line;
                  if (nextLine >= endLine) {
                    break OUTER;
                  }
                  if (state.sCount[nextLine] < state.blkIndent) {
                    break OUTER;
                  }
                  contentStart = skipMarker(state, nextLine);
                  if (contentStart < 0) {
                    break;
                  }
                  ddLine = nextLine;
                }
                if (nextLine >= endLine) {
                  break;
                }
                dtLine = nextLine;
                if (state.isEmpty(dtLine)) {
                  break;
                }
                if (state.sCount[dtLine] < state.blkIndent) {
                  break;
                }
                ddLine = dtLine + 1;
                if (ddLine >= endLine) {
                  break;
                }
                if (state.isEmpty(ddLine)) {
                  ddLine++;
                }
                if (ddLine >= endLine) {
                  break;
                }
                if (state.sCount[ddLine] < state.blkIndent) {
                  break;
                }
                contentStart = skipMarker(state, ddLine);
                if (contentStart < 0) {
                  break;
                }
              }
            token = state.push("dl_close", "dl", -1);
            listLines[1] = nextLine;
            state.line = nextLine;
            if (tight) {
              markTightParagraphs(state, listTokIdx);
            }
            return true;
          }
          md2.block.ruler.before("paragraph", "deflist", deflist, { alt: ["paragraph", "reference", "blockquote"] });
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-ins@3.0.1/node_modules/markdown-it-ins/index.js
    var require_markdown_it_ins = __commonJS({
      "node_modules/.pnpm/markdown-it-ins@3.0.1/node_modules/markdown-it-ins/index.js"(exports2, module2) {
        "use strict";
        module2.exports = function ins_plugin(md2) {
          function tokenize(state, silent) {
            var i, scanned, token, len, ch, start = state.pos, marker = state.src.charCodeAt(start);
            if (silent) {
              return false;
            }
            if (marker !== 43) {
              return false;
            }
            scanned = state.scanDelims(state.pos, true);
            len = scanned.length;
            ch = String.fromCharCode(marker);
            if (len < 2) {
              return false;
            }
            if (len % 2) {
              token = state.push("text", "", 0);
              token.content = ch;
              len--;
            }
            for (i = 0; i < len; i += 2) {
              token = state.push("text", "", 0);
              token.content = ch + ch;
              if (!scanned.can_open && !scanned.can_close) {
                continue;
              }
              state.delimiters.push({
                marker,
                length: 0,
                // disable "rule of 3" length checks meant for emphasis
                jump: i / 2,
                // 1 delimiter = 2 characters
                token: state.tokens.length - 1,
                end: -1,
                open: scanned.can_open,
                close: scanned.can_close
              });
            }
            state.pos += scanned.length;
            return true;
          }
          function postProcess(state, delimiters) {
            var i, j, startDelim, endDelim, token, loneMarkers = [], max = delimiters.length;
            for (i = 0; i < max; i++) {
              startDelim = delimiters[i];
              if (startDelim.marker !== 43) {
                continue;
              }
              if (startDelim.end === -1) {
                continue;
              }
              endDelim = delimiters[startDelim.end];
              token = state.tokens[startDelim.token];
              token.type = "ins_open";
              token.tag = "ins";
              token.nesting = 1;
              token.markup = "++";
              token.content = "";
              token = state.tokens[endDelim.token];
              token.type = "ins_close";
              token.tag = "ins";
              token.nesting = -1;
              token.markup = "++";
              token.content = "";
              if (state.tokens[endDelim.token - 1].type === "text" && state.tokens[endDelim.token - 1].content === "+") {
                loneMarkers.push(endDelim.token - 1);
              }
            }
            while (loneMarkers.length) {
              i = loneMarkers.pop();
              j = i + 1;
              while (j < state.tokens.length && state.tokens[j].type === "ins_close") {
                j++;
              }
              j--;
              if (i !== j) {
                token = state.tokens[j];
                state.tokens[j] = state.tokens[i];
                state.tokens[i] = token;
              }
            }
          }
          md2.inline.ruler.before("emphasis", "ins", tokenize);
          md2.inline.ruler2.before("emphasis", "ins", function(state) {
            var curr, tokens_meta = state.tokens_meta, max = (state.tokens_meta || []).length;
            postProcess(state, state.delimiters);
            for (curr = 0; curr < max; curr++) {
              if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
                postProcess(state, tokens_meta[curr].delimiters);
              }
            }
          });
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-mark@3.0.1/node_modules/markdown-it-mark/index.js
    var require_markdown_it_mark = __commonJS({
      "node_modules/.pnpm/markdown-it-mark@3.0.1/node_modules/markdown-it-mark/index.js"(exports2, module2) {
        "use strict";
        module2.exports = function ins_plugin(md2) {
          function tokenize(state, silent) {
            var i, scanned, token, len, ch, start = state.pos, marker = state.src.charCodeAt(start);
            if (silent) {
              return false;
            }
            if (marker !== 61) {
              return false;
            }
            scanned = state.scanDelims(state.pos, true);
            len = scanned.length;
            ch = String.fromCharCode(marker);
            if (len < 2) {
              return false;
            }
            if (len % 2) {
              token = state.push("text", "", 0);
              token.content = ch;
              len--;
            }
            for (i = 0; i < len; i += 2) {
              token = state.push("text", "", 0);
              token.content = ch + ch;
              if (!scanned.can_open && !scanned.can_close) {
                continue;
              }
              state.delimiters.push({
                marker,
                length: 0,
                // disable "rule of 3" length checks meant for emphasis
                jump: i / 2,
                // 1 delimiter = 2 characters
                token: state.tokens.length - 1,
                end: -1,
                open: scanned.can_open,
                close: scanned.can_close
              });
            }
            state.pos += scanned.length;
            return true;
          }
          function postProcess(state, delimiters) {
            var i, j, startDelim, endDelim, token, loneMarkers = [], max = delimiters.length;
            for (i = 0; i < max; i++) {
              startDelim = delimiters[i];
              if (startDelim.marker !== 61) {
                continue;
              }
              if (startDelim.end === -1) {
                continue;
              }
              endDelim = delimiters[startDelim.end];
              token = state.tokens[startDelim.token];
              token.type = "mark_open";
              token.tag = "mark";
              token.nesting = 1;
              token.markup = "==";
              token.content = "";
              token = state.tokens[endDelim.token];
              token.type = "mark_close";
              token.tag = "mark";
              token.nesting = -1;
              token.markup = "==";
              token.content = "";
              if (state.tokens[endDelim.token - 1].type === "text" && state.tokens[endDelim.token - 1].content === "=") {
                loneMarkers.push(endDelim.token - 1);
              }
            }
            while (loneMarkers.length) {
              i = loneMarkers.pop();
              j = i + 1;
              while (j < state.tokens.length && state.tokens[j].type === "mark_close") {
                j++;
              }
              j--;
              if (i !== j) {
                token = state.tokens[j];
                state.tokens[j] = state.tokens[i];
                state.tokens[i] = token;
              }
            }
          }
          md2.inline.ruler.before("emphasis", "mark", tokenize);
          md2.inline.ruler2.before("emphasis", "mark", function(state) {
            var curr, tokens_meta = state.tokens_meta, max = (state.tokens_meta || []).length;
            postProcess(state, state.delimiters);
            for (curr = 0; curr < max; curr++) {
              if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
                postProcess(state, tokens_meta[curr].delimiters);
              }
            }
          });
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-sub@1.0.0/node_modules/markdown-it-sub/index.js
    var require_markdown_it_sub = __commonJS({
      "node_modules/.pnpm/markdown-it-sub@1.0.0/node_modules/markdown-it-sub/index.js"(exports2, module2) {
        "use strict";
        var UNESCAPE_RE = /\\([ \\!"#$%&'()*+,.\/:;<=>?@[\]^_`{|}~-])/g;
        function subscript2(state, silent) {
          var found, content, token, max = state.posMax, start = state.pos;
          if (state.src.charCodeAt(start) !== 126) {
            return false;
          }
          if (silent) {
            return false;
          }
          if (start + 2 >= max) {
            return false;
          }
          state.pos = start + 1;
          while (state.pos < max) {
            if (state.src.charCodeAt(state.pos) === 126) {
              found = true;
              break;
            }
            state.md.inline.skipToken(state);
          }
          if (!found || start + 1 === state.pos) {
            state.pos = start;
            return false;
          }
          content = state.src.slice(start + 1, state.pos);
          if (content.match(/(^|[^\\])(\\\\)*\s/)) {
            state.pos = start;
            return false;
          }
          state.posMax = state.pos;
          state.pos = start + 1;
          token = state.push("sub_open", "sub", 1);
          token.markup = "~";
          token = state.push("text", "", 0);
          token.content = content.replace(UNESCAPE_RE, "$1");
          token = state.push("sub_close", "sub", -1);
          token.markup = "~";
          state.pos = state.posMax + 1;
          state.posMax = max;
          return true;
        }
        module2.exports = function sub_plugin(md2) {
          md2.inline.ruler.after("emphasis", "sub", subscript2);
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-sup@1.0.0/node_modules/markdown-it-sup/index.js
    var require_markdown_it_sup = __commonJS({
      "node_modules/.pnpm/markdown-it-sup@1.0.0/node_modules/markdown-it-sup/index.js"(exports2, module2) {
        "use strict";
        var UNESCAPE_RE = /\\([ \\!"#$%&'()*+,.\/:;<=>?@[\]^_`{|}~-])/g;
        function superscript2(state, silent) {
          var found, content, token, max = state.posMax, start = state.pos;
          if (state.src.charCodeAt(start) !== 94) {
            return false;
          }
          if (silent) {
            return false;
          }
          if (start + 2 >= max) {
            return false;
          }
          state.pos = start + 1;
          while (state.pos < max) {
            if (state.src.charCodeAt(state.pos) === 94) {
              found = true;
              break;
            }
            state.md.inline.skipToken(state);
          }
          if (!found || start + 1 === state.pos) {
            state.pos = start;
            return false;
          }
          content = state.src.slice(start + 1, state.pos);
          if (content.match(/(^|[^\\])(\\\\)*\s/)) {
            state.pos = start;
            return false;
          }
          state.posMax = state.pos;
          state.pos = start + 1;
          token = state.push("sup_open", "sup", 1);
          token.markup = "^";
          token = state.push("text", "", 0);
          token.content = content.replace(UNESCAPE_RE, "$1");
          token = state.push("sup_close", "sup", -1);
          token.markup = "^";
          state.pos = state.posMax + 1;
          state.posMax = max;
          return true;
        }
        module2.exports = function sup_plugin(md2) {
          md2.inline.ruler.after("emphasis", "sup", superscript2);
        };
      }
    });
    
    // node_modules/.pnpm/markdown-it-container@3.0.0/node_modules/markdown-it-container/index.js
    var require_markdown_it_container = __commonJS({
      "node_modules/.pnpm/markdown-it-container@3.0.0/node_modules/markdown-it-container/index.js"(exports2, module2) {
        "use strict";
        module2.exports = function container_plugin(md2, name, options2) {
          function validateDefault(params) {
            return params.trim().split(" ", 2)[0] === name;
          }
          function renderDefault(tokens, idx, _options, env, slf) {
            if (tokens[idx].nesting === 1) {
              tokens[idx].attrJoin("class", name);
            }
            return slf.renderToken(tokens, idx, _options, env, slf);
          }
          options2 = options2 || {};
          var min_markers = 3, marker_str = options2.marker || ":", marker_char = marker_str.charCodeAt(0), marker_len = marker_str.length, validate = options2.validate || validateDefault, render = options2.render || renderDefault;
          function container2(state, startLine, endLine, silent) {
            var pos, nextLine, marker_count, markup, params, token, old_parent, old_line_max, auto_closed = false, start = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
            if (marker_char !== state.src.charCodeAt(start)) {
              return false;
            }
            for (pos = start + 1; pos <= max; pos++) {
              if (marker_str[(pos - start) % marker_len] !== state.src[pos]) {
                break;
              }
            }
            marker_count = Math.floor((pos - start) / marker_len);
            if (marker_count < min_markers) {
              return false;
            }
            pos -= (pos - start) % marker_len;
            markup = state.src.slice(start, pos);
            params = state.src.slice(pos, max);
            if (!validate(params, markup)) {
              return false;
            }
            if (silent) {
              return true;
            }
            nextLine = startLine;
            for (; ; ) {
              nextLine++;
              if (nextLine >= endLine) {
                break;
              }
              start = state.bMarks[nextLine] + state.tShift[nextLine];
              max = state.eMarks[nextLine];
              if (start < max && state.sCount[nextLine] < state.blkIndent) {
                break;
              }
              if (marker_char !== state.src.charCodeAt(start)) {
                continue;
              }
              if (state.sCount[nextLine] - state.blkIndent >= 4) {
                continue;
              }
              for (pos = start + 1; pos <= max; pos++) {
                if (marker_str[(pos - start) % marker_len] !== state.src[pos]) {
                  break;
                }
              }
              if (Math.floor((pos - start) / marker_len) < marker_count) {
                continue;
              }
              pos -= (pos - start) % marker_len;
              pos = state.skipSpaces(pos);
              if (pos < max) {
                continue;
              }
              auto_closed = true;
              break;
            }
            old_parent = state.parentType;
            old_line_max = state.lineMax;
            state.parentType = "container";
            state.lineMax = nextLine;
            token = state.push("container_" + name + "_open", "div", 1);
            token.markup = markup;
            token.block = true;
            token.info = params;
            token.map = [startLine, nextLine];
            state.md.block.tokenize(state, startLine + 1, nextLine);
            token = state.push("container_" + name + "_close", "div", -1);
            token.markup = state.src.slice(start, pos);
            token.block = true;
            state.parentType = old_parent;
            state.lineMax = old_line_max;
            state.line = nextLine + (auto_closed ? 1 : 0);
            return true;
          }
          md2.block.ruler.before("fence", "container_" + name, container2, {
            alt: ["paragraph", "reference", "blockquote", "list"]
          });
          md2.renderer.rules["container_" + name + "_open"] = render;
          md2.renderer.rules["container_" + name + "_close"] = render;
        };
      }
    });
    
    // node_modules/.pnpm/commander@10.0.1/node_modules/commander/esm.mjs
    var import_index = __toESM(require_commander(), 1);
    var {
      program,
      createCommand,
      createArgument,
      createOption,
      CommanderError,
      InvalidArgumentError,
      InvalidOptionArgumentError,
      // deprecated old name
      Command,
      Argument,
      Option,
      Help
    } = import_index.default;
    
    // src/index.ts
    var import_promises = __toESM(require("node:fs/promises"));
    
    // src/lib/parsing.ts
    var import_gray_matter = __toESM(require_gray_matter());
    var import_markdown_it = __toESM(require_markdown_it());
    var import_markdown_it_bracketed_spans = __toESM(require_markdown_it_bracketed_spans());
    var import_markdown_it_attrs = __toESM(require_markdown_it_attrs());
    var import_markdown_it_emoji = __toESM(require_markdown_it_emoji());
    var import_markdown_it_footnote = __toESM(require_markdown_it_footnote());
    var import_markdown_it_abbr = __toESM(require_markdown_it_abbr());
    var import_markdown_it_deflist = __toESM(require_markdown_it_deflist());
    var import_markdown_it_ins = __toESM(require_markdown_it_ins());
    var import_markdown_it_mark = __toESM(require_markdown_it_mark());
    var import_markdown_it_sub = __toESM(require_markdown_it_sub());
    var import_markdown_it_sup = __toESM(require_markdown_it_sup());
    var import_markdown_it_container = __toESM(require_markdown_it_container());
    var import_token = __toESM(require_token());
    
    // src/lib/metadataChecks.ts
    function getMetadataProblems(metaData) {
      const warnings = [];
      const errors = [];
      if (typeof metaData["spec_version"] === "undefined") {
        errors.push(
          `Metadata is missing attribute 'spec_version'. Suggested fix: Insert 'spec_version: "2"' into the metadata-block `
        );
      } else if ("" + metaData["spec_version"] !== "2") {
        errors.push(
          "Metadata attribute 'spec_version' should always be 2, because the current CI can't handle other version. Suggested fix: Replace 'spec_version: " + metaData["spec_version"] + `' with 'spec_version: "2"'.`
        );
      }
      if (typeof metaData["lang"] !== "string") {
        warnings.push(
          `Metadata is missing attribute 'lang'. This influences some metadata and might end up in resulting documents. Suggested fix: Insert 'lang: "de"' into the metadata-block.`
        );
      }
      if (typeof metaData["title"] !== "string" || metaData["title"].trim().length === 0) {
        errors.push(
          "Metadata is missing attribute 'title'. Used by website-generator to display a propper title. Suggested fix: Insert a valid title into the metadata-block."
        );
      }
      if (metaData["date"] === void 0 || typeof metaData["date"] === "string" && metaData["date"].trim().length === 0) {
        errors.push(
          `Metadata is missing attribute 'date'. You absolutely need a valid date at which the transcript was initiall written. Suggested fix: Insert a valid date into the metadata-block in the format of 'date: "YYYY-MM-DD"', e.g.'date: "2015-02-28"'`
        );
      } else if (typeof Date.parse(metaData["date"]) !== "number" || isNaN(Date.parse(metaData["date"]))) {
        errors.push(
          "Metadata attribute 'date' ('" + metaData["date"] + `')is not a valid date. You absolutely need a valid date at which the transcript was initiall written. Suggested fix: Replace 'date: "` + metaData["date"] + `"' with a valid entry in the format of 'date: "YYYY-MM-DD"', e.g.'date: "2015-02-28"'`
        );
      }
      if (typeof metaData["number"] === "undefined") {
        errors.push(
          `Metadata is missing attribute 'number'. Fachschaft Informatik TU Dortmunds requires a valid transcript number. Suggested fix: Insert a number into the metadata-block in the format of 'number: "N"', e.g.'number: "404"'`
        );
      } else if (typeof parseInt(metaData["number"], 10) !== "number" || isNaN(parseInt(metaData["number"], 10)) || ("" + metaData["number"]).search(/[^\d]/g) !== -1) {
        errors.push(
          `Metadata attribute 'number' must be a valid transcript number. Suggested fix: Replace 'number: "` + metaData["number"] + `"' with a valid number-entry in the format of 'number: "N"', e.g.'number: "404"'`
        );
      }
      if (typeof metaData["start"] !== "string") {
        errors.push(
          `Metadata is missing attribute 'start'. Suggested fix: Insert a valid start time into the metadata-block in the format of 'start: "hh:mm"', e.g.'start: "22:15"'`
        );
      } else if (!isValidGermanTimeStamp(metaData["start"])) {
        errors.push(
          `Metadata attribute 'start' must be a valid start time. Suggested fix: Replace 'start: "` + metaData["start"] + `"' with a valid start-entry in the format of 'start: "hh:mm"', e.g.'start: "22:15"'`
        );
      }
      if (typeof metaData["end"] !== "string") {
        errors.push(
          `Metadata is missing attribute 'end'. Suggested fix: Insert a valid end time into the metadata-block in the format of 'end: "hh:mm"', e.g.'end: "22:45"'`
        );
      } else if (!isValidGermanTimeStamp(metaData["end"])) {
        errors.push(
          `Metadata attribute 'end' must be a valid end time. Suggested fix: Replace 'end: "` + metaData["end"] + `"' with a valid end-entry in the format of 'end: "hh:mm"', e.g.'end: "22:45"'`
        );
      }
      if (isValidGermanTimeStamp(metaData["start"]) && isValidGermanTimeStamp(metaData["end"]) && !isSecondTimeGreaterThanFirst(metaData["start"], metaData["end"])) {
        errors.push(
          "Metadata attribute 'end' ('" + metaData["end"] + "') must be a later time than 'start' ('" + metaData["start"] + "')."
        );
      }
      if (typeof metaData["author"] !== "string") {
        errors.push(
          `Metadata is missing attribute 'author'. Suggested fix: Insert a valid author into the metadata-block in the format of 'author: "Your name"'`
        );
      }
      if (typeof metaData["head"] !== "string") {
        errors.push(
          `Metadata is missing attribute 'head'. Suggested fix: Insert a valid head name (or -) into the metadata-block in the format of 'head: "Name of chairman"'`
        );
      }
      if (metaData["present"] === void 0) {
        errors.push(
          `Metadata is missing attribute 'present'. Suggested fix: Insert a list of people who were present into the metadata-block in the format of 'present: ["Name of person1", ...]'`
        );
      } else if (!Array.isArray(metaData["present"])) {
        errors.push(
          "Metadata attribute 'present' should be an Array of names, even if only one person is present. Suggested fix: Make sure that 'present' is a yaml-Array of names (See: https://www.w3schools.io/file/yaml-arrays/)"
        );
      } else if (!metaData["present"].every((entry) => typeof entry === "string")) {
        errors.push(
          "Metadata attribute 'present' should be an Array of names (which are strings), even if only one person is present. Suggested fix: Make sure that 'present' is a yaml-Array of names (See: https://www.w3schools.io/file/yaml-arrays/)"
        );
      }
      if (metaData["absent"] === void 0) {
        errors.push(
          `Metadata is missing attribute 'absent'. Suggested fix: Insert a list of people who were absent into the metadata-block in the format of 'absent: ["Name of person1", ...]'`
        );
      } else if (!Array.isArray(metaData["absent"])) {
        errors.push(
          "Metadata attribute 'absent' should be an Array of names, even if only one person is absent. Suggested fix: Make sure that 'absent' is a yaml-Array of names (See: https://www.w3schools.io/file/yaml-arrays/)"
        );
      } else if (!metaData["absent"].every((entry) => typeof entry === "string")) {
        errors.push(
          "Metadata attribute 'absent' should be an Array of names (which are strings), even if only one person is absent. Suggested fix: Make sure that 'absent' is a yaml-Array of names (See: https://www.w3schools.io/file/yaml-arrays/)"
        );
      }
      if (metaData["guests"] === void 0) {
        errors.push(
          `Metadata is missing attribute 'guests'. Suggested fix: Insert a list of people who were guests into the metadata-block in the format of 'guests: ["Name of person1", ...]'`
        );
      } else if (!Array.isArray(metaData["guests"])) {
        errors.push(
          "Metadata attribute 'guests' should be an Array of names, even if only one person is attending as a guest. Suggested fix: Make sure that 'guests' is a yaml-Array of names (See: https://www.w3schools.io/file/yaml-arrays/)"
        );
      } else if (!metaData["guests"].every((entry) => typeof entry === "string")) {
        errors.push(
          "Metadata attribute 'guests' should be an Array of names (which are strings), even if only one person is guests. Suggested fix: Make sure that 'guests' is a yaml-Array of names (See: https://www.w3schools.io/file/yaml-arrays/)"
        );
      }
      return {
        warnings,
        errors
      };
    }
    function isValidGermanTimeStamp(input) {
      if (typeof input !== "string")
        return false;
      if (input.search(/^(\d\d:\d\d)$/g) === -1)
        return false;
      const hours = parseInt(input.split(":")[0], 10);
      if (hours < 0 || hours > 23)
        return false;
      const minutes = parseInt(input.split(":")[1], 10);
      if (minutes < 0 || minutes > 59)
        return false;
      return true;
    }
    function isSecondTimeGreaterThanFirst(firstTimeStr, secondTimeStr) {
      const firstTime = parseInt(firstTimeStr.split(":")[0], 10) * 100 + parseInt(firstTimeStr.split(":")[1], 10);
      const secondTime = parseInt(secondTimeStr.split(":")[0], 10) * 100 + parseInt(secondTimeStr.split(":")[1], 10);
      return firstTime < secondTime;
    }
    
    // src/lib/rendering.ts
    function renderResolutionToHtml(resolution) {
      return `<div class="card mb-3 text-center" id="${resolution.number}">
        <div class="card-header" >Beschluss <code>${resolution.number}</code></div>
        <div class="card-body">
          <h5 class="card-title"></h5>
          <p class="card-text">${resolution.text}</p>
          <div class="container container-sm">
            <div class="row align-items-center">
                <div class="col">
                    <span class="p-1 border-bottom border-success border-2"> 
                        Ja: ${resolution.votes.yes}
                    </span>
                </div>
                <div class="col">
                    <span class="p-1 border-bottom border-danger border-2"> 
                        Nein: ${resolution.votes.no}
                    </span>
                </div>
                <div class="col">
                    <span class="p-1 border-bottom border-info border-2"> 
                        Enthaltung: ${resolution.votes.abstention}
                    </span>
                </div>
            </div>
          </div>
        </div>
        <div class="card-footer ${resolution.result === "Angenommen" ? "bg-success" : "bg-danger"} bg-opacity-25">
          ${resolution.result}
          </div>
      </div>`;
    }
    function renderTranscriptPageHtml(transcriptHtml, meta) {
      return `<!DOCTYPE html>
      <html lang="de">
        <head>
          <meta charset="UTF-8" />
          <meta http-equiv="X-UA-Compatible" content="IE=edge" />
          <meta name="viewport" content="width=device-width, initial-scale=1.0" />
          <title>${meta.title}</title>
          <link href="../bootstrap.min.css" rel="stylesheet">
          <style>
          div:target {
            border-width: 0.4rem;
            border-color: #f4c4aa;
            scroll-margin-top: 4rem;
          }        
          </style>
        </head>
        <body class="bg-body">
          <div>
            <header>
              <nav class="navbar navbar-expand bg-body-tertiary">
                <ul class="navbar-nav">
                <li class="nav-item">
                  <a class="nav-link" href="..">Protokolle</a>
                </li>
                <li class="nav-item">
                  <a class="nav-link" href="../resolutions.html">Beschl\xFCsse</a>
                </li>
                <li class="nav-item">
                  <a class="nav-link" href="https://gitlab.fachschaften.org/search?group_id=29&project_id=77&repository_ref=master&scope=blobs&search=">Suche</a>
                </li>
              </ul>
              </nav>
            </header>
          </div>
          <div class="container mt-2 mb-2">
            <div class="bg-body-tertiary">
              <article class="p-4">
                ${transcriptHtml}
              </article>
            </div>
          </div>
        </body>
      </html>`;
    }
    function generateIndexHtml(parseResults) {
      return `<!DOCTYPE html>
      <html lang="de">
        <head>
          <meta charset="UTF-8" />
          <meta http-equiv="X-UA-Compatible" content="IE=edge" />
          <meta name="viewport" content="width=device-width, initial-scale=1.0" />
          <title>FSR-Protokolle</title>
          <link href="./bootstrap.min.css" rel="stylesheet">
        </head>
        <body>
          <div class="">
            <header>
              <nav class="navbar navbar-expand bg-body-tertiary">
                <ul class="navbar-nav">
                <li class="nav-item">
                  <a class="nav-link" href="#">Protokolle</a>
                </li>
                <li class="nav-item">
                  <a class="nav-link" href="./resolutions.html">Beschl\xFCsse</a>
                </li>
                <li class="nav-item">
                  <a class="nav-link" href="https://gitlab.fachschaften.org/search?group_id=29&project_id=77&repository_ref=master&scope=blobs&search=">Suche</a>
                </li>
              </ul>
              </nav>
            </header>
          </div>
          <div class="container mt-2 mb-2">
            <ul>
              ${parseResults.map(
        (t) => `<li><a href="./fsr-sitzung-${t.meta.number}-${t.meta.date}">FSR-Sitzung ${t.meta.number} (${t.meta.date})</a></li>`
      ).join("\n")}
            </ul>
          </div>
        </body>
      </html>`;
    }
    function generateResolutionsHtml(transcripts) {
      return `<!DOCTYPE html>
        <html lang="de">
          <head>
            <meta charset="UTF-8" />
            <meta http-equiv="X-UA-Compatible" content="IE=edge" />
            <meta name="viewport" content="width=device-width, initial-scale=1.0" />
            <title>FSR-Protokolle</title>
            <link href="./bootstrap.min.css" rel="stylesheet">
            <style>
            tr:target {
              border-width: 0.4rem;
              border-color: #f4c4aa;
              scroll-margin-top: 4rem;
            }        
            </style>
          </head>
          <body>
            <div class="">
              <header>
                <nav class="navbar navbar-expand bg-body-tertiary">
                  <ul class="navbar-nav">
                  <li class="nav-item">
                    <a class="nav-link" href="./index.html">Protokolle</a>
                    <i class="fa fa-link"></i>    </li>
                  <li class="nav-item">
                    <a class="nav-link" href="#">Beschl\xFCsse</a>
                  </li>
                  <li class="nav-item">
                    <a class="nav-link" href="https://gitlab.fachschaften.org/search?group_id=29&project_id=77&repository_ref=master&scope=blobs&search=">Suche</a>
                  </li>
                </ul>
                </nav>
              </header>
            </div>
            <div class="container mt-2 mb-2">
              <table class="table">
                <thead>
                  <tr>
                      <th>
                          Datum
                      </th>
                      <th>
                          Nummer
                      </th>
                      <th>
                          Text
                      </th>
                      <th>
                          Ja/Nein/Enth.
                      </th>
                      <th>
                          Ergebnis
                      </th>
                      <th>
                      \u2693\uFE0F
                      </th>
                  </tr>
                </thead>
                <tbody>
                  ${transcripts.map(
        (t) => t.meta.resolutions.map(
          (r) => generateResolutionRowHtml(r)
        )
      ).flat().join("\n")}
                </tbody>
              </table>
            </div>
          </body>
        </html>`;
    }
    function generateResolutionRowHtml(resolution) {
      return `<tr id="${resolution.number}">
        <td>
          ${resolution.date}
        </td>
        <td>
          <a href="./fsr-sitzung-${resolution.number.split(".")[0]}-${resolution.date}/#${resolution.number}">
            ${resolution.number}
          </a>
        </td>
        <td>
          ${resolution.text}
        </td>
        <td>
          ${resolution.votes.yes} / ${resolution.votes.no} / ${resolution.votes.abstention}
        </td>
        <td>
        ${resolution.result}
        </td>
        <td>
            <a href="#${resolution.number}">
            \u{1F517}
            </a>
        </td>
    </tr>`;
    }
    
    // src/lib/parsing.ts
    var markdownParser = (0, import_markdown_it.default)({
      html: true,
      xhtmlOut: true,
      breaks: true,
      linkify: true,
      typographer: true
    }).use(import_markdown_it_bracketed_spans.default).use(import_markdown_it_attrs.default).use(import_markdown_it_emoji.default).use(import_markdown_it_footnote.default).use(import_markdown_it_abbr.default).use(import_markdown_it_deflist.default).use(import_markdown_it_ins.default).use(import_markdown_it_mark.default).use(import_markdown_it_sub.default).use(import_markdown_it_sup.default).use(import_markdown_it_container.default);
    markdownParser.linkify.set({ fuzzyEmail: false });
    function parse2(markdown) {
      let { data, content } = (0, import_gray_matter.default)(markdown, { language: "yaml" });
      const startOfEndBlock = content.indexOf("---\nend:");
      if (startOfEndBlock > -1) {
        const endData = (0, import_gray_matter.default)(content.slice(startOfEndBlock), {
          language: "yaml"
        }).data;
        data = { ...data, ...endData };
        content = content.replace(/---\nend:.+?\n---/m, "");
      }
      const { warnings, errors } = getMetadataProblems(data);
      if (errors.length > 0) {
        throw errors.join("\n");
      }
      const markdownAstTokens = markdownParser.parse(content, {});
      const nextResoNumbers = {
        B: 1,
        F: 1,
        P: 1
      };
      const resolutions = [];
      for (let tokenIdx = 0; tokenIdx < markdownAstTokens.length; tokenIdx++) {
        const token = markdownAstTokens[tokenIdx];
        if (token.type === "inline" && token.children?.[0]?.type === "span_open") {
          const resolution = extractResolution(token);
          if (resolution) {
            resolution.number = data.number + "." + nextResoNumbers[resolution.type] + resolution.type;
            nextResoNumbers[resolution.type] += 1;
            resolution.date = data.date;
            const resolutionToken = new import_token.default("html_block", "div", 0);
            resolutionToken.content = renderResolutionToHtml(resolution);
            markdownAstTokens[tokenIdx] = resolutionToken;
            resolutions.push(resolution);
          }
        }
        if (token.type === "heading_open") {
        }
      }
      data.resolutions = resolutions;
      const renderedHtml = markdownParser.renderer.render(
        markdownAstTokens,
        markdownParser.options,
        {}
      );
      return {
        meta: data,
        html: renderedHtml,
        ast: markdownAstTokens
      };
    }
    function extractResolution(token) {
      if (!Array.isArray(token?.children) || token.children.length < 1) {
        throw TypeError(
          "Resolution parsing requires an inline span with at least one child"
        );
      }
      const spanAttributes = new Map(token.children[0].attrs);
      if (!spanAttributes.get("class")?.split(" ")?.includes("resolution")) {
        return null;
      }
      let type = "B";
      if (spanAttributes.get("class")?.split(" ")?.includes("fin")) {
        type = "F";
      } else if (spanAttributes.get("class")?.split(" ")?.includes("transcript")) {
        type = "P";
      }
      const rawYes = spanAttributes.get("yes")?.trim();
      let yes = NaN;
      if (!rawYes || typeof rawYes !== "string" || rawYes.length === 0) {
        throw new TypeError(
          "Beschluss muss ein `yes`-Attribut (Ja-Stimmen) enthalten"
        );
      }
      yes = parseInt(rawYes, 10);
      const rawNo = spanAttributes.get("no")?.trim();
      let no = NaN;
      if (!rawNo || typeof rawNo !== "string" || rawNo.length === 0) {
        throw new TypeError(
          "Beschluss muss ein `no`-Attribut (Nein-Stimmen) enthalten"
        );
      }
      no = parseInt(rawNo, 10);
      const rawAbstention = spanAttributes.get("abstention")?.trim();
      let abstention = NaN;
      if (!rawAbstention || typeof rawAbstention !== "string" || rawAbstention.length === 0) {
        throw new TypeError(
          "Beschluss muss ein `abstention`-Attribut (Enhaltungen) enthalten"
        );
      }
      abstention = parseInt(rawAbstention, 10);
      const rawResult = spanAttributes.get("result")?.trim();
      let result = "";
      if (!rawResult || typeof rawResult !== "string" || rawResult.length === 0) {
        throw new TypeError(
          "Beschluss muss ein `result`-Attribut (Ergebnis, 'Angenommen' oder 'Abgelehnt') enthalten"
        );
      }
      result = rawResult;
      const rawMoneyGranted = spanAttributes.get("money-granted")?.trim();
      let moneyGranted = void 0;
      if (!rawMoneyGranted || typeof rawMoneyGranted !== "string" || rawMoneyGranted.length === 0) {
      } else if (rawMoneyGranted.split(",").length === 2) {
        moneyGranted = rawMoneyGranted;
      }
      const resolutionText = token.children.filter((token2) => token2.type === "text").map((token2) => token2.content).join(" ").trim();
      return {
        date: "",
        number: "???",
        type,
        result,
        text: resolutionText,
        votes: {
          yes,
          no,
          abstention
        },
        money_granted: moneyGranted
      };
    }
    
    // src/css/bootstrap.min.css.ts
    var bootstrap = `@charset "UTF-8";/*!
     * Bootstrap  v5.3.0 (https://getbootstrap.com/)
     * Copyright 2011-2023 The Bootstrap Authors
     * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
     */:root,[data-bs-theme=light]{--bs-blue:#0d6efd;--bs-indigo:#6610f2;--bs-purple:#6f42c1;--bs-pink:#d63384;--bs-red:#dc3545;--bs-orange:#fd7e14;--bs-yellow:#ffc107;--bs-green:#198754;--bs-teal:#20c997;--bs-cyan:#0dcaf0;--bs-black:#000;--bs-white:#fff;--bs-gray:#6c757d;--bs-gray-dark:#343a40;--bs-gray-100:#f8f9fa;--bs-gray-200:#e9ecef;--bs-gray-300:#dee2e6;--bs-gray-400:#ced4da;--bs-gray-500:#adb5bd;--bs-gray-600:#6c757d;--bs-gray-700:#495057;--bs-gray-800:#343a40;--bs-gray-900:#212529;--bs-primary:#0d6efd;--bs-secondary:#6c757d;--bs-success:#198754;--bs-info:#0dcaf0;--bs-warning:#ffc107;--bs-danger:#dc3545;--bs-light:#f8f9fa;--bs-dark:#212529;--bs-primary-rgb:13,110,253;--bs-secondary-rgb:108,117,125;--bs-success-rgb:25,135,84;--bs-info-rgb:13,202,240;--bs-warning-rgb:255,193,7;--bs-danger-rgb:220,53,69;--bs-light-rgb:248,249,250;--bs-dark-rgb:33,37,41;--bs-primary-text-emphasis:#052c65;--bs-secondary-text-emphasis:#2b2f32;--bs-success-text-emphasis:#0a3622;--bs-info-text-emphasis:#055160;--bs-warning-text-emphasis:#664d03;--bs-danger-text-emphasis:#58151c;--bs-light-text-emphasis:#495057;--bs-dark-text-emphasis:#495057;--bs-primary-bg-subtle:#cfe2ff;--bs-secondary-bg-subtle:#e2e3e5;--bs-success-bg-subtle:#d1e7dd;--bs-info-bg-subtle:#cff4fc;--bs-warning-bg-subtle:#fff3cd;--bs-danger-bg-subtle:#f8d7da;--bs-light-bg-subtle:#fcfcfd;--bs-dark-bg-subtle:#ced4da;--bs-primary-border-subtle:#9ec5fe;--bs-secondary-border-subtle:#c4c8cb;--bs-success-border-subtle:#a3cfbb;--bs-info-border-subtle:#9eeaf9;--bs-warning-border-subtle:#ffe69c;--bs-danger-border-subtle:#f1aeb5;--bs-light-border-subtle:#e9ecef;--bs-dark-border-subtle:#adb5bd;--bs-white-rgb:255,255,255;--bs-black-rgb:0,0,0;--bs-font-sans-serif:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue","Noto Sans","Liberation Sans",Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--bs-font-monospace:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;--bs-gradient:linear-gradient(180deg, rgba(255, 255, 255, 0.15), rgba(255, 255, 255, 0));--bs-body-font-family:var(--bs-font-sans-serif);--bs-body-font-size:1rem;--bs-body-font-weight:400;--bs-body-line-height:1.5;--bs-body-color:#212529;--bs-body-color-rgb:33,37,41;--bs-body-bg:#fff;--bs-body-bg-rgb:255,255,255;--bs-emphasis-color:#000;--bs-emphasis-color-rgb:0,0,0;--bs-secondary-color:rgba(33, 37, 41, 0.75);--bs-secondary-color-rgb:33,37,41;--bs-secondary-bg:#e9ecef;--bs-secondary-bg-rgb:233,236,239;--bs-tertiary-color:rgba(33, 37, 41, 0.5);--bs-tertiary-color-rgb:33,37,41;--bs-tertiary-bg:#f8f9fa;--bs-tertiary-bg-rgb:248,249,250;--bs-heading-color:inherit;--bs-link-color:#0d6efd;--bs-link-color-rgb:13,110,253;--bs-link-decoration:underline;--bs-link-hover-color:#0a58ca;--bs-link-hover-color-rgb:10,88,202;--bs-code-color:#d63384;--bs-highlight-bg:#fff3cd;--bs-border-width:1px;--bs-border-style:solid;--bs-border-color:#dee2e6;--bs-border-color-translucent:rgba(0, 0, 0, 0.175);--bs-border-radius:0.375rem;--bs-border-radius-sm:0.25rem;--bs-border-radius-lg:0.5rem;--bs-border-radius-xl:1rem;--bs-border-radius-xxl:2rem;--bs-border-radius-2xl:var(--bs-border-radius-xxl);--bs-border-radius-pill:50rem;--bs-box-shadow:0 0.5rem 1rem rgba(0, 0, 0, 0.15);--bs-box-shadow-sm:0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);--bs-box-shadow-lg:0 1rem 3rem rgba(0, 0, 0, 0.175);--bs-box-shadow-inset:inset 0 1px 2px rgba(0, 0, 0, 0.075);--bs-focus-ring-width:0.25rem;--bs-focus-ring-opacity:0.25;--bs-focus-ring-color:rgba(13, 110, 253, 0.25);--bs-form-valid-color:#198754;--bs-form-valid-border-color:#198754;--bs-form-invalid-color:#dc3545;--bs-form-invalid-border-color:#dc3545}[data-bs-theme=dark]{color-scheme:dark;--bs-body-color:#adb5bd;--bs-body-color-rgb:173,181,189;--bs-body-bg:#212529;--bs-body-bg-rgb:33,37,41;--bs-emphasis-color:#fff;--bs-emphasis-color-rgb:255,255,255;--bs-secondary-color:rgba(173, 181, 189, 0.75);--bs-secondary-color-rgb:173,181,189;--bs-secondary-bg:#343a40;--bs-secondary-bg-rgb:52,58,64;--bs-tertiary-color:rgba(173, 181, 189, 0.5);--bs-tertiary-color-rgb:173,181,189;--bs-tertiary-bg:#2b3035;--bs-tertiary-bg-rgb:43,48,53;--bs-primary-text-emphasis:#6ea8fe;--bs-secondary-text-emphasis:#a7acb1;--bs-success-text-emphasis:#75b798;--bs-info-text-emphasis:#6edff6;--bs-warning-text-emphasis:#ffda6a;--bs-danger-text-emphasis:#ea868f;--bs-light-text-emphasis:#f8f9fa;--bs-dark-text-emphasis:#dee2e6;--bs-primary-bg-subtle:#031633;--bs-secondary-bg-subtle:#161719;--bs-success-bg-subtle:#051b11;--bs-info-bg-subtle:#032830;--bs-warning-bg-subtle:#332701;--bs-danger-bg-subtle:#2c0b0e;--bs-light-bg-subtle:#343a40;--bs-dark-bg-subtle:#1a1d20;--bs-primary-border-subtle:#084298;--bs-secondary-border-subtle:#41464b;--bs-success-border-subtle:#0f5132;--bs-info-border-subtle:#087990;--bs-warning-border-subtle:#997404;--bs-danger-border-subtle:#842029;--bs-light-border-subtle:#495057;--bs-dark-border-subtle:#343a40;--bs-heading-color:inherit;--bs-link-color:#6ea8fe;--bs-link-hover-color:#8bb9fe;--bs-link-color-rgb:110,168,254;--bs-link-hover-color-rgb:139,185,254;--bs-code-color:#e685b5;--bs-border-color:#495057;--bs-border-color-translucent:rgba(255, 255, 255, 0.15);--bs-form-valid-color:#75b798;--bs-form-valid-border-color:#75b798;--bs-form-invalid-color:#ea868f;--bs-form-invalid-border-color:#ea868f}*,::after,::before{box-sizing:border-box}@media (prefers-reduced-motion:no-preference){:root{scroll-behavior:smooth}}body{margin:0;font-family:var(--bs-body-font-family);font-size:var(--bs-body-font-size);font-weight:var(--bs-body-font-weight);line-height:var(--bs-body-line-height);color:var(--bs-body-color);text-align:var(--bs-body-text-align);background-color:var(--bs-body-bg);-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:transparent}hr{margin:1rem 0;color:inherit;border:0;border-top:var(--bs-border-width) solid;opacity:.25}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem;font-weight:500;line-height:1.2;color:var(--bs-heading-color)}.h1,h1{font-size:calc(1.375rem + 1.5vw)}@media (min-width:1200px){.h1,h1{font-size:2.5rem}}.h2,h2{font-size:calc(1.325rem + .9vw)}@media (min-width:1200px){.h2,h2{font-size:2rem}}.h3,h3{font-size:calc(1.3rem + .6vw)}@media (min-width:1200px){.h3,h3{font-size:1.75rem}}.h4,h4{font-size:calc(1.275rem + .3vw)}@media (min-width:1200px){.h4,h4{font-size:1.5rem}}.h5,h5{font-size:1.25rem}.h6,h6{font-size:1rem}p{margin-top:0;margin-bottom:1rem}abbr[title]{-webkit-text-decoration:underline dotted;text-decoration:underline dotted;cursor:help;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{margin-bottom:1rem;font-style:normal;line-height:inherit}ol,ul{padding-left:2rem}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}.small,small{font-size:.875em}.mark,mark{padding:.1875em;background-color:var(--bs-highlight-bg)}sub,sup{position:relative;font-size:.75em;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:rgba(var(--bs-link-color-rgb),var(--bs-link-opacity,1));text-decoration:underline}a:hover{--bs-link-color-rgb:var(--bs-link-hover-color-rgb)}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:var(--bs-font-monospace);font-size:1em}pre{display:block;margin-top:0;margin-bottom:1rem;overflow:auto;font-size:.875em}pre code{font-size:inherit;color:inherit;word-break:normal}code{font-size:.875em;color:var(--bs-code-color);word-wrap:break-word}a>code{color:inherit}kbd{padding:.1875rem .375rem;font-size:.875em;color:var(--bs-body-bg);background-color:var(--bs-body-color);border-radius:.25rem}kbd kbd{padding:0;font-size:1em}figure{margin:0 0 1rem}img,svg{vertical-align:middle}table{caption-side:bottom;border-collapse:collapse}caption{padding-top:.5rem;padding-bottom:.5rem;color:var(--bs-secondary-color);text-align:left}th{text-align:inherit;text-align:-webkit-match-parent}tbody,td,tfoot,th,thead,tr{border-color:inherit;border-style:solid;border-width:0}label{display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}select:disabled{opacity:1}[list]:not([type=date]):not([type=datetime-local]):not([type=month]):not([type=week]):not([type=time])::-webkit-calendar-picker-indicator{display:none!important}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}::-moz-focus-inner{padding:0;border-style:none}textarea{resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{float:left;width:100%;padding:0;margin-bottom:.5rem;font-size:calc(1.275rem + .3vw);line-height:inherit}@media (min-width:1200px){legend{font-size:1.5rem}}legend+*{clear:left}::-webkit-datetime-edit-day-field,::-webkit-datetime-edit-fields-wrapper,::-webkit-datetime-edit-hour-field,::-webkit-datetime-edit-minute,::-webkit-datetime-edit-month-field,::-webkit-datetime-edit-text,::-webkit-datetime-edit-year-field{padding:0}::-webkit-inner-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:textfield}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-color-swatch-wrapper{padding:0}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}::file-selector-button{font:inherit;-webkit-appearance:button}output{display:inline-block}iframe{border:0}summary{display:list-item;cursor:pointer}progress{vertical-align:baseline}[hidden]{display:none!important}.lead{font-size:1.25rem;font-weight:300}.display-1{font-size:calc(1.625rem + 4.5vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-1{font-size:5rem}}.display-2{font-size:calc(1.575rem + 3.9vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-2{font-size:4.5rem}}.display-3{font-size:calc(1.525rem + 3.3vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-3{font-size:4rem}}.display-4{font-size:calc(1.475rem + 2.7vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-4{font-size:3.5rem}}.display-5{font-size:calc(1.425rem + 2.1vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-5{font-size:3rem}}.display-6{font-size:calc(1.375rem + 1.5vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-6{font-size:2.5rem}}.list-unstyled{padding-left:0;list-style:none}.list-inline{padding-left:0;list-style:none}.list-inline-item{display:inline-block}.list-inline-item:not(:last-child){margin-right:.5rem}.initialism{font-size:.875em;text-transform:uppercase}.blockquote{margin-bottom:1rem;font-size:1.25rem}.blockquote>:last-child{margin-bottom:0}.blockquote-footer{margin-top:-1rem;margin-bottom:1rem;font-size:.875em;color:#6c757d}.blockquote-footer::before{content:"\u2014\xA0"}.img-fluid{max-width:100%;height:auto}.img-thumbnail{padding:.25rem;background-color:var(--bs-body-bg);border:var(--bs-border-width) solid var(--bs-border-color);border-radius:var(--bs-border-radius);max-width:100%;height:auto}.figure{display:inline-block}.figure-img{margin-bottom:.5rem;line-height:1}.figure-caption{font-size:.875em;color:var(--bs-secondary-color)}.container,.container-fluid,.container-lg,.container-md,.container-sm,.container-xl,.container-xxl{--bs-gutter-x:1.5rem;--bs-gutter-y:0;width:100%;padding-right:calc(var(--bs-gutter-x) * .5);padding-left:calc(var(--bs-gutter-x) * .5);margin-right:auto;margin-left:auto}@media (min-width:576px){.container,.container-sm{max-width:540px}}@media (min-width:768px){.container,.container-md,.container-sm{max-width:720px}}@media (min-width:992px){.container,.container-lg,.container-md,.container-sm{max-width:960px}}@media (min-width:1200px){.container,.container-lg,.container-md,.container-sm,.container-xl{max-width:1140px}}@media (min-width:1400px){.container,.container-lg,.container-md,.container-sm,.container-xl,.container-xxl{max-width:1320px}}:root{--bs-breakpoint-xs:0;--bs-breakpoint-sm:576px;--bs-breakpoint-md:768px;--bs-breakpoint-lg:992px;--bs-breakpoint-xl:1200px;--bs-breakpoint-xxl:1400px}.row{--bs-gutter-x:1.5rem;--bs-gutter-y:0;display:flex;flex-wrap:wrap;margin-top:calc(-1 * var(--bs-gutter-y));margin-right:calc(-.5 * var(--bs-gutter-x));margin-left:calc(-.5 * var(--bs-gutter-x))}.row>*{flex-shrink:0;width:100%;max-width:100%;padding-right:calc(var(--bs-gutter-x) * .5);padding-left:calc(var(--bs-gutter-x) * .5);margin-top:var(--bs-gutter-y)}.col{flex:1 0 0%}.row-cols-auto>*{flex:0 0 auto;width:auto}.row-cols-1>*{flex:0 0 auto;width:100%}.row-cols-2>*{flex:0 0 auto;width:50%}.row-cols-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-4>*{flex:0 0 auto;width:25%}.row-cols-5>*{flex:0 0 auto;width:20%}.row-cols-6>*{flex:0 0 auto;width:16.6666666667%}.col-auto{flex:0 0 auto;width:auto}.col-1{flex:0 0 auto;width:8.33333333%}.col-2{flex:0 0 auto;width:16.66666667%}.col-3{flex:0 0 auto;width:25%}.col-4{flex:0 0 auto;width:33.33333333%}.col-5{flex:0 0 auto;width:41.66666667%}.col-6{flex:0 0 auto;width:50%}.col-7{flex:0 0 auto;width:58.33333333%}.col-8{flex:0 0 auto;width:66.66666667%}.col-9{flex:0 0 auto;width:75%}.col-10{flex:0 0 auto;width:83.33333333%}.col-11{flex:0 0 auto;width:91.66666667%}.col-12{flex:0 0 auto;width:100%}.offset-1{margin-left:8.33333333%}.offset-2{margin-left:16.66666667%}.offset-3{margin-left:25%}.offset-4{margin-left:33.33333333%}.offset-5{margin-left:41.66666667%}.offset-6{margin-left:50%}.offset-7{margin-left:58.33333333%}.offset-8{margin-left:66.66666667%}.offset-9{margin-left:75%}.offset-10{margin-left:83.33333333%}.offset-11{margin-left:91.66666667%}.g-0,.gx-0{--bs-gutter-x:0}.g-0,.gy-0{--bs-gutter-y:0}.g-1,.gx-1{--bs-gutter-x:0.25rem}.g-1,.gy-1{--bs-gutter-y:0.25rem}.g-2,.gx-2{--bs-gutter-x:0.5rem}.g-2,.gy-2{--bs-gutter-y:0.5rem}.g-3,.gx-3{--bs-gutter-x:1rem}.g-3,.gy-3{--bs-gutter-y:1rem}.g-4,.gx-4{--bs-gutter-x:1.5rem}.g-4,.gy-4{--bs-gutter-y:1.5rem}.g-5,.gx-5{--bs-gutter-x:3rem}.g-5,.gy-5{--bs-gutter-y:3rem}@media (min-width:576px){.col-sm{flex:1 0 0%}.row-cols-sm-auto>*{flex:0 0 auto;width:auto}.row-cols-sm-1>*{flex:0 0 auto;width:100%}.row-cols-sm-2>*{flex:0 0 auto;width:50%}.row-cols-sm-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-sm-4>*{flex:0 0 auto;width:25%}.row-cols-sm-5>*{flex:0 0 auto;width:20%}.row-cols-sm-6>*{flex:0 0 auto;width:16.6666666667%}.col-sm-auto{flex:0 0 auto;width:auto}.col-sm-1{flex:0 0 auto;width:8.33333333%}.col-sm-2{flex:0 0 auto;width:16.66666667%}.col-sm-3{flex:0 0 auto;width:25%}.col-sm-4{flex:0 0 auto;width:33.33333333%}.col-sm-5{flex:0 0 auto;width:41.66666667%}.col-sm-6{flex:0 0 auto;width:50%}.col-sm-7{flex:0 0 auto;width:58.33333333%}.col-sm-8{flex:0 0 auto;width:66.66666667%}.col-sm-9{flex:0 0 auto;width:75%}.col-sm-10{flex:0 0 auto;width:83.33333333%}.col-sm-11{flex:0 0 auto;width:91.66666667%}.col-sm-12{flex:0 0 auto;width:100%}.offset-sm-0{margin-left:0}.offset-sm-1{margin-left:8.33333333%}.offset-sm-2{margin-left:16.66666667%}.offset-sm-3{margin-left:25%}.offset-sm-4{margin-left:33.33333333%}.offset-sm-5{margin-left:41.66666667%}.offset-sm-6{margin-left:50%}.offset-sm-7{margin-left:58.33333333%}.offset-sm-8{margin-left:66.66666667%}.offset-sm-9{margin-left:75%}.offset-sm-10{margin-left:83.33333333%}.offset-sm-11{margin-left:91.66666667%}.g-sm-0,.gx-sm-0{--bs-gutter-x:0}.g-sm-0,.gy-sm-0{--bs-gutter-y:0}.g-sm-1,.gx-sm-1{--bs-gutter-x:0.25rem}.g-sm-1,.gy-sm-1{--bs-gutter-y:0.25rem}.g-sm-2,.gx-sm-2{--bs-gutter-x:0.5rem}.g-sm-2,.gy-sm-2{--bs-gutter-y:0.5rem}.g-sm-3,.gx-sm-3{--bs-gutter-x:1rem}.g-sm-3,.gy-sm-3{--bs-gutter-y:1rem}.g-sm-4,.gx-sm-4{--bs-gutter-x:1.5rem}.g-sm-4,.gy-sm-4{--bs-gutter-y:1.5rem}.g-sm-5,.gx-sm-5{--bs-gutter-x:3rem}.g-sm-5,.gy-sm-5{--bs-gutter-y:3rem}}@media (min-width:768px){.col-md{flex:1 0 0%}.row-cols-md-auto>*{flex:0 0 auto;width:auto}.row-cols-md-1>*{flex:0 0 auto;width:100%}.row-cols-md-2>*{flex:0 0 auto;width:50%}.row-cols-md-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-md-4>*{flex:0 0 auto;width:25%}.row-cols-md-5>*{flex:0 0 auto;width:20%}.row-cols-md-6>*{flex:0 0 auto;width:16.6666666667%}.col-md-auto{flex:0 0 auto;width:auto}.col-md-1{flex:0 0 auto;width:8.33333333%}.col-md-2{flex:0 0 auto;width:16.66666667%}.col-md-3{flex:0 0 auto;width:25%}.col-md-4{flex:0 0 auto;width:33.33333333%}.col-md-5{flex:0 0 auto;width:41.66666667%}.col-md-6{flex:0 0 auto;width:50%}.col-md-7{flex:0 0 auto;width:58.33333333%}.col-md-8{flex:0 0 auto;width:66.66666667%}.col-md-9{flex:0 0 auto;width:75%}.col-md-10{flex:0 0 auto;width:83.33333333%}.col-md-11{flex:0 0 auto;width:91.66666667%}.col-md-12{flex:0 0 auto;width:100%}.offset-md-0{margin-left:0}.offset-md-1{margin-left:8.33333333%}.offset-md-2{margin-left:16.66666667%}.offset-md-3{margin-left:25%}.offset-md-4{margin-left:33.33333333%}.offset-md-5{margin-left:41.66666667%}.offset-md-6{margin-left:50%}.offset-md-7{margin-left:58.33333333%}.offset-md-8{margin-left:66.66666667%}.offset-md-9{margin-left:75%}.offset-md-10{margin-left:83.33333333%}.offset-md-11{margin-left:91.66666667%}.g-md-0,.gx-md-0{--bs-gutter-x:0}.g-md-0,.gy-md-0{--bs-gutter-y:0}.g-md-1,.gx-md-1{--bs-gutter-x:0.25rem}.g-md-1,.gy-md-1{--bs-gutter-y:0.25rem}.g-md-2,.gx-md-2{--bs-gutter-x:0.5rem}.g-md-2,.gy-md-2{--bs-gutter-y:0.5rem}.g-md-3,.gx-md-3{--bs-gutter-x:1rem}.g-md-3,.gy-md-3{--bs-gutter-y:1rem}.g-md-4,.gx-md-4{--bs-gutter-x:1.5rem}.g-md-4,.gy-md-4{--bs-gutter-y:1.5rem}.g-md-5,.gx-md-5{--bs-gutter-x:3rem}.g-md-5,.gy-md-5{--bs-gutter-y:3rem}}@media (min-width:992px){.col-lg{flex:1 0 0%}.row-cols-lg-auto>*{flex:0 0 auto;width:auto}.row-cols-lg-1>*{flex:0 0 auto;width:100%}.row-cols-lg-2>*{flex:0 0 auto;width:50%}.row-cols-lg-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-lg-4>*{flex:0 0 auto;width:25%}.row-cols-lg-5>*{flex:0 0 auto;width:20%}.row-cols-lg-6>*{flex:0 0 auto;width:16.6666666667%}.col-lg-auto{flex:0 0 auto;width:auto}.col-lg-1{flex:0 0 auto;width:8.33333333%}.col-lg-2{flex:0 0 auto;width:16.66666667%}.col-lg-3{flex:0 0 auto;width:25%}.col-lg-4{flex:0 0 auto;width:33.33333333%}.col-lg-5{flex:0 0 auto;width:41.66666667%}.col-lg-6{flex:0 0 auto;width:50%}.col-lg-7{flex:0 0 auto;width:58.33333333%}.col-lg-8{flex:0 0 auto;width:66.66666667%}.col-lg-9{flex:0 0 auto;width:75%}.col-lg-10{flex:0 0 auto;width:83.33333333%}.col-lg-11{flex:0 0 auto;width:91.66666667%}.col-lg-12{flex:0 0 auto;width:100%}.offset-lg-0{margin-left:0}.offset-lg-1{margin-left:8.33333333%}.offset-lg-2{margin-left:16.66666667%}.offset-lg-3{margin-left:25%}.offset-lg-4{margin-left:33.33333333%}.offset-lg-5{margin-left:41.66666667%}.offset-lg-6{margin-left:50%}.offset-lg-7{margin-left:58.33333333%}.offset-lg-8{margin-left:66.66666667%}.offset-lg-9{margin-left:75%}.offset-lg-10{margin-left:83.33333333%}.offset-lg-11{margin-left:91.66666667%}.g-lg-0,.gx-lg-0{--bs-gutter-x:0}.g-lg-0,.gy-lg-0{--bs-gutter-y:0}.g-lg-1,.gx-lg-1{--bs-gutter-x:0.25rem}.g-lg-1,.gy-lg-1{--bs-gutter-y:0.25rem}.g-lg-2,.gx-lg-2{--bs-gutter-x:0.5rem}.g-lg-2,.gy-lg-2{--bs-gutter-y:0.5rem}.g-lg-3,.gx-lg-3{--bs-gutter-x:1rem}.g-lg-3,.gy-lg-3{--bs-gutter-y:1rem}.g-lg-4,.gx-lg-4{--bs-gutter-x:1.5rem}.g-lg-4,.gy-lg-4{--bs-gutter-y:1.5rem}.g-lg-5,.gx-lg-5{--bs-gutter-x:3rem}.g-lg-5,.gy-lg-5{--bs-gutter-y:3rem}}@media (min-width:1200px){.col-xl{flex:1 0 0%}.row-cols-xl-auto>*{flex:0 0 auto;width:auto}.row-cols-xl-1>*{flex:0 0 auto;width:100%}.row-cols-xl-2>*{flex:0 0 auto;width:50%}.row-cols-xl-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-xl-4>*{flex:0 0 auto;width:25%}.row-cols-xl-5>*{flex:0 0 auto;width:20%}.row-cols-xl-6>*{flex:0 0 auto;width:16.6666666667%}.col-xl-auto{flex:0 0 auto;width:auto}.col-xl-1{flex:0 0 auto;width:8.33333333%}.col-xl-2{flex:0 0 auto;width:16.66666667%}.col-xl-3{flex:0 0 auto;width:25%}.col-xl-4{flex:0 0 auto;width:33.33333333%}.col-xl-5{flex:0 0 auto;width:41.66666667%}.col-xl-6{flex:0 0 auto;width:50%}.col-xl-7{flex:0 0 auto;width:58.33333333%}.col-xl-8{flex:0 0 auto;width:66.66666667%}.col-xl-9{flex:0 0 auto;width:75%}.col-xl-10{flex:0 0 auto;width:83.33333333%}.col-xl-11{flex:0 0 auto;width:91.66666667%}.col-xl-12{flex:0 0 auto;width:100%}.offset-xl-0{margin-left:0}.offset-xl-1{margin-left:8.33333333%}.offset-xl-2{margin-left:16.66666667%}.offset-xl-3{margin-left:25%}.offset-xl-4{margin-left:33.33333333%}.offset-xl-5{margin-left:41.66666667%}.offset-xl-6{margin-left:50%}.offset-xl-7{margin-left:58.33333333%}.offset-xl-8{margin-left:66.66666667%}.offset-xl-9{margin-left:75%}.offset-xl-10{margin-left:83.33333333%}.offset-xl-11{margin-left:91.66666667%}.g-xl-0,.gx-xl-0{--bs-gutter-x:0}.g-xl-0,.gy-xl-0{--bs-gutter-y:0}.g-xl-1,.gx-xl-1{--bs-gutter-x:0.25rem}.g-xl-1,.gy-xl-1{--bs-gutter-y:0.25rem}.g-xl-2,.gx-xl-2{--bs-gutter-x:0.5rem}.g-xl-2,.gy-xl-2{--bs-gutter-y:0.5rem}.g-xl-3,.gx-xl-3{--bs-gutter-x:1rem}.g-xl-3,.gy-xl-3{--bs-gutter-y:1rem}.g-xl-4,.gx-xl-4{--bs-gutter-x:1.5rem}.g-xl-4,.gy-xl-4{--bs-gutter-y:1.5rem}.g-xl-5,.gx-xl-5{--bs-gutter-x:3rem}.g-xl-5,.gy-xl-5{--bs-gutter-y:3rem}}@media (min-width:1400px){.col-xxl{flex:1 0 0%}.row-cols-xxl-auto>*{flex:0 0 auto;width:auto}.row-cols-xxl-1>*{flex:0 0 auto;width:100%}.row-cols-xxl-2>*{flex:0 0 auto;width:50%}.row-cols-xxl-3>*{flex:0 0 auto;width:33.3333333333%}.row-cols-xxl-4>*{flex:0 0 auto;width:25%}.row-cols-xxl-5>*{flex:0 0 auto;width:20%}.row-cols-xxl-6>*{flex:0 0 auto;width:16.6666666667%}.col-xxl-auto{flex:0 0 auto;width:auto}.col-xxl-1{flex:0 0 auto;width:8.33333333%}.col-xxl-2{flex:0 0 auto;width:16.66666667%}.col-xxl-3{flex:0 0 auto;width:25%}.col-xxl-4{flex:0 0 auto;width:33.33333333%}.col-xxl-5{flex:0 0 auto;width:41.66666667%}.col-xxl-6{flex:0 0 auto;width:50%}.col-xxl-7{flex:0 0 auto;width:58.33333333%}.col-xxl-8{flex:0 0 auto;width:66.66666667%}.col-xxl-9{flex:0 0 auto;width:75%}.col-xxl-10{flex:0 0 auto;width:83.33333333%}.col-xxl-11{flex:0 0 auto;width:91.66666667%}.col-xxl-12{flex:0 0 auto;width:100%}.offset-xxl-0{margin-left:0}.offset-xxl-1{margin-left:8.33333333%}.offset-xxl-2{margin-left:16.66666667%}.offset-xxl-3{margin-left:25%}.offset-xxl-4{margin-left:33.33333333%}.offset-xxl-5{margin-left:41.66666667%}.offset-xxl-6{margin-left:50%}.offset-xxl-7{margin-left:58.33333333%}.offset-xxl-8{margin-left:66.66666667%}.offset-xxl-9{margin-left:75%}.offset-xxl-10{margin-left:83.33333333%}.offset-xxl-11{margin-left:91.66666667%}.g-xxl-0,.gx-xxl-0{--bs-gutter-x:0}.g-xxl-0,.gy-xxl-0{--bs-gutter-y:0}.g-xxl-1,.gx-xxl-1{--bs-gutter-x:0.25rem}.g-xxl-1,.gy-xxl-1{--bs-gutter-y:0.25rem}.g-xxl-2,.gx-xxl-2{--bs-gutter-x:0.5rem}.g-xxl-2,.gy-xxl-2{--bs-gutter-y:0.5rem}.g-xxl-3,.gx-xxl-3{--bs-gutter-x:1rem}.g-xxl-3,.gy-xxl-3{--bs-gutter-y:1rem}.g-xxl-4,.gx-xxl-4{--bs-gutter-x:1.5rem}.g-xxl-4,.gy-xxl-4{--bs-gutter-y:1.5rem}.g-xxl-5,.gx-xxl-5{--bs-gutter-x:3rem}.g-xxl-5,.gy-xxl-5{--bs-gutter-y:3rem}}.table{--bs-table-color-type:initial;--bs-table-bg-type:initial;--bs-table-color-state:initial;--bs-table-bg-state:initial;--bs-table-color:var(--bs-body-color);--bs-table-bg:var(--bs-body-bg);--bs-table-border-color:var(--bs-border-color);--bs-table-accent-bg:transparent;--bs-table-striped-color:var(--bs-body-color);--bs-table-striped-bg:rgba(0, 0, 0, 0.05);--bs-table-active-color:var(--bs-body-color);--bs-table-active-bg:rgba(0, 0, 0, 0.1);--bs-table-hover-color:var(--bs-body-color);--bs-table-hover-bg:rgba(0, 0, 0, 0.075);width:100%;margin-bottom:1rem;vertical-align:top;border-color:var(--bs-table-border-color)}.table>:not(caption)>*>*{padding:.5rem .5rem;color:var(--bs-table-color-state,var(--bs-table-color-type,var(--bs-table-color)));background-color:var(--bs-table-bg);border-bottom-width:var(--bs-border-width);box-shadow:inset 0 0 0 9999px var(--bs-table-bg-state,var(--bs-table-bg-type,var(--bs-table-accent-bg)))}.table>tbody{vertical-align:inherit}.table>thead{vertical-align:bottom}.table-group-divider{border-top:calc(var(--bs-border-width) * 2) solid currentcolor}.caption-top{caption-side:top}.table-sm>:not(caption)>*>*{padding:.25rem .25rem}.table-bordered>:not(caption)>*{border-width:var(--bs-border-width) 0}.table-bordered>:not(caption)>*>*{border-width:0 var(--bs-border-width)}.table-borderless>:not(caption)>*>*{border-bottom-width:0}.table-borderless>:not(:first-child){border-top-width:0}.table-striped>tbody>tr:nth-of-type(odd)>*{--bs-table-color-type:var(--bs-table-striped-color);--bs-table-bg-type:var(--bs-table-striped-bg)}.table-striped-columns>:not(caption)>tr>:nth-child(2n){--bs-table-color-type:var(--bs-table-striped-color);--bs-table-bg-type:var(--bs-table-striped-bg)}.table-active{--bs-table-color-state:var(--bs-table-active-color);--bs-table-bg-state:var(--bs-table-active-bg)}.table-hover>tbody>tr:hover>*{--bs-table-color-state:var(--bs-table-hover-color);--bs-table-bg-state:var(--bs-table-hover-bg)}.table-primary{--bs-table-color:#000;--bs-table-bg:#cfe2ff;--bs-table-border-color:#bacbe6;--bs-table-striped-bg:#c5d7f2;--bs-table-striped-color:#000;--bs-table-active-bg:#bacbe6;--bs-table-active-color:#000;--bs-table-hover-bg:#bfd1ec;--bs-table-hover-color:#000;color:var(--bs-table-color);border-color:var(--bs-table-border-color)}.table-secondary{--bs-table-color:#000;--bs-table-bg:#e2e3e5;--bs-table-border-color:#cbccce;--bs-table-striped-bg:#d7d8da;--bs-table-striped-color:#000;--bs-table-active-bg:#cbccce;--bs-table-active-color:#000;--bs-table-hover-bg:#d1d2d4;--bs-table-hover-color:#000;color:var(--bs-table-color);border-color:var(--bs-table-border-color)}.table-success{--bs-table-color:#000;--bs-table-bg:#d1e7dd;--bs-table-border-color:#bcd0c7;--bs-table-striped-bg:#c7dbd2;--bs-table-striped-color:#000;--bs-table-active-bg:#bcd0c7;--bs-table-active-color:#000;--bs-table-hover-bg:#c1d6cc;--bs-table-hover-color:#000;color:var(--bs-table-color);border-color:var(--bs-table-border-color)}.table-info{--bs-table-color:#000;--bs-table-bg:#cff4fc;--bs-table-border-color:#badce3;--bs-table-striped-bg:#c5e8ef;--bs-table-striped-color:#000;--bs-table-active-bg:#badce3;--bs-table-active-color:#000;--bs-table-hover-bg:#bfe2e9;--bs-table-hover-color:#000;color:var(--bs-table-color);border-color:var(--bs-table-border-color)}.table-warning{--bs-table-color:#000;--bs-table-bg:#fff3cd;--bs-table-border-color:#e6dbb9;--bs-table-striped-bg:#f2e7c3;--bs-table-striped-color:#000;--bs-table-active-bg:#e6dbb9;--bs-table-active-color:#000;--bs-table-hover-bg:#ece1be;--bs-table-hover-color:#000;color:var(--bs-table-color);border-color:var(--bs-table-border-color)}.table-danger{--bs-table-color:#000;--bs-table-bg:#f8d7da;--bs-table-border-color:#dfc2c4;--bs-table-striped-bg:#eccccf;--bs-table-striped-color:#000;--bs-table-active-bg:#dfc2c4;--bs-table-active-color:#000;--bs-table-hover-bg:#e5c7ca;--bs-table-hover-color:#000;color:var(--bs-table-color);border-color:var(--bs-table-border-color)}.table-light{--bs-table-color:#000;--bs-table-bg:#f8f9fa;--bs-table-border-color:#dfe0e1;--bs-table-striped-bg:#ecedee;--bs-table-striped-color:#000;--bs-table-active-bg:#dfe0e1;--bs-table-active-color:#000;--bs-table-hover-bg:#e5e6e7;--bs-table-hover-color:#000;color:var(--bs-table-color);border-color:var(--bs-table-border-color)}.table-dark{--bs-table-color:#fff;--bs-table-bg:#212529;--bs-table-border-color:#373b3e;--bs-table-striped-bg:#2c3034;--bs-table-striped-color:#fff;--bs-table-active-bg:#373b3e;--bs-table-active-color:#fff;--bs-table-hover-bg:#323539;--bs-table-hover-color:#fff;color:var(--bs-table-color);border-color:var(--bs-table-border-color)}.table-responsive{overflow-x:auto;-webkit-overflow-scrolling:touch}@media (max-width:575.98px){.table-responsive-sm{overflow-x:auto;-webkit-overflow-scrolling:touch}}@media (max-width:767.98px){.table-responsive-md{overflow-x:auto;-webkit-overflow-scrolling:touch}}@media (max-width:991.98px){.table-responsive-lg{overflow-x:auto;-webkit-overflow-scrolling:touch}}@media (max-width:1199.98px){.table-responsive-xl{overflow-x:auto;-webkit-overflow-scrolling:touch}}@media (max-width:1399.98px){.table-responsive-xxl{overflow-x:auto;-webkit-overflow-scrolling:touch}}.form-label{margin-bottom:.5rem}.col-form-label{padding-top:calc(.375rem + var(--bs-border-width));padding-bottom:calc(.375rem + var(--bs-border-width));margin-bottom:0;font-size:inherit;line-height:1.5}.col-form-label-lg{padding-top:calc(.5rem + var(--bs-border-width));padding-bottom:calc(.5rem + var(--bs-border-width));font-size:1.25rem}.col-form-label-sm{padding-top:calc(.25rem + var(--bs-border-width));padding-bottom:calc(.25rem + var(--bs-border-width));font-size:.875rem}.form-text{margin-top:.25rem;font-size:.875em;color:var(--bs-secondary-color)}.form-control{display:block;width:100%;padding:.375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:var(--bs-body-color);background-color:var(--bs-body-bg);background-clip:padding-box;border:var(--bs-border-width) solid var(--bs-border-color);-webkit-appearance:none;-moz-appearance:none;appearance:none;border-radius:var(--bs-border-radius);transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-control{transition:none}}.form-control[type=file]{overflow:hidden}.form-control[type=file]:not(:disabled):not([readonly]){cursor:pointer}.form-control:focus{color:var(--bs-body-color);background-color:var(--bs-body-bg);border-color:#86b7fe;outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.form-control::-webkit-date-and-time-value{min-width:85px;height:1.5em;margin:0}.form-control::-webkit-datetime-edit{display:block;padding:0}.form-control::-moz-placeholder{color:var(--bs-secondary-color);opacity:1}.form-control::placeholder{color:var(--bs-secondary-color);opacity:1}.form-control:disabled{background-color:var(--bs-secondary-bg);opacity:1}.form-control::-webkit-file-upload-button{padding:.375rem .75rem;margin:-.375rem -.75rem;-webkit-margin-end:.75rem;margin-inline-end:.75rem;color:var(--bs-body-color);background-color:var(--bs-tertiary-bg);pointer-events:none;border-color:inherit;border-style:solid;border-width:0;border-inline-end-width:var(--bs-border-width);border-radius:0;-webkit-transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}.form-control::file-selector-button{padding:.375rem .75rem;margin:-.375rem -.75rem;-webkit-margin-end:.75rem;margin-inline-end:.75rem;color:var(--bs-body-color);background-color:var(--bs-tertiary-bg);pointer-events:none;border-color:inherit;border-style:solid;border-width:0;border-inline-end-width:var(--bs-border-width);border-radius:0;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-control::-webkit-file-upload-button{-webkit-transition:none;transition:none}.form-control::file-selector-button{transition:none}}.form-control:hover:not(:disabled):not([readonly])::-webkit-file-upload-button{background-color:var(--bs-secondary-bg)}.form-control:hover:not(:disabled):not([readonly])::file-selector-button{background-color:var(--bs-secondary-bg)}.form-control-plaintext{display:block;width:100%;padding:.375rem 0;margin-bottom:0;line-height:1.5;color:var(--bs-body-color);background-color:transparent;border:solid transparent;border-width:var(--bs-border-width) 0}.form-control-plaintext:focus{outline:0}.form-control-plaintext.form-control-lg,.form-control-plaintext.form-control-sm{padding-right:0;padding-left:0}.form-control-sm{min-height:calc(1.5em + .5rem + calc(var(--bs-border-width) * 2));padding:.25rem .5rem;font-size:.875rem;border-radius:var(--bs-border-radius-sm)}.form-control-sm::-webkit-file-upload-button{padding:.25rem .5rem;margin:-.25rem -.5rem;-webkit-margin-end:.5rem;margin-inline-end:.5rem}.form-control-sm::file-selector-button{padding:.25rem .5rem;margin:-.25rem -.5rem;-webkit-margin-end:.5rem;margin-inline-end:.5rem}.form-control-lg{min-height:calc(1.5em + 1rem + calc(var(--bs-border-width) * 2));padding:.5rem 1rem;font-size:1.25rem;border-radius:var(--bs-border-radius-lg)}.form-control-lg::-webkit-file-upload-button{padding:.5rem 1rem;margin:-.5rem -1rem;-webkit-margin-end:1rem;margin-inline-end:1rem}.form-control-lg::file-selector-button{padding:.5rem 1rem;margin:-.5rem -1rem;-webkit-margin-end:1rem;margin-inline-end:1rem}textarea.form-control{min-height:calc(1.5em + .75rem + calc(var(--bs-border-width) * 2))}textarea.form-control-sm{min-height:calc(1.5em + .5rem + calc(var(--bs-border-width) * 2))}textarea.form-control-lg{min-height:calc(1.5em + 1rem + calc(var(--bs-border-width) * 2))}.form-control-color{width:3rem;height:calc(1.5em + .75rem + calc(var(--bs-border-width) * 2));padding:.375rem}.form-control-color:not(:disabled):not([readonly]){cursor:pointer}.form-control-color::-moz-color-swatch{border:0!important;border-radius:var(--bs-border-radius)}.form-control-color::-webkit-color-swatch{border:0!important;border-radius:var(--bs-border-radius)}.form-control-color.form-control-sm{height:calc(1.5em + .5rem + calc(var(--bs-border-width) * 2))}.form-control-color.form-control-lg{height:calc(1.5em + 1rem + calc(var(--bs-border-width) * 2))}.form-select{--bs-form-select-bg-img:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3e%3cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='m2 5 6 6 6-6'/%3e%3c/svg%3e");display:block;width:100%;padding:.375rem 2.25rem .375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:var(--bs-body-color);background-color:var(--bs-body-bg);background-image:var(--bs-form-select-bg-img),var(--bs-form-select-bg-icon,none);background-repeat:no-repeat;background-position:right .75rem center;background-size:16px 12px;border:var(--bs-border-width) solid var(--bs-border-color);border-radius:var(--bs-border-radius);transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;-webkit-appearance:none;-moz-appearance:none;appearance:none}@media (prefers-reduced-motion:reduce){.form-select{transition:none}}.form-select:focus{border-color:#86b7fe;outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.form-select[multiple],.form-select[size]:not([size="1"]){padding-right:.75rem;background-image:none}.form-select:disabled{background-color:var(--bs-secondary-bg)}.form-select:-moz-focusring{color:transparent;text-shadow:0 0 0 var(--bs-body-color)}.form-select-sm{padding-top:.25rem;padding-bottom:.25rem;padding-left:.5rem;font-size:.875rem;border-radius:var(--bs-border-radius-sm)}.form-select-lg{padding-top:.5rem;padding-bottom:.5rem;padding-left:1rem;font-size:1.25rem;border-radius:var(--bs-border-radius-lg)}[data-bs-theme=dark] .form-select{--bs-form-select-bg-img:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3e%3cpath fill='none' stroke='%23adb5bd' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='m2 5 6 6 6-6'/%3e%3c/svg%3e")}.form-check{display:block;min-height:1.5rem;padding-left:1.5em;margin-bottom:.125rem}.form-check .form-check-input{float:left;margin-left:-1.5em}.form-check-reverse{padding-right:1.5em;padding-left:0;text-align:right}.form-check-reverse .form-check-input{float:right;margin-right:-1.5em;margin-left:0}.form-check-input{--bs-form-check-bg:var(--bs-body-bg);width:1em;height:1em;margin-top:.25em;vertical-align:top;background-color:var(--bs-form-check-bg);background-image:var(--bs-form-check-bg-image);background-repeat:no-repeat;background-position:center;background-size:contain;border:var(--bs-border-width) solid var(--bs-border-color);-webkit-appearance:none;-moz-appearance:none;appearance:none;-webkit-print-color-adjust:exact;color-adjust:exact;print-color-adjust:exact}.form-check-input[type=checkbox]{border-radius:.25em}.form-check-input[type=radio]{border-radius:50%}.form-check-input:active{filter:brightness(90%)}.form-check-input:focus{border-color:#86b7fe;outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.form-check-input:checked{background-color:#0d6efd;border-color:#0d6efd}.form-check-input:checked[type=checkbox]{--bs-form-check-bg-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3e%3cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='m6 10 3 3 6-6'/%3e%3c/svg%3e")}.form-check-input:checked[type=radio]{--bs-form-check-bg-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='2' fill='%23fff'/%3e%3c/svg%3e")}.form-check-input[type=checkbox]:indeterminate{background-color:#0d6efd;border-color:#0d6efd;--bs-form-check-bg-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3e%3cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='M6 10h8'/%3e%3c/svg%3e")}.form-check-input:disabled{pointer-events:none;filter:none;opacity:.5}.form-check-input:disabled~.form-check-label,.form-check-input[disabled]~.form-check-label{cursor:default;opacity:.5}.form-switch{padding-left:2.5em}.form-switch .form-check-input{--bs-form-switch-bg:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='rgba%280, 0, 0, 0.25%29'/%3e%3c/svg%3e");width:2em;margin-left:-2.5em;background-image:var(--bs-form-switch-bg);background-position:left center;border-radius:2em;transition:background-position .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-switch .form-check-input{transition:none}}.form-switch .form-check-input:focus{--bs-form-switch-bg:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='%2386b7fe'/%3e%3c/svg%3e")}.form-switch .form-check-input:checked{background-position:right center;--bs-form-switch-bg:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='%23fff'/%3e%3c/svg%3e")}.form-switch.form-check-reverse{padding-right:2.5em;padding-left:0}.form-switch.form-check-reverse .form-check-input{margin-right:-2.5em;margin-left:0}.form-check-inline{display:inline-block;margin-right:1rem}.btn-check{position:absolute;clip:rect(0,0,0,0);pointer-events:none}.btn-check:disabled+.btn,.btn-check[disabled]+.btn{pointer-events:none;filter:none;opacity:.65}[data-bs-theme=dark] .form-switch .form-check-input:not(:checked):not(:focus){--bs-form-switch-bg:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='rgba%28255, 255, 255, 0.25%29'/%3e%3c/svg%3e")}.form-range{width:100%;height:1.5rem;padding:0;background-color:transparent;-webkit-appearance:none;-moz-appearance:none;appearance:none}.form-range:focus{outline:0}.form-range:focus::-webkit-slider-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .25rem rgba(13,110,253,.25)}.form-range:focus::-moz-range-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .25rem rgba(13,110,253,.25)}.form-range::-moz-focus-outer{border:0}.form-range::-webkit-slider-thumb{width:1rem;height:1rem;margin-top:-.25rem;background-color:#0d6efd;border:0;border-radius:1rem;-webkit-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;-webkit-appearance:none;appearance:none}@media (prefers-reduced-motion:reduce){.form-range::-webkit-slider-thumb{-webkit-transition:none;transition:none}}.form-range::-webkit-slider-thumb:active{background-color:#b6d4fe}.form-range::-webkit-slider-runnable-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:var(--bs-tertiary-bg);border-color:transparent;border-radius:1rem}.form-range::-moz-range-thumb{width:1rem;height:1rem;background-color:#0d6efd;border:0;border-radius:1rem;-moz-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;-moz-appearance:none;appearance:none}@media (prefers-reduced-motion:reduce){.form-range::-moz-range-thumb{-moz-transition:none;transition:none}}.form-range::-moz-range-thumb:active{background-color:#b6d4fe}.form-range::-moz-range-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:var(--bs-tertiary-bg);border-color:transparent;border-radius:1rem}.form-range:disabled{pointer-events:none}.form-range:disabled::-webkit-slider-thumb{background-color:var(--bs-secondary-color)}.form-range:disabled::-moz-range-thumb{background-color:var(--bs-secondary-color)}.form-floating{position:relative}.form-floating>.form-control,.form-floating>.form-control-plaintext,.form-floating>.form-select{height:calc(3.5rem + calc(var(--bs-border-width) * 2));min-height:calc(3.5rem + calc(var(--bs-border-width) * 2));line-height:1.25}.form-floating>label{position:absolute;top:0;left:0;z-index:2;height:100%;padding:1rem .75rem;overflow:hidden;text-align:start;text-overflow:ellipsis;white-space:nowrap;pointer-events:none;border:var(--bs-border-width) solid transparent;transform-origin:0 0;transition:opacity .1s ease-in-out,transform .1s ease-in-out}@media (prefers-reduced-motion:reduce){.form-floating>label{transition:none}}.form-floating>.form-control,.form-floating>.form-control-plaintext{padding:1rem .75rem}.form-floating>.form-control-plaintext::-moz-placeholder,.form-floating>.form-control::-moz-placeholder{color:transparent}.form-floating>.form-control-plaintext::placeholder,.form-floating>.form-control::placeholder{color:transparent}.form-floating>.form-control-plaintext:not(:-moz-placeholder-shown),.form-floating>.form-control:not(:-moz-placeholder-shown){padding-top:1.625rem;padding-bottom:.625rem}.form-floating>.form-control-plaintext:focus,.form-floating>.form-control-plaintext:not(:placeholder-shown),.form-floating>.form-control:focus,.form-floating>.form-control:not(:placeholder-shown){padding-top:1.625rem;padding-bottom:.625rem}.form-floating>.form-control-plaintext:-webkit-autofill,.form-floating>.form-control:-webkit-autofill{padding-top:1.625rem;padding-bottom:.625rem}.form-floating>.form-select{padding-top:1.625rem;padding-bottom:.625rem}.form-floating>.form-control:not(:-moz-placeholder-shown)~label{color:rgba(var(--bs-body-color-rgb),.65);transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.form-floating>.form-control-plaintext~label,.form-floating>.form-control:focus~label,.form-floating>.form-control:not(:placeholder-shown)~label,.form-floating>.form-select~label{color:rgba(var(--bs-body-color-rgb),.65);transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.form-floating>.form-control:not(:-moz-placeholder-shown)~label::after{position:absolute;inset:1rem 0.375rem;z-index:-1;height:1.5em;content:"";background-color:var(--bs-body-bg);border-radius:var(--bs-border-radius)}.form-floating>.form-control-plaintext~label::after,.form-floating>.form-control:focus~label::after,.form-floating>.form-control:not(:placeholder-shown)~label::after,.form-floating>.form-select~label::after{position:absolute;inset:1rem 0.375rem;z-index:-1;height:1.5em;content:"";background-color:var(--bs-body-bg);border-radius:var(--bs-border-radius)}.form-floating>.form-control:-webkit-autofill~label{color:rgba(var(--bs-body-color-rgb),.65);transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.form-floating>.form-control-plaintext~label{border-width:var(--bs-border-width) 0}.form-floating>:disabled~label{color:#6c757d}.form-floating>:disabled~label::after{background-color:var(--bs-secondary-bg)}.input-group{position:relative;display:flex;flex-wrap:wrap;align-items:stretch;width:100%}.input-group>.form-control,.input-group>.form-floating,.input-group>.form-select{position:relative;flex:1 1 auto;width:1%;min-width:0}.input-group>.form-control:focus,.input-group>.form-floating:focus-within,.input-group>.form-select:focus{z-index:5}.input-group .btn{position:relative;z-index:2}.input-group .btn:focus{z-index:5}.input-group-text{display:flex;align-items:center;padding:.375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:var(--bs-body-color);text-align:center;white-space:nowrap;background-color:var(--bs-tertiary-bg);border:var(--bs-border-width) solid var(--bs-border-color);border-radius:var(--bs-border-radius)}.input-group-lg>.btn,.input-group-lg>.form-control,.input-group-lg>.form-select,.input-group-lg>.input-group-text{padding:.5rem 1rem;font-size:1.25rem;border-radius:var(--bs-border-radius-lg)}.input-group-sm>.btn,.input-group-sm>.form-control,.input-group-sm>.form-select,.input-group-sm>.input-group-text{padding:.25rem .5rem;font-size:.875rem;border-radius:var(--bs-border-radius-sm)}.input-group-lg>.form-select,.input-group-sm>.form-select{padding-right:3rem}.input-group:not(.has-validation)>.dropdown-toggle:nth-last-child(n+3),.input-group:not(.has-validation)>.form-floating:not(:last-child)>.form-control,.input-group:not(.has-validation)>.form-floating:not(:last-child)>.form-select,.input-group:not(.has-validation)>:not(:last-child):not(.dropdown-toggle):not(.dropdown-menu):not(.form-floating){border-top-right-radius:0;border-bottom-right-radius:0}.input-group.has-validation>.dropdown-toggle:nth-last-child(n+4),.input-group.has-validation>.form-floating:nth-last-child(n+3)>.form-control,.input-group.has-validation>.form-floating:nth-last-child(n+3)>.form-select,.input-group.has-validation>:nth-last-child(n+3):not(.dropdown-toggle):not(.dropdown-menu):not(.form-floating){border-top-right-radius:0;border-bottom-right-radius:0}.input-group>:not(:first-child):not(.dropdown-menu):not(.valid-tooltip):not(.valid-feedback):not(.invalid-tooltip):not(.invalid-feedback){margin-left:calc(var(--bs-border-width) * -1);border-top-left-radius:0;border-bottom-left-radius:0}.input-group>.form-floating:not(:first-child)>.form-control,.input-group>.form-floating:not(:first-child)>.form-select{border-top-left-radius:0;border-bottom-left-radius:0}.valid-feedback{display:none;width:100%;margin-top:.25rem;font-size:.875em;color:var(--bs-form-valid-color)}.valid-tooltip{position:absolute;top:100%;z-index:5;display:none;max-width:100%;padding:.25rem .5rem;margin-top:.1rem;font-size:.875rem;color:#fff;background-color:var(--bs-success);border-radius:var(--bs-border-radius)}.is-valid~.valid-feedback,.is-valid~.valid-tooltip,.was-validated :valid~.valid-feedback,.was-validated :valid~.valid-tooltip{display:block}.form-control.is-valid,.was-validated .form-control:valid{border-color:var(--bs-form-valid-border-color);padding-right:calc(1.5em + .75rem);background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3e%3cpath fill='%23198754' d='M2.3 6.73.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e");background-repeat:no-repeat;background-position:right calc(.375em + .1875rem) center;background-size:calc(.75em + .375rem) calc(.75em + .375rem)}.form-control.is-valid:focus,.was-validated .form-control:valid:focus{border-color:var(--bs-form-valid-border-color);box-shadow:0 0 0 .25rem rgba(var(--bs-success-rgb),.25)}.was-validated textarea.form-control:valid,textarea.form-control.is-valid{padding-right:calc(1.5em + .75rem);background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem)}.form-select.is-valid,.was-validated .form-select:valid{border-color:var(--bs-form-valid-border-color)}.form-select.is-valid:not([multiple]):not([size]),.form-select.is-valid:not([multiple])[size="1"],.was-validated .form-select:valid:not([multiple]):not([size]),.was-validated .form-select:valid:not([multiple])[size="1"]{--bs-form-select-bg-icon:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3e%3cpath fill='%23198754' d='M2.3 6.73.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e");padding-right:4.125rem;background-position:right .75rem center,center right 2.25rem;background-size:16px 12px,calc(.75em + .375rem) calc(.75em + .375rem)}.form-select.is-valid:focus,.was-validated .form-select:valid:focus{border-color:var(--bs-form-valid-border-color);box-shadow:0 0 0 .25rem rgba(var(--bs-success-rgb),.25)}.form-control-color.is-valid,.was-validated .form-control-color:valid{width:calc(3rem + calc(1.5em + .75rem))}.form-check-input.is-valid,.was-validated .form-check-input:valid{border-color:var(--bs-form-valid-border-color)}.form-check-input.is-valid:checked,.was-validated .form-check-input:valid:checked{background-color:var(--bs-form-valid-color)}.form-check-input.is-valid:focus,.was-validated .form-check-input:valid:focus{box-shadow:0 0 0 .25rem rgba(var(--bs-success-rgb),.25)}.form-check-input.is-valid~.form-check-label,.was-validated .form-check-input:valid~.form-check-label{color:var(--bs-form-valid-color)}.form-check-inline .form-check-input~.valid-feedback{margin-left:.5em}.input-group>.form-control:not(:focus).is-valid,.input-group>.form-floating:not(:focus-within).is-valid,.input-group>.form-select:not(:focus).is-valid,.was-validated .input-group>.form-control:not(:focus):valid,.was-validated .input-group>.form-floating:not(:focus-within):valid,.was-validated .input-group>.form-select:not(:focus):valid{z-index:3}.invalid-feedback{display:none;width:100%;margin-top:.25rem;font-size:.875em;color:var(--bs-form-invalid-color)}.invalid-tooltip{position:absolute;top:100%;z-index:5;display:none;max-width:100%;padding:.25rem .5rem;margin-top:.1rem;font-size:.875rem;color:#fff;background-color:var(--bs-danger);border-radius:var(--bs-border-radius)}.is-invalid~.invalid-feedback,.is-invalid~.invalid-tooltip,.was-validated :invalid~.invalid-feedback,.was-validated :invalid~.invalid-tooltip{display:block}.form-control.is-invalid,.was-validated .form-control:invalid{border-color:var(--bs-form-invalid-border-color);padding-right:calc(1.5em + .75rem);background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12' width='12' height='12' fill='none' stroke='%23dc3545'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e");background-repeat:no-repeat;background-position:right calc(.375em + .1875rem) center;background-size:calc(.75em + .375rem) calc(.75em + .375rem)}.form-control.is-invalid:focus,.was-validated .form-control:invalid:focus{border-color:var(--bs-form-invalid-border-color);box-shadow:0 0 0 .25rem rgba(var(--bs-danger-rgb),.25)}.was-validated textarea.form-control:invalid,textarea.form-control.is-invalid{padding-right:calc(1.5em + .75rem);background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem)}.form-select.is-invalid,.was-validated .form-select:invalid{border-color:var(--bs-form-invalid-border-color)}.form-select.is-invalid:not([multiple]):not([size]),.form-select.is-invalid:not([multiple])[size="1"],.was-validated .form-select:invalid:not([multiple]):not([size]),.was-validated .form-select:invalid:not([multiple])[size="1"]{--bs-form-select-bg-icon:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 12 12' width='12' height='12' fill='none' stroke='%23dc3545'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e");padding-right:4.125rem;background-position:right .75rem center,center right 2.25rem;background-size:16px 12px,calc(.75em + .375rem) calc(.75em + .375rem)}.form-select.is-invalid:focus,.was-validated .form-select:invalid:focus{border-color:var(--bs-form-invalid-border-color);box-shadow:0 0 0 .25rem rgba(var(--bs-danger-rgb),.25)}.form-control-color.is-invalid,.was-validated .form-control-color:invalid{width:calc(3rem + calc(1.5em + .75rem))}.form-check-input.is-invalid,.was-validated .form-check-input:invalid{border-color:var(--bs-form-invalid-border-color)}.form-check-input.is-invalid:checked,.was-validated .form-check-input:invalid:checked{background-color:var(--bs-form-invalid-color)}.form-check-input.is-invalid:focus,.was-validated .form-check-input:invalid:focus{box-shadow:0 0 0 .25rem rgba(var(--bs-danger-rgb),.25)}.form-check-input.is-invalid~.form-check-label,.was-validated .form-check-input:invalid~.form-check-label{color:var(--bs-form-invalid-color)}.form-check-inline .form-check-input~.invalid-feedback{margin-left:.5em}.input-group>.form-control:not(:focus).is-invalid,.input-group>.form-floating:not(:focus-within).is-invalid,.input-group>.form-select:not(:focus).is-invalid,.was-validated .input-group>.form-control:not(:focus):invalid,.was-validated .input-group>.form-floating:not(:focus-within):invalid,.was-validated .input-group>.form-select:not(:focus):invalid{z-index:4}.btn{--bs-btn-padding-x:0.75rem;--bs-btn-padding-y:0.375rem;--bs-btn-font-family: ;--bs-btn-font-size:1rem;--bs-btn-font-weight:400;--bs-btn-line-height:1.5;--bs-btn-color:var(--bs-body-color);--bs-btn-bg:transparent;--bs-btn-border-width:var(--bs-border-width);--bs-btn-border-color:transparent;--bs-btn-border-radius:var(--bs-border-radius);--bs-btn-hover-border-color:transparent;--bs-btn-box-shadow:inset 0 1px 0 rgba(255, 255, 255, 0.15),0 1px 1px rgba(0, 0, 0, 0.075);--bs-btn-disabled-opacity:0.65;--bs-btn-focus-box-shadow:0 0 0 0.25rem rgba(var(--bs-btn-focus-shadow-rgb), .5);display:inline-block;padding:var(--bs-btn-padding-y) var(--bs-btn-padding-x);font-family:var(--bs-btn-font-family);font-size:var(--bs-btn-font-size);font-weight:var(--bs-btn-font-weight);line-height:var(--bs-btn-line-height);color:var(--bs-btn-color);text-align:center;text-decoration:none;vertical-align:middle;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none;border:var(--bs-btn-border-width) solid var(--bs-btn-border-color);border-radius:var(--bs-btn-border-radius);background-color:var(--bs-btn-bg);transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.btn{transition:none}}.btn:hover{color:var(--bs-btn-hover-color);background-color:var(--bs-btn-hover-bg);border-color:var(--bs-btn-hover-border-color)}.btn-check+.btn:hover{color:var(--bs-btn-color);background-color:var(--bs-btn-bg);border-color:var(--bs-btn-border-color)}.btn:focus-visible{color:var(--bs-btn-hover-color);background-color:var(--bs-btn-hover-bg);border-color:var(--bs-btn-hover-border-color);outline:0;box-shadow:var(--bs-btn-focus-box-shadow)}.btn-check:focus-visible+.btn{border-color:var(--bs-btn-hover-border-color);outline:0;box-shadow:var(--bs-btn-focus-box-shadow)}.btn-check:checked+.btn,.btn.active,.btn.show,.btn:first-child:active,:not(.btn-check)+.btn:active{color:var(--bs-btn-active-color);background-color:var(--bs-btn-active-bg);border-color:var(--bs-btn-active-border-color)}.btn-check:checked+.btn:focus-visible,.btn.active:focus-visible,.btn.show:focus-visible,.btn:first-child:active:focus-visible,:not(.btn-check)+.btn:active:focus-visible{box-shadow:var(--bs-btn-focus-box-shadow)}.btn.disabled,.btn:disabled,fieldset:disabled .btn{color:var(--bs-btn-disabled-color);pointer-events:none;background-color:var(--bs-btn-disabled-bg);border-color:var(--bs-btn-disabled-border-color);opacity:var(--bs-btn-disabled-opacity)}.btn-primary{--bs-btn-color:#fff;--bs-btn-bg:#0d6efd;--bs-btn-border-color:#0d6efd;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#0b5ed7;--bs-btn-hover-border-color:#0a58ca;--bs-btn-focus-shadow-rgb:49,132,253;--bs-btn-active-color:#fff;--bs-btn-active-bg:#0a58ca;--bs-btn-active-border-color:#0a53be;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#0d6efd;--bs-btn-disabled-border-color:#0d6efd}.btn-secondary{--bs-btn-color:#fff;--bs-btn-bg:#6c757d;--bs-btn-border-color:#6c757d;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#5c636a;--bs-btn-hover-border-color:#565e64;--bs-btn-focus-shadow-rgb:130,138,145;--bs-btn-active-color:#fff;--bs-btn-active-bg:#565e64;--bs-btn-active-border-color:#51585e;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#6c757d;--bs-btn-disabled-border-color:#6c757d}.btn-success{--bs-btn-color:#fff;--bs-btn-bg:#198754;--bs-btn-border-color:#198754;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#157347;--bs-btn-hover-border-color:#146c43;--bs-btn-focus-shadow-rgb:60,153,110;--bs-btn-active-color:#fff;--bs-btn-active-bg:#146c43;--bs-btn-active-border-color:#13653f;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#198754;--bs-btn-disabled-border-color:#198754}.btn-info{--bs-btn-color:#000;--bs-btn-bg:#0dcaf0;--bs-btn-border-color:#0dcaf0;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#31d2f2;--bs-btn-hover-border-color:#25cff2;--bs-btn-focus-shadow-rgb:11,172,204;--bs-btn-active-color:#000;--bs-btn-active-bg:#3dd5f3;--bs-btn-active-border-color:#25cff2;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#000;--bs-btn-disabled-bg:#0dcaf0;--bs-btn-disabled-border-color:#0dcaf0}.btn-warning{--bs-btn-color:#000;--bs-btn-bg:#ffc107;--bs-btn-border-color:#ffc107;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#ffca2c;--bs-btn-hover-border-color:#ffc720;--bs-btn-focus-shadow-rgb:217,164,6;--bs-btn-active-color:#000;--bs-btn-active-bg:#ffcd39;--bs-btn-active-border-color:#ffc720;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#000;--bs-btn-disabled-bg:#ffc107;--bs-btn-disabled-border-color:#ffc107}.btn-danger{--bs-btn-color:#fff;--bs-btn-bg:#dc3545;--bs-btn-border-color:#dc3545;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#bb2d3b;--bs-btn-hover-border-color:#b02a37;--bs-btn-focus-shadow-rgb:225,83,97;--bs-btn-active-color:#fff;--bs-btn-active-bg:#b02a37;--bs-btn-active-border-color:#a52834;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#dc3545;--bs-btn-disabled-border-color:#dc3545}.btn-light{--bs-btn-color:#000;--bs-btn-bg:#f8f9fa;--bs-btn-border-color:#f8f9fa;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#d3d4d5;--bs-btn-hover-border-color:#c6c7c8;--bs-btn-focus-shadow-rgb:211,212,213;--bs-btn-active-color:#000;--bs-btn-active-bg:#c6c7c8;--bs-btn-active-border-color:#babbbc;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#000;--bs-btn-disabled-bg:#f8f9fa;--bs-btn-disabled-border-color:#f8f9fa}.btn-dark{--bs-btn-color:#fff;--bs-btn-bg:#212529;--bs-btn-border-color:#212529;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#424649;--bs-btn-hover-border-color:#373b3e;--bs-btn-focus-shadow-rgb:66,70,73;--bs-btn-active-color:#fff;--bs-btn-active-bg:#4d5154;--bs-btn-active-border-color:#373b3e;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#212529;--bs-btn-disabled-border-color:#212529}.btn-outline-primary{--bs-btn-color:#0d6efd;--bs-btn-border-color:#0d6efd;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#0d6efd;--bs-btn-hover-border-color:#0d6efd;--bs-btn-focus-shadow-rgb:13,110,253;--bs-btn-active-color:#fff;--bs-btn-active-bg:#0d6efd;--bs-btn-active-border-color:#0d6efd;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#0d6efd;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#0d6efd;--bs-gradient:none}.btn-outline-secondary{--bs-btn-color:#6c757d;--bs-btn-border-color:#6c757d;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#6c757d;--bs-btn-hover-border-color:#6c757d;--bs-btn-focus-shadow-rgb:108,117,125;--bs-btn-active-color:#fff;--bs-btn-active-bg:#6c757d;--bs-btn-active-border-color:#6c757d;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#6c757d;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#6c757d;--bs-gradient:none}.btn-outline-success{--bs-btn-color:#198754;--bs-btn-border-color:#198754;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#198754;--bs-btn-hover-border-color:#198754;--bs-btn-focus-shadow-rgb:25,135,84;--bs-btn-active-color:#fff;--bs-btn-active-bg:#198754;--bs-btn-active-border-color:#198754;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#198754;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#198754;--bs-gradient:none}.btn-outline-info{--bs-btn-color:#0dcaf0;--bs-btn-border-color:#0dcaf0;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#0dcaf0;--bs-btn-hover-border-color:#0dcaf0;--bs-btn-focus-shadow-rgb:13,202,240;--bs-btn-active-color:#000;--bs-btn-active-bg:#0dcaf0;--bs-btn-active-border-color:#0dcaf0;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#0dcaf0;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#0dcaf0;--bs-gradient:none}.btn-outline-warning{--bs-btn-color:#ffc107;--bs-btn-border-color:#ffc107;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#ffc107;--bs-btn-hover-border-color:#ffc107;--bs-btn-focus-shadow-rgb:255,193,7;--bs-btn-active-color:#000;--bs-btn-active-bg:#ffc107;--bs-btn-active-border-color:#ffc107;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#ffc107;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#ffc107;--bs-gradient:none}.btn-outline-danger{--bs-btn-color:#dc3545;--bs-btn-border-color:#dc3545;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#dc3545;--bs-btn-hover-border-color:#dc3545;--bs-btn-focus-shadow-rgb:220,53,69;--bs-btn-active-color:#fff;--bs-btn-active-bg:#dc3545;--bs-btn-active-border-color:#dc3545;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#dc3545;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#dc3545;--bs-gradient:none}.btn-outline-light{--bs-btn-color:#f8f9fa;--bs-btn-border-color:#f8f9fa;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#f8f9fa;--bs-btn-hover-border-color:#f8f9fa;--bs-btn-focus-shadow-rgb:248,249,250;--bs-btn-active-color:#000;--bs-btn-active-bg:#f8f9fa;--bs-btn-active-border-color:#f8f9fa;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#f8f9fa;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#f8f9fa;--bs-gradient:none}.btn-outline-dark{--bs-btn-color:#212529;--bs-btn-border-color:#212529;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#212529;--bs-btn-hover-border-color:#212529;--bs-btn-focus-shadow-rgb:33,37,41;--bs-btn-active-color:#fff;--bs-btn-active-bg:#212529;--bs-btn-active-border-color:#212529;--bs-btn-active-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);--bs-btn-disabled-color:#212529;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#212529;--bs-gradient:none}.btn-link{--bs-btn-font-weight:400;--bs-btn-color:var(--bs-link-color);--bs-btn-bg:transparent;--bs-btn-border-color:transparent;--bs-btn-hover-color:var(--bs-link-hover-color);--bs-btn-hover-border-color:transparent;--bs-btn-active-color:var(--bs-link-hover-color);--bs-btn-active-border-color:transparent;--bs-btn-disabled-color:#6c757d;--bs-btn-disabled-border-color:transparent;--bs-btn-box-shadow:0 0 0 #000;--bs-btn-focus-shadow-rgb:49,132,253;text-decoration:underline}.btn-link:focus-visible{color:var(--bs-btn-color)}.btn-link:hover{color:var(--bs-btn-hover-color)}.btn-group-lg>.btn,.btn-lg{--bs-btn-padding-y:0.5rem;--bs-btn-padding-x:1rem;--bs-btn-font-size:1.25rem;--bs-btn-border-radius:var(--bs-border-radius-lg)}.btn-group-sm>.btn,.btn-sm{--bs-btn-padding-y:0.25rem;--bs-btn-padding-x:0.5rem;--bs-btn-font-size:0.875rem;--bs-btn-border-radius:var(--bs-border-radius-sm)}.fade{transition:opacity .15s linear}@media (prefers-reduced-motion:reduce){.fade{transition:none}}.fade:not(.show){opacity:0}.collapse:not(.show){display:none}.collapsing{height:0;overflow:hidden;transition:height .35s ease}@media (prefers-reduced-motion:reduce){.collapsing{transition:none}}.collapsing.collapse-horizontal{width:0;height:auto;transition:width .35s ease}@media (prefers-reduced-motion:reduce){.collapsing.collapse-horizontal{transition:none}}.dropdown,.dropdown-center,.dropend,.dropstart,.dropup,.dropup-center{position:relative}.dropdown-toggle{white-space:nowrap}.dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:.3em solid;border-right:.3em solid transparent;border-bottom:0;border-left:.3em solid transparent}.dropdown-toggle:empty::after{margin-left:0}.dropdown-menu{--bs-dropdown-zindex:1000;--bs-dropdown-min-width:10rem;--bs-dropdown-padding-x:0;--bs-dropdown-padding-y:0.5rem;--bs-dropdown-spacer:0.125rem;--bs-dropdown-font-size:1rem;--bs-dropdown-color:var(--bs-body-color);--bs-dropdown-bg:var(--bs-body-bg);--bs-dropdown-border-color:var(--bs-border-color-translucent);--bs-dropdown-border-radius:var(--bs-border-radius);--bs-dropdown-border-width:var(--bs-border-width);--bs-dropdown-inner-border-radius:calc(var(--bs-border-radius) - var(--bs-border-width));--bs-dropdown-divider-bg:var(--bs-border-color-translucent);--bs-dropdown-divider-margin-y:0.5rem;--bs-dropdown-box-shadow:0 0.5rem 1rem rgba(0, 0, 0, 0.15);--bs-dropdown-link-color:var(--bs-body-color);--bs-dropdown-link-hover-color:var(--bs-body-color);--bs-dropdown-link-hover-bg:var(--bs-tertiary-bg);--bs-dropdown-link-active-color:#fff;--bs-dropdown-link-active-bg:#0d6efd;--bs-dropdown-link-disabled-color:var(--bs-tertiary-color);--bs-dropdown-item-padding-x:1rem;--bs-dropdown-item-padding-y:0.25rem;--bs-dropdown-header-color:#6c757d;--bs-dropdown-header-padding-x:1rem;--bs-dropdown-header-padding-y:0.5rem;position:absolute;z-index:var(--bs-dropdown-zindex);display:none;min-width:var(--bs-dropdown-min-width);padding:var(--bs-dropdown-padding-y) var(--bs-dropdown-padding-x);margin:0;font-size:var(--bs-dropdown-font-size);color:var(--bs-dropdown-color);text-align:left;list-style:none;background-color:var(--bs-dropdown-bg);background-clip:padding-box;border:var(--bs-dropdown-border-width) solid var(--bs-dropdown-border-color);border-radius:var(--bs-dropdown-border-radius)}.dropdown-menu[data-bs-popper]{top:100%;left:0;margin-top:var(--bs-dropdown-spacer)}.dropdown-menu-start{--bs-position:start}.dropdown-menu-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-end{--bs-position:end}.dropdown-menu-end[data-bs-popper]{right:0;left:auto}@media (min-width:576px){.dropdown-menu-sm-start{--bs-position:start}.dropdown-menu-sm-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-sm-end{--bs-position:end}.dropdown-menu-sm-end[data-bs-popper]{right:0;left:auto}}@media (min-width:768px){.dropdown-menu-md-start{--bs-position:start}.dropdown-menu-md-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-md-end{--bs-position:end}.dropdown-menu-md-end[data-bs-popper]{right:0;left:auto}}@media (min-width:992px){.dropdown-menu-lg-start{--bs-position:start}.dropdown-menu-lg-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-lg-end{--bs-position:end}.dropdown-menu-lg-end[data-bs-popper]{right:0;left:auto}}@media (min-width:1200px){.dropdown-menu-xl-start{--bs-position:start}.dropdown-menu-xl-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-xl-end{--bs-position:end}.dropdown-menu-xl-end[data-bs-popper]{right:0;left:auto}}@media (min-width:1400px){.dropdown-menu-xxl-start{--bs-position:start}.dropdown-menu-xxl-start[data-bs-popper]{right:auto;left:0}.dropdown-menu-xxl-end{--bs-position:end}.dropdown-menu-xxl-end[data-bs-popper]{right:0;left:auto}}.dropup .dropdown-menu[data-bs-popper]{top:auto;bottom:100%;margin-top:0;margin-bottom:var(--bs-dropdown-spacer)}.dropup .dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:0;border-right:.3em solid transparent;border-bottom:.3em solid;border-left:.3em solid transparent}.dropup .dropdown-toggle:empty::after{margin-left:0}.dropend .dropdown-menu[data-bs-popper]{top:0;right:auto;left:100%;margin-top:0;margin-left:var(--bs-dropdown-spacer)}.dropend .dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:.3em solid transparent;border-right:0;border-bottom:.3em solid transparent;border-left:.3em solid}.dropend .dropdown-toggle:empty::after{margin-left:0}.dropend .dropdown-toggle::after{vertical-align:0}.dropstart .dropdown-menu[data-bs-popper]{top:0;right:100%;left:auto;margin-top:0;margin-right:var(--bs-dropdown-spacer)}.dropstart .dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:""}.dropstart .dropdown-toggle::after{display:none}.dropstart .dropdown-toggle::before{display:inline-block;margin-right:.255em;vertical-align:.255em;content:"";border-top:.3em solid transparent;border-right:.3em solid;border-bottom:.3em solid transparent}.dropstart .dropdown-toggle:empty::after{margin-left:0}.dropstart .dropdown-toggle::before{vertical-align:0}.dropdown-divider{height:0;margin:var(--bs-dropdown-divider-margin-y) 0;overflow:hidden;border-top:1px solid var(--bs-dropdown-divider-bg);opacity:1}.dropdown-item{display:block;width:100%;padding:var(--bs-dropdown-item-padding-y) var(--bs-dropdown-item-padding-x);clear:both;font-weight:400;color:var(--bs-dropdown-link-color);text-align:inherit;text-decoration:none;white-space:nowrap;background-color:transparent;border:0;border-radius:var(--bs-dropdown-item-border-radius,0)}.dropdown-item:focus,.dropdown-item:hover{color:var(--bs-dropdown-link-hover-color);background-color:var(--bs-dropdown-link-hover-bg)}.dropdown-item.active,.dropdown-item:active{color:var(--bs-dropdown-link-active-color);text-decoration:none;background-color:var(--bs-dropdown-link-active-bg)}.dropdown-item.disabled,.dropdown-item:disabled{color:var(--bs-dropdown-link-disabled-color);pointer-events:none;background-color:transparent}.dropdown-menu.show{display:block}.dropdown-header{display:block;padding:var(--bs-dropdown-header-padding-y) var(--bs-dropdown-header-padding-x);margin-bottom:0;font-size:.875rem;color:var(--bs-dropdown-header-color);white-space:nowrap}.dropdown-item-text{display:block;padding:var(--bs-dropdown-item-padding-y) var(--bs-dropdown-item-padding-x);color:var(--bs-dropdown-link-color)}.dropdown-menu-dark{--bs-dropdown-color:#dee2e6;--bs-dropdown-bg:#343a40;--bs-dropdown-border-color:var(--bs-border-color-translucent);--bs-dropdown-box-shadow: ;--bs-dropdown-link-color:#dee2e6;--bs-dropdown-link-hover-color:#fff;--bs-dropdown-divider-bg:var(--bs-border-color-translucent);--bs-dropdown-link-hover-bg:rgba(255, 255, 255, 0.15);--bs-dropdown-link-active-color:#fff;--bs-dropdown-link-active-bg:#0d6efd;--bs-dropdown-link-disabled-color:#adb5bd;--bs-dropdown-header-color:#adb5bd}.btn-group,.btn-group-vertical{position:relative;display:inline-flex;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{position:relative;flex:1 1 auto}.btn-group-vertical>.btn-check:checked+.btn,.btn-group-vertical>.btn-check:focus+.btn,.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:hover,.btn-group>.btn-check:checked+.btn,.btn-group>.btn-check:focus+.btn,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus,.btn-group>.btn:hover{z-index:1}.btn-toolbar{display:flex;flex-wrap:wrap;justify-content:flex-start}.btn-toolbar .input-group{width:auto}.btn-group{border-radius:var(--bs-border-radius)}.btn-group>.btn-group:not(:first-child),.btn-group>:not(.btn-check:first-child)+.btn{margin-left:calc(var(--bs-border-width) * -1)}.btn-group>.btn-group:not(:last-child)>.btn,.btn-group>.btn.dropdown-toggle-split:first-child,.btn-group>.btn:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn-group:not(:first-child)>.btn,.btn-group>.btn:nth-child(n+3),.btn-group>:not(.btn-check)+.btn{border-top-left-radius:0;border-bottom-left-radius:0}.dropdown-toggle-split{padding-right:.5625rem;padding-left:.5625rem}.dropdown-toggle-split::after,.dropend .dropdown-toggle-split::after,.dropup .dropdown-toggle-split::after{margin-left:0}.dropstart .dropdown-toggle-split::before{margin-right:0}.btn-group-sm>.btn+.dropdown-toggle-split,.btn-sm+.dropdown-toggle-split{padding-right:.375rem;padding-left:.375rem}.btn-group-lg>.btn+.dropdown-toggle-split,.btn-lg+.dropdown-toggle-split{padding-right:.75rem;padding-left:.75rem}.btn-group-vertical{flex-direction:column;align-items:flex-start;justify-content:center}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group{width:100%}.btn-group-vertical>.btn-group:not(:first-child),.btn-group-vertical>.btn:not(:first-child){margin-top:calc(var(--bs-border-width) * -1)}.btn-group-vertical>.btn-group:not(:last-child)>.btn,.btn-group-vertical>.btn:not(:last-child):not(.dropdown-toggle){border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:not(:first-child)>.btn,.btn-group-vertical>.btn~.btn{border-top-left-radius:0;border-top-right-radius:0}.nav{--bs-nav-link-padding-x:1rem;--bs-nav-link-padding-y:0.5rem;--bs-nav-link-font-weight: ;--bs-nav-link-color:var(--bs-link-color);--bs-nav-link-hover-color:var(--bs-link-hover-color);--bs-nav-link-disabled-color:var(--bs-secondary-color);display:flex;flex-wrap:wrap;padding-left:0;margin-bottom:0;list-style:none}.nav-link{display:block;padding:var(--bs-nav-link-padding-y) var(--bs-nav-link-padding-x);font-size:var(--bs-nav-link-font-size);font-weight:var(--bs-nav-link-font-weight);color:var(--bs-nav-link-color);text-decoration:none;background:0 0;border:0;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out}@media (prefers-reduced-motion:reduce){.nav-link{transition:none}}.nav-link:focus,.nav-link:hover{color:var(--bs-nav-link-hover-color)}.nav-link:focus-visible{outline:0;box-shadow:0 0 0 .25rem rgba(13,110,253,.25)}.nav-link.disabled{color:var(--bs-nav-link-disabled-color);pointer-events:none;cursor:default}.nav-tabs{--bs-nav-tabs-border-width:var(--bs-border-width);--bs-nav-tabs-border-color:var(--bs-border-color);--bs-nav-tabs-border-radius:var(--bs-border-radius);--bs-nav-tabs-link-hover-border-color:var(--bs-secondary-bg) var(--bs-secondary-bg) var(--bs-border-color);--bs-nav-tabs-link-active-color:var(--bs-emphasis-color);--bs-nav-tabs-link-active-bg:var(--bs-body-bg);--bs-nav-tabs-link-active-border-color:var(--bs-border-color) var(--bs-border-color) var(--bs-body-bg);border-bottom:var(--bs-nav-tabs-border-width) solid var(--bs-nav-tabs-border-color)}.nav-tabs .nav-link{margin-bottom:calc(-1 * var(--bs-nav-tabs-border-width));border:var(--bs-nav-tabs-border-width) solid transparent;border-top-left-radius:var(--bs-nav-tabs-border-radius);border-top-right-radius:var(--bs-nav-tabs-border-radius)}.nav-tabs .nav-link:focus,.nav-tabs .nav-link:hover{isolation:isolate;border-color:var(--bs-nav-tabs-link-hover-border-color)}.nav-tabs .nav-link.disabled,.nav-tabs .nav-link:disabled{color:var(--bs-nav-link-disabled-color);background-color:transparent;border-color:transparent}.nav-tabs .nav-item.show .nav-link,.nav-tabs .nav-link.active{color:var(--bs-nav-tabs-link-active-color);background-color:var(--bs-nav-tabs-link-active-bg);border-color:var(--bs-nav-tabs-link-active-border-color)}.nav-tabs .dropdown-menu{margin-top:calc(-1 * var(--bs-nav-tabs-border-width));border-top-left-radius:0;border-top-right-radius:0}.nav-pills{--bs-nav-pills-border-radius:var(--bs-border-radius);--bs-nav-pills-link-active-color:#fff;--bs-nav-pills-link-active-bg:#0d6efd}.nav-pills .nav-link{border-radius:var(--bs-nav-pills-border-radius)}.nav-pills .nav-link:disabled{color:var(--bs-nav-link-disabled-color);background-color:transparent;border-color:transparent}.nav-pills .nav-link.active,.nav-pills .show>.nav-link{color:var(--bs-nav-pills-link-active-color);background-color:var(--bs-nav-pills-link-active-bg)}.nav-underline{--bs-nav-underline-gap:1rem;--bs-nav-underline-border-width:0.125rem;--bs-nav-underline-link-active-color:var(--bs-emphasis-color);gap:var(--bs-nav-underline-gap)}.nav-underline .nav-link{padding-right:0;padding-left:0;border-bottom:var(--bs-nav-underline-border-width) solid transparent}.nav-underline .nav-link:focus,.nav-underline .nav-link:hover{border-bottom-color:currentcolor}.nav-underline .nav-link.active,.nav-underline .show>.nav-link{font-weight:700;color:var(--bs-nav-underline-link-active-color);border-bottom-color:currentcolor}.nav-fill .nav-item,.nav-fill>.nav-link{flex:1 1 auto;text-align:center}.nav-justified .nav-item,.nav-justified>.nav-link{flex-basis:0;flex-grow:1;text-align:center}.nav-fill .nav-item .nav-link,.nav-justified .nav-item .nav-link{width:100%}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.navbar{--bs-navbar-padding-x:0;--bs-navbar-padding-y:0.5rem;--bs-navbar-color:rgba(var(--bs-emphasis-color-rgb), 0.65);--bs-navbar-hover-color:rgba(var(--bs-emphasis-color-rgb), 0.8);--bs-navbar-disabled-color:rgba(var(--bs-emphasis-color-rgb), 0.3);--bs-navbar-active-color:rgba(var(--bs-emphasis-color-rgb), 1);--bs-navbar-brand-padding-y:0.3125rem;--bs-navbar-brand-margin-end:1rem;--bs-navbar-brand-font-size:1.25rem;--bs-navbar-brand-color:rgba(var(--bs-emphasis-color-rgb), 1);--bs-navbar-brand-hover-color:rgba(var(--bs-emphasis-color-rgb), 1);--bs-navbar-nav-link-padding-x:0.5rem;--bs-navbar-toggler-padding-y:0.25rem;--bs-navbar-toggler-padding-x:0.75rem;--bs-navbar-toggler-font-size:1.25rem;--bs-navbar-toggler-icon-bg:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%2833, 37, 41, 0.75%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e");--bs-navbar-toggler-border-color:rgba(var(--bs-emphasis-color-rgb), 0.15);--bs-navbar-toggler-border-radius:var(--bs-border-radius);--bs-navbar-toggler-focus-width:0.25rem;--bs-navbar-toggler-transition:box-shadow 0.15s ease-in-out;position:relative;display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;padding:var(--bs-navbar-padding-y) var(--bs-navbar-padding-x)}.navbar>.container,.navbar>.container-fluid,.navbar>.container-lg,.navbar>.container-md,.navbar>.container-sm,.navbar>.container-xl,.navbar>.container-xxl{display:flex;flex-wrap:inherit;align-items:center;justify-content:space-between}.navbar-brand{padding-top:var(--bs-navbar-brand-padding-y);padding-bottom:var(--bs-navbar-brand-padding-y);margin-right:var(--bs-navbar-brand-margin-end);font-size:var(--bs-navbar-brand-font-size);color:var(--bs-navbar-brand-color);text-decoration:none;white-space:nowrap}.navbar-brand:focus,.navbar-brand:hover{color:var(--bs-navbar-brand-hover-color)}.navbar-nav{--bs-nav-link-padding-x:0;--bs-nav-link-padding-y:0.5rem;--bs-nav-link-font-weight: ;--bs-nav-link-color:var(--bs-navbar-color);--bs-nav-link-hover-color:var(--bs-navbar-hover-color);--bs-nav-link-disabled-color:var(--bs-navbar-disabled-color);display:flex;flex-direction:column;padding-left:0;margin-bottom:0;list-style:none}.navbar-nav .nav-link.active,.navbar-nav .nav-link.show{color:var(--bs-navbar-active-color)}.navbar-nav .dropdown-menu{position:static}.navbar-text{padding-top:.5rem;padding-bottom:.5rem;color:var(--bs-navbar-color)}.navbar-text a,.navbar-text a:focus,.navbar-text a:hover{color:var(--bs-navbar-active-color)}.navbar-collapse{flex-basis:100%;flex-grow:1;align-items:center}.navbar-toggler{padding:var(--bs-navbar-toggler-padding-y) var(--bs-navbar-toggler-padding-x);font-size:var(--bs-navbar-toggler-font-size);line-height:1;color:var(--bs-navbar-color);background-color:transparent;border:var(--bs-border-width) solid var(--bs-navbar-toggler-border-color);border-radius:var(--bs-navbar-toggler-border-radius);transition:var(--bs-navbar-toggler-transition)}@media (prefers-reduced-motion:reduce){.navbar-toggler{transition:none}}.navbar-toggler:hover{text-decoration:none}.navbar-toggler:focus{text-decoration:none;outline:0;box-shadow:0 0 0 var(--bs-navbar-toggler-focus-width)}.navbar-toggler-icon{display:inline-block;width:1.5em;height:1.5em;vertical-align:middle;background-image:var(--bs-navbar-toggler-icon-bg);background-repeat:no-repeat;background-position:center;background-size:100%}.navbar-nav-scroll{max-height:var(--bs-scroll-height,75vh);overflow-y:auto}@media (min-width:576px){.navbar-expand-sm{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-sm .navbar-nav{flex-direction:row}.navbar-expand-sm .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-sm .navbar-nav .nav-link{padding-right:var(--bs-navbar-nav-link-padding-x);padding-left:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-sm .navbar-nav-scroll{overflow:visible}.navbar-expand-sm .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-sm .navbar-toggler{display:none}.navbar-expand-sm .offcanvas{position:static;z-index:auto;flex-grow:1;width:auto!important;height:auto!important;visibility:visible!important;background-color:transparent!important;border:0!important;transform:none!important;transition:none}.navbar-expand-sm .offcanvas .offcanvas-header{display:none}.navbar-expand-sm .offcanvas .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible}}@media (min-width:768px){.navbar-expand-md{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-md .navbar-nav{flex-direction:row}.navbar-expand-md .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-md .navbar-nav .nav-link{padding-right:var(--bs-navbar-nav-link-padding-x);padding-left:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-md .navbar-nav-scroll{overflow:visible}.navbar-expand-md .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-md .navbar-toggler{display:none}.navbar-expand-md .offcanvas{position:static;z-index:auto;flex-grow:1;width:auto!important;height:auto!important;visibility:visible!important;background-color:transparent!important;border:0!important;transform:none!important;transition:none}.navbar-expand-md .offcanvas .offcanvas-header{display:none}.navbar-expand-md .offcanvas .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible}}@media (min-width:992px){.navbar-expand-lg{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-lg .navbar-nav{flex-direction:row}.navbar-expand-lg .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-lg .navbar-nav .nav-link{padding-right:var(--bs-navbar-nav-link-padding-x);padding-left:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-lg .navbar-nav-scroll{overflow:visible}.navbar-expand-lg .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-lg .navbar-toggler{display:none}.navbar-expand-lg .offcanvas{position:static;z-index:auto;flex-grow:1;width:auto!important;height:auto!important;visibility:visible!important;background-color:transparent!important;border:0!important;transform:none!important;transition:none}.navbar-expand-lg .offcanvas .offcanvas-header{display:none}.navbar-expand-lg .offcanvas .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible}}@media (min-width:1200px){.navbar-expand-xl{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-xl .navbar-nav{flex-direction:row}.navbar-expand-xl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xl .navbar-nav .nav-link{padding-right:var(--bs-navbar-nav-link-padding-x);padding-left:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-xl .navbar-nav-scroll{overflow:visible}.navbar-expand-xl .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-xl .navbar-toggler{display:none}.navbar-expand-xl .offcanvas{position:static;z-index:auto;flex-grow:1;width:auto!important;height:auto!important;visibility:visible!important;background-color:transparent!important;border:0!important;transform:none!important;transition:none}.navbar-expand-xl .offcanvas .offcanvas-header{display:none}.navbar-expand-xl .offcanvas .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible}}@media (min-width:1400px){.navbar-expand-xxl{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-xxl .navbar-nav{flex-direction:row}.navbar-expand-xxl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xxl .navbar-nav .nav-link{padding-right:var(--bs-navbar-nav-link-padding-x);padding-left:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-xxl .navbar-nav-scroll{overflow:visible}.navbar-expand-xxl .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-xxl .navbar-toggler{display:none}.navbar-expand-xxl .offcanvas{position:static;z-index:auto;flex-grow:1;width:auto!important;height:auto!important;visibility:visible!important;background-color:transparent!important;border:0!important;transform:none!important;transition:none}.navbar-expand-xxl .offcanvas .offcanvas-header{display:none}.navbar-expand-xxl .offcanvas .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible}}.navbar-expand{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand .navbar-nav{flex-direction:row}.navbar-expand .navbar-nav .dropdown-menu{position:absolute}.navbar-expand .navbar-nav .nav-link{padding-right:var(--bs-navbar-nav-link-padding-x);padding-left:var(--bs-navbar-nav-link-padding-x)}.navbar-expand .navbar-nav-scroll{overflow:visible}.navbar-expand .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand .navbar-toggler{display:none}.navbar-expand .offcanvas{position:static;z-index:auto;flex-grow:1;width:auto!important;height:auto!important;visibility:visible!important;background-color:transparent!important;border:0!important;transform:none!important;transition:none}.navbar-expand .offcanvas .offcanvas-header{display:none}.navbar-expand .offcanvas .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible}.navbar-dark,.navbar[data-bs-theme=dark]{--bs-navbar-color:rgba(255, 255, 255, 0.55);--bs-navbar-hover-color:rgba(255, 255, 255, 0.75);--bs-navbar-disabled-color:rgba(255, 255, 255, 0.25);--bs-navbar-active-color:#fff;--bs-navbar-brand-color:#fff;--bs-navbar-brand-hover-color:#fff;--bs-navbar-toggler-border-color:rgba(255, 255, 255, 0.1);--bs-navbar-toggler-icon-bg:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%28255, 255, 255, 0.55%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e")}[data-bs-theme=dark] .navbar-toggler-icon{--bs-navbar-toggler-icon-bg:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%28255, 255, 255, 0.55%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e")}.card{--bs-card-spacer-y:1rem;--bs-card-spacer-x:1rem;--bs-card-title-spacer-y:0.5rem;--bs-card-title-color: ;--bs-card-subtitle-color: ;--bs-card-border-width:var(--bs-border-width);--bs-card-border-color:var(--bs-border-color-translucent);--bs-card-border-radius:var(--bs-border-radius);--bs-card-box-shadow: ;--bs-card-inner-border-radius:calc(var(--bs-border-radius) - (var(--bs-border-width)));--bs-card-cap-padding-y:0.5rem;--bs-card-cap-padding-x:1rem;--bs-card-cap-bg:rgba(var(--bs-body-color-rgb), 0.03);--bs-card-cap-color: ;--bs-card-height: ;--bs-card-color: ;--bs-card-bg:var(--bs-body-bg);--bs-card-img-overlay-padding:1rem;--bs-card-group-margin:0.75rem;position:relative;display:flex;flex-direction:column;min-width:0;height:var(--bs-card-height);color:var(--bs-body-color);word-wrap:break-word;background-color:var(--bs-card-bg);background-clip:border-box;border:var(--bs-card-border-width) solid var(--bs-card-border-color);border-radius:var(--bs-card-border-radius)}.card>hr{margin-right:0;margin-left:0}.card>.list-group{border-top:inherit;border-bottom:inherit}.card>.list-group:first-child{border-top-width:0;border-top-left-radius:var(--bs-card-inner-border-radius);border-top-right-radius:var(--bs-card-inner-border-radius)}.card>.list-group:last-child{border-bottom-width:0;border-bottom-right-radius:var(--bs-card-inner-border-radius);border-bottom-left-radius:var(--bs-card-inner-border-radius)}.card>.card-header+.list-group,.card>.list-group+.card-footer{border-top:0}.card-body{flex:1 1 auto;padding:var(--bs-card-spacer-y) var(--bs-card-spacer-x);color:var(--bs-card-color)}.card-title{margin-bottom:var(--bs-card-title-spacer-y);color:var(--bs-card-title-color)}.card-subtitle{margin-top:calc(-.5 * var(--bs-card-title-spacer-y));margin-bottom:0;color:var(--bs-card-subtitle-color)}.card-text:last-child{margin-bottom:0}.card-link+.card-link{margin-left:var(--bs-card-spacer-x)}.card-header{padding:var(--bs-card-cap-padding-y) var(--bs-card-cap-padding-x);margin-bottom:0;color:var(--bs-card-cap-color);background-color:var(--bs-card-cap-bg);border-bottom:var(--bs-card-border-width) solid var(--bs-card-border-color)}.card-header:first-child{border-radius:var(--bs-card-inner-border-radius) var(--bs-card-inner-border-radius) 0 0}.card-footer{padding:var(--bs-card-cap-padding-y) var(--bs-card-cap-padding-x);color:var(--bs-card-cap-color);background-color:var(--bs-card-cap-bg);border-top:var(--bs-card-border-width) solid var(--bs-card-border-color)}.card-footer:last-child{border-radius:0 0 var(--bs-card-inner-border-radius) var(--bs-card-inner-border-radius)}.card-header-tabs{margin-right:calc(-.5 * var(--bs-card-cap-padding-x));margin-bottom:calc(-1 * var(--bs-card-cap-padding-y));margin-left:calc(-.5 * var(--bs-card-cap-padding-x));border-bottom:0}.card-header-tabs .nav-link.active{background-color:var(--bs-card-bg);border-bottom-color:var(--bs-card-bg)}.card-header-pills{margin-right:calc(-.5 * var(--bs-card-cap-padding-x));margin-left:calc(-.5 * var(--bs-card-cap-padding-x))}.card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:var(--bs-card-img-overlay-padding);border-radius:var(--bs-card-inner-border-radius)}.card-img,.card-img-bottom,.card-img-top{width:100%}.card-img,.card-img-top{border-top-left-radius:var(--bs-card-inner-border-radius);border-top-right-radius:var(--bs-card-inner-border-radius)}.card-img,.card-img-bottom{border-bottom-right-radius:var(--bs-card-inner-border-radius);border-bottom-left-radius:var(--bs-card-inner-border-radius)}.card-group>.card{margin-bottom:var(--bs-card-group-margin)}@media (min-width:576px){.card-group{display:flex;flex-flow:row wrap}.card-group>.card{flex:1 0 0%;margin-bottom:0}.card-group>.card+.card{margin-left:0;border-left:0}.card-group>.card:not(:last-child){border-top-right-radius:0;border-bottom-right-radius:0}.card-group>.card:not(:last-child) .card-header,.card-group>.card:not(:last-child) .card-img-top{border-top-right-radius:0}.card-group>.card:not(:last-child) .card-footer,.card-group>.card:not(:last-child) .card-img-bottom{border-bottom-right-radius:0}.card-group>.card:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.card-group>.card:not(:first-child) .card-header,.card-group>.card:not(:first-child) .card-img-top{border-top-left-radius:0}.card-group>.card:not(:first-child) .card-footer,.card-group>.card:not(:first-child) .card-img-bottom{border-bottom-left-radius:0}}.accordion{--bs-accordion-color:var(--bs-body-color);--bs-accordion-bg:var(--bs-body-bg);--bs-accordion-transition:color 0.15s ease-in-out,background-color 0.15s ease-in-out,border-color 0.15s ease-in-out,box-shadow 0.15s ease-in-out,border-radius 0.15s ease;--bs-accordion-border-color:var(--bs-border-color);--bs-accordion-border-width:var(--bs-border-width);--bs-accordion-border-radius:var(--bs-border-radius);--bs-accordion-inner-border-radius:calc(var(--bs-border-radius) - (var(--bs-border-width)));--bs-accordion-btn-padding-x:1.25rem;--bs-accordion-btn-padding-y:1rem;--bs-accordion-btn-color:var(--bs-body-color);--bs-accordion-btn-bg:var(--bs-accordion-bg);--bs-accordion-btn-icon:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23212529'%3e%3cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e");--bs-accordion-btn-icon-width:1.25rem;--bs-accordion-btn-icon-transform:rotate(-180deg);--bs-accordion-btn-icon-transition:transform 0.2s ease-in-out;--bs-accordion-btn-active-icon:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23052c65'%3e%3cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e");--bs-accordion-btn-focus-border-color:#86b7fe;--bs-accordion-btn-focus-box-shadow:0 0 0 0.25rem rgba(13, 110, 253, 0.25);--bs-accordion-body-padding-x:1.25rem;--bs-accordion-body-padding-y:1rem;--bs-accordion-active-color:var(--bs-primary-text-emphasis);--bs-accordion-active-bg:var(--bs-primary-bg-subtle)}.accordion-button{position:relative;display:flex;align-items:center;width:100%;padding:var(--bs-accordion-btn-padding-y) var(--bs-accordion-btn-padding-x);font-size:1rem;color:var(--bs-accordion-btn-color);text-align:left;background-color:var(--bs-accordion-btn-bg);border:0;border-radius:0;overflow-anchor:none;transition:var(--bs-accordion-transition)}@media (prefers-reduced-motion:reduce){.accordion-button{transition:none}}.accordion-button:not(.collapsed){color:var(--bs-accordion-active-color);background-color:var(--bs-accordion-active-bg);box-shadow:inset 0 calc(-1 * var(--bs-accordion-border-width)) 0 var(--bs-accordion-border-color)}.accordion-button:not(.collapsed)::after{background-image:var(--bs-accordion-btn-active-icon);transform:var(--bs-accordion-btn-icon-transform)}.accordion-button::after{flex-shrink:0;width:var(--bs-accordion-btn-icon-width);height:var(--bs-accordion-btn-icon-width);margin-left:auto;content:"";background-image:var(--bs-accordion-btn-icon);background-repeat:no-repeat;background-size:var(--bs-accordion-btn-icon-width);transition:var(--bs-accordion-btn-icon-transition)}@media (prefers-reduced-motion:reduce){.accordion-button::after{transition:none}}.accordion-button:hover{z-index:2}.accordion-button:focus{z-index:3;border-color:var(--bs-accordion-btn-focus-border-color);outline:0;box-shadow:var(--bs-accordion-btn-focus-box-shadow)}.accordion-header{margin-bottom:0}.accordion-item{color:var(--bs-accordion-color);background-color:var(--bs-accordion-bg);border:var(--bs-accordion-border-width) solid var(--bs-accordion-border-color)}.accordion-item:first-of-type{border-top-left-radius:var(--bs-accordion-border-radius);border-top-right-radius:var(--bs-accordion-border-radius)}.accordion-item:first-of-type .accordion-button{border-top-left-radius:var(--bs-accordion-inner-border-radius);border-top-right-radius:var(--bs-accordion-inner-border-radius)}.accordion-item:not(:first-of-type){border-top:0}.accordion-item:last-of-type{border-bottom-right-radius:var(--bs-accordion-border-radius);border-bottom-left-radius:var(--bs-accordion-border-radius)}.accordion-item:last-of-type .accordion-button.collapsed{border-bottom-right-radius:var(--bs-accordion-inner-border-radius);border-bottom-left-radius:var(--bs-accordion-inner-border-radius)}.accordion-item:last-of-type .accordion-collapse{border-bottom-right-radius:var(--bs-accordion-border-radius);border-bottom-left-radius:var(--bs-accordion-border-radius)}.accordion-body{padding:var(--bs-accordion-body-padding-y) var(--bs-accordion-body-padding-x)}.accordion-flush .accordion-collapse{border-width:0}.accordion-flush .accordion-item{border-right:0;border-left:0;border-radius:0}.accordion-flush .accordion-item:first-child{border-top:0}.accordion-flush .accordion-item:last-child{border-bottom:0}.accordion-flush .accordion-item .accordion-button,.accordion-flush .accordion-item .accordion-button.collapsed{border-radius:0}[data-bs-theme=dark] .accordion-button::after{--bs-accordion-btn-icon:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%236ea8fe'%3e%3cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e");--bs-accordion-btn-active-icon:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%236ea8fe'%3e%3cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e")}.breadcrumb{--bs-breadcrumb-padding-x:0;--bs-breadcrumb-padding-y:0;--bs-breadcrumb-margin-bottom:1rem;--bs-breadcrumb-bg: ;--bs-breadcrumb-border-radius: ;--bs-breadcrumb-divider-color:var(--bs-secondary-color);--bs-breadcrumb-item-padding-x:0.5rem;--bs-breadcrumb-item-active-color:var(--bs-secondary-color);display:flex;flex-wrap:wrap;padding:var(--bs-breadcrumb-padding-y) var(--bs-breadcrumb-padding-x);margin-bottom:var(--bs-breadcrumb-margin-bottom);font-size:var(--bs-breadcrumb-font-size);list-style:none;background-color:var(--bs-breadcrumb-bg);border-radius:var(--bs-breadcrumb-border-radius)}.breadcrumb-item+.breadcrumb-item{padding-left:var(--bs-breadcrumb-item-padding-x)}.breadcrumb-item+.breadcrumb-item::before{float:left;padding-right:var(--bs-breadcrumb-item-padding-x);color:var(--bs-breadcrumb-divider-color);content:var(--bs-breadcrumb-divider, "/")}.breadcrumb-item.active{color:var(--bs-breadcrumb-item-active-color)}.pagination{--bs-pagination-padding-x:0.75rem;--bs-pagination-padding-y:0.375rem;--bs-pagination-font-size:1rem;--bs-pagination-color:var(--bs-link-color);--bs-pagination-bg:var(--bs-body-bg);--bs-pagination-border-width:var(--bs-border-width);--bs-pagination-border-color:var(--bs-border-color);--bs-pagination-border-radius:var(--bs-border-radius);--bs-pagination-hover-color:var(--bs-link-hover-color);--bs-pagination-hover-bg:var(--bs-tertiary-bg);--bs-pagination-hover-border-color:var(--bs-border-color);--bs-pagination-focus-color:var(--bs-link-hover-color);--bs-pagination-focus-bg:var(--bs-secondary-bg);--bs-pagination-focus-box-shadow:0 0 0 0.25rem rgba(13, 110, 253, 0.25);--bs-pagination-active-color:#fff;--bs-pagination-active-bg:#0d6efd;--bs-pagination-active-border-color:#0d6efd;--bs-pagination-disabled-color:var(--bs-secondary-color);--bs-pagination-disabled-bg:var(--bs-secondary-bg);--bs-pagination-disabled-border-color:var(--bs-border-color);display:flex;padding-left:0;list-style:none}.page-link{position:relative;display:block;padding:var(--bs-pagination-padding-y) var(--bs-pagination-padding-x);font-size:var(--bs-pagination-font-size);color:var(--bs-pagination-color);text-decoration:none;background-color:var(--bs-pagination-bg);border:var(--bs-pagination-border-width) solid var(--bs-pagination-border-color);transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.page-link{transition:none}}.page-link:hover{z-index:2;color:var(--bs-pagination-hover-color);background-color:var(--bs-pagination-hover-bg);border-color:var(--bs-pagination-hover-border-color)}.page-link:focus{z-index:3;color:var(--bs-pagination-focus-color);background-color:var(--bs-pagination-focus-bg);outline:0;box-shadow:var(--bs-pagination-focus-box-shadow)}.active>.page-link,.page-link.active{z-index:3;color:var(--bs-pagination-active-color);background-color:var(--bs-pagination-active-bg);border-color:var(--bs-pagination-active-border-color)}.disabled>.page-link,.page-link.disabled{color:var(--bs-pagination-disabled-color);pointer-events:none;background-color:var(--bs-pagination-disabled-bg);border-color:var(--bs-pagination-disabled-border-color)}.page-item:not(:first-child) .page-link{margin-left:calc(var(--bs-border-width) * -1)}.page-item:first-child .page-link{border-top-left-radius:var(--bs-pagination-border-radius);border-bottom-left-radius:var(--bs-pagination-border-radius)}.page-item:last-child .page-link{border-top-right-radius:var(--bs-pagination-border-radius);border-bottom-right-radius:var(--bs-pagination-border-radius)}.pagination-lg{--bs-pagination-padding-x:1.5rem;--bs-pagination-padding-y:0.75rem;--bs-pagination-font-size:1.25rem;--bs-pagination-border-radius:var(--bs-border-radius-lg)}.pagination-sm{--bs-pagination-padding-x:0.5rem;--bs-pagination-padding-y:0.25rem;--bs-pagination-font-size:0.875rem;--bs-pagination-border-radius:var(--bs-border-radius-sm)}.badge{--bs-badge-padding-x:0.65em;--bs-badge-padding-y:0.35em;--bs-badge-font-size:0.75em;--bs-badge-font-weight:700;--bs-badge-color:#fff;--bs-badge-border-radius:var(--bs-border-radius);display:inline-block;padding:var(--bs-badge-padding-y) var(--bs-badge-padding-x);font-size:var(--bs-badge-font-size);font-weight:var(--bs-badge-font-weight);line-height:1;color:var(--bs-badge-color);text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:var(--bs-badge-border-radius)}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.alert{--bs-alert-bg:transparent;--bs-alert-padding-x:1rem;--bs-alert-padding-y:1rem;--bs-alert-margin-bottom:1rem;--bs-alert-color:inherit;--bs-alert-border-color:transparent;--bs-alert-border:var(--bs-border-width) solid var(--bs-alert-border-color);--bs-alert-border-radius:var(--bs-border-radius);--bs-alert-link-color:inherit;position:relative;padding:var(--bs-alert-padding-y) var(--bs-alert-padding-x);margin-bottom:var(--bs-alert-margin-bottom);color:var(--bs-alert-color);background-color:var(--bs-alert-bg);border:var(--bs-alert-border);border-radius:var(--bs-alert-border-radius)}.alert-heading{color:inherit}.alert-link{font-weight:700;color:var(--bs-alert-link-color)}.alert-dismissible{padding-right:3rem}.alert-dismissible .btn-close{position:absolute;top:0;right:0;z-index:2;padding:1.25rem 1rem}.alert-primary{--bs-alert-color:var(--bs-primary-text-emphasis);--bs-alert-bg:var(--bs-primary-bg-subtle);--bs-alert-border-color:var(--bs-primary-border-subtle);--bs-alert-link-color:var(--bs-primary-text-emphasis)}.alert-secondary{--bs-alert-color:var(--bs-secondary-text-emphasis);--bs-alert-bg:var(--bs-secondary-bg-subtle);--bs-alert-border-color:var(--bs-secondary-border-subtle);--bs-alert-link-color:var(--bs-secondary-text-emphasis)}.alert-success{--bs-alert-color:var(--bs-success-text-emphasis);--bs-alert-bg:var(--bs-success-bg-subtle);--bs-alert-border-color:var(--bs-success-border-subtle);--bs-alert-link-color:var(--bs-success-text-emphasis)}.alert-info{--bs-alert-color:var(--bs-info-text-emphasis);--bs-alert-bg:var(--bs-info-bg-subtle);--bs-alert-border-color:var(--bs-info-border-subtle);--bs-alert-link-color:var(--bs-info-text-emphasis)}.alert-warning{--bs-alert-color:var(--bs-warning-text-emphasis);--bs-alert-bg:var(--bs-warning-bg-subtle);--bs-alert-border-color:var(--bs-warning-border-subtle);--bs-alert-link-color:var(--bs-warning-text-emphasis)}.alert-danger{--bs-alert-color:var(--bs-danger-text-emphasis);--bs-alert-bg:var(--bs-danger-bg-subtle);--bs-alert-border-color:var(--bs-danger-border-subtle);--bs-alert-link-color:var(--bs-danger-text-emphasis)}.alert-light{--bs-alert-color:var(--bs-light-text-emphasis);--bs-alert-bg:var(--bs-light-bg-subtle);--bs-alert-border-color:var(--bs-light-border-subtle);--bs-alert-link-color:var(--bs-light-text-emphasis)}.alert-dark{--bs-alert-color:var(--bs-dark-text-emphasis);--bs-alert-bg:var(--bs-dark-bg-subtle);--bs-alert-border-color:var(--bs-dark-border-subtle);--bs-alert-link-color:var(--bs-dark-text-emphasis)}@keyframes progress-bar-stripes{0%{background-position-x:1rem}}.progress,.progress-stacked{--bs-progress-height:1rem;--bs-progress-font-size:0.75rem;--bs-progress-bg:var(--bs-secondary-bg);--bs-progress-border-radius:var(--bs-border-radius);--bs-progress-box-shadow:var(--bs-box-shadow-inset);--bs-progress-bar-color:#fff;--bs-progress-bar-bg:#0d6efd;--bs-progress-bar-transition:width 0.6s ease;display:flex;height:var(--bs-progress-height);overflow:hidden;font-size:var(--bs-progress-font-size);background-color:var(--bs-progress-bg);border-radius:var(--bs-progress-border-radius)}.progress-bar{display:flex;flex-direction:column;justify-content:center;overflow:hidden;color:var(--bs-progress-bar-color);text-align:center;white-space:nowrap;background-color:var(--bs-progress-bar-bg);transition:var(--bs-progress-bar-transition)}@media (prefers-reduced-motion:reduce){.progress-bar{transition:none}}.progress-bar-striped{background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-size:var(--bs-progress-height) var(--bs-progress-height)}.progress-stacked>.progress{overflow:visible}.progress-stacked>.progress>.progress-bar{width:100%}.progress-bar-animated{animation:1s linear infinite progress-bar-stripes}@media (prefers-reduced-motion:reduce){.progress-bar-animated{animation:none}}.list-group{--bs-list-group-color:var(--bs-body-color);--bs-list-group-bg:var(--bs-body-bg);--bs-list-group-border-color:var(--bs-border-color);--bs-list-group-border-width:var(--bs-border-width);--bs-list-group-border-radius:var(--bs-border-radius);--bs-list-group-item-padding-x:1rem;--bs-list-group-item-padding-y:0.5rem;--bs-list-group-action-color:var(--bs-secondary-color);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-tertiary-bg);--bs-list-group-action-active-color:var(--bs-body-color);--bs-list-group-action-active-bg:var(--bs-secondary-bg);--bs-list-group-disabled-color:var(--bs-secondary-color);--bs-list-group-disabled-bg:var(--bs-body-bg);--bs-list-group-active-color:#fff;--bs-list-group-active-bg:#0d6efd;--bs-list-group-active-border-color:#0d6efd;display:flex;flex-direction:column;padding-left:0;margin-bottom:0;border-radius:var(--bs-list-group-border-radius)}.list-group-numbered{list-style-type:none;counter-reset:section}.list-group-numbered>.list-group-item::before{content:counters(section, ".") ". ";counter-increment:section}.list-group-item-action{width:100%;color:var(--bs-list-group-action-color);text-align:inherit}.list-group-item-action:focus,.list-group-item-action:hover{z-index:1;color:var(--bs-list-group-action-hover-color);text-decoration:none;background-color:var(--bs-list-group-action-hover-bg)}.list-group-item-action:active{color:var(--bs-list-group-action-active-color);background-color:var(--bs-list-group-action-active-bg)}.list-group-item{position:relative;display:block;padding:var(--bs-list-group-item-padding-y) var(--bs-list-group-item-padding-x);color:var(--bs-list-group-color);text-decoration:none;background-color:var(--bs-list-group-bg);border:var(--bs-list-group-border-width) solid var(--bs-list-group-border-color)}.list-group-item:first-child{border-top-left-radius:inherit;border-top-right-radius:inherit}.list-group-item:last-child{border-bottom-right-radius:inherit;border-bottom-left-radius:inherit}.list-group-item.disabled,.list-group-item:disabled{color:var(--bs-list-group-disabled-color);pointer-events:none;background-color:var(--bs-list-group-disabled-bg)}.list-group-item.active{z-index:2;color:var(--bs-list-group-active-color);background-color:var(--bs-list-group-active-bg);border-color:var(--bs-list-group-active-border-color)}.list-group-item+.list-group-item{border-top-width:0}.list-group-item+.list-group-item.active{margin-top:calc(-1 * var(--bs-list-group-border-width));border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal{flex-direction:row}.list-group-horizontal>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal>.list-group-item:last-child:not(:first-child){border-top-right-radius:var(--bs-list-group-border-radius);border-bottom-left-radius:0}.list-group-horizontal>.list-group-item.active{margin-top:0}.list-group-horizontal>.list-group-item+.list-group-item{border-top-width:var(--bs-list-group-border-width);border-left-width:0}.list-group-horizontal>.list-group-item+.list-group-item.active{margin-left:calc(-1 * var(--bs-list-group-border-width));border-left-width:var(--bs-list-group-border-width)}@media (min-width:576px){.list-group-horizontal-sm{flex-direction:row}.list-group-horizontal-sm>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-sm>.list-group-item:last-child:not(:first-child){border-top-right-radius:var(--bs-list-group-border-radius);border-bottom-left-radius:0}.list-group-horizontal-sm>.list-group-item.active{margin-top:0}.list-group-horizontal-sm>.list-group-item+.list-group-item{border-top-width:var(--bs-list-group-border-width);border-left-width:0}.list-group-horizontal-sm>.list-group-item+.list-group-item.active{margin-left:calc(-1 * var(--bs-list-group-border-width));border-left-width:var(--bs-list-group-border-width)}}@media (min-width:768px){.list-group-horizontal-md{flex-direction:row}.list-group-horizontal-md>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-md>.list-group-item:last-child:not(:first-child){border-top-right-radius:var(--bs-list-group-border-radius);border-bottom-left-radius:0}.list-group-horizontal-md>.list-group-item.active{margin-top:0}.list-group-horizontal-md>.list-group-item+.list-group-item{border-top-width:var(--bs-list-group-border-width);border-left-width:0}.list-group-horizontal-md>.list-group-item+.list-group-item.active{margin-left:calc(-1 * var(--bs-list-group-border-width));border-left-width:var(--bs-list-group-border-width)}}@media (min-width:992px){.list-group-horizontal-lg{flex-direction:row}.list-group-horizontal-lg>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-lg>.list-group-item:last-child:not(:first-child){border-top-right-radius:var(--bs-list-group-border-radius);border-bottom-left-radius:0}.list-group-horizontal-lg>.list-group-item.active{margin-top:0}.list-group-horizontal-lg>.list-group-item+.list-group-item{border-top-width:var(--bs-list-group-border-width);border-left-width:0}.list-group-horizontal-lg>.list-group-item+.list-group-item.active{margin-left:calc(-1 * var(--bs-list-group-border-width));border-left-width:var(--bs-list-group-border-width)}}@media (min-width:1200px){.list-group-horizontal-xl{flex-direction:row}.list-group-horizontal-xl>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-xl>.list-group-item:last-child:not(:first-child){border-top-right-radius:var(--bs-list-group-border-radius);border-bottom-left-radius:0}.list-group-horizontal-xl>.list-group-item.active{margin-top:0}.list-group-horizontal-xl>.list-group-item+.list-group-item{border-top-width:var(--bs-list-group-border-width);border-left-width:0}.list-group-horizontal-xl>.list-group-item+.list-group-item.active{margin-left:calc(-1 * var(--bs-list-group-border-width));border-left-width:var(--bs-list-group-border-width)}}@media (min-width:1400px){.list-group-horizontal-xxl{flex-direction:row}.list-group-horizontal-xxl>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-xxl>.list-group-item:last-child:not(:first-child){border-top-right-radius:var(--bs-list-group-border-radius);border-bottom-left-radius:0}.list-group-horizontal-xxl>.list-group-item.active{margin-top:0}.list-group-horizontal-xxl>.list-group-item+.list-group-item{border-top-width:var(--bs-list-group-border-width);border-left-width:0}.list-group-horizontal-xxl>.list-group-item+.list-group-item.active{margin-left:calc(-1 * var(--bs-list-group-border-width));border-left-width:var(--bs-list-group-border-width)}}.list-group-flush{border-radius:0}.list-group-flush>.list-group-item{border-width:0 0 var(--bs-list-group-border-width)}.list-group-flush>.list-group-item:last-child{border-bottom-width:0}.list-group-item-primary{--bs-list-group-color:var(--bs-primary-text-emphasis);--bs-list-group-bg:var(--bs-primary-bg-subtle);--bs-list-group-border-color:var(--bs-primary-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-primary-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-primary-border-subtle);--bs-list-group-active-color:var(--bs-primary-bg-subtle);--bs-list-group-active-bg:var(--bs-primary-text-emphasis);--bs-list-group-active-border-color:var(--bs-primary-text-emphasis)}.list-group-item-secondary{--bs-list-group-color:var(--bs-secondary-text-emphasis);--bs-list-group-bg:var(--bs-secondary-bg-subtle);--bs-list-group-border-color:var(--bs-secondary-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-secondary-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-secondary-border-subtle);--bs-list-group-active-color:var(--bs-secondary-bg-subtle);--bs-list-group-active-bg:var(--bs-secondary-text-emphasis);--bs-list-group-active-border-color:var(--bs-secondary-text-emphasis)}.list-group-item-success{--bs-list-group-color:var(--bs-success-text-emphasis);--bs-list-group-bg:var(--bs-success-bg-subtle);--bs-list-group-border-color:var(--bs-success-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-success-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-success-border-subtle);--bs-list-group-active-color:var(--bs-success-bg-subtle);--bs-list-group-active-bg:var(--bs-success-text-emphasis);--bs-list-group-active-border-color:var(--bs-success-text-emphasis)}.list-group-item-info{--bs-list-group-color:var(--bs-info-text-emphasis);--bs-list-group-bg:var(--bs-info-bg-subtle);--bs-list-group-border-color:var(--bs-info-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-info-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-info-border-subtle);--bs-list-group-active-color:var(--bs-info-bg-subtle);--bs-list-group-active-bg:var(--bs-info-text-emphasis);--bs-list-group-active-border-color:var(--bs-info-text-emphasis)}.list-group-item-warning{--bs-list-group-color:var(--bs-warning-text-emphasis);--bs-list-group-bg:var(--bs-warning-bg-subtle);--bs-list-group-border-color:var(--bs-warning-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-warning-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-warning-border-subtle);--bs-list-group-active-color:var(--bs-warning-bg-subtle);--bs-list-group-active-bg:var(--bs-warning-text-emphasis);--bs-list-group-active-border-color:var(--bs-warning-text-emphasis)}.list-group-item-danger{--bs-list-group-color:var(--bs-danger-text-emphasis);--bs-list-group-bg:var(--bs-danger-bg-subtle);--bs-list-group-border-color:var(--bs-danger-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-danger-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-danger-border-subtle);--bs-list-group-active-color:var(--bs-danger-bg-subtle);--bs-list-group-active-bg:var(--bs-danger-text-emphasis);--bs-list-group-active-border-color:var(--bs-danger-text-emphasis)}.list-group-item-light{--bs-list-group-color:var(--bs-light-text-emphasis);--bs-list-group-bg:var(--bs-light-bg-subtle);--bs-list-group-border-color:var(--bs-light-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-light-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-light-border-subtle);--bs-list-group-active-color:var(--bs-light-bg-subtle);--bs-list-group-active-bg:var(--bs-light-text-emphasis);--bs-list-group-active-border-color:var(--bs-light-text-emphasis)}.list-group-item-dark{--bs-list-group-color:var(--bs-dark-text-emphasis);--bs-list-group-bg:var(--bs-dark-bg-subtle);--bs-list-group-border-color:var(--bs-dark-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-dark-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-dark-border-subtle);--bs-list-group-active-color:var(--bs-dark-bg-subtle);--bs-list-group-active-bg:var(--bs-dark-text-emphasis);--bs-list-group-active-border-color:var(--bs-dark-text-emphasis)}.btn-close{--bs-btn-close-color:#000;--bs-btn-close-bg:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23000'%3e%3cpath d='M.293.293a1 1 0 0 1 1.414 0L8 6.586 14.293.293a1 1 0 1 1 1.414 1.414L9.414 8l6.293 6.293a1 1 0 0 1-1.414 1.414L8 9.414l-6.293 6.293a1 1 0 0 1-1.414-1.414L6.586 8 .293 1.707a1 1 0 0 1 0-1.414z'/%3e%3c/svg%3e");--bs-btn-close-opacity:0.5;--bs-btn-close-hover-opacity:0.75;--bs-btn-close-focus-shadow:0 0 0 0.25rem rgba(13, 110, 253, 0.25);--bs-btn-close-focus-opacity:1;--bs-btn-close-disabled-opacity:0.25;--bs-btn-close-white-filter:invert(1) grayscale(100%) brightness(200%);box-sizing:content-box;width:1em;height:1em;padding:.25em .25em;color:var(--bs-btn-close-color);background:transparent var(--bs-btn-close-bg) center/1em auto no-repeat;border:0;border-radius:.375rem;opacity:var(--bs-btn-close-opacity)}.btn-close:hover{color:var(--bs-btn-close-color);text-decoration:none;opacity:var(--bs-btn-close-hover-opacity)}.btn-close:focus{outline:0;box-shadow:var(--bs-btn-close-focus-shadow);opacity:var(--bs-btn-close-focus-opacity)}.btn-close.disabled,.btn-close:disabled{pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none;opacity:var(--bs-btn-close-disabled-opacity)}.btn-close-white{filter:var(--bs-btn-close-white-filter)}[data-bs-theme=dark] .btn-close{filter:var(--bs-btn-close-white-filter)}.toast{--bs-toast-zindex:1090;--bs-toast-padding-x:0.75rem;--bs-toast-padding-y:0.5rem;--bs-toast-spacing:1.5rem;--bs-toast-max-width:350px;--bs-toast-font-size:0.875rem;--bs-toast-color: ;--bs-toast-bg:rgba(var(--bs-body-bg-rgb), 0.85);--bs-toast-border-width:var(--bs-border-width);--bs-toast-border-color:var(--bs-border-color-translucent);--bs-toast-border-radius:var(--bs-border-radius);--bs-toast-box-shadow:var(--bs-box-shadow);--bs-toast-header-color:var(--bs-secondary-color);--bs-toast-header-bg:rgba(var(--bs-body-bg-rgb), 0.85);--bs-toast-header-border-color:var(--bs-border-color-translucent);width:var(--bs-toast-max-width);max-width:100%;font-size:var(--bs-toast-font-size);color:var(--bs-toast-color);pointer-events:auto;background-color:var(--bs-toast-bg);background-clip:padding-box;border:var(--bs-toast-border-width) solid var(--bs-toast-border-color);box-shadow:var(--bs-toast-box-shadow);border-radius:var(--bs-toast-border-radius)}.toast.showing{opacity:0}.toast:not(.show){display:none}.toast-container{--bs-toast-zindex:1090;position:absolute;z-index:var(--bs-toast-zindex);width:-webkit-max-content;width:-moz-max-content;width:max-content;max-width:100%;pointer-events:none}.toast-container>:not(:last-child){margin-bottom:var(--bs-toast-spacing)}.toast-header{display:flex;align-items:center;padding:var(--bs-toast-padding-y) var(--bs-toast-padding-x);color:var(--bs-toast-header-color);background-color:var(--bs-toast-header-bg);background-clip:padding-box;border-bottom:var(--bs-toast-border-width) solid var(--bs-toast-header-border-color);border-top-left-radius:calc(var(--bs-toast-border-radius) - var(--bs-toast-border-width));border-top-right-radius:calc(var(--bs-toast-border-radius) - var(--bs-toast-border-width))}.toast-header .btn-close{margin-right:calc(-.5 * var(--bs-toast-padding-x));margin-left:var(--bs-toast-padding-x)}.toast-body{padding:var(--bs-toast-padding-x);word-wrap:break-word}.modal{--bs-modal-zindex:1055;--bs-modal-width:500px;--bs-modal-padding:1rem;--bs-modal-margin:0.5rem;--bs-modal-color: ;--bs-modal-bg:var(--bs-body-bg);--bs-modal-border-color:var(--bs-border-color-translucent);--bs-modal-border-width:var(--bs-border-width);--bs-modal-border-radius:var(--bs-border-radius-lg);--bs-modal-box-shadow:0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);--bs-modal-inner-border-radius:calc(var(--bs-border-radius-lg) - (var(--bs-border-width)));--bs-modal-header-padding-x:1rem;--bs-modal-header-padding-y:1rem;--bs-modal-header-padding:1rem 1rem;--bs-modal-header-border-color:var(--bs-border-color);--bs-modal-header-border-width:var(--bs-border-width);--bs-modal-title-line-height:1.5;--bs-modal-footer-gap:0.5rem;--bs-modal-footer-bg: ;--bs-modal-footer-border-color:var(--bs-border-color);--bs-modal-footer-border-width:var(--bs-border-width);position:fixed;top:0;left:0;z-index:var(--bs-modal-zindex);display:none;width:100%;height:100%;overflow-x:hidden;overflow-y:auto;outline:0}.modal-dialog{position:relative;width:auto;margin:var(--bs-modal-margin);pointer-events:none}.modal.fade .modal-dialog{transition:transform .3s ease-out;transform:translate(0,-50px)}@media (prefers-reduced-motion:reduce){.modal.fade .modal-dialog{transition:none}}.modal.show .modal-dialog{transform:none}.modal.modal-static .modal-dialog{transform:scale(1.02)}.modal-dialog-scrollable{height:calc(100% - var(--bs-modal-margin) * 2)}.modal-dialog-scrollable .modal-content{max-height:100%;overflow:hidden}.modal-dialog-scrollable .modal-body{overflow-y:auto}.modal-dialog-centered{display:flex;align-items:center;min-height:calc(100% - var(--bs-modal-margin) * 2)}.modal-content{position:relative;display:flex;flex-direction:column;width:100%;color:var(--bs-modal-color);pointer-events:auto;background-color:var(--bs-modal-bg);background-clip:padding-box;border:var(--bs-modal-border-width) solid var(--bs-modal-border-color);border-radius:var(--bs-modal-border-radius);outline:0}.modal-backdrop{--bs-backdrop-zindex:1050;--bs-backdrop-bg:#000;--bs-backdrop-opacity:0.5;position:fixed;top:0;left:0;z-index:var(--bs-backdrop-zindex);width:100vw;height:100vh;background-color:var(--bs-backdrop-bg)}.modal-backdrop.fade{opacity:0}.modal-backdrop.show{opacity:var(--bs-backdrop-opacity)}.modal-header{display:flex;flex-shrink:0;align-items:center;justify-content:space-between;padding:var(--bs-modal-header-padding);border-bottom:var(--bs-modal-header-border-width) solid var(--bs-modal-header-border-color);border-top-left-radius:var(--bs-modal-inner-border-radius);border-top-right-radius:var(--bs-modal-inner-border-radius)}.modal-header .btn-close{padding:calc(var(--bs-modal-header-padding-y) * .5) calc(var(--bs-modal-header-padding-x) * .5);margin:calc(-.5 * var(--bs-modal-header-padding-y)) calc(-.5 * var(--bs-modal-header-padding-x)) calc(-.5 * var(--bs-modal-header-padding-y)) auto}.modal-title{margin-bottom:0;line-height:var(--bs-modal-title-line-height)}.modal-body{position:relative;flex:1 1 auto;padding:var(--bs-modal-padding)}.modal-footer{display:flex;flex-shrink:0;flex-wrap:wrap;align-items:center;justify-content:flex-end;padding:calc(var(--bs-modal-padding) - var(--bs-modal-footer-gap) * .5);background-color:var(--bs-modal-footer-bg);border-top:var(--bs-modal-footer-border-width) solid var(--bs-modal-footer-border-color);border-bottom-right-radius:var(--bs-modal-inner-border-radius);border-bottom-left-radius:var(--bs-modal-inner-border-radius)}.modal-footer>*{margin:calc(var(--bs-modal-footer-gap) * .5)}@media (min-width:576px){.modal{--bs-modal-margin:1.75rem;--bs-modal-box-shadow:0 0.5rem 1rem rgba(0, 0, 0, 0.15)}.modal-dialog{max-width:var(--bs-modal-width);margin-right:auto;margin-left:auto}.modal-sm{--bs-modal-width:300px}}@media (min-width:992px){.modal-lg,.modal-xl{--bs-modal-width:800px}}@media (min-width:1200px){.modal-xl{--bs-modal-width:1140px}}.modal-fullscreen{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen .modal-footer,.modal-fullscreen .modal-header{border-radius:0}.modal-fullscreen .modal-body{overflow-y:auto}@media (max-width:575.98px){.modal-fullscreen-sm-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-sm-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-sm-down .modal-footer,.modal-fullscreen-sm-down .modal-header{border-radius:0}.modal-fullscreen-sm-down .modal-body{overflow-y:auto}}@media (max-width:767.98px){.modal-fullscreen-md-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-md-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-md-down .modal-footer,.modal-fullscreen-md-down .modal-header{border-radius:0}.modal-fullscreen-md-down .modal-body{overflow-y:auto}}@media (max-width:991.98px){.modal-fullscreen-lg-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-lg-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-lg-down .modal-footer,.modal-fullscreen-lg-down .modal-header{border-radius:0}.modal-fullscreen-lg-down .modal-body{overflow-y:auto}}@media (max-width:1199.98px){.modal-fullscreen-xl-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-xl-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-xl-down .modal-footer,.modal-fullscreen-xl-down .modal-header{border-radius:0}.modal-fullscreen-xl-down .modal-body{overflow-y:auto}}@media (max-width:1399.98px){.modal-fullscreen-xxl-down{width:100vw;max-width:none;height:100%;margin:0}.modal-fullscreen-xxl-down .modal-content{height:100%;border:0;border-radius:0}.modal-fullscreen-xxl-down .modal-footer,.modal-fullscreen-xxl-down .modal-header{border-radius:0}.modal-fullscreen-xxl-down .modal-body{overflow-y:auto}}.tooltip{--bs-tooltip-zindex:1080;--bs-tooltip-max-width:200px;--bs-tooltip-padding-x:0.5rem;--bs-tooltip-padding-y:0.25rem;--bs-tooltip-margin: ;--bs-tooltip-font-size:0.875rem;--bs-tooltip-color:var(--bs-body-bg);--bs-tooltip-bg:var(--bs-emphasis-color);--bs-tooltip-border-radius:var(--bs-border-radius);--bs-tooltip-opacity:0.9;--bs-tooltip-arrow-width:0.8rem;--bs-tooltip-arrow-height:0.4rem;z-index:var(--bs-tooltip-zindex);display:block;margin:var(--bs-tooltip-margin);font-family:var(--bs-font-sans-serif);font-style:normal;font-weight:400;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;white-space:normal;word-spacing:normal;line-break:auto;font-size:var(--bs-tooltip-font-size);word-wrap:break-word;opacity:0}.tooltip.show{opacity:var(--bs-tooltip-opacity)}.tooltip .tooltip-arrow{display:block;width:var(--bs-tooltip-arrow-width);height:var(--bs-tooltip-arrow-height)}.tooltip .tooltip-arrow::before{position:absolute;content:"";border-color:transparent;border-style:solid}.bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow,.bs-tooltip-top .tooltip-arrow{bottom:calc(-1 * var(--bs-tooltip-arrow-height))}.bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow::before,.bs-tooltip-top .tooltip-arrow::before{top:-1px;border-width:var(--bs-tooltip-arrow-height) calc(var(--bs-tooltip-arrow-width) * .5) 0;border-top-color:var(--bs-tooltip-bg)}.bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow,.bs-tooltip-end .tooltip-arrow{left:calc(-1 * var(--bs-tooltip-arrow-height));width:var(--bs-tooltip-arrow-height);height:var(--bs-tooltip-arrow-width)}.bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow::before,.bs-tooltip-end .tooltip-arrow::before{right:-1px;border-width:calc(var(--bs-tooltip-arrow-width) * .5) var(--bs-tooltip-arrow-height) calc(var(--bs-tooltip-arrow-width) * .5) 0;border-right-color:var(--bs-tooltip-bg)}.bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow,.bs-tooltip-bottom .tooltip-arrow{top:calc(-1 * var(--bs-tooltip-arrow-height))}.bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow::before,.bs-tooltip-bottom .tooltip-arrow::before{bottom:-1px;border-width:0 calc(var(--bs-tooltip-arrow-width) * .5) var(--bs-tooltip-arrow-height);border-bottom-color:var(--bs-tooltip-bg)}.bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow,.bs-tooltip-start .tooltip-arrow{right:calc(-1 * var(--bs-tooltip-arrow-height));width:var(--bs-tooltip-arrow-height);height:var(--bs-tooltip-arrow-width)}.bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow::before,.bs-tooltip-start .tooltip-arrow::before{left:-1px;border-width:calc(var(--bs-tooltip-arrow-width) * .5) 0 calc(var(--bs-tooltip-arrow-width) * .5) var(--bs-tooltip-arrow-height);border-left-color:var(--bs-tooltip-bg)}.tooltip-inner{max-width:var(--bs-tooltip-max-width);padding:var(--bs-tooltip-padding-y) var(--bs-tooltip-padding-x);color:var(--bs-tooltip-color);text-align:center;background-color:var(--bs-tooltip-bg);border-radius:var(--bs-tooltip-border-radius)}.popover{--bs-popover-zindex:1070;--bs-popover-max-width:276px;--bs-popover-font-size:0.875rem;--bs-popover-bg:var(--bs-body-bg);--bs-popover-border-width:var(--bs-border-width);--bs-popover-border-color:var(--bs-border-color-translucent);--bs-popover-border-radius:var(--bs-border-radius-lg);--bs-popover-inner-border-radius:calc(var(--bs-border-radius-lg) - var(--bs-border-width));--bs-popover-box-shadow:0 0.5rem 1rem rgba(0, 0, 0, 0.15);--bs-popover-header-padding-x:1rem;--bs-popover-header-padding-y:0.5rem;--bs-popover-header-font-size:1rem;--bs-popover-header-color:inherit;--bs-popover-header-bg:var(--bs-secondary-bg);--bs-popover-body-padding-x:1rem;--bs-popover-body-padding-y:1rem;--bs-popover-body-color:var(--bs-body-color);--bs-popover-arrow-width:1rem;--bs-popover-arrow-height:0.5rem;--bs-popover-arrow-border:var(--bs-popover-border-color);z-index:var(--bs-popover-zindex);display:block;max-width:var(--bs-popover-max-width);font-family:var(--bs-font-sans-serif);font-style:normal;font-weight:400;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;white-space:normal;word-spacing:normal;line-break:auto;font-size:var(--bs-popover-font-size);word-wrap:break-word;background-color:var(--bs-popover-bg);background-clip:padding-box;border:var(--bs-popover-border-width) solid var(--bs-popover-border-color);border-radius:var(--bs-popover-border-radius)}.popover .popover-arrow{display:block;width:var(--bs-popover-arrow-width);height:var(--bs-popover-arrow-height)}.popover .popover-arrow::after,.popover .popover-arrow::before{position:absolute;display:block;content:"";border-color:transparent;border-style:solid;border-width:0}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow,.bs-popover-top>.popover-arrow{bottom:calc(-1 * (var(--bs-popover-arrow-height)) - var(--bs-popover-border-width))}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow::after,.bs-popover-auto[data-popper-placement^=top]>.popover-arrow::before,.bs-popover-top>.popover-arrow::after,.bs-popover-top>.popover-arrow::before{border-width:var(--bs-popover-arrow-height) calc(var(--bs-popover-arrow-width) * .5) 0}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow::before,.bs-popover-top>.popover-arrow::before{bottom:0;border-top-color:var(--bs-popover-arrow-border)}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow::after,.bs-popover-top>.popover-arrow::after{bottom:var(--bs-popover-border-width);border-top-color:var(--bs-popover-bg)}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow,.bs-popover-end>.popover-arrow{left:calc(-1 * (var(--bs-popover-arrow-height)) - var(--bs-popover-border-width));width:var(--bs-popover-arrow-height);height:var(--bs-popover-arrow-width)}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow::after,.bs-popover-auto[data-popper-placement^=right]>.popover-arrow::before,.bs-popover-end>.popover-arrow::after,.bs-popover-end>.popover-arrow::before{border-width:calc(var(--bs-popover-arrow-width) * .5) var(--bs-popover-arrow-height) calc(var(--bs-popover-arrow-width) * .5) 0}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow::before,.bs-popover-end>.popover-arrow::before{left:0;border-right-color:var(--bs-popover-arrow-border)}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow::after,.bs-popover-end>.popover-arrow::after{left:var(--bs-popover-border-width);border-right-color:var(--bs-popover-bg)}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow,.bs-popover-bottom>.popover-arrow{top:calc(-1 * (var(--bs-popover-arrow-height)) - var(--bs-popover-border-width))}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow::after,.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow::before,.bs-popover-bottom>.popover-arrow::after,.bs-popover-bottom>.popover-arrow::before{border-width:0 calc(var(--bs-popover-arrow-width) * .5) var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow::before,.bs-popover-bottom>.popover-arrow::before{top:0;border-bottom-color:var(--bs-popover-arrow-border)}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow::after,.bs-popover-bottom>.popover-arrow::after{top:var(--bs-popover-border-width);border-bottom-color:var(--bs-popover-bg)}.bs-popover-auto[data-popper-placement^=bottom] .popover-header::before,.bs-popover-bottom .popover-header::before{position:absolute;top:0;left:50%;display:block;width:var(--bs-popover-arrow-width);margin-left:calc(-.5 * var(--bs-popover-arrow-width));content:"";border-bottom:var(--bs-popover-border-width) solid var(--bs-popover-header-bg)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow,.bs-popover-start>.popover-arrow{right:calc(-1 * (var(--bs-popover-arrow-height)) - var(--bs-popover-border-width));width:var(--bs-popover-arrow-height);height:var(--bs-popover-arrow-width)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow::after,.bs-popover-auto[data-popper-placement^=left]>.popover-arrow::before,.bs-popover-start>.popover-arrow::after,.bs-popover-start>.popover-arrow::before{border-width:calc(var(--bs-popover-arrow-width) * .5) 0 calc(var(--bs-popover-arrow-width) * .5) var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow::before,.bs-popover-start>.popover-arrow::before{right:0;border-left-color:var(--bs-popover-arrow-border)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow::after,.bs-popover-start>.popover-arrow::after{right:var(--bs-popover-border-width);border-left-color:var(--bs-popover-bg)}.popover-header{padding:var(--bs-popover-header-padding-y) var(--bs-popover-header-padding-x);margin-bottom:0;font-size:var(--bs-popover-header-font-size);color:var(--bs-popover-header-color);background-color:var(--bs-popover-header-bg);border-bottom:var(--bs-popover-border-width) solid var(--bs-popover-border-color);border-top-left-radius:var(--bs-popover-inner-border-radius);border-top-right-radius:var(--bs-popover-inner-border-radius)}.popover-header:empty{display:none}.popover-body{padding:var(--bs-popover-body-padding-y) var(--bs-popover-body-padding-x);color:var(--bs-popover-body-color)}.carousel{position:relative}.carousel.pointer-event{touch-action:pan-y}.carousel-inner{position:relative;width:100%;overflow:hidden}.carousel-inner::after{display:block;clear:both;content:""}.carousel-item{position:relative;display:none;float:left;width:100%;margin-right:-100%;-webkit-backface-visibility:hidden;backface-visibility:hidden;transition:transform .6s ease-in-out}@media (prefers-reduced-motion:reduce){.carousel-item{transition:none}}.carousel-item-next,.carousel-item-prev,.carousel-item.active{display:block}.active.carousel-item-end,.carousel-item-next:not(.carousel-item-start){transform:translateX(100%)}.active.carousel-item-start,.carousel-item-prev:not(.carousel-item-end){transform:translateX(-100%)}.carousel-fade .carousel-item{opacity:0;transition-property:opacity;transform:none}.carousel-fade .carousel-item-next.carousel-item-start,.carousel-fade .carousel-item-prev.carousel-item-end,.carousel-fade .carousel-item.active{z-index:1;opacity:1}.carousel-fade .active.carousel-item-end,.carousel-fade .active.carousel-item-start{z-index:0;opacity:0;transition:opacity 0s .6s}@media (prefers-reduced-motion:reduce){.carousel-fade .active.carousel-item-end,.carousel-fade .active.carousel-item-start{transition:none}}.carousel-control-next,.carousel-control-prev{position:absolute;top:0;bottom:0;z-index:1;display:flex;align-items:center;justify-content:center;width:15%;padding:0;color:#fff;text-align:center;background:0 0;border:0;opacity:.5;transition:opacity .15s ease}@media (prefers-reduced-motion:reduce){.carousel-control-next,.carousel-control-prev{transition:none}}.carousel-control-next:focus,.carousel-control-next:hover,.carousel-control-prev:focus,.carousel-control-prev:hover{color:#fff;text-decoration:none;outline:0;opacity:.9}.carousel-control-prev{left:0}.carousel-control-next{right:0}.carousel-control-next-icon,.carousel-control-prev-icon{display:inline-block;width:2rem;height:2rem;background-repeat:no-repeat;background-position:50%;background-size:100% 100%}.carousel-control-prev-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3e%3cpath d='M11.354 1.646a.5.5 0 0 1 0 .708L5.707 8l5.647 5.646a.5.5 0 0 1-.708.708l-6-6a.5.5 0 0 1 0-.708l6-6a.5.5 0 0 1 .708 0z'/%3e%3c/svg%3e")}.carousel-control-next-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3e%3cpath d='M4.646 1.646a.5.5 0 0 1 .708 0l6 6a.5.5 0 0 1 0 .708l-6 6a.5.5 0 0 1-.708-.708L10.293 8 4.646 2.354a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e")}.carousel-indicators{position:absolute;right:0;bottom:0;left:0;z-index:2;display:flex;justify-content:center;padding:0;margin-right:15%;margin-bottom:1rem;margin-left:15%}.carousel-indicators [data-bs-target]{box-sizing:content-box;flex:0 1 auto;width:30px;height:3px;padding:0;margin-right:3px;margin-left:3px;text-indent:-999px;cursor:pointer;background-color:#fff;background-clip:padding-box;border:0;border-top:10px solid transparent;border-bottom:10px solid transparent;opacity:.5;transition:opacity .6s ease}@media (prefers-reduced-motion:reduce){.carousel-indicators [data-bs-target]{transition:none}}.carousel-indicators .active{opacity:1}.carousel-caption{position:absolute;right:15%;bottom:1.25rem;left:15%;padding-top:1.25rem;padding-bottom:1.25rem;color:#fff;text-align:center}.carousel-dark .carousel-control-next-icon,.carousel-dark .carousel-control-prev-icon{filter:invert(1) grayscale(100)}.carousel-dark .carousel-indicators [data-bs-target]{background-color:#000}.carousel-dark .carousel-caption{color:#000}[data-bs-theme=dark] .carousel .carousel-control-next-icon,[data-bs-theme=dark] .carousel .carousel-control-prev-icon,[data-bs-theme=dark].carousel .carousel-control-next-icon,[data-bs-theme=dark].carousel .carousel-control-prev-icon{filter:invert(1) grayscale(100)}[data-bs-theme=dark] .carousel .carousel-indicators [data-bs-target],[data-bs-theme=dark].carousel .carousel-indicators [data-bs-target]{background-color:#000}[data-bs-theme=dark] .carousel .carousel-caption,[data-bs-theme=dark].carousel .carousel-caption{color:#000}.spinner-border,.spinner-grow{display:inline-block;width:var(--bs-spinner-width);height:var(--bs-spinner-height);vertical-align:var(--bs-spinner-vertical-align);border-radius:50%;animation:var(--bs-spinner-animation-speed) linear infinite var(--bs-spinner-animation-name)}@keyframes spinner-border{to{transform:rotate(360deg)}}.spinner-border{--bs-spinner-width:2rem;--bs-spinner-height:2rem;--bs-spinner-vertical-align:-0.125em;--bs-spinner-border-width:0.25em;--bs-spinner-animation-speed:0.75s;--bs-spinner-animation-name:spinner-border;border:var(--bs-spinner-border-width) solid currentcolor;border-right-color:transparent}.spinner-border-sm{--bs-spinner-width:1rem;--bs-spinner-height:1rem;--bs-spinner-border-width:0.2em}@keyframes spinner-grow{0%{transform:scale(0)}50%{opacity:1;transform:none}}.spinner-grow{--bs-spinner-width:2rem;--bs-spinner-height:2rem;--bs-spinner-vertical-align:-0.125em;--bs-spinner-animation-speed:0.75s;--bs-spinner-animation-name:spinner-grow;background-color:currentcolor;opacity:0}.spinner-grow-sm{--bs-spinner-width:1rem;--bs-spinner-height:1rem}@media (prefers-reduced-motion:reduce){.spinner-border,.spinner-grow{--bs-spinner-animation-speed:1.5s}}.offcanvas,.offcanvas-lg,.offcanvas-md,.offcanvas-sm,.offcanvas-xl,.offcanvas-xxl{--bs-offcanvas-zindex:1045;--bs-offcanvas-width:400px;--bs-offcanvas-height:30vh;--bs-offcanvas-padding-x:1rem;--bs-offcanvas-padding-y:1rem;--bs-offcanvas-color:var(--bs-body-color);--bs-offcanvas-bg:var(--bs-body-bg);--bs-offcanvas-border-width:var(--bs-border-width);--bs-offcanvas-border-color:var(--bs-border-color-translucent);--bs-offcanvas-box-shadow:0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);--bs-offcanvas-transition:transform 0.3s ease-in-out;--bs-offcanvas-title-line-height:1.5}@media (max-width:575.98px){.offcanvas-sm{position:fixed;bottom:0;z-index:var(--bs-offcanvas-zindex);display:flex;flex-direction:column;max-width:100%;color:var(--bs-offcanvas-color);visibility:hidden;background-color:var(--bs-offcanvas-bg);background-clip:padding-box;outline:0;transition:var(--bs-offcanvas-transition)}}@media (max-width:575.98px) and (prefers-reduced-motion:reduce){.offcanvas-sm{transition:none}}@media (max-width:575.98px){.offcanvas-sm.offcanvas-start{top:0;left:0;width:var(--bs-offcanvas-width);border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(-100%)}.offcanvas-sm.offcanvas-end{top:0;right:0;width:var(--bs-offcanvas-width);border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(100%)}.offcanvas-sm.offcanvas-top{top:0;right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(-100%)}.offcanvas-sm.offcanvas-bottom{right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(100%)}.offcanvas-sm.show:not(.hiding),.offcanvas-sm.showing{transform:none}.offcanvas-sm.hiding,.offcanvas-sm.show,.offcanvas-sm.showing{visibility:visible}}@media (min-width:576px){.offcanvas-sm{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:transparent!important}.offcanvas-sm .offcanvas-header{display:none}.offcanvas-sm .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible;background-color:transparent!important}}@media (max-width:767.98px){.offcanvas-md{position:fixed;bottom:0;z-index:var(--bs-offcanvas-zindex);display:flex;flex-direction:column;max-width:100%;color:var(--bs-offcanvas-color);visibility:hidden;background-color:var(--bs-offcanvas-bg);background-clip:padding-box;outline:0;transition:var(--bs-offcanvas-transition)}}@media (max-width:767.98px) and (prefers-reduced-motion:reduce){.offcanvas-md{transition:none}}@media (max-width:767.98px){.offcanvas-md.offcanvas-start{top:0;left:0;width:var(--bs-offcanvas-width);border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(-100%)}.offcanvas-md.offcanvas-end{top:0;right:0;width:var(--bs-offcanvas-width);border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(100%)}.offcanvas-md.offcanvas-top{top:0;right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(-100%)}.offcanvas-md.offcanvas-bottom{right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(100%)}.offcanvas-md.show:not(.hiding),.offcanvas-md.showing{transform:none}.offcanvas-md.hiding,.offcanvas-md.show,.offcanvas-md.showing{visibility:visible}}@media (min-width:768px){.offcanvas-md{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:transparent!important}.offcanvas-md .offcanvas-header{display:none}.offcanvas-md .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible;background-color:transparent!important}}@media (max-width:991.98px){.offcanvas-lg{position:fixed;bottom:0;z-index:var(--bs-offcanvas-zindex);display:flex;flex-direction:column;max-width:100%;color:var(--bs-offcanvas-color);visibility:hidden;background-color:var(--bs-offcanvas-bg);background-clip:padding-box;outline:0;transition:var(--bs-offcanvas-transition)}}@media (max-width:991.98px) and (prefers-reduced-motion:reduce){.offcanvas-lg{transition:none}}@media (max-width:991.98px){.offcanvas-lg.offcanvas-start{top:0;left:0;width:var(--bs-offcanvas-width);border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(-100%)}.offcanvas-lg.offcanvas-end{top:0;right:0;width:var(--bs-offcanvas-width);border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(100%)}.offcanvas-lg.offcanvas-top{top:0;right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(-100%)}.offcanvas-lg.offcanvas-bottom{right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(100%)}.offcanvas-lg.show:not(.hiding),.offcanvas-lg.showing{transform:none}.offcanvas-lg.hiding,.offcanvas-lg.show,.offcanvas-lg.showing{visibility:visible}}@media (min-width:992px){.offcanvas-lg{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:transparent!important}.offcanvas-lg .offcanvas-header{display:none}.offcanvas-lg .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible;background-color:transparent!important}}@media (max-width:1199.98px){.offcanvas-xl{position:fixed;bottom:0;z-index:var(--bs-offcanvas-zindex);display:flex;flex-direction:column;max-width:100%;color:var(--bs-offcanvas-color);visibility:hidden;background-color:var(--bs-offcanvas-bg);background-clip:padding-box;outline:0;transition:var(--bs-offcanvas-transition)}}@media (max-width:1199.98px) and (prefers-reduced-motion:reduce){.offcanvas-xl{transition:none}}@media (max-width:1199.98px){.offcanvas-xl.offcanvas-start{top:0;left:0;width:var(--bs-offcanvas-width);border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(-100%)}.offcanvas-xl.offcanvas-end{top:0;right:0;width:var(--bs-offcanvas-width);border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(100%)}.offcanvas-xl.offcanvas-top{top:0;right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(-100%)}.offcanvas-xl.offcanvas-bottom{right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(100%)}.offcanvas-xl.show:not(.hiding),.offcanvas-xl.showing{transform:none}.offcanvas-xl.hiding,.offcanvas-xl.show,.offcanvas-xl.showing{visibility:visible}}@media (min-width:1200px){.offcanvas-xl{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:transparent!important}.offcanvas-xl .offcanvas-header{display:none}.offcanvas-xl .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible;background-color:transparent!important}}@media (max-width:1399.98px){.offcanvas-xxl{position:fixed;bottom:0;z-index:var(--bs-offcanvas-zindex);display:flex;flex-direction:column;max-width:100%;color:var(--bs-offcanvas-color);visibility:hidden;background-color:var(--bs-offcanvas-bg);background-clip:padding-box;outline:0;transition:var(--bs-offcanvas-transition)}}@media (max-width:1399.98px) and (prefers-reduced-motion:reduce){.offcanvas-xxl{transition:none}}@media (max-width:1399.98px){.offcanvas-xxl.offcanvas-start{top:0;left:0;width:var(--bs-offcanvas-width);border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(-100%)}.offcanvas-xxl.offcanvas-end{top:0;right:0;width:var(--bs-offcanvas-width);border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(100%)}.offcanvas-xxl.offcanvas-top{top:0;right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(-100%)}.offcanvas-xxl.offcanvas-bottom{right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(100%)}.offcanvas-xxl.show:not(.hiding),.offcanvas-xxl.showing{transform:none}.offcanvas-xxl.hiding,.offcanvas-xxl.show,.offcanvas-xxl.showing{visibility:visible}}@media (min-width:1400px){.offcanvas-xxl{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:transparent!important}.offcanvas-xxl .offcanvas-header{display:none}.offcanvas-xxl .offcanvas-body{display:flex;flex-grow:0;padding:0;overflow-y:visible;background-color:transparent!important}}.offcanvas{position:fixed;bottom:0;z-index:var(--bs-offcanvas-zindex);display:flex;flex-direction:column;max-width:100%;color:var(--bs-offcanvas-color);visibility:hidden;background-color:var(--bs-offcanvas-bg);background-clip:padding-box;outline:0;transition:var(--bs-offcanvas-transition)}@media (prefers-reduced-motion:reduce){.offcanvas{transition:none}}.offcanvas.offcanvas-start{top:0;left:0;width:var(--bs-offcanvas-width);border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(-100%)}.offcanvas.offcanvas-end{top:0;right:0;width:var(--bs-offcanvas-width);border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateX(100%)}.offcanvas.offcanvas-top{top:0;right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(-100%)}.offcanvas.offcanvas-bottom{right:0;left:0;height:var(--bs-offcanvas-height);max-height:100%;border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);transform:translateY(100%)}.offcanvas.show:not(.hiding),.offcanvas.showing{transform:none}.offcanvas.hiding,.offcanvas.show,.offcanvas.showing{visibility:visible}.offcanvas-backdrop{position:fixed;top:0;left:0;z-index:1040;width:100vw;height:100vh;background-color:#000}.offcanvas-backdrop.fade{opacity:0}.offcanvas-backdrop.show{opacity:.5}.offcanvas-header{display:flex;align-items:center;justify-content:space-between;padding:var(--bs-offcanvas-padding-y) var(--bs-offcanvas-padding-x)}.offcanvas-header .btn-close{padding:calc(var(--bs-offcanvas-padding-y) * .5) calc(var(--bs-offcanvas-padding-x) * .5);margin-top:calc(-.5 * var(--bs-offcanvas-padding-y));margin-right:calc(-.5 * var(--bs-offcanvas-padding-x));margin-bottom:calc(-.5 * var(--bs-offcanvas-padding-y))}.offcanvas-title{margin-bottom:0;line-height:var(--bs-offcanvas-title-line-height)}.offcanvas-body{flex-grow:1;padding:var(--bs-offcanvas-padding-y) var(--bs-offcanvas-padding-x);overflow-y:auto}.placeholder{display:inline-block;min-height:1em;vertical-align:middle;cursor:wait;background-color:currentcolor;opacity:.5}.placeholder.btn::before{display:inline-block;content:""}.placeholder-xs{min-height:.6em}.placeholder-sm{min-height:.8em}.placeholder-lg{min-height:1.2em}.placeholder-glow .placeholder{animation:placeholder-glow 2s ease-in-out infinite}@keyframes placeholder-glow{50%{opacity:.2}}.placeholder-wave{-webkit-mask-image:linear-gradient(130deg,#000 55%,rgba(0,0,0,0.8) 75%,#000 95%);mask-image:linear-gradient(130deg,#000 55%,rgba(0,0,0,0.8) 75%,#000 95%);-webkit-mask-size:200% 100%;mask-size:200% 100%;animation:placeholder-wave 2s linear infinite}@keyframes placeholder-wave{100%{-webkit-mask-position:-200% 0%;mask-position:-200% 0%}}.clearfix::after{display:block;clear:both;content:""}.text-bg-primary{color:#fff!important;background-color:RGBA(13,110,253,var(--bs-bg-opacity,1))!important}.text-bg-secondary{color:#fff!important;background-color:RGBA(108,117,125,var(--bs-bg-opacity,1))!important}.text-bg-success{color:#fff!important;background-color:RGBA(25,135,84,var(--bs-bg-opacity,1))!important}.text-bg-info{color:#000!important;background-color:RGBA(13,202,240,var(--bs-bg-opacity,1))!important}.text-bg-warning{color:#000!important;background-color:RGBA(255,193,7,var(--bs-bg-opacity,1))!important}.text-bg-danger{color:#fff!important;background-color:RGBA(220,53,69,var(--bs-bg-opacity,1))!important}.text-bg-light{color:#000!important;background-color:RGBA(248,249,250,var(--bs-bg-opacity,1))!important}.text-bg-dark{color:#fff!important;background-color:RGBA(33,37,41,var(--bs-bg-opacity,1))!important}.link-primary{color:RGBA(var(--bs-primary-rgb),var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(var(--bs-primary-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(var(--bs-primary-rgb),var(--bs-link-underline-opacity,1))!important}.link-primary:focus,.link-primary:hover{color:RGBA(10,88,202,var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(10,88,202,var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(10,88,202,var(--bs-link-underline-opacity,1))!important}.link-secondary{color:RGBA(var(--bs-secondary-rgb),var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(var(--bs-secondary-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(var(--bs-secondary-rgb),var(--bs-link-underline-opacity,1))!important}.link-secondary:focus,.link-secondary:hover{color:RGBA(86,94,100,var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(86,94,100,var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(86,94,100,var(--bs-link-underline-opacity,1))!important}.link-success{color:RGBA(var(--bs-success-rgb),var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(var(--bs-success-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(var(--bs-success-rgb),var(--bs-link-underline-opacity,1))!important}.link-success:focus,.link-success:hover{color:RGBA(20,108,67,var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(20,108,67,var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(20,108,67,var(--bs-link-underline-opacity,1))!important}.link-info{color:RGBA(var(--bs-info-rgb),var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(var(--bs-info-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(var(--bs-info-rgb),var(--bs-link-underline-opacity,1))!important}.link-info:focus,.link-info:hover{color:RGBA(61,213,243,var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(61,213,243,var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(61,213,243,var(--bs-link-underline-opacity,1))!important}.link-warning{color:RGBA(var(--bs-warning-rgb),var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(var(--bs-warning-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(var(--bs-warning-rgb),var(--bs-link-underline-opacity,1))!important}.link-warning:focus,.link-warning:hover{color:RGBA(255,205,57,var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(255,205,57,var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(255,205,57,var(--bs-link-underline-opacity,1))!important}.link-danger{color:RGBA(var(--bs-danger-rgb),var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(var(--bs-danger-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(var(--bs-danger-rgb),var(--bs-link-underline-opacity,1))!important}.link-danger:focus,.link-danger:hover{color:RGBA(176,42,55,var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(176,42,55,var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(176,42,55,var(--bs-link-underline-opacity,1))!important}.link-light{color:RGBA(var(--bs-light-rgb),var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(var(--bs-light-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(var(--bs-light-rgb),var(--bs-link-underline-opacity,1))!important}.link-light:focus,.link-light:hover{color:RGBA(249,250,251,var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(249,250,251,var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(249,250,251,var(--bs-link-underline-opacity,1))!important}.link-dark{color:RGBA(var(--bs-dark-rgb),var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(var(--bs-dark-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(var(--bs-dark-rgb),var(--bs-link-underline-opacity,1))!important}.link-dark:focus,.link-dark:hover{color:RGBA(26,30,33,var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(26,30,33,var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(26,30,33,var(--bs-link-underline-opacity,1))!important}.link-body-emphasis{color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-opacity,1))!important;-webkit-text-decoration-color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-underline-opacity,1))!important}.link-body-emphasis:focus,.link-body-emphasis:hover{color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-opacity,.75))!important;-webkit-text-decoration-color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-underline-opacity,0.75))!important;text-decoration-color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-underline-opacity,0.75))!important}.focus-ring:focus{outline:0;box-shadow:var(--bs-focus-ring-x,0) var(--bs-focus-ring-y,0) var(--bs-focus-ring-blur,0) var(--bs-focus-ring-width) var(--bs-focus-ring-color)}.icon-link{display:inline-flex;gap:.375rem;align-items:center;-webkit-text-decoration-color:rgba(var(--bs-link-color-rgb),var(--bs-link-opacity,0.5));text-decoration-color:rgba(var(--bs-link-color-rgb),var(--bs-link-opacity,0.5));text-underline-offset:0.25em;-webkit-backface-visibility:hidden;backface-visibility:hidden}.icon-link>.bi{flex-shrink:0;width:1em;height:1em;fill:currentcolor;transition:.2s ease-in-out transform}@media (prefers-reduced-motion:reduce){.icon-link>.bi{transition:none}}.icon-link-hover:focus-visible>.bi,.icon-link-hover:hover>.bi{transform:var(--bs-icon-link-transform,translate3d(.25em,0,0))}.ratio{position:relative;width:100%}.ratio::before{display:block;padding-top:var(--bs-aspect-ratio);content:""}.ratio>*{position:absolute;top:0;left:0;width:100%;height:100%}.ratio-1x1{--bs-aspect-ratio:100%}.ratio-4x3{--bs-aspect-ratio:75%}.ratio-16x9{--bs-aspect-ratio:56.25%}.ratio-21x9{--bs-aspect-ratio:42.8571428571%}.fixed-top{position:fixed;top:0;right:0;left:0;z-index:1030}.fixed-bottom{position:fixed;right:0;bottom:0;left:0;z-index:1030}.sticky-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}.sticky-bottom{position:-webkit-sticky;position:sticky;bottom:0;z-index:1020}@media (min-width:576px){.sticky-sm-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}.sticky-sm-bottom{position:-webkit-sticky;position:sticky;bottom:0;z-index:1020}}@media (min-width:768px){.sticky-md-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}.sticky-md-bottom{position:-webkit-sticky;position:sticky;bottom:0;z-index:1020}}@media (min-width:992px){.sticky-lg-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}.sticky-lg-bottom{position:-webkit-sticky;position:sticky;bottom:0;z-index:1020}}@media (min-width:1200px){.sticky-xl-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}.sticky-xl-bottom{position:-webkit-sticky;position:sticky;bottom:0;z-index:1020}}@media (min-width:1400px){.sticky-xxl-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}.sticky-xxl-bottom{position:-webkit-sticky;position:sticky;bottom:0;z-index:1020}}.hstack{display:flex;flex-direction:row;align-items:center;align-self:stretch}.vstack{display:flex;flex:1 1 auto;flex-direction:column;align-self:stretch}.visually-hidden,.visually-hidden-focusable:not(:focus):not(:focus-within){width:1px!important;height:1px!important;padding:0!important;margin:-1px!important;overflow:hidden!important;clip:rect(0,0,0,0)!important;white-space:nowrap!important;border:0!important}.visually-hidden-focusable:not(:focus):not(:focus-within):not(caption),.visually-hidden:not(caption){position:absolute!important}.stretched-link::after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;content:""}.text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.vr{display:inline-block;align-self:stretch;width:1px;min-height:1em;background-color:currentcolor;opacity:.25}.align-baseline{vertical-align:baseline!important}.align-top{vertical-align:top!important}.align-middle{vertical-align:middle!important}.align-bottom{vertical-align:bottom!important}.align-text-bottom{vertical-align:text-bottom!important}.align-text-top{vertical-align:text-top!important}.float-start{float:left!important}.float-end{float:right!important}.float-none{float:none!important}.object-fit-contain{-o-object-fit:contain!important;object-fit:contain!important}.object-fit-cover{-o-object-fit:cover!important;object-fit:cover!important}.object-fit-fill{-o-object-fit:fill!important;object-fit:fill!important}.object-fit-scale{-o-object-fit:scale-down!important;object-fit:scale-down!important}.object-fit-none{-o-object-fit:none!important;object-fit:none!important}.opacity-0{opacity:0!important}.opacity-25{opacity:.25!important}.opacity-50{opacity:.5!important}.opacity-75{opacity:.75!important}.opacity-100{opacity:1!important}.overflow-auto{overflow:auto!important}.overflow-hidden{overflow:hidden!important}.overflow-visible{overflow:visible!important}.overflow-scroll{overflow:scroll!important}.overflow-x-auto{overflow-x:auto!important}.overflow-x-hidden{overflow-x:hidden!important}.overflow-x-visible{overflow-x:visible!important}.overflow-x-scroll{overflow-x:scroll!important}.overflow-y-auto{overflow-y:auto!important}.overflow-y-hidden{overflow-y:hidden!important}.overflow-y-visible{overflow-y:visible!important}.overflow-y-scroll{overflow-y:scroll!important}.d-inline{display:inline!important}.d-inline-block{display:inline-block!important}.d-block{display:block!important}.d-grid{display:grid!important}.d-inline-grid{display:inline-grid!important}.d-table{display:table!important}.d-table-row{display:table-row!important}.d-table-cell{display:table-cell!important}.d-flex{display:flex!important}.d-inline-flex{display:inline-flex!important}.d-none{display:none!important}.shadow{box-shadow:0 .5rem 1rem rgba(0,0,0,.15)!important}.shadow-sm{box-shadow:0 .125rem .25rem rgba(0,0,0,.075)!important}.shadow-lg{box-shadow:0 1rem 3rem rgba(0,0,0,.175)!important}.shadow-none{box-shadow:none!important}.focus-ring-primary{--bs-focus-ring-color:rgba(var(--bs-primary-rgb), var(--bs-focus-ring-opacity))}.focus-ring-secondary{--bs-focus-ring-color:rgba(var(--bs-secondary-rgb), var(--bs-focus-ring-opacity))}.focus-ring-success{--bs-focus-ring-color:rgba(var(--bs-success-rgb), var(--bs-focus-ring-opacity))}.focus-ring-info{--bs-focus-ring-color:rgba(var(--bs-info-rgb), var(--bs-focus-ring-opacity))}.focus-ring-warning{--bs-focus-ring-color:rgba(var(--bs-warning-rgb), var(--bs-focus-ring-opacity))}.focus-ring-danger{--bs-focus-ring-color:rgba(var(--bs-danger-rgb), var(--bs-focus-ring-opacity))}.focus-ring-light{--bs-focus-ring-color:rgba(var(--bs-light-rgb), var(--bs-focus-ring-opacity))}.focus-ring-dark{--bs-focus-ring-color:rgba(var(--bs-dark-rgb), var(--bs-focus-ring-opacity))}.position-static{position:static!important}.position-relative{position:relative!important}.position-absolute{position:absolute!important}.position-fixed{position:fixed!important}.position-sticky{position:-webkit-sticky!important;position:sticky!important}.top-0{top:0!important}.top-50{top:50%!important}.top-100{top:100%!important}.bottom-0{bottom:0!important}.bottom-50{bottom:50%!important}.bottom-100{bottom:100%!important}.start-0{left:0!important}.start-50{left:50%!important}.start-100{left:100%!important}.end-0{right:0!important}.end-50{right:50%!important}.end-100{right:100%!important}.translate-middle{transform:translate(-50%,-50%)!important}.translate-middle-x{transform:translateX(-50%)!important}.translate-middle-y{transform:translateY(-50%)!important}.border{border:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-0{border:0!important}.border-top{border-top:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-top-0{border-top:0!important}.border-end{border-right:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-end-0{border-right:0!important}.border-bottom{border-bottom:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-bottom-0{border-bottom:0!important}.border-start{border-left:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-start-0{border-left:0!important}.border-primary{--bs-border-opacity:1;border-color:rgba(var(--bs-primary-rgb),var(--bs-border-opacity))!important}.border-secondary{--bs-border-opacity:1;border-color:rgba(var(--bs-secondary-rgb),var(--bs-border-opacity))!important}.border-success{--bs-border-opacity:1;border-color:rgba(var(--bs-success-rgb),var(--bs-border-opacity))!important}.border-info{--bs-border-opacity:1;border-color:rgba(var(--bs-info-rgb),var(--bs-border-opacity))!important}.border-warning{--bs-border-opacity:1;border-color:rgba(var(--bs-warning-rgb),var(--bs-border-opacity))!important}.border-danger{--bs-border-opacity:1;border-color:rgba(var(--bs-danger-rgb),var(--bs-border-opacity))!important}.border-light{--bs-border-opacity:1;border-color:rgba(var(--bs-light-rgb),var(--bs-border-opacity))!important}.border-dark{--bs-border-opacity:1;border-color:rgba(var(--bs-dark-rgb),var(--bs-border-opacity))!important}.border-black{--bs-border-opacity:1;border-color:rgba(var(--bs-black-rgb),var(--bs-border-opacity))!important}.border-white{--bs-border-opacity:1;border-color:rgba(var(--bs-white-rgb),var(--bs-border-opacity))!important}.border-primary-subtle{border-color:var(--bs-primary-border-subtle)!important}.border-secondary-subtle{border-color:var(--bs-secondary-border-subtle)!important}.border-success-subtle{border-color:var(--bs-success-border-subtle)!important}.border-info-subtle{border-color:var(--bs-info-border-subtle)!important}.border-warning-subtle{border-color:var(--bs-warning-border-subtle)!important}.border-danger-subtle{border-color:var(--bs-danger-border-subtle)!important}.border-light-subtle{border-color:var(--bs-light-border-subtle)!important}.border-dark-subtle{border-color:var(--bs-dark-border-subtle)!important}.border-1{border-width:1px!important}.border-2{border-width:2px!important}.border-3{border-width:3px!important}.border-4{border-width:4px!important}.border-5{border-width:5px!important}.border-opacity-10{--bs-border-opacity:0.1}.border-opacity-25{--bs-border-opacity:0.25}.border-opacity-50{--bs-border-opacity:0.5}.border-opacity-75{--bs-border-opacity:0.75}.border-opacity-100{--bs-border-opacity:1}.w-25{width:25%!important}.w-50{width:50%!important}.w-75{width:75%!important}.w-100{width:100%!important}.w-auto{width:auto!important}.mw-100{max-width:100%!important}.vw-100{width:100vw!important}.min-vw-100{min-width:100vw!important}.h-25{height:25%!important}.h-50{height:50%!important}.h-75{height:75%!important}.h-100{height:100%!important}.h-auto{height:auto!important}.mh-100{max-height:100%!important}.vh-100{height:100vh!important}.min-vh-100{min-height:100vh!important}.flex-fill{flex:1 1 auto!important}.flex-row{flex-direction:row!important}.flex-column{flex-direction:column!important}.flex-row-reverse{flex-direction:row-reverse!important}.flex-column-reverse{flex-direction:column-reverse!important}.flex-grow-0{flex-grow:0!important}.flex-grow-1{flex-grow:1!important}.flex-shrink-0{flex-shrink:0!important}.flex-shrink-1{flex-shrink:1!important}.flex-wrap{flex-wrap:wrap!important}.flex-nowrap{flex-wrap:nowrap!important}.flex-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-start{justify-content:flex-start!important}.justify-content-end{justify-content:flex-end!important}.justify-content-center{justify-content:center!important}.justify-content-between{justify-content:space-between!important}.justify-content-around{justify-content:space-around!important}.justify-content-evenly{justify-content:space-evenly!important}.align-items-start{align-items:flex-start!important}.align-items-end{align-items:flex-end!important}.align-items-center{align-items:center!important}.align-items-baseline{align-items:baseline!important}.align-items-stretch{align-items:stretch!important}.align-content-start{align-content:flex-start!important}.align-content-end{align-content:flex-end!important}.align-content-center{align-content:center!important}.align-content-between{align-content:space-between!important}.align-content-around{align-content:space-around!important}.align-content-stretch{align-content:stretch!important}.align-self-auto{align-self:auto!important}.align-self-start{align-self:flex-start!important}.align-self-end{align-self:flex-end!important}.align-self-center{align-self:center!important}.align-self-baseline{align-self:baseline!important}.align-self-stretch{align-self:stretch!important}.order-first{order:-1!important}.order-0{order:0!important}.order-1{order:1!important}.order-2{order:2!important}.order-3{order:3!important}.order-4{order:4!important}.order-5{order:5!important}.order-last{order:6!important}.m-0{margin:0!important}.m-1{margin:.25rem!important}.m-2{margin:.5rem!important}.m-3{margin:1rem!important}.m-4{margin:1.5rem!important}.m-5{margin:3rem!important}.m-auto{margin:auto!important}.mx-0{margin-right:0!important;margin-left:0!important}.mx-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-3{margin-right:1rem!important;margin-left:1rem!important}.mx-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-5{margin-right:3rem!important;margin-left:3rem!important}.mx-auto{margin-right:auto!important;margin-left:auto!important}.my-0{margin-top:0!important;margin-bottom:0!important}.my-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-0{margin-top:0!important}.mt-1{margin-top:.25rem!important}.mt-2{margin-top:.5rem!important}.mt-3{margin-top:1rem!important}.mt-4{margin-top:1.5rem!important}.mt-5{margin-top:3rem!important}.mt-auto{margin-top:auto!important}.me-0{margin-right:0!important}.me-1{margin-right:.25rem!important}.me-2{margin-right:.5rem!important}.me-3{margin-right:1rem!important}.me-4{margin-right:1.5rem!important}.me-5{margin-right:3rem!important}.me-auto{margin-right:auto!important}.mb-0{margin-bottom:0!important}.mb-1{margin-bottom:.25rem!important}.mb-2{margin-bottom:.5rem!important}.mb-3{margin-bottom:1rem!important}.mb-4{margin-bottom:1.5rem!important}.mb-5{margin-bottom:3rem!important}.mb-auto{margin-bottom:auto!important}.ms-0{margin-left:0!important}.ms-1{margin-left:.25rem!important}.ms-2{margin-left:.5rem!important}.ms-3{margin-left:1rem!important}.ms-4{margin-left:1.5rem!important}.ms-5{margin-left:3rem!important}.ms-auto{margin-left:auto!important}.p-0{padding:0!important}.p-1{padding:.25rem!important}.p-2{padding:.5rem!important}.p-3{padding:1rem!important}.p-4{padding:1.5rem!important}.p-5{padding:3rem!important}.px-0{padding-right:0!important;padding-left:0!important}.px-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-3{padding-right:1rem!important;padding-left:1rem!important}.px-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-5{padding-right:3rem!important;padding-left:3rem!important}.py-0{padding-top:0!important;padding-bottom:0!important}.py-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-0{padding-top:0!important}.pt-1{padding-top:.25rem!important}.pt-2{padding-top:.5rem!important}.pt-3{padding-top:1rem!important}.pt-4{padding-top:1.5rem!important}.pt-5{padding-top:3rem!important}.pe-0{padding-right:0!important}.pe-1{padding-right:.25rem!important}.pe-2{padding-right:.5rem!important}.pe-3{padding-right:1rem!important}.pe-4{padding-right:1.5rem!important}.pe-5{padding-right:3rem!important}.pb-0{padding-bottom:0!important}.pb-1{padding-bottom:.25rem!important}.pb-2{padding-bottom:.5rem!important}.pb-3{padding-bottom:1rem!important}.pb-4{padding-bottom:1.5rem!important}.pb-5{padding-bottom:3rem!important}.ps-0{padding-left:0!important}.ps-1{padding-left:.25rem!important}.ps-2{padding-left:.5rem!important}.ps-3{padding-left:1rem!important}.ps-4{padding-left:1.5rem!important}.ps-5{padding-left:3rem!important}.gap-0{gap:0!important}.gap-1{gap:.25rem!important}.gap-2{gap:.5rem!important}.gap-3{gap:1rem!important}.gap-4{gap:1.5rem!important}.gap-5{gap:3rem!important}.row-gap-0{row-gap:0!important}.row-gap-1{row-gap:.25rem!important}.row-gap-2{row-gap:.5rem!important}.row-gap-3{row-gap:1rem!important}.row-gap-4{row-gap:1.5rem!important}.row-gap-5{row-gap:3rem!important}.column-gap-0{-moz-column-gap:0!important;column-gap:0!important}.column-gap-1{-moz-column-gap:0.25rem!important;column-gap:.25rem!important}.column-gap-2{-moz-column-gap:0.5rem!important;column-gap:.5rem!important}.column-gap-3{-moz-column-gap:1rem!important;column-gap:1rem!important}.column-gap-4{-moz-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-5{-moz-column-gap:3rem!important;column-gap:3rem!important}.font-monospace{font-family:var(--bs-font-monospace)!important}.fs-1{font-size:calc(1.375rem + 1.5vw)!important}.fs-2{font-size:calc(1.325rem + .9vw)!important}.fs-3{font-size:calc(1.3rem + .6vw)!important}.fs-4{font-size:calc(1.275rem + .3vw)!important}.fs-5{font-size:1.25rem!important}.fs-6{font-size:1rem!important}.fst-italic{font-style:italic!important}.fst-normal{font-style:normal!important}.fw-lighter{font-weight:lighter!important}.fw-light{font-weight:300!important}.fw-normal{font-weight:400!important}.fw-medium{font-weight:500!important}.fw-semibold{font-weight:600!important}.fw-bold{font-weight:700!important}.fw-bolder{font-weight:bolder!important}.lh-1{line-height:1!important}.lh-sm{line-height:1.25!important}.lh-base{line-height:1.5!important}.lh-lg{line-height:2!important}.text-start{text-align:left!important}.text-end{text-align:right!important}.text-center{text-align:center!important}.text-decoration-none{text-decoration:none!important}.text-decoration-underline{text-decoration:underline!important}.text-decoration-line-through{text-decoration:line-through!important}.text-lowercase{text-transform:lowercase!important}.text-uppercase{text-transform:uppercase!important}.text-capitalize{text-transform:capitalize!important}.text-wrap{white-space:normal!important}.text-nowrap{white-space:nowrap!important}.text-break{word-wrap:break-word!important;word-break:break-word!important}.text-primary{--bs-text-opacity:1;color:rgba(var(--bs-primary-rgb),var(--bs-text-opacity))!important}.text-secondary{--bs-text-opacity:1;color:rgba(var(--bs-secondary-rgb),var(--bs-text-opacity))!important}.text-success{--bs-text-opacity:1;color:rgba(var(--bs-success-rgb),var(--bs-text-opacity))!important}.text-info{--bs-text-opacity:1;color:rgba(var(--bs-info-rgb),var(--bs-text-opacity))!important}.text-warning{--bs-text-opacity:1;color:rgba(var(--bs-warning-rgb),var(--bs-text-opacity))!important}.text-danger{--bs-text-opacity:1;color:rgba(var(--bs-danger-rgb),var(--bs-text-opacity))!important}.text-light{--bs-text-opacity:1;color:rgba(var(--bs-light-rgb),var(--bs-text-opacity))!important}.text-dark{--bs-text-opacity:1;color:rgba(var(--bs-dark-rgb),var(--bs-text-opacity))!important}.text-black{--bs-text-opacity:1;color:rgba(var(--bs-black-rgb),var(--bs-text-opacity))!important}.text-white{--bs-text-opacity:1;color:rgba(var(--bs-white-rgb),var(--bs-text-opacity))!important}.text-body{--bs-text-opacity:1;color:rgba(var(--bs-body-color-rgb),var(--bs-text-opacity))!important}.text-muted{--bs-text-opacity:1;color:var(--bs-secondary-color)!important}.text-black-50{--bs-text-opacity:1;color:rgba(0,0,0,.5)!important}.text-white-50{--bs-text-opacity:1;color:rgba(255,255,255,.5)!important}.text-body-secondary{--bs-text-opacity:1;color:var(--bs-secondary-color)!important}.text-body-tertiary{--bs-text-opacity:1;color:var(--bs-tertiary-color)!important}.text-body-emphasis{--bs-text-opacity:1;color:var(--bs-emphasis-color)!important}.text-reset{--bs-text-opacity:1;color:inherit!important}.text-opacity-25{--bs-text-opacity:0.25}.text-opacity-50{--bs-text-opacity:0.5}.text-opacity-75{--bs-text-opacity:0.75}.text-opacity-100{--bs-text-opacity:1}.text-primary-emphasis{color:var(--bs-primary-text-emphasis)!important}.text-secondary-emphasis{color:var(--bs-secondary-text-emphasis)!important}.text-success-emphasis{color:var(--bs-success-text-emphasis)!important}.text-info-emphasis{color:var(--bs-info-text-emphasis)!important}.text-warning-emphasis{color:var(--bs-warning-text-emphasis)!important}.text-danger-emphasis{color:var(--bs-danger-text-emphasis)!important}.text-light-emphasis{color:var(--bs-light-text-emphasis)!important}.text-dark-emphasis{color:var(--bs-dark-text-emphasis)!important}.link-opacity-10{--bs-link-opacity:0.1}.link-opacity-10-hover:hover{--bs-link-opacity:0.1}.link-opacity-25{--bs-link-opacity:0.25}.link-opacity-25-hover:hover{--bs-link-opacity:0.25}.link-opacity-50{--bs-link-opacity:0.5}.link-opacity-50-hover:hover{--bs-link-opacity:0.5}.link-opacity-75{--bs-link-opacity:0.75}.link-opacity-75-hover:hover{--bs-link-opacity:0.75}.link-opacity-100{--bs-link-opacity:1}.link-opacity-100-hover:hover{--bs-link-opacity:1}.link-offset-1{text-underline-offset:0.125em!important}.link-offset-1-hover:hover{text-underline-offset:0.125em!important}.link-offset-2{text-underline-offset:0.25em!important}.link-offset-2-hover:hover{text-underline-offset:0.25em!important}.link-offset-3{text-underline-offset:0.375em!important}.link-offset-3-hover:hover{text-underline-offset:0.375em!important}.link-underline-primary{--bs-link-underline-opacity:1;-webkit-text-decoration-color:rgba(var(--bs-primary-rgb),var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-primary-rgb),var(--bs-link-underline-opacity))!important}.link-underline-secondary{--bs-link-underline-opacity:1;-webkit-text-decoration-color:rgba(var(--bs-secondary-rgb),var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-secondary-rgb),var(--bs-link-underline-opacity))!important}.link-underline-success{--bs-link-underline-opacity:1;-webkit-text-decoration-color:rgba(var(--bs-success-rgb),var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-success-rgb),var(--bs-link-underline-opacity))!important}.link-underline-info{--bs-link-underline-opacity:1;-webkit-text-decoration-color:rgba(var(--bs-info-rgb),var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-info-rgb),var(--bs-link-underline-opacity))!important}.link-underline-warning{--bs-link-underline-opacity:1;-webkit-text-decoration-color:rgba(var(--bs-warning-rgb),var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-warning-rgb),var(--bs-link-underline-opacity))!important}.link-underline-danger{--bs-link-underline-opacity:1;-webkit-text-decoration-color:rgba(var(--bs-danger-rgb),var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-danger-rgb),var(--bs-link-underline-opacity))!important}.link-underline-light{--bs-link-underline-opacity:1;-webkit-text-decoration-color:rgba(var(--bs-light-rgb),var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-light-rgb),var(--bs-link-underline-opacity))!important}.link-underline-dark{--bs-link-underline-opacity:1;-webkit-text-decoration-color:rgba(var(--bs-dark-rgb),var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-dark-rgb),var(--bs-link-underline-opacity))!important}.link-underline{--bs-link-underline-opacity:1;-webkit-text-decoration-color:rgba(var(--bs-link-color-rgb),var(--bs-link-underline-opacity,1))!important;text-decoration-color:rgba(var(--bs-link-color-rgb),var(--bs-link-underline-opacity,1))!important}.link-underline-opacity-0{--bs-link-underline-opacity:0}.link-underline-opacity-0-hover:hover{--bs-link-underline-opacity:0}.link-underline-opacity-10{--bs-link-underline-opacity:0.1}.link-underline-opacity-10-hover:hover{--bs-link-underline-opacity:0.1}.link-underline-opacity-25{--bs-link-underline-opacity:0.25}.link-underline-opacity-25-hover:hover{--bs-link-underline-opacity:0.25}.link-underline-opacity-50{--bs-link-underline-opacity:0.5}.link-underline-opacity-50-hover:hover{--bs-link-underline-opacity:0.5}.link-underline-opacity-75{--bs-link-underline-opacity:0.75}.link-underline-opacity-75-hover:hover{--bs-link-underline-opacity:0.75}.link-underline-opacity-100{--bs-link-underline-opacity:1}.link-underline-opacity-100-hover:hover{--bs-link-underline-opacity:1}.bg-primary{--bs-bg-opacity:1;background-color:rgba(var(--bs-primary-rgb),var(--bs-bg-opacity))!important}.bg-secondary{--bs-bg-opacity:1;background-color:rgba(var(--bs-secondary-rgb),var(--bs-bg-opacity))!important}.bg-success{--bs-bg-opacity:1;background-color:rgba(var(--bs-success-rgb),var(--bs-bg-opacity))!important}.bg-info{--bs-bg-opacity:1;background-color:rgba(var(--bs-info-rgb),var(--bs-bg-opacity))!important}.bg-warning{--bs-bg-opacity:1;background-color:rgba(var(--bs-warning-rgb),var(--bs-bg-opacity))!important}.bg-danger{--bs-bg-opacity:1;background-color:rgba(var(--bs-danger-rgb),var(--bs-bg-opacity))!important}.bg-light{--bs-bg-opacity:1;background-color:rgba(var(--bs-light-rgb),var(--bs-bg-opacity))!important}.bg-dark{--bs-bg-opacity:1;background-color:rgba(var(--bs-dark-rgb),var(--bs-bg-opacity))!important}.bg-black{--bs-bg-opacity:1;background-color:rgba(var(--bs-black-rgb),var(--bs-bg-opacity))!important}.bg-white{--bs-bg-opacity:1;background-color:rgba(var(--bs-white-rgb),var(--bs-bg-opacity))!important}.bg-body{--bs-bg-opacity:1;background-color:rgba(var(--bs-body-bg-rgb),var(--bs-bg-opacity))!important}.bg-transparent{--bs-bg-opacity:1;background-color:transparent!important}.bg-body-secondary{--bs-bg-opacity:1;background-color:rgba(var(--bs-secondary-bg-rgb),var(--bs-bg-opacity))!important}.bg-body-tertiary{--bs-bg-opacity:1;background-color:rgba(var(--bs-tertiary-bg-rgb),var(--bs-bg-opacity))!important}.bg-opacity-10{--bs-bg-opacity:0.1}.bg-opacity-25{--bs-bg-opacity:0.25}.bg-opacity-50{--bs-bg-opacity:0.5}.bg-opacity-75{--bs-bg-opacity:0.75}.bg-opacity-100{--bs-bg-opacity:1}.bg-primary-subtle{background-color:var(--bs-primary-bg-subtle)!important}.bg-secondary-subtle{background-color:var(--bs-secondary-bg-subtle)!important}.bg-success-subtle{background-color:var(--bs-success-bg-subtle)!important}.bg-info-subtle{background-color:var(--bs-info-bg-subtle)!important}.bg-warning-subtle{background-color:var(--bs-warning-bg-subtle)!important}.bg-danger-subtle{background-color:var(--bs-danger-bg-subtle)!important}.bg-light-subtle{background-color:var(--bs-light-bg-subtle)!important}.bg-dark-subtle{background-color:var(--bs-dark-bg-subtle)!important}.bg-gradient{background-image:var(--bs-gradient)!important}.user-select-all{-webkit-user-select:all!important;-moz-user-select:all!important;user-select:all!important}.user-select-auto{-webkit-user-select:auto!important;-moz-user-select:auto!important;user-select:auto!important}.user-select-none{-webkit-user-select:none!important;-moz-user-select:none!important;user-select:none!important}.pe-none{pointer-events:none!important}.pe-auto{pointer-events:auto!important}.rounded{border-radius:var(--bs-border-radius)!important}.rounded-0{border-radius:0!important}.rounded-1{border-radius:var(--bs-border-radius-sm)!important}.rounded-2{border-radius:var(--bs-border-radius)!important}.rounded-3{border-radius:var(--bs-border-radius-lg)!important}.rounded-4{border-radius:var(--bs-border-radius-xl)!important}.rounded-5{border-radius:var(--bs-border-radius-xxl)!important}.rounded-circle{border-radius:50%!important}.rounded-pill{border-radius:var(--bs-border-radius-pill)!important}.rounded-top{border-top-left-radius:var(--bs-border-radius)!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-top-0{border-top-left-radius:0!important;border-top-right-radius:0!important}.rounded-top-1{border-top-left-radius:var(--bs-border-radius-sm)!important;border-top-right-radius:var(--bs-border-radius-sm)!important}.rounded-top-2{border-top-left-radius:var(--bs-border-radius)!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-top-3{border-top-left-radius:var(--bs-border-radius-lg)!important;border-top-right-radius:var(--bs-border-radius-lg)!important}.rounded-top-4{border-top-left-radius:var(--bs-border-radius-xl)!important;border-top-right-radius:var(--bs-border-radius-xl)!important}.rounded-top-5{border-top-left-radius:var(--bs-border-radius-xxl)!important;border-top-right-radius:var(--bs-border-radius-xxl)!important}.rounded-top-circle{border-top-left-radius:50%!important;border-top-right-radius:50%!important}.rounded-top-pill{border-top-left-radius:var(--bs-border-radius-pill)!important;border-top-right-radius:var(--bs-border-radius-pill)!important}.rounded-end{border-top-right-radius:var(--bs-border-radius)!important;border-bottom-right-radius:var(--bs-border-radius)!important}.rounded-end-0{border-top-right-radius:0!important;border-bottom-right-radius:0!important}.rounded-end-1{border-top-right-radius:var(--bs-border-radius-sm)!important;border-bottom-right-radius:var(--bs-border-radius-sm)!important}.rounded-end-2{border-top-right-radius:var(--bs-border-radius)!important;border-bottom-right-radius:var(--bs-border-radius)!important}.rounded-end-3{border-top-right-radius:var(--bs-border-radius-lg)!important;border-bottom-right-radius:var(--bs-border-radius-lg)!important}.rounded-end-4{border-top-right-radius:var(--bs-border-radius-xl)!important;border-bottom-right-radius:var(--bs-border-radius-xl)!important}.rounded-end-5{border-top-right-radius:var(--bs-border-radius-xxl)!important;border-bottom-right-radius:var(--bs-border-radius-xxl)!important}.rounded-end-circle{border-top-right-radius:50%!important;border-bottom-right-radius:50%!important}.rounded-end-pill{border-top-right-radius:var(--bs-border-radius-pill)!important;border-bottom-right-radius:var(--bs-border-radius-pill)!important}.rounded-bottom{border-bottom-right-radius:var(--bs-border-radius)!important;border-bottom-left-radius:var(--bs-border-radius)!important}.rounded-bottom-0{border-bottom-right-radius:0!important;border-bottom-left-radius:0!important}.rounded-bottom-1{border-bottom-right-radius:var(--bs-border-radius-sm)!important;border-bottom-left-radius:var(--bs-border-radius-sm)!important}.rounded-bottom-2{border-bottom-right-radius:var(--bs-border-radius)!important;border-bottom-left-radius:var(--bs-border-radius)!important}.rounded-bottom-3{border-bottom-right-radius:var(--bs-border-radius-lg)!important;border-bottom-left-radius:var(--bs-border-radius-lg)!important}.rounded-bottom-4{border-bottom-right-radius:var(--bs-border-radius-xl)!important;border-bottom-left-radius:var(--bs-border-radius-xl)!important}.rounded-bottom-5{border-bottom-right-radius:var(--bs-border-radius-xxl)!important;border-bottom-left-radius:var(--bs-border-radius-xxl)!important}.rounded-bottom-circle{border-bottom-right-radius:50%!important;border-bottom-left-radius:50%!important}.rounded-bottom-pill{border-bottom-right-radius:var(--bs-border-radius-pill)!important;border-bottom-left-radius:var(--bs-border-radius-pill)!important}.rounded-start{border-bottom-left-radius:var(--bs-border-radius)!important;border-top-left-radius:var(--bs-border-radius)!important}.rounded-start-0{border-bottom-left-radius:0!important;border-top-left-radius:0!important}.rounded-start-1{border-bottom-left-radius:var(--bs-border-radius-sm)!important;border-top-left-radius:var(--bs-border-radius-sm)!important}.rounded-start-2{border-bottom-left-radius:var(--bs-border-radius)!important;border-top-left-radius:var(--bs-border-radius)!important}.rounded-start-3{border-bottom-left-radius:var(--bs-border-radius-lg)!important;border-top-left-radius:var(--bs-border-radius-lg)!important}.rounded-start-4{border-bottom-left-radius:var(--bs-border-radius-xl)!important;border-top-left-radius:var(--bs-border-radius-xl)!important}.rounded-start-5{border-bottom-left-radius:var(--bs-border-radius-xxl)!important;border-top-left-radius:var(--bs-border-radius-xxl)!important}.rounded-start-circle{border-bottom-left-radius:50%!important;border-top-left-radius:50%!important}.rounded-start-pill{border-bottom-left-radius:var(--bs-border-radius-pill)!important;border-top-left-radius:var(--bs-border-radius-pill)!important}.visible{visibility:visible!important}.invisible{visibility:hidden!important}.z-n1{z-index:-1!important}.z-0{z-index:0!important}.z-1{z-index:1!important}.z-2{z-index:2!important}.z-3{z-index:3!important}@media (min-width:576px){.float-sm-start{float:left!important}.float-sm-end{float:right!important}.float-sm-none{float:none!important}.object-fit-sm-contain{-o-object-fit:contain!important;object-fit:contain!important}.object-fit-sm-cover{-o-object-fit:cover!important;object-fit:cover!important}.object-fit-sm-fill{-o-object-fit:fill!important;object-fit:fill!important}.object-fit-sm-scale{-o-object-fit:scale-down!important;object-fit:scale-down!important}.object-fit-sm-none{-o-object-fit:none!important;object-fit:none!important}.d-sm-inline{display:inline!important}.d-sm-inline-block{display:inline-block!important}.d-sm-block{display:block!important}.d-sm-grid{display:grid!important}.d-sm-inline-grid{display:inline-grid!important}.d-sm-table{display:table!important}.d-sm-table-row{display:table-row!important}.d-sm-table-cell{display:table-cell!important}.d-sm-flex{display:flex!important}.d-sm-inline-flex{display:inline-flex!important}.d-sm-none{display:none!important}.flex-sm-fill{flex:1 1 auto!important}.flex-sm-row{flex-direction:row!important}.flex-sm-column{flex-direction:column!important}.flex-sm-row-reverse{flex-direction:row-reverse!important}.flex-sm-column-reverse{flex-direction:column-reverse!important}.flex-sm-grow-0{flex-grow:0!important}.flex-sm-grow-1{flex-grow:1!important}.flex-sm-shrink-0{flex-shrink:0!important}.flex-sm-shrink-1{flex-shrink:1!important}.flex-sm-wrap{flex-wrap:wrap!important}.flex-sm-nowrap{flex-wrap:nowrap!important}.flex-sm-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-sm-start{justify-content:flex-start!important}.justify-content-sm-end{justify-content:flex-end!important}.justify-content-sm-center{justify-content:center!important}.justify-content-sm-between{justify-content:space-between!important}.justify-content-sm-around{justify-content:space-around!important}.justify-content-sm-evenly{justify-content:space-evenly!important}.align-items-sm-start{align-items:flex-start!important}.align-items-sm-end{align-items:flex-end!important}.align-items-sm-center{align-items:center!important}.align-items-sm-baseline{align-items:baseline!important}.align-items-sm-stretch{align-items:stretch!important}.align-content-sm-start{align-content:flex-start!important}.align-content-sm-end{align-content:flex-end!important}.align-content-sm-center{align-content:center!important}.align-content-sm-between{align-content:space-between!important}.align-content-sm-around{align-content:space-around!important}.align-content-sm-stretch{align-content:stretch!important}.align-self-sm-auto{align-self:auto!important}.align-self-sm-start{align-self:flex-start!important}.align-self-sm-end{align-self:flex-end!important}.align-self-sm-center{align-self:center!important}.align-self-sm-baseline{align-self:baseline!important}.align-self-sm-stretch{align-self:stretch!important}.order-sm-first{order:-1!important}.order-sm-0{order:0!important}.order-sm-1{order:1!important}.order-sm-2{order:2!important}.order-sm-3{order:3!important}.order-sm-4{order:4!important}.order-sm-5{order:5!important}.order-sm-last{order:6!important}.m-sm-0{margin:0!important}.m-sm-1{margin:.25rem!important}.m-sm-2{margin:.5rem!important}.m-sm-3{margin:1rem!important}.m-sm-4{margin:1.5rem!important}.m-sm-5{margin:3rem!important}.m-sm-auto{margin:auto!important}.mx-sm-0{margin-right:0!important;margin-left:0!important}.mx-sm-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-sm-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-sm-3{margin-right:1rem!important;margin-left:1rem!important}.mx-sm-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-sm-5{margin-right:3rem!important;margin-left:3rem!important}.mx-sm-auto{margin-right:auto!important;margin-left:auto!important}.my-sm-0{margin-top:0!important;margin-bottom:0!important}.my-sm-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-sm-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-sm-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-sm-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-sm-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-sm-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-sm-0{margin-top:0!important}.mt-sm-1{margin-top:.25rem!important}.mt-sm-2{margin-top:.5rem!important}.mt-sm-3{margin-top:1rem!important}.mt-sm-4{margin-top:1.5rem!important}.mt-sm-5{margin-top:3rem!important}.mt-sm-auto{margin-top:auto!important}.me-sm-0{margin-right:0!important}.me-sm-1{margin-right:.25rem!important}.me-sm-2{margin-right:.5rem!important}.me-sm-3{margin-right:1rem!important}.me-sm-4{margin-right:1.5rem!important}.me-sm-5{margin-right:3rem!important}.me-sm-auto{margin-right:auto!important}.mb-sm-0{margin-bottom:0!important}.mb-sm-1{margin-bottom:.25rem!important}.mb-sm-2{margin-bottom:.5rem!important}.mb-sm-3{margin-bottom:1rem!important}.mb-sm-4{margin-bottom:1.5rem!important}.mb-sm-5{margin-bottom:3rem!important}.mb-sm-auto{margin-bottom:auto!important}.ms-sm-0{margin-left:0!important}.ms-sm-1{margin-left:.25rem!important}.ms-sm-2{margin-left:.5rem!important}.ms-sm-3{margin-left:1rem!important}.ms-sm-4{margin-left:1.5rem!important}.ms-sm-5{margin-left:3rem!important}.ms-sm-auto{margin-left:auto!important}.p-sm-0{padding:0!important}.p-sm-1{padding:.25rem!important}.p-sm-2{padding:.5rem!important}.p-sm-3{padding:1rem!important}.p-sm-4{padding:1.5rem!important}.p-sm-5{padding:3rem!important}.px-sm-0{padding-right:0!important;padding-left:0!important}.px-sm-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-sm-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-sm-3{padding-right:1rem!important;padding-left:1rem!important}.px-sm-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-sm-5{padding-right:3rem!important;padding-left:3rem!important}.py-sm-0{padding-top:0!important;padding-bottom:0!important}.py-sm-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-sm-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-sm-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-sm-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-sm-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-sm-0{padding-top:0!important}.pt-sm-1{padding-top:.25rem!important}.pt-sm-2{padding-top:.5rem!important}.pt-sm-3{padding-top:1rem!important}.pt-sm-4{padding-top:1.5rem!important}.pt-sm-5{padding-top:3rem!important}.pe-sm-0{padding-right:0!important}.pe-sm-1{padding-right:.25rem!important}.pe-sm-2{padding-right:.5rem!important}.pe-sm-3{padding-right:1rem!important}.pe-sm-4{padding-right:1.5rem!important}.pe-sm-5{padding-right:3rem!important}.pb-sm-0{padding-bottom:0!important}.pb-sm-1{padding-bottom:.25rem!important}.pb-sm-2{padding-bottom:.5rem!important}.pb-sm-3{padding-bottom:1rem!important}.pb-sm-4{padding-bottom:1.5rem!important}.pb-sm-5{padding-bottom:3rem!important}.ps-sm-0{padding-left:0!important}.ps-sm-1{padding-left:.25rem!important}.ps-sm-2{padding-left:.5rem!important}.ps-sm-3{padding-left:1rem!important}.ps-sm-4{padding-left:1.5rem!important}.ps-sm-5{padding-left:3rem!important}.gap-sm-0{gap:0!important}.gap-sm-1{gap:.25rem!important}.gap-sm-2{gap:.5rem!important}.gap-sm-3{gap:1rem!important}.gap-sm-4{gap:1.5rem!important}.gap-sm-5{gap:3rem!important}.row-gap-sm-0{row-gap:0!important}.row-gap-sm-1{row-gap:.25rem!important}.row-gap-sm-2{row-gap:.5rem!important}.row-gap-sm-3{row-gap:1rem!important}.row-gap-sm-4{row-gap:1.5rem!important}.row-gap-sm-5{row-gap:3rem!important}.column-gap-sm-0{-moz-column-gap:0!important;column-gap:0!important}.column-gap-sm-1{-moz-column-gap:0.25rem!important;column-gap:.25rem!important}.column-gap-sm-2{-moz-column-gap:0.5rem!important;column-gap:.5rem!important}.column-gap-sm-3{-moz-column-gap:1rem!important;column-gap:1rem!important}.column-gap-sm-4{-moz-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-sm-5{-moz-column-gap:3rem!important;column-gap:3rem!important}.text-sm-start{text-align:left!important}.text-sm-end{text-align:right!important}.text-sm-center{text-align:center!important}}@media (min-width:768px){.float-md-start{float:left!important}.float-md-end{float:right!important}.float-md-none{float:none!important}.object-fit-md-contain{-o-object-fit:contain!important;object-fit:contain!important}.object-fit-md-cover{-o-object-fit:cover!important;object-fit:cover!important}.object-fit-md-fill{-o-object-fit:fill!important;object-fit:fill!important}.object-fit-md-scale{-o-object-fit:scale-down!important;object-fit:scale-down!important}.object-fit-md-none{-o-object-fit:none!important;object-fit:none!important}.d-md-inline{display:inline!important}.d-md-inline-block{display:inline-block!important}.d-md-block{display:block!important}.d-md-grid{display:grid!important}.d-md-inline-grid{display:inline-grid!important}.d-md-table{display:table!important}.d-md-table-row{display:table-row!important}.d-md-table-cell{display:table-cell!important}.d-md-flex{display:flex!important}.d-md-inline-flex{display:inline-flex!important}.d-md-none{display:none!important}.flex-md-fill{flex:1 1 auto!important}.flex-md-row{flex-direction:row!important}.flex-md-column{flex-direction:column!important}.flex-md-row-reverse{flex-direction:row-reverse!important}.flex-md-column-reverse{flex-direction:column-reverse!important}.flex-md-grow-0{flex-grow:0!important}.flex-md-grow-1{flex-grow:1!important}.flex-md-shrink-0{flex-shrink:0!important}.flex-md-shrink-1{flex-shrink:1!important}.flex-md-wrap{flex-wrap:wrap!important}.flex-md-nowrap{flex-wrap:nowrap!important}.flex-md-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-md-start{justify-content:flex-start!important}.justify-content-md-end{justify-content:flex-end!important}.justify-content-md-center{justify-content:center!important}.justify-content-md-between{justify-content:space-between!important}.justify-content-md-around{justify-content:space-around!important}.justify-content-md-evenly{justify-content:space-evenly!important}.align-items-md-start{align-items:flex-start!important}.align-items-md-end{align-items:flex-end!important}.align-items-md-center{align-items:center!important}.align-items-md-baseline{align-items:baseline!important}.align-items-md-stretch{align-items:stretch!important}.align-content-md-start{align-content:flex-start!important}.align-content-md-end{align-content:flex-end!important}.align-content-md-center{align-content:center!important}.align-content-md-between{align-content:space-between!important}.align-content-md-around{align-content:space-around!important}.align-content-md-stretch{align-content:stretch!important}.align-self-md-auto{align-self:auto!important}.align-self-md-start{align-self:flex-start!important}.align-self-md-end{align-self:flex-end!important}.align-self-md-center{align-self:center!important}.align-self-md-baseline{align-self:baseline!important}.align-self-md-stretch{align-self:stretch!important}.order-md-first{order:-1!important}.order-md-0{order:0!important}.order-md-1{order:1!important}.order-md-2{order:2!important}.order-md-3{order:3!important}.order-md-4{order:4!important}.order-md-5{order:5!important}.order-md-last{order:6!important}.m-md-0{margin:0!important}.m-md-1{margin:.25rem!important}.m-md-2{margin:.5rem!important}.m-md-3{margin:1rem!important}.m-md-4{margin:1.5rem!important}.m-md-5{margin:3rem!important}.m-md-auto{margin:auto!important}.mx-md-0{margin-right:0!important;margin-left:0!important}.mx-md-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-md-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-md-3{margin-right:1rem!important;margin-left:1rem!important}.mx-md-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-md-5{margin-right:3rem!important;margin-left:3rem!important}.mx-md-auto{margin-right:auto!important;margin-left:auto!important}.my-md-0{margin-top:0!important;margin-bottom:0!important}.my-md-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-md-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-md-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-md-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-md-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-md-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-md-0{margin-top:0!important}.mt-md-1{margin-top:.25rem!important}.mt-md-2{margin-top:.5rem!important}.mt-md-3{margin-top:1rem!important}.mt-md-4{margin-top:1.5rem!important}.mt-md-5{margin-top:3rem!important}.mt-md-auto{margin-top:auto!important}.me-md-0{margin-right:0!important}.me-md-1{margin-right:.25rem!important}.me-md-2{margin-right:.5rem!important}.me-md-3{margin-right:1rem!important}.me-md-4{margin-right:1.5rem!important}.me-md-5{margin-right:3rem!important}.me-md-auto{margin-right:auto!important}.mb-md-0{margin-bottom:0!important}.mb-md-1{margin-bottom:.25rem!important}.mb-md-2{margin-bottom:.5rem!important}.mb-md-3{margin-bottom:1rem!important}.mb-md-4{margin-bottom:1.5rem!important}.mb-md-5{margin-bottom:3rem!important}.mb-md-auto{margin-bottom:auto!important}.ms-md-0{margin-left:0!important}.ms-md-1{margin-left:.25rem!important}.ms-md-2{margin-left:.5rem!important}.ms-md-3{margin-left:1rem!important}.ms-md-4{margin-left:1.5rem!important}.ms-md-5{margin-left:3rem!important}.ms-md-auto{margin-left:auto!important}.p-md-0{padding:0!important}.p-md-1{padding:.25rem!important}.p-md-2{padding:.5rem!important}.p-md-3{padding:1rem!important}.p-md-4{padding:1.5rem!important}.p-md-5{padding:3rem!important}.px-md-0{padding-right:0!important;padding-left:0!important}.px-md-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-md-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-md-3{padding-right:1rem!important;padding-left:1rem!important}.px-md-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-md-5{padding-right:3rem!important;padding-left:3rem!important}.py-md-0{padding-top:0!important;padding-bottom:0!important}.py-md-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-md-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-md-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-md-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-md-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-md-0{padding-top:0!important}.pt-md-1{padding-top:.25rem!important}.pt-md-2{padding-top:.5rem!important}.pt-md-3{padding-top:1rem!important}.pt-md-4{padding-top:1.5rem!important}.pt-md-5{padding-top:3rem!important}.pe-md-0{padding-right:0!important}.pe-md-1{padding-right:.25rem!important}.pe-md-2{padding-right:.5rem!important}.pe-md-3{padding-right:1rem!important}.pe-md-4{padding-right:1.5rem!important}.pe-md-5{padding-right:3rem!important}.pb-md-0{padding-bottom:0!important}.pb-md-1{padding-bottom:.25rem!important}.pb-md-2{padding-bottom:.5rem!important}.pb-md-3{padding-bottom:1rem!important}.pb-md-4{padding-bottom:1.5rem!important}.pb-md-5{padding-bottom:3rem!important}.ps-md-0{padding-left:0!important}.ps-md-1{padding-left:.25rem!important}.ps-md-2{padding-left:.5rem!important}.ps-md-3{padding-left:1rem!important}.ps-md-4{padding-left:1.5rem!important}.ps-md-5{padding-left:3rem!important}.gap-md-0{gap:0!important}.gap-md-1{gap:.25rem!important}.gap-md-2{gap:.5rem!important}.gap-md-3{gap:1rem!important}.gap-md-4{gap:1.5rem!important}.gap-md-5{gap:3rem!important}.row-gap-md-0{row-gap:0!important}.row-gap-md-1{row-gap:.25rem!important}.row-gap-md-2{row-gap:.5rem!important}.row-gap-md-3{row-gap:1rem!important}.row-gap-md-4{row-gap:1.5rem!important}.row-gap-md-5{row-gap:3rem!important}.column-gap-md-0{-moz-column-gap:0!important;column-gap:0!important}.column-gap-md-1{-moz-column-gap:0.25rem!important;column-gap:.25rem!important}.column-gap-md-2{-moz-column-gap:0.5rem!important;column-gap:.5rem!important}.column-gap-md-3{-moz-column-gap:1rem!important;column-gap:1rem!important}.column-gap-md-4{-moz-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-md-5{-moz-column-gap:3rem!important;column-gap:3rem!important}.text-md-start{text-align:left!important}.text-md-end{text-align:right!important}.text-md-center{text-align:center!important}}@media (min-width:992px){.float-lg-start{float:left!important}.float-lg-end{float:right!important}.float-lg-none{float:none!important}.object-fit-lg-contain{-o-object-fit:contain!important;object-fit:contain!important}.object-fit-lg-cover{-o-object-fit:cover!important;object-fit:cover!important}.object-fit-lg-fill{-o-object-fit:fill!important;object-fit:fill!important}.object-fit-lg-scale{-o-object-fit:scale-down!important;object-fit:scale-down!important}.object-fit-lg-none{-o-object-fit:none!important;object-fit:none!important}.d-lg-inline{display:inline!important}.d-lg-inline-block{display:inline-block!important}.d-lg-block{display:block!important}.d-lg-grid{display:grid!important}.d-lg-inline-grid{display:inline-grid!important}.d-lg-table{display:table!important}.d-lg-table-row{display:table-row!important}.d-lg-table-cell{display:table-cell!important}.d-lg-flex{display:flex!important}.d-lg-inline-flex{display:inline-flex!important}.d-lg-none{display:none!important}.flex-lg-fill{flex:1 1 auto!important}.flex-lg-row{flex-direction:row!important}.flex-lg-column{flex-direction:column!important}.flex-lg-row-reverse{flex-direction:row-reverse!important}.flex-lg-column-reverse{flex-direction:column-reverse!important}.flex-lg-grow-0{flex-grow:0!important}.flex-lg-grow-1{flex-grow:1!important}.flex-lg-shrink-0{flex-shrink:0!important}.flex-lg-shrink-1{flex-shrink:1!important}.flex-lg-wrap{flex-wrap:wrap!important}.flex-lg-nowrap{flex-wrap:nowrap!important}.flex-lg-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-lg-start{justify-content:flex-start!important}.justify-content-lg-end{justify-content:flex-end!important}.justify-content-lg-center{justify-content:center!important}.justify-content-lg-between{justify-content:space-between!important}.justify-content-lg-around{justify-content:space-around!important}.justify-content-lg-evenly{justify-content:space-evenly!important}.align-items-lg-start{align-items:flex-start!important}.align-items-lg-end{align-items:flex-end!important}.align-items-lg-center{align-items:center!important}.align-items-lg-baseline{align-items:baseline!important}.align-items-lg-stretch{align-items:stretch!important}.align-content-lg-start{align-content:flex-start!important}.align-content-lg-end{align-content:flex-end!important}.align-content-lg-center{align-content:center!important}.align-content-lg-between{align-content:space-between!important}.align-content-lg-around{align-content:space-around!important}.align-content-lg-stretch{align-content:stretch!important}.align-self-lg-auto{align-self:auto!important}.align-self-lg-start{align-self:flex-start!important}.align-self-lg-end{align-self:flex-end!important}.align-self-lg-center{align-self:center!important}.align-self-lg-baseline{align-self:baseline!important}.align-self-lg-stretch{align-self:stretch!important}.order-lg-first{order:-1!important}.order-lg-0{order:0!important}.order-lg-1{order:1!important}.order-lg-2{order:2!important}.order-lg-3{order:3!important}.order-lg-4{order:4!important}.order-lg-5{order:5!important}.order-lg-last{order:6!important}.m-lg-0{margin:0!important}.m-lg-1{margin:.25rem!important}.m-lg-2{margin:.5rem!important}.m-lg-3{margin:1rem!important}.m-lg-4{margin:1.5rem!important}.m-lg-5{margin:3rem!important}.m-lg-auto{margin:auto!important}.mx-lg-0{margin-right:0!important;margin-left:0!important}.mx-lg-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-lg-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-lg-3{margin-right:1rem!important;margin-left:1rem!important}.mx-lg-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-lg-5{margin-right:3rem!important;margin-left:3rem!important}.mx-lg-auto{margin-right:auto!important;margin-left:auto!important}.my-lg-0{margin-top:0!important;margin-bottom:0!important}.my-lg-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-lg-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-lg-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-lg-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-lg-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-lg-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-lg-0{margin-top:0!important}.mt-lg-1{margin-top:.25rem!important}.mt-lg-2{margin-top:.5rem!important}.mt-lg-3{margin-top:1rem!important}.mt-lg-4{margin-top:1.5rem!important}.mt-lg-5{margin-top:3rem!important}.mt-lg-auto{margin-top:auto!important}.me-lg-0{margin-right:0!important}.me-lg-1{margin-right:.25rem!important}.me-lg-2{margin-right:.5rem!important}.me-lg-3{margin-right:1rem!important}.me-lg-4{margin-right:1.5rem!important}.me-lg-5{margin-right:3rem!important}.me-lg-auto{margin-right:auto!important}.mb-lg-0{margin-bottom:0!important}.mb-lg-1{margin-bottom:.25rem!important}.mb-lg-2{margin-bottom:.5rem!important}.mb-lg-3{margin-bottom:1rem!important}.mb-lg-4{margin-bottom:1.5rem!important}.mb-lg-5{margin-bottom:3rem!important}.mb-lg-auto{margin-bottom:auto!important}.ms-lg-0{margin-left:0!important}.ms-lg-1{margin-left:.25rem!important}.ms-lg-2{margin-left:.5rem!important}.ms-lg-3{margin-left:1rem!important}.ms-lg-4{margin-left:1.5rem!important}.ms-lg-5{margin-left:3rem!important}.ms-lg-auto{margin-left:auto!important}.p-lg-0{padding:0!important}.p-lg-1{padding:.25rem!important}.p-lg-2{padding:.5rem!important}.p-lg-3{padding:1rem!important}.p-lg-4{padding:1.5rem!important}.p-lg-5{padding:3rem!important}.px-lg-0{padding-right:0!important;padding-left:0!important}.px-lg-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-lg-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-lg-3{padding-right:1rem!important;padding-left:1rem!important}.px-lg-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-lg-5{padding-right:3rem!important;padding-left:3rem!important}.py-lg-0{padding-top:0!important;padding-bottom:0!important}.py-lg-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-lg-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-lg-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-lg-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-lg-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-lg-0{padding-top:0!important}.pt-lg-1{padding-top:.25rem!important}.pt-lg-2{padding-top:.5rem!important}.pt-lg-3{padding-top:1rem!important}.pt-lg-4{padding-top:1.5rem!important}.pt-lg-5{padding-top:3rem!important}.pe-lg-0{padding-right:0!important}.pe-lg-1{padding-right:.25rem!important}.pe-lg-2{padding-right:.5rem!important}.pe-lg-3{padding-right:1rem!important}.pe-lg-4{padding-right:1.5rem!important}.pe-lg-5{padding-right:3rem!important}.pb-lg-0{padding-bottom:0!important}.pb-lg-1{padding-bottom:.25rem!important}.pb-lg-2{padding-bottom:.5rem!important}.pb-lg-3{padding-bottom:1rem!important}.pb-lg-4{padding-bottom:1.5rem!important}.pb-lg-5{padding-bottom:3rem!important}.ps-lg-0{padding-left:0!important}.ps-lg-1{padding-left:.25rem!important}.ps-lg-2{padding-left:.5rem!important}.ps-lg-3{padding-left:1rem!important}.ps-lg-4{padding-left:1.5rem!important}.ps-lg-5{padding-left:3rem!important}.gap-lg-0{gap:0!important}.gap-lg-1{gap:.25rem!important}.gap-lg-2{gap:.5rem!important}.gap-lg-3{gap:1rem!important}.gap-lg-4{gap:1.5rem!important}.gap-lg-5{gap:3rem!important}.row-gap-lg-0{row-gap:0!important}.row-gap-lg-1{row-gap:.25rem!important}.row-gap-lg-2{row-gap:.5rem!important}.row-gap-lg-3{row-gap:1rem!important}.row-gap-lg-4{row-gap:1.5rem!important}.row-gap-lg-5{row-gap:3rem!important}.column-gap-lg-0{-moz-column-gap:0!important;column-gap:0!important}.column-gap-lg-1{-moz-column-gap:0.25rem!important;column-gap:.25rem!important}.column-gap-lg-2{-moz-column-gap:0.5rem!important;column-gap:.5rem!important}.column-gap-lg-3{-moz-column-gap:1rem!important;column-gap:1rem!important}.column-gap-lg-4{-moz-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-lg-5{-moz-column-gap:3rem!important;column-gap:3rem!important}.text-lg-start{text-align:left!important}.text-lg-end{text-align:right!important}.text-lg-center{text-align:center!important}}@media (min-width:1200px){.float-xl-start{float:left!important}.float-xl-end{float:right!important}.float-xl-none{float:none!important}.object-fit-xl-contain{-o-object-fit:contain!important;object-fit:contain!important}.object-fit-xl-cover{-o-object-fit:cover!important;object-fit:cover!important}.object-fit-xl-fill{-o-object-fit:fill!important;object-fit:fill!important}.object-fit-xl-scale{-o-object-fit:scale-down!important;object-fit:scale-down!important}.object-fit-xl-none{-o-object-fit:none!important;object-fit:none!important}.d-xl-inline{display:inline!important}.d-xl-inline-block{display:inline-block!important}.d-xl-block{display:block!important}.d-xl-grid{display:grid!important}.d-xl-inline-grid{display:inline-grid!important}.d-xl-table{display:table!important}.d-xl-table-row{display:table-row!important}.d-xl-table-cell{display:table-cell!important}.d-xl-flex{display:flex!important}.d-xl-inline-flex{display:inline-flex!important}.d-xl-none{display:none!important}.flex-xl-fill{flex:1 1 auto!important}.flex-xl-row{flex-direction:row!important}.flex-xl-column{flex-direction:column!important}.flex-xl-row-reverse{flex-direction:row-reverse!important}.flex-xl-column-reverse{flex-direction:column-reverse!important}.flex-xl-grow-0{flex-grow:0!important}.flex-xl-grow-1{flex-grow:1!important}.flex-xl-shrink-0{flex-shrink:0!important}.flex-xl-shrink-1{flex-shrink:1!important}.flex-xl-wrap{flex-wrap:wrap!important}.flex-xl-nowrap{flex-wrap:nowrap!important}.flex-xl-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-xl-start{justify-content:flex-start!important}.justify-content-xl-end{justify-content:flex-end!important}.justify-content-xl-center{justify-content:center!important}.justify-content-xl-between{justify-content:space-between!important}.justify-content-xl-around{justify-content:space-around!important}.justify-content-xl-evenly{justify-content:space-evenly!important}.align-items-xl-start{align-items:flex-start!important}.align-items-xl-end{align-items:flex-end!important}.align-items-xl-center{align-items:center!important}.align-items-xl-baseline{align-items:baseline!important}.align-items-xl-stretch{align-items:stretch!important}.align-content-xl-start{align-content:flex-start!important}.align-content-xl-end{align-content:flex-end!important}.align-content-xl-center{align-content:center!important}.align-content-xl-between{align-content:space-between!important}.align-content-xl-around{align-content:space-around!important}.align-content-xl-stretch{align-content:stretch!important}.align-self-xl-auto{align-self:auto!important}.align-self-xl-start{align-self:flex-start!important}.align-self-xl-end{align-self:flex-end!important}.align-self-xl-center{align-self:center!important}.align-self-xl-baseline{align-self:baseline!important}.align-self-xl-stretch{align-self:stretch!important}.order-xl-first{order:-1!important}.order-xl-0{order:0!important}.order-xl-1{order:1!important}.order-xl-2{order:2!important}.order-xl-3{order:3!important}.order-xl-4{order:4!important}.order-xl-5{order:5!important}.order-xl-last{order:6!important}.m-xl-0{margin:0!important}.m-xl-1{margin:.25rem!important}.m-xl-2{margin:.5rem!important}.m-xl-3{margin:1rem!important}.m-xl-4{margin:1.5rem!important}.m-xl-5{margin:3rem!important}.m-xl-auto{margin:auto!important}.mx-xl-0{margin-right:0!important;margin-left:0!important}.mx-xl-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-xl-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-xl-3{margin-right:1rem!important;margin-left:1rem!important}.mx-xl-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-xl-5{margin-right:3rem!important;margin-left:3rem!important}.mx-xl-auto{margin-right:auto!important;margin-left:auto!important}.my-xl-0{margin-top:0!important;margin-bottom:0!important}.my-xl-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-xl-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-xl-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-xl-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-xl-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-xl-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-xl-0{margin-top:0!important}.mt-xl-1{margin-top:.25rem!important}.mt-xl-2{margin-top:.5rem!important}.mt-xl-3{margin-top:1rem!important}.mt-xl-4{margin-top:1.5rem!important}.mt-xl-5{margin-top:3rem!important}.mt-xl-auto{margin-top:auto!important}.me-xl-0{margin-right:0!important}.me-xl-1{margin-right:.25rem!important}.me-xl-2{margin-right:.5rem!important}.me-xl-3{margin-right:1rem!important}.me-xl-4{margin-right:1.5rem!important}.me-xl-5{margin-right:3rem!important}.me-xl-auto{margin-right:auto!important}.mb-xl-0{margin-bottom:0!important}.mb-xl-1{margin-bottom:.25rem!important}.mb-xl-2{margin-bottom:.5rem!important}.mb-xl-3{margin-bottom:1rem!important}.mb-xl-4{margin-bottom:1.5rem!important}.mb-xl-5{margin-bottom:3rem!important}.mb-xl-auto{margin-bottom:auto!important}.ms-xl-0{margin-left:0!important}.ms-xl-1{margin-left:.25rem!important}.ms-xl-2{margin-left:.5rem!important}.ms-xl-3{margin-left:1rem!important}.ms-xl-4{margin-left:1.5rem!important}.ms-xl-5{margin-left:3rem!important}.ms-xl-auto{margin-left:auto!important}.p-xl-0{padding:0!important}.p-xl-1{padding:.25rem!important}.p-xl-2{padding:.5rem!important}.p-xl-3{padding:1rem!important}.p-xl-4{padding:1.5rem!important}.p-xl-5{padding:3rem!important}.px-xl-0{padding-right:0!important;padding-left:0!important}.px-xl-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-xl-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-xl-3{padding-right:1rem!important;padding-left:1rem!important}.px-xl-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-xl-5{padding-right:3rem!important;padding-left:3rem!important}.py-xl-0{padding-top:0!important;padding-bottom:0!important}.py-xl-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-xl-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-xl-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-xl-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-xl-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-xl-0{padding-top:0!important}.pt-xl-1{padding-top:.25rem!important}.pt-xl-2{padding-top:.5rem!important}.pt-xl-3{padding-top:1rem!important}.pt-xl-4{padding-top:1.5rem!important}.pt-xl-5{padding-top:3rem!important}.pe-xl-0{padding-right:0!important}.pe-xl-1{padding-right:.25rem!important}.pe-xl-2{padding-right:.5rem!important}.pe-xl-3{padding-right:1rem!important}.pe-xl-4{padding-right:1.5rem!important}.pe-xl-5{padding-right:3rem!important}.pb-xl-0{padding-bottom:0!important}.pb-xl-1{padding-bottom:.25rem!important}.pb-xl-2{padding-bottom:.5rem!important}.pb-xl-3{padding-bottom:1rem!important}.pb-xl-4{padding-bottom:1.5rem!important}.pb-xl-5{padding-bottom:3rem!important}.ps-xl-0{padding-left:0!important}.ps-xl-1{padding-left:.25rem!important}.ps-xl-2{padding-left:.5rem!important}.ps-xl-3{padding-left:1rem!important}.ps-xl-4{padding-left:1.5rem!important}.ps-xl-5{padding-left:3rem!important}.gap-xl-0{gap:0!important}.gap-xl-1{gap:.25rem!important}.gap-xl-2{gap:.5rem!important}.gap-xl-3{gap:1rem!important}.gap-xl-4{gap:1.5rem!important}.gap-xl-5{gap:3rem!important}.row-gap-xl-0{row-gap:0!important}.row-gap-xl-1{row-gap:.25rem!important}.row-gap-xl-2{row-gap:.5rem!important}.row-gap-xl-3{row-gap:1rem!important}.row-gap-xl-4{row-gap:1.5rem!important}.row-gap-xl-5{row-gap:3rem!important}.column-gap-xl-0{-moz-column-gap:0!important;column-gap:0!important}.column-gap-xl-1{-moz-column-gap:0.25rem!important;column-gap:.25rem!important}.column-gap-xl-2{-moz-column-gap:0.5rem!important;column-gap:.5rem!important}.column-gap-xl-3{-moz-column-gap:1rem!important;column-gap:1rem!important}.column-gap-xl-4{-moz-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-xl-5{-moz-column-gap:3rem!important;column-gap:3rem!important}.text-xl-start{text-align:left!important}.text-xl-end{text-align:right!important}.text-xl-center{text-align:center!important}}@media (min-width:1400px){.float-xxl-start{float:left!important}.float-xxl-end{float:right!important}.float-xxl-none{float:none!important}.object-fit-xxl-contain{-o-object-fit:contain!important;object-fit:contain!important}.object-fit-xxl-cover{-o-object-fit:cover!important;object-fit:cover!important}.object-fit-xxl-fill{-o-object-fit:fill!important;object-fit:fill!important}.object-fit-xxl-scale{-o-object-fit:scale-down!important;object-fit:scale-down!important}.object-fit-xxl-none{-o-object-fit:none!important;object-fit:none!important}.d-xxl-inline{display:inline!important}.d-xxl-inline-block{display:inline-block!important}.d-xxl-block{display:block!important}.d-xxl-grid{display:grid!important}.d-xxl-inline-grid{display:inline-grid!important}.d-xxl-table{display:table!important}.d-xxl-table-row{display:table-row!important}.d-xxl-table-cell{display:table-cell!important}.d-xxl-flex{display:flex!important}.d-xxl-inline-flex{display:inline-flex!important}.d-xxl-none{display:none!important}.flex-xxl-fill{flex:1 1 auto!important}.flex-xxl-row{flex-direction:row!important}.flex-xxl-column{flex-direction:column!important}.flex-xxl-row-reverse{flex-direction:row-reverse!important}.flex-xxl-column-reverse{flex-direction:column-reverse!important}.flex-xxl-grow-0{flex-grow:0!important}.flex-xxl-grow-1{flex-grow:1!important}.flex-xxl-shrink-0{flex-shrink:0!important}.flex-xxl-shrink-1{flex-shrink:1!important}.flex-xxl-wrap{flex-wrap:wrap!important}.flex-xxl-nowrap{flex-wrap:nowrap!important}.flex-xxl-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-xxl-start{justify-content:flex-start!important}.justify-content-xxl-end{justify-content:flex-end!important}.justify-content-xxl-center{justify-content:center!important}.justify-content-xxl-between{justify-content:space-between!important}.justify-content-xxl-around{justify-content:space-around!important}.justify-content-xxl-evenly{justify-content:space-evenly!important}.align-items-xxl-start{align-items:flex-start!important}.align-items-xxl-end{align-items:flex-end!important}.align-items-xxl-center{align-items:center!important}.align-items-xxl-baseline{align-items:baseline!important}.align-items-xxl-stretch{align-items:stretch!important}.align-content-xxl-start{align-content:flex-start!important}.align-content-xxl-end{align-content:flex-end!important}.align-content-xxl-center{align-content:center!important}.align-content-xxl-between{align-content:space-between!important}.align-content-xxl-around{align-content:space-around!important}.align-content-xxl-stretch{align-content:stretch!important}.align-self-xxl-auto{align-self:auto!important}.align-self-xxl-start{align-self:flex-start!important}.align-self-xxl-end{align-self:flex-end!important}.align-self-xxl-center{align-self:center!important}.align-self-xxl-baseline{align-self:baseline!important}.align-self-xxl-stretch{align-self:stretch!important}.order-xxl-first{order:-1!important}.order-xxl-0{order:0!important}.order-xxl-1{order:1!important}.order-xxl-2{order:2!important}.order-xxl-3{order:3!important}.order-xxl-4{order:4!important}.order-xxl-5{order:5!important}.order-xxl-last{order:6!important}.m-xxl-0{margin:0!important}.m-xxl-1{margin:.25rem!important}.m-xxl-2{margin:.5rem!important}.m-xxl-3{margin:1rem!important}.m-xxl-4{margin:1.5rem!important}.m-xxl-5{margin:3rem!important}.m-xxl-auto{margin:auto!important}.mx-xxl-0{margin-right:0!important;margin-left:0!important}.mx-xxl-1{margin-right:.25rem!important;margin-left:.25rem!important}.mx-xxl-2{margin-right:.5rem!important;margin-left:.5rem!important}.mx-xxl-3{margin-right:1rem!important;margin-left:1rem!important}.mx-xxl-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.mx-xxl-5{margin-right:3rem!important;margin-left:3rem!important}.mx-xxl-auto{margin-right:auto!important;margin-left:auto!important}.my-xxl-0{margin-top:0!important;margin-bottom:0!important}.my-xxl-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.my-xxl-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.my-xxl-3{margin-top:1rem!important;margin-bottom:1rem!important}.my-xxl-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.my-xxl-5{margin-top:3rem!important;margin-bottom:3rem!important}.my-xxl-auto{margin-top:auto!important;margin-bottom:auto!important}.mt-xxl-0{margin-top:0!important}.mt-xxl-1{margin-top:.25rem!important}.mt-xxl-2{margin-top:.5rem!important}.mt-xxl-3{margin-top:1rem!important}.mt-xxl-4{margin-top:1.5rem!important}.mt-xxl-5{margin-top:3rem!important}.mt-xxl-auto{margin-top:auto!important}.me-xxl-0{margin-right:0!important}.me-xxl-1{margin-right:.25rem!important}.me-xxl-2{margin-right:.5rem!important}.me-xxl-3{margin-right:1rem!important}.me-xxl-4{margin-right:1.5rem!important}.me-xxl-5{margin-right:3rem!important}.me-xxl-auto{margin-right:auto!important}.mb-xxl-0{margin-bottom:0!important}.mb-xxl-1{margin-bottom:.25rem!important}.mb-xxl-2{margin-bottom:.5rem!important}.mb-xxl-3{margin-bottom:1rem!important}.mb-xxl-4{margin-bottom:1.5rem!important}.mb-xxl-5{margin-bottom:3rem!important}.mb-xxl-auto{margin-bottom:auto!important}.ms-xxl-0{margin-left:0!important}.ms-xxl-1{margin-left:.25rem!important}.ms-xxl-2{margin-left:.5rem!important}.ms-xxl-3{margin-left:1rem!important}.ms-xxl-4{margin-left:1.5rem!important}.ms-xxl-5{margin-left:3rem!important}.ms-xxl-auto{margin-left:auto!important}.p-xxl-0{padding:0!important}.p-xxl-1{padding:.25rem!important}.p-xxl-2{padding:.5rem!important}.p-xxl-3{padding:1rem!important}.p-xxl-4{padding:1.5rem!important}.p-xxl-5{padding:3rem!important}.px-xxl-0{padding-right:0!important;padding-left:0!important}.px-xxl-1{padding-right:.25rem!important;padding-left:.25rem!important}.px-xxl-2{padding-right:.5rem!important;padding-left:.5rem!important}.px-xxl-3{padding-right:1rem!important;padding-left:1rem!important}.px-xxl-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.px-xxl-5{padding-right:3rem!important;padding-left:3rem!important}.py-xxl-0{padding-top:0!important;padding-bottom:0!important}.py-xxl-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.py-xxl-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.py-xxl-3{padding-top:1rem!important;padding-bottom:1rem!important}.py-xxl-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.py-xxl-5{padding-top:3rem!important;padding-bottom:3rem!important}.pt-xxl-0{padding-top:0!important}.pt-xxl-1{padding-top:.25rem!important}.pt-xxl-2{padding-top:.5rem!important}.pt-xxl-3{padding-top:1rem!important}.pt-xxl-4{padding-top:1.5rem!important}.pt-xxl-5{padding-top:3rem!important}.pe-xxl-0{padding-right:0!important}.pe-xxl-1{padding-right:.25rem!important}.pe-xxl-2{padding-right:.5rem!important}.pe-xxl-3{padding-right:1rem!important}.pe-xxl-4{padding-right:1.5rem!important}.pe-xxl-5{padding-right:3rem!important}.pb-xxl-0{padding-bottom:0!important}.pb-xxl-1{padding-bottom:.25rem!important}.pb-xxl-2{padding-bottom:.5rem!important}.pb-xxl-3{padding-bottom:1rem!important}.pb-xxl-4{padding-bottom:1.5rem!important}.pb-xxl-5{padding-bottom:3rem!important}.ps-xxl-0{padding-left:0!important}.ps-xxl-1{padding-left:.25rem!important}.ps-xxl-2{padding-left:.5rem!important}.ps-xxl-3{padding-left:1rem!important}.ps-xxl-4{padding-left:1.5rem!important}.ps-xxl-5{padding-left:3rem!important}.gap-xxl-0{gap:0!important}.gap-xxl-1{gap:.25rem!important}.gap-xxl-2{gap:.5rem!important}.gap-xxl-3{gap:1rem!important}.gap-xxl-4{gap:1.5rem!important}.gap-xxl-5{gap:3rem!important}.row-gap-xxl-0{row-gap:0!important}.row-gap-xxl-1{row-gap:.25rem!important}.row-gap-xxl-2{row-gap:.5rem!important}.row-gap-xxl-3{row-gap:1rem!important}.row-gap-xxl-4{row-gap:1.5rem!important}.row-gap-xxl-5{row-gap:3rem!important}.column-gap-xxl-0{-moz-column-gap:0!important;column-gap:0!important}.column-gap-xxl-1{-moz-column-gap:0.25rem!important;column-gap:.25rem!important}.column-gap-xxl-2{-moz-column-gap:0.5rem!important;column-gap:.5rem!important}.column-gap-xxl-3{-moz-column-gap:1rem!important;column-gap:1rem!important}.column-gap-xxl-4{-moz-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-xxl-5{-moz-column-gap:3rem!important;column-gap:3rem!important}.text-xxl-start{text-align:left!important}.text-xxl-end{text-align:right!important}.text-xxl-center{text-align:center!important}}@media (min-width:1200px){.fs-1{font-size:2.5rem!important}.fs-2{font-size:2rem!important}.fs-3{font-size:1.75rem!important}.fs-4{font-size:1.5rem!important}}@media print{.d-print-inline{display:inline!important}.d-print-inline-block{display:inline-block!important}.d-print-block{display:block!important}.d-print-grid{display:grid!important}.d-print-inline-grid{display:inline-grid!important}.d-print-table{display:table!important}.d-print-table-row{display:table-row!important}.d-print-table-cell{display:table-cell!important}.d-print-flex{display:flex!important}.d-print-inline-flex{display:inline-flex!important}.d-print-none{display:none!important}}
    /*# sourceMappingURL=bootstrap.min.css.map */`;
    
    // src/index.ts
    async function main() {
      const program2 = new Command();
      program2.name("fsinfo-transcript-postprocessor").description("CLI to post-process markdown transcripts of FSR meetings").version("unknown").argument(
        "<inputDir>",
        "path to directory containing the input markdown files"
      ).argument("<outputDir>", "path to output the rendered html to").option("-A, --output-ast", "Also save the AST as a file", false).action(run);
      await program2.parseAsync(process.argv);
    }
    main();
    async function run(inputDir, outputDir, options2) {
      const files = await getListOfFiles(inputDir);
      if (files.length > 1e3) {
        throw "Too many files to be read, something is off: " + files.length;
      }
      console.info("\u2699\uFE0F  Parsing", files.length, "markdown files...");
      const parseResults = await Promise.all(
        files.map((file) => parseFileWithoutCrashing(file))
      );
      const errorResults = parseResults.filter((r) => !r.ok && r.data == void 0);
      if (errorResults.length > 0) {
        console.error(errorResults.length, "transcripts had errors. Aborting.");
        process.exit(1);
      }
      console.info("\u270F\uFE0F  Writing individual HTML files...");
      await generateAllTranscriptPages(
        outputDir,
        parseResults.map((res) => res.data),
        options2
      );
      console.info("\u270F\uFE0F  Writing index file...");
      await generateIndexPage(
        outputDir,
        parseResults.map((res) => res.data),
        options2
      );
      console.info("\u270F\uFE0F  Writing resolutions list file...");
      await generateResolutionsPage(
        outputDir,
        parseResults.map((res) => res.data),
        options2
      );
      await import_promises.default.writeFile(outputDir + "/bootstrap.min.css", bootstrap, "utf8");
      console.info("\u2705 All done!");
    }
    async function getListOfFiles(rootPath) {
      if (typeof rootPath !== "string") {
        throw new TypeError("Missing argument <filesDirectory>");
      }
      return (await import_promises.default.readdir(rootPath)).filter((path) => path.endsWith(".md")).map((path) => rootPath + "/" + path).reverse();
    }
    async function parseFileWithoutCrashing(path) {
      try {
        const fileContent = await import_promises.default.readFile(path, "utf-8");
        const data = parse2(fileContent);
        return { ok: true, data, error: void 0 };
      } catch (error) {
        console.log("Error for file", path, error);
        return { ok: false, data: void 0, error };
      }
    }
    async function generateAllTranscriptPages(outputDir, transcripts, options2) {
      await import_promises.default.mkdir(outputDir, { recursive: true });
      await import_promises.default.rm(outputDir, {
        force: true,
        recursive: true
      });
      await import_promises.default.mkdir(outputDir, { recursive: true });
      await Promise.all(
        transcripts.map(
          (transcript) => generateTranscriptPage(transcript, outputDir, options2)
        )
      );
    }
    async function generateTranscriptPage(transcript, outputDir, options2) {
      const { meta, html, ast } = transcript;
      const transcriptDir = `fsr-sitzung-${meta.number}-${meta.date}`;
      const makeDirPromise = import_promises.default.mkdir(outputDir + "/" + transcriptDir, {
        recursive: true
      });
      const pageHtml = renderTranscriptPageHtml(html, meta);
      const htmlFilePath = outputDir + "/" + transcriptDir + "/index.html";
      await makeDirPromise;
      await import_promises.default.writeFile(htmlFilePath, pageHtml, "utf-8");
      if (options2.outputAst) {
        const astFilePath = outputDir + "/" + transcriptDir + "/ast.json";
        await import_promises.default.writeFile(astFilePath, JSON.stringify(ast, null, 2), "utf-8");
      }
    }
    async function generateIndexPage(outputDir, parseResults, options2) {
      const html = generateIndexHtml(parseResults);
      const htmlFilePath = outputDir + "/index.html";
      await import_promises.default.writeFile(htmlFilePath, html, "utf8");
    }
    async function generateResolutionsPage(outputDir, parseResults, options2) {
      const html = generateResolutionsHtml(parseResults);
      const htmlFilePath = outputDir + "/resolutions.html";
      await import_promises.default.writeFile(htmlFilePath, html, "utf8");
    }
    /*! Bundled license information:
    
    is-extendable/index.js:
      (*!
       * is-extendable <https://github.com/jonschlinkert/is-extendable>
       *
       * Copyright (c) 2015, Jon Schlinkert.
       * Licensed under the MIT License.
       *)
    
    strip-bom-string/index.js:
      (*!
       * strip-bom-string <https://github.com/jonschlinkert/strip-bom-string>
       *
       * Copyright (c) 2015, 2017, Jon Schlinkert.
       * Released under the MIT License.
       *)
    */