"use strict";
var __getOwnPropNames = Object.getOwnPropertyNames;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};

// node_modules/picocolors/picocolors.js
var require_picocolors = __commonJS({
  "node_modules/picocolors/picocolors.js"(exports2, module2) {
    var tty = require("tty");
    var isColorSupported = !("NO_COLOR" in process.env || process.argv.includes("--no-color")) && ("FORCE_COLOR" in process.env || process.argv.includes("--color") || process.platform === "win32" || tty.isatty(1) && process.env.TERM !== "dumb" || "CI" in process.env);
    var formatter = (open, close, replace = open) => (input) => {
      let string = "" + input;
      let index = string.indexOf(close, open.length);
      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
    };
    var replaceClose = (string, close, replace, index) => {
      let start = string.substring(0, index) + replace;
      let end = string.substring(index + close.length);
      let nextIndex = end.indexOf(close);
      return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
    };
    var createColors = (enabled = isColorSupported) => ({
      isColorSupported: enabled,
      reset: enabled ? (s) => `\x1B[0m${s}\x1B[0m` : String,
      bold: enabled ? formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m") : String,
      dim: enabled ? formatter("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m") : String,
      italic: enabled ? formatter("\x1B[3m", "\x1B[23m") : String,
      underline: enabled ? formatter("\x1B[4m", "\x1B[24m") : String,
      inverse: enabled ? formatter("\x1B[7m", "\x1B[27m") : String,
      hidden: enabled ? formatter("\x1B[8m", "\x1B[28m") : String,
      strikethrough: enabled ? formatter("\x1B[9m", "\x1B[29m") : String,
      black: enabled ? formatter("\x1B[30m", "\x1B[39m") : String,
      red: enabled ? formatter("\x1B[31m", "\x1B[39m") : String,
      green: enabled ? formatter("\x1B[32m", "\x1B[39m") : String,
      yellow: enabled ? formatter("\x1B[33m", "\x1B[39m") : String,
      blue: enabled ? formatter("\x1B[34m", "\x1B[39m") : String,
      magenta: enabled ? formatter("\x1B[35m", "\x1B[39m") : String,
      cyan: enabled ? formatter("\x1B[36m", "\x1B[39m") : String,
      white: enabled ? formatter("\x1B[37m", "\x1B[39m") : String,
      gray: enabled ? formatter("\x1B[90m", "\x1B[39m") : String,
      bgBlack: enabled ? formatter("\x1B[40m", "\x1B[49m") : String,
      bgRed: enabled ? formatter("\x1B[41m", "\x1B[49m") : String,
      bgGreen: enabled ? formatter("\x1B[42m", "\x1B[49m") : String,
      bgYellow: enabled ? formatter("\x1B[43m", "\x1B[49m") : String,
      bgBlue: enabled ? formatter("\x1B[44m", "\x1B[49m") : String,
      bgMagenta: enabled ? formatter("\x1B[45m", "\x1B[49m") : String,
      bgCyan: enabled ? formatter("\x1B[46m", "\x1B[49m") : String,
      bgWhite: enabled ? formatter("\x1B[47m", "\x1B[49m") : String
    });
    module2.exports = createColors();
    module2.exports.createColors = createColors;
  }
});

// node_modules/postcss/lib/tokenize.js
var require_tokenize = __commonJS({
  "node_modules/postcss/lib/tokenize.js"(exports2, module2) {
    "use strict";
    var SINGLE_QUOTE = "'".charCodeAt(0);
    var DOUBLE_QUOTE = '"'.charCodeAt(0);
    var BACKSLASH = "\\".charCodeAt(0);
    var SLASH = "/".charCodeAt(0);
    var NEWLINE = "\n".charCodeAt(0);
    var SPACE = " ".charCodeAt(0);
    var FEED = "\f".charCodeAt(0);
    var TAB = "	".charCodeAt(0);
    var CR = "\r".charCodeAt(0);
    var OPEN_SQUARE = "[".charCodeAt(0);
    var CLOSE_SQUARE = "]".charCodeAt(0);
    var OPEN_PARENTHESES = "(".charCodeAt(0);
    var CLOSE_PARENTHESES = ")".charCodeAt(0);
    var OPEN_CURLY = "{".charCodeAt(0);
    var CLOSE_CURLY = "}".charCodeAt(0);
    var SEMICOLON = ";".charCodeAt(0);
    var ASTERISK = "*".charCodeAt(0);
    var COLON = ":".charCodeAt(0);
    var AT = "@".charCodeAt(0);
    var RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
    var RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
    var RE_BAD_BRACKET = /.[\n"'(/\\]/;
    var RE_HEX_ESCAPE = /[\da-f]/i;
    module2.exports = function tokenizer(input, options = {}) {
      let css = input.css.valueOf();
      let ignore = options.ignoreErrors;
      let code, next, quote, content, escape;
      let escaped, escapePos, prev, n, currentToken;
      let length = css.length;
      let pos = 0;
      let buffer = [];
      let returned = [];
      function position() {
        return pos;
      }
      function unclosed(what) {
        throw input.error("Unclosed " + what, pos);
      }
      function endOfFile() {
        return returned.length === 0 && pos >= length;
      }
      function nextToken(opts) {
        if (returned.length)
          return returned.pop();
        if (pos >= length)
          return;
        let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
        code = css.charCodeAt(pos);
        switch (code) {
          case NEWLINE:
          case SPACE:
          case TAB:
          case CR:
          case FEED: {
            next = pos;
            do {
              next += 1;
              code = css.charCodeAt(next);
            } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
            currentToken = ["space", css.slice(pos, next)];
            pos = next - 1;
            break;
          }
          case OPEN_SQUARE:
          case CLOSE_SQUARE:
          case OPEN_CURLY:
          case CLOSE_CURLY:
          case COLON:
          case SEMICOLON:
          case CLOSE_PARENTHESES: {
            let controlChar = String.fromCharCode(code);
            currentToken = [controlChar, controlChar, pos];
            break;
          }
          case OPEN_PARENTHESES: {
            prev = buffer.length ? buffer.pop()[1] : "";
            n = css.charCodeAt(pos + 1);
            if (prev === "url" && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
              next = pos;
              do {
                escaped = false;
                next = css.indexOf(")", next + 1);
                if (next === -1) {
                  if (ignore || ignoreUnclosed) {
                    next = pos;
                    break;
                  } else {
                    unclosed("bracket");
                  }
                }
                escapePos = next;
                while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                  escapePos -= 1;
                  escaped = !escaped;
                }
              } while (escaped);
              currentToken = ["brackets", css.slice(pos, next + 1), pos, next];
              pos = next;
            } else {
              next = css.indexOf(")", pos + 1);
              content = css.slice(pos, next + 1);
              if (next === -1 || RE_BAD_BRACKET.test(content)) {
                currentToken = ["(", "(", pos];
              } else {
                currentToken = ["brackets", content, pos, next];
                pos = next;
              }
            }
            break;
          }
          case SINGLE_QUOTE:
          case DOUBLE_QUOTE: {
            quote = code === SINGLE_QUOTE ? "'" : '"';
            next = pos;
            do {
              escaped = false;
              next = css.indexOf(quote, next + 1);
              if (next === -1) {
                if (ignore || ignoreUnclosed) {
                  next = pos + 1;
                  break;
                } else {
                  unclosed("string");
                }
              }
              escapePos = next;
              while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                escapePos -= 1;
                escaped = !escaped;
              }
            } while (escaped);
            currentToken = ["string", css.slice(pos, next + 1), pos, next];
            pos = next;
            break;
          }
          case AT: {
            RE_AT_END.lastIndex = pos + 1;
            RE_AT_END.test(css);
            if (RE_AT_END.lastIndex === 0) {
              next = css.length - 1;
            } else {
              next = RE_AT_END.lastIndex - 2;
            }
            currentToken = ["at-word", css.slice(pos, next + 1), pos, next];
            pos = next;
            break;
          }
          case BACKSLASH: {
            next = pos;
            escape = true;
            while (css.charCodeAt(next + 1) === BACKSLASH) {
              next += 1;
              escape = !escape;
            }
            code = css.charCodeAt(next + 1);
            if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
              next += 1;
              if (RE_HEX_ESCAPE.test(css.charAt(next))) {
                while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
                  next += 1;
                }
                if (css.charCodeAt(next + 1) === SPACE) {
                  next += 1;
                }
              }
            }
            currentToken = ["word", css.slice(pos, next + 1), pos, next];
            pos = next;
            break;
          }
          default: {
            if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
              next = css.indexOf("*/", pos + 2) + 1;
              if (next === 0) {
                if (ignore || ignoreUnclosed) {
                  next = css.length;
                } else {
                  unclosed("comment");
                }
              }
              currentToken = ["comment", css.slice(pos, next + 1), pos, next];
              pos = next;
            } else {
              RE_WORD_END.lastIndex = pos + 1;
              RE_WORD_END.test(css);
              if (RE_WORD_END.lastIndex === 0) {
                next = css.length - 1;
              } else {
                next = RE_WORD_END.lastIndex - 2;
              }
              currentToken = ["word", css.slice(pos, next + 1), pos, next];
              buffer.push(currentToken);
              pos = next;
            }
            break;
          }
        }
        pos++;
        return currentToken;
      }
      function back(token) {
        returned.push(token);
      }
      return {
        back,
        nextToken,
        endOfFile,
        position
      };
    };
  }
});

// node_modules/postcss/lib/terminal-highlight.js
var require_terminal_highlight = __commonJS({
  "node_modules/postcss/lib/terminal-highlight.js"(exports2, module2) {
    "use strict";
    var pico = require_picocolors();
    var tokenizer = require_tokenize();
    var Input;
    function registerInput(dependant) {
      Input = dependant;
    }
    var HIGHLIGHT_THEME = {
      "brackets": pico.cyan,
      "at-word": pico.cyan,
      "comment": pico.gray,
      "string": pico.green,
      "class": pico.yellow,
      "hash": pico.magenta,
      "call": pico.cyan,
      "(": pico.cyan,
      ")": pico.cyan,
      "{": pico.yellow,
      "}": pico.yellow,
      "[": pico.yellow,
      "]": pico.yellow,
      ":": pico.yellow,
      ";": pico.yellow
    };
    function getTokenType([type, value], processor) {
      if (type === "word") {
        if (value[0] === ".") {
          return "class";
        }
        if (value[0] === "#") {
          return "hash";
        }
      }
      if (!processor.endOfFile()) {
        let next = processor.nextToken();
        processor.back(next);
        if (next[0] === "brackets" || next[0] === "(")
          return "call";
      }
      return type;
    }
    function terminalHighlight(css) {
      let processor = tokenizer(new Input(css), { ignoreErrors: true });
      let result = "";
      while (!processor.endOfFile()) {
        let token = processor.nextToken();
        let color = HIGHLIGHT_THEME[getTokenType(token, processor)];
        if (color) {
          result += token[1].split(/\r?\n/).map((i) => color(i)).join("\n");
        } else {
          result += token[1];
        }
      }
      return result;
    }
    terminalHighlight.registerInput = registerInput;
    module2.exports = terminalHighlight;
  }
});

// node_modules/postcss/lib/css-syntax-error.js
var require_css_syntax_error = __commonJS({
  "node_modules/postcss/lib/css-syntax-error.js"(exports2, module2) {
    "use strict";
    var pico = require_picocolors();
    var terminalHighlight = require_terminal_highlight();
    var CssSyntaxError = class extends Error {
      constructor(message, line, column, source, file, plugin) {
        super(message);
        this.name = "CssSyntaxError";
        this.reason = message;
        if (file) {
          this.file = file;
        }
        if (source) {
          this.source = source;
        }
        if (plugin) {
          this.plugin = plugin;
        }
        if (typeof line !== "undefined" && typeof column !== "undefined") {
          if (typeof line === "number") {
            this.line = line;
            this.column = column;
          } else {
            this.line = line.line;
            this.column = line.column;
            this.endLine = column.line;
            this.endColumn = column.column;
          }
        }
        this.setMessage();
        if (Error.captureStackTrace) {
          Error.captureStackTrace(this, CssSyntaxError);
        }
      }
      setMessage() {
        this.message = this.plugin ? this.plugin + ": " : "";
        this.message += this.file ? this.file : "<css input>";
        if (typeof this.line !== "undefined") {
          this.message += ":" + this.line + ":" + this.column;
        }
        this.message += ": " + this.reason;
      }
      showSourceCode(color) {
        if (!this.source)
          return "";
        let css = this.source;
        if (color == null)
          color = pico.isColorSupported;
        if (terminalHighlight) {
          if (color)
            css = terminalHighlight(css);
        }
        let lines = css.split(/\r?\n/);
        let start = Math.max(this.line - 3, 0);
        let end = Math.min(this.line + 2, lines.length);
        let maxWidth = String(end).length;
        let mark, aside;
        if (color) {
          let { bold, red, gray } = pico.createColors(true);
          mark = (text) => bold(red(text));
          aside = (text) => gray(text);
        } else {
          mark = aside = (str) => str;
        }
        return lines.slice(start, end).map((line, index) => {
          let number = start + 1 + index;
          let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
          if (number === this.line) {
            let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
            return mark(">") + aside(gutter) + line + "\n " + spacing + mark("^");
          }
          return " " + aside(gutter) + line;
        }).join("\n");
      }
      toString() {
        let code = this.showSourceCode();
        if (code) {
          code = "\n\n" + code + "\n";
        }
        return this.name + ": " + this.message + code;
      }
    };
    module2.exports = CssSyntaxError;
    CssSyntaxError.default = CssSyntaxError;
  }
});

// node_modules/postcss/lib/symbols.js
var require_symbols = __commonJS({
  "node_modules/postcss/lib/symbols.js"(exports2, module2) {
    "use strict";
    module2.exports.isClean = Symbol("isClean");
    module2.exports.my = Symbol("my");
  }
});

// node_modules/postcss/lib/stringifier.js
var require_stringifier = __commonJS({
  "node_modules/postcss/lib/stringifier.js"(exports2, module2) {
    "use strict";
    var DEFAULT_RAW = {
      colon: ": ",
      indent: "    ",
      beforeDecl: "\n",
      beforeRule: "\n",
      beforeOpen: " ",
      beforeClose: "\n",
      beforeComment: "\n",
      after: "\n",
      emptyBody: "",
      commentLeft: " ",
      commentRight: " ",
      semicolon: false
    };
    function capitalize(str) {
      return str[0].toUpperCase() + str.slice(1);
    }
    var Stringifier = class {
      constructor(builder) {
        this.builder = builder;
      }
      stringify(node, semicolon) {
        if (!this[node.type]) {
          throw new Error("Unknown AST node type " + node.type + ". Maybe you need to change PostCSS stringifier.");
        }
        this[node.type](node, semicolon);
      }
      document(node) {
        this.body(node);
      }
      root(node) {
        this.body(node);
        if (node.raws.after)
          this.builder(node.raws.after);
      }
      comment(node) {
        let left = this.raw(node, "left", "commentLeft");
        let right = this.raw(node, "right", "commentRight");
        this.builder("/*" + left + node.text + right + "*/", node);
      }
      decl(node, semicolon) {
        let between = this.raw(node, "between", "colon");
        let string = node.prop + between + this.rawValue(node, "value");
        if (node.important) {
          string += node.raws.important || " !important";
        }
        if (semicolon)
          string += ";";
        this.builder(string, node);
      }
      rule(node) {
        this.block(node, this.rawValue(node, "selector"));
        if (node.raws.ownSemicolon) {
          this.builder(node.raws.ownSemicolon, node, "end");
        }
      }
      atrule(node, semicolon) {
        let name = "@" + node.name;
        let params = node.params ? this.rawValue(node, "params") : "";
        if (typeof node.raws.afterName !== "undefined") {
          name += node.raws.afterName;
        } else if (params) {
          name += " ";
        }
        if (node.nodes) {
          this.block(node, name + params);
        } else {
          let end = (node.raws.between || "") + (semicolon ? ";" : "");
          this.builder(name + params + end, node);
        }
      }
      body(node) {
        let last = node.nodes.length - 1;
        while (last > 0) {
          if (node.nodes[last].type !== "comment")
            break;
          last -= 1;
        }
        let semicolon = this.raw(node, "semicolon");
        for (let i = 0; i < node.nodes.length; i++) {
          let child = node.nodes[i];
          let before = this.raw(child, "before");
          if (before)
            this.builder(before);
          this.stringify(child, last !== i || semicolon);
        }
      }
      block(node, start) {
        let between = this.raw(node, "between", "beforeOpen");
        this.builder(start + between + "{", node, "start");
        let after;
        if (node.nodes && node.nodes.length) {
          this.body(node);
          after = this.raw(node, "after");
        } else {
          after = this.raw(node, "after", "emptyBody");
        }
        if (after)
          this.builder(after);
        this.builder("}", node, "end");
      }
      raw(node, own, detect) {
        let value;
        if (!detect)
          detect = own;
        if (own) {
          value = node.raws[own];
          if (typeof value !== "undefined")
            return value;
        }
        let parent = node.parent;
        if (detect === "before") {
          if (!parent || parent.type === "root" && parent.first === node) {
            return "";
          }
          if (parent && parent.type === "document") {
            return "";
          }
        }
        if (!parent)
          return DEFAULT_RAW[detect];
        let root = node.root();
        if (!root.rawCache)
          root.rawCache = {};
        if (typeof root.rawCache[detect] !== "undefined") {
          return root.rawCache[detect];
        }
        if (detect === "before" || detect === "after") {
          return this.beforeAfter(node, detect);
        } else {
          let method = "raw" + capitalize(detect);
          if (this[method]) {
            value = this[method](root, node);
          } else {
            root.walk((i) => {
              value = i.raws[own];
              if (typeof value !== "undefined")
                return false;
            });
          }
        }
        if (typeof value === "undefined")
          value = DEFAULT_RAW[detect];
        root.rawCache[detect] = value;
        return value;
      }
      rawSemicolon(root) {
        let value;
        root.walk((i) => {
          if (i.nodes && i.nodes.length && i.last.type === "decl") {
            value = i.raws.semicolon;
            if (typeof value !== "undefined")
              return false;
          }
        });
        return value;
      }
      rawEmptyBody(root) {
        let value;
        root.walk((i) => {
          if (i.nodes && i.nodes.length === 0) {
            value = i.raws.after;
            if (typeof value !== "undefined")
              return false;
          }
        });
        return value;
      }
      rawIndent(root) {
        if (root.raws.indent)
          return root.raws.indent;
        let value;
        root.walk((i) => {
          let p = i.parent;
          if (p && p !== root && p.parent && p.parent === root) {
            if (typeof i.raws.before !== "undefined") {
              let parts = i.raws.before.split("\n");
              value = parts[parts.length - 1];
              value = value.replace(/\S/g, "");
              return false;
            }
          }
        });
        return value;
      }
      rawBeforeComment(root, node) {
        let value;
        root.walkComments((i) => {
          if (typeof i.raws.before !== "undefined") {
            value = i.raws.before;
            if (value.includes("\n")) {
              value = value.replace(/[^\n]+$/, "");
            }
            return false;
          }
        });
        if (typeof value === "undefined") {
          value = this.raw(node, null, "beforeDecl");
        } else if (value) {
          value = value.replace(/\S/g, "");
        }
        return value;
      }
      rawBeforeDecl(root, node) {
        let value;
        root.walkDecls((i) => {
          if (typeof i.raws.before !== "undefined") {
            value = i.raws.before;
            if (value.includes("\n")) {
              value = value.replace(/[^\n]+$/, "");
            }
            return false;
          }
        });
        if (typeof value === "undefined") {
          value = this.raw(node, null, "beforeRule");
        } else if (value) {
          value = value.replace(/\S/g, "");
        }
        return value;
      }
      rawBeforeRule(root) {
        let value;
        root.walk((i) => {
          if (i.nodes && (i.parent !== root || root.first !== i)) {
            if (typeof i.raws.before !== "undefined") {
              value = i.raws.before;
              if (value.includes("\n")) {
                value = value.replace(/[^\n]+$/, "");
              }
              return false;
            }
          }
        });
        if (value)
          value = value.replace(/\S/g, "");
        return value;
      }
      rawBeforeClose(root) {
        let value;
        root.walk((i) => {
          if (i.nodes && i.nodes.length > 0) {
            if (typeof i.raws.after !== "undefined") {
              value = i.raws.after;
              if (value.includes("\n")) {
                value = value.replace(/[^\n]+$/, "");
              }
              return false;
            }
          }
        });
        if (value)
          value = value.replace(/\S/g, "");
        return value;
      }
      rawBeforeOpen(root) {
        let value;
        root.walk((i) => {
          if (i.type !== "decl") {
            value = i.raws.between;
            if (typeof value !== "undefined")
              return false;
          }
        });
        return value;
      }
      rawColon(root) {
        let value;
        root.walkDecls((i) => {
          if (typeof i.raws.between !== "undefined") {
            value = i.raws.between.replace(/[^\s:]/g, "");
            return false;
          }
        });
        return value;
      }
      beforeAfter(node, detect) {
        let value;
        if (node.type === "decl") {
          value = this.raw(node, null, "beforeDecl");
        } else if (node.type === "comment") {
          value = this.raw(node, null, "beforeComment");
        } else if (detect === "before") {
          value = this.raw(node, null, "beforeRule");
        } else {
          value = this.raw(node, null, "beforeClose");
        }
        let buf = node.parent;
        let depth = 0;
        while (buf && buf.type !== "root") {
          depth += 1;
          buf = buf.parent;
        }
        if (value.includes("\n")) {
          let indent = this.raw(node, null, "indent");
          if (indent.length) {
            for (let step = 0; step < depth; step++)
              value += indent;
          }
        }
        return value;
      }
      rawValue(node, prop) {
        let value = node[prop];
        let raw = node.raws[prop];
        if (raw && raw.value === value) {
          return raw.raw;
        }
        return value;
      }
    };
    module2.exports = Stringifier;
    Stringifier.default = Stringifier;
  }
});

// node_modules/postcss/lib/stringify.js
var require_stringify = __commonJS({
  "node_modules/postcss/lib/stringify.js"(exports2, module2) {
    "use strict";
    var Stringifier = require_stringifier();
    function stringify(node, builder) {
      let str = new Stringifier(builder);
      str.stringify(node);
    }
    module2.exports = stringify;
    stringify.default = stringify;
  }
});

// node_modules/postcss/lib/node.js
var require_node = __commonJS({
  "node_modules/postcss/lib/node.js"(exports2, module2) {
    "use strict";
    var { isClean, my } = require_symbols();
    var CssSyntaxError = require_css_syntax_error();
    var Stringifier = require_stringifier();
    var stringify = require_stringify();
    function cloneNode(obj, parent) {
      let cloned = new obj.constructor();
      for (let i in obj) {
        if (!Object.prototype.hasOwnProperty.call(obj, i)) {
          continue;
        }
        if (i === "proxyCache")
          continue;
        let value = obj[i];
        let type = typeof value;
        if (i === "parent" && type === "object") {
          if (parent)
            cloned[i] = parent;
        } else if (i === "source") {
          cloned[i] = value;
        } else if (Array.isArray(value)) {
          cloned[i] = value.map((j) => cloneNode(j, cloned));
        } else {
          if (type === "object" && value !== null)
            value = cloneNode(value);
          cloned[i] = value;
        }
      }
      return cloned;
    }
    var Node = class {
      constructor(defaults = {}) {
        this.raws = {};
        this[isClean] = false;
        this[my] = true;
        for (let name in defaults) {
          if (name === "nodes") {
            this.nodes = [];
            for (let node of defaults[name]) {
              if (typeof node.clone === "function") {
                this.append(node.clone());
              } else {
                this.append(node);
              }
            }
          } else {
            this[name] = defaults[name];
          }
        }
      }
      error(message, opts = {}) {
        if (this.source) {
          let { start, end } = this.rangeBy(opts);
          return this.source.input.error(message, { line: start.line, column: start.column }, { line: end.line, column: end.column }, opts);
        }
        return new CssSyntaxError(message);
      }
      warn(result, text, opts) {
        let data = { node: this };
        for (let i in opts)
          data[i] = opts[i];
        return result.warn(text, data);
      }
      remove() {
        if (this.parent) {
          this.parent.removeChild(this);
        }
        this.parent = void 0;
        return this;
      }
      toString(stringifier = stringify) {
        if (stringifier.stringify)
          stringifier = stringifier.stringify;
        let result = "";
        stringifier(this, (i) => {
          result += i;
        });
        return result;
      }
      assign(overrides = {}) {
        for (let name in overrides) {
          this[name] = overrides[name];
        }
        return this;
      }
      clone(overrides = {}) {
        let cloned = cloneNode(this);
        for (let name in overrides) {
          cloned[name] = overrides[name];
        }
        return cloned;
      }
      cloneBefore(overrides = {}) {
        let cloned = this.clone(overrides);
        this.parent.insertBefore(this, cloned);
        return cloned;
      }
      cloneAfter(overrides = {}) {
        let cloned = this.clone(overrides);
        this.parent.insertAfter(this, cloned);
        return cloned;
      }
      replaceWith(...nodes) {
        if (this.parent) {
          let bookmark = this;
          let foundSelf = false;
          for (let node of nodes) {
            if (node === this) {
              foundSelf = true;
            } else if (foundSelf) {
              this.parent.insertAfter(bookmark, node);
              bookmark = node;
            } else {
              this.parent.insertBefore(bookmark, node);
            }
          }
          if (!foundSelf) {
            this.remove();
          }
        }
        return this;
      }
      next() {
        if (!this.parent)
          return void 0;
        let index = this.parent.index(this);
        return this.parent.nodes[index + 1];
      }
      prev() {
        if (!this.parent)
          return void 0;
        let index = this.parent.index(this);
        return this.parent.nodes[index - 1];
      }
      before(add) {
        this.parent.insertBefore(this, add);
        return this;
      }
      after(add) {
        this.parent.insertAfter(this, add);
        return this;
      }
      root() {
        let result = this;
        while (result.parent && result.parent.type !== "document") {
          result = result.parent;
        }
        return result;
      }
      raw(prop, defaultType) {
        let str = new Stringifier();
        return str.raw(this, prop, defaultType);
      }
      cleanRaws(keepBetween) {
        delete this.raws.before;
        delete this.raws.after;
        if (!keepBetween)
          delete this.raws.between;
      }
      toJSON(_, inputs) {
        let fixed = {};
        let emitInputs = inputs == null;
        inputs = inputs || /* @__PURE__ */ new Map();
        let inputsNextIndex = 0;
        for (let name in this) {
          if (!Object.prototype.hasOwnProperty.call(this, name)) {
            continue;
          }
          if (name === "parent" || name === "proxyCache")
            continue;
          let value = this[name];
          if (Array.isArray(value)) {
            fixed[name] = value.map((i) => {
              if (typeof i === "object" && i.toJSON) {
                return i.toJSON(null, inputs);
              } else {
                return i;
              }
            });
          } else if (typeof value === "object" && value.toJSON) {
            fixed[name] = value.toJSON(null, inputs);
          } else if (name === "source") {
            let inputId = inputs.get(value.input);
            if (inputId == null) {
              inputId = inputsNextIndex;
              inputs.set(value.input, inputsNextIndex);
              inputsNextIndex++;
            }
            fixed[name] = {
              inputId,
              start: value.start,
              end: value.end
            };
          } else {
            fixed[name] = value;
          }
        }
        if (emitInputs) {
          fixed.inputs = [...inputs.keys()].map((input) => input.toJSON());
        }
        return fixed;
      }
      positionInside(index) {
        let string = this.toString();
        let column = this.source.start.column;
        let line = this.source.start.line;
        for (let i = 0; i < index; i++) {
          if (string[i] === "\n") {
            column = 1;
            line += 1;
          } else {
            column += 1;
          }
        }
        return { line, column };
      }
      positionBy(opts) {
        let pos = this.source.start;
        if (opts.index) {
          pos = this.positionInside(opts.index);
        } else if (opts.word) {
          let index = this.toString().indexOf(opts.word);
          if (index !== -1)
            pos = this.positionInside(index);
        }
        return pos;
      }
      rangeBy(opts) {
        let start = {
          line: this.source.start.line,
          column: this.source.start.column
        };
        let end = this.source.end ? {
          line: this.source.end.line,
          column: this.source.end.column + 1
        } : {
          line: start.line,
          column: start.column + 1
        };
        if (opts.word) {
          let index = this.toString().indexOf(opts.word);
          if (index !== -1) {
            start = this.positionInside(index);
            end = this.positionInside(index + opts.word.length);
          }
        } else {
          if (opts.start) {
            start = {
              line: opts.start.line,
              column: opts.start.column
            };
          } else if (opts.index) {
            start = this.positionInside(opts.index);
          }
          if (opts.end) {
            end = {
              line: opts.end.line,
              column: opts.end.column
            };
          } else if (opts.endIndex) {
            end = this.positionInside(opts.endIndex);
          } else if (opts.index) {
            end = this.positionInside(opts.index + 1);
          }
        }
        if (end.line < start.line || end.line === start.line && end.column <= start.column) {
          end = { line: start.line, column: start.column + 1 };
        }
        return { start, end };
      }
      getProxyProcessor() {
        return {
          set(node, prop, value) {
            if (node[prop] === value)
              return true;
            node[prop] = value;
            if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || prop === "text") {
              node.markDirty();
            }
            return true;
          },
          get(node, prop) {
            if (prop === "proxyOf") {
              return node;
            } else if (prop === "root") {
              return () => node.root().toProxy();
            } else {
              return node[prop];
            }
          }
        };
      }
      toProxy() {
        if (!this.proxyCache) {
          this.proxyCache = new Proxy(this, this.getProxyProcessor());
        }
        return this.proxyCache;
      }
      addToError(error) {
        error.postcssNode = this;
        if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
          let s = this.source;
          error.stack = error.stack.replace(/\n\s{4}at /, `$&${s.input.from}:${s.start.line}:${s.start.column}$&`);
        }
        return error;
      }
      markDirty() {
        if (this[isClean]) {
          this[isClean] = false;
          let next = this;
          while (next = next.parent) {
            next[isClean] = false;
          }
        }
      }
      get proxyOf() {
        return this;
      }
    };
    module2.exports = Node;
    Node.default = Node;
  }
});

// node_modules/postcss/lib/declaration.js
var require_declaration = __commonJS({
  "node_modules/postcss/lib/declaration.js"(exports2, module2) {
    "use strict";
    var Node = require_node();
    var Declaration = class extends Node {
      constructor(defaults) {
        if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") {
          defaults = { ...defaults, value: String(defaults.value) };
        }
        super(defaults);
        this.type = "decl";
      }
      get variable() {
        return this.prop.startsWith("--") || this.prop[0] === "$";
      }
    };
    module2.exports = Declaration;
    Declaration.default = Declaration;
  }
});

// node_modules/source-map-js/lib/base64.js
var require_base64 = __commonJS({
  "node_modules/source-map-js/lib/base64.js"(exports2) {
    var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
    exports2.encode = function(number) {
      if (0 <= number && number < intToCharMap.length) {
        return intToCharMap[number];
      }
      throw new TypeError("Must be between 0 and 63: " + number);
    };
    exports2.decode = function(charCode) {
      var bigA = 65;
      var bigZ = 90;
      var littleA = 97;
      var littleZ = 122;
      var zero = 48;
      var nine = 57;
      var plus = 43;
      var slash = 47;
      var littleOffset = 26;
      var numberOffset = 52;
      if (bigA <= charCode && charCode <= bigZ) {
        return charCode - bigA;
      }
      if (littleA <= charCode && charCode <= littleZ) {
        return charCode - littleA + littleOffset;
      }
      if (zero <= charCode && charCode <= nine) {
        return charCode - zero + numberOffset;
      }
      if (charCode == plus) {
        return 62;
      }
      if (charCode == slash) {
        return 63;
      }
      return -1;
    };
  }
});

// node_modules/source-map-js/lib/base64-vlq.js
var require_base64_vlq = __commonJS({
  "node_modules/source-map-js/lib/base64-vlq.js"(exports2) {
    var base64 = require_base64();
    var VLQ_BASE_SHIFT = 5;
    var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
    var VLQ_BASE_MASK = VLQ_BASE - 1;
    var VLQ_CONTINUATION_BIT = VLQ_BASE;
    function toVLQSigned(aValue) {
      return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
    }
    function fromVLQSigned(aValue) {
      var isNegative = (aValue & 1) === 1;
      var shifted = aValue >> 1;
      return isNegative ? -shifted : shifted;
    }
    exports2.encode = function base64VLQ_encode(aValue) {
      var encoded = "";
      var digit;
      var vlq = toVLQSigned(aValue);
      do {
        digit = vlq & VLQ_BASE_MASK;
        vlq >>>= VLQ_BASE_SHIFT;
        if (vlq > 0) {
          digit |= VLQ_CONTINUATION_BIT;
        }
        encoded += base64.encode(digit);
      } while (vlq > 0);
      return encoded;
    };
    exports2.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
      var strLen = aStr.length;
      var result = 0;
      var shift = 0;
      var continuation, digit;
      do {
        if (aIndex >= strLen) {
          throw new Error("Expected more digits in base 64 VLQ value.");
        }
        digit = base64.decode(aStr.charCodeAt(aIndex++));
        if (digit === -1) {
          throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
        }
        continuation = !!(digit & VLQ_CONTINUATION_BIT);
        digit &= VLQ_BASE_MASK;
        result = result + (digit << shift);
        shift += VLQ_BASE_SHIFT;
      } while (continuation);
      aOutParam.value = fromVLQSigned(result);
      aOutParam.rest = aIndex;
    };
  }
});

// node_modules/source-map-js/lib/util.js
var require_util = __commonJS({
  "node_modules/source-map-js/lib/util.js"(exports2) {
    function getArg(aArgs, aName, aDefaultValue) {
      if (aName in aArgs) {
        return aArgs[aName];
      } else if (arguments.length === 3) {
        return aDefaultValue;
      } else {
        throw new Error('"' + aName + '" is a required argument.');
      }
    }
    exports2.getArg = getArg;
    var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
    var dataUrlRegexp = /^data:.+\,.+$/;
    function urlParse(aUrl) {
      var match = aUrl.match(urlRegexp);
      if (!match) {
        return null;
      }
      return {
        scheme: match[1],
        auth: match[2],
        host: match[3],
        port: match[4],
        path: match[5]
      };
    }
    exports2.urlParse = urlParse;
    function urlGenerate(aParsedUrl) {
      var url = "";
      if (aParsedUrl.scheme) {
        url += aParsedUrl.scheme + ":";
      }
      url += "//";
      if (aParsedUrl.auth) {
        url += aParsedUrl.auth + "@";
      }
      if (aParsedUrl.host) {
        url += aParsedUrl.host;
      }
      if (aParsedUrl.port) {
        url += ":" + aParsedUrl.port;
      }
      if (aParsedUrl.path) {
        url += aParsedUrl.path;
      }
      return url;
    }
    exports2.urlGenerate = urlGenerate;
    var MAX_CACHED_INPUTS = 32;
    function lruMemoize(f) {
      var cache = [];
      return function(input) {
        for (var i = 0; i < cache.length; i++) {
          if (cache[i].input === input) {
            var temp = cache[0];
            cache[0] = cache[i];
            cache[i] = temp;
            return cache[0].result;
          }
        }
        var result = f(input);
        cache.unshift({
          input,
          result
        });
        if (cache.length > MAX_CACHED_INPUTS) {
          cache.pop();
        }
        return result;
      };
    }
    var normalize = lruMemoize(function normalize2(aPath) {
      var path = aPath;
      var url = urlParse(aPath);
      if (url) {
        if (!url.path) {
          return aPath;
        }
        path = url.path;
      }
      var isAbsolute = exports2.isAbsolute(path);
      var parts = [];
      var start = 0;
      var i = 0;
      while (true) {
        start = i;
        i = path.indexOf("/", start);
        if (i === -1) {
          parts.push(path.slice(start));
          break;
        } else {
          parts.push(path.slice(start, i));
          while (i < path.length && path[i] === "/") {
            i++;
          }
        }
      }
      for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
        part = parts[i];
        if (part === ".") {
          parts.splice(i, 1);
        } else if (part === "..") {
          up++;
        } else if (up > 0) {
          if (part === "") {
            parts.splice(i + 1, up);
            up = 0;
          } else {
            parts.splice(i, 2);
            up--;
          }
        }
      }
      path = parts.join("/");
      if (path === "") {
        path = isAbsolute ? "/" : ".";
      }
      if (url) {
        url.path = path;
        return urlGenerate(url);
      }
      return path;
    });
    exports2.normalize = normalize;
    function join(aRoot, aPath) {
      if (aRoot === "") {
        aRoot = ".";
      }
      if (aPath === "") {
        aPath = ".";
      }
      var aPathUrl = urlParse(aPath);
      var aRootUrl = urlParse(aRoot);
      if (aRootUrl) {
        aRoot = aRootUrl.path || "/";
      }
      if (aPathUrl && !aPathUrl.scheme) {
        if (aRootUrl) {
          aPathUrl.scheme = aRootUrl.scheme;
        }
        return urlGenerate(aPathUrl);
      }
      if (aPathUrl || aPath.match(dataUrlRegexp)) {
        return aPath;
      }
      if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
        aRootUrl.host = aPath;
        return urlGenerate(aRootUrl);
      }
      var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
      if (aRootUrl) {
        aRootUrl.path = joined;
        return urlGenerate(aRootUrl);
      }
      return joined;
    }
    exports2.join = join;
    exports2.isAbsolute = function(aPath) {
      return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
    };
    function relative(aRoot, aPath) {
      if (aRoot === "") {
        aRoot = ".";
      }
      aRoot = aRoot.replace(/\/$/, "");
      var level = 0;
      while (aPath.indexOf(aRoot + "/") !== 0) {
        var index = aRoot.lastIndexOf("/");
        if (index < 0) {
          return aPath;
        }
        aRoot = aRoot.slice(0, index);
        if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
          return aPath;
        }
        ++level;
      }
      return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
    }
    exports2.relative = relative;
    var supportsNullProto = function() {
      var obj = /* @__PURE__ */ Object.create(null);
      return !("__proto__" in obj);
    }();
    function identity(s) {
      return s;
    }
    function toSetString(aStr) {
      if (isProtoString(aStr)) {
        return "$" + aStr;
      }
      return aStr;
    }
    exports2.toSetString = supportsNullProto ? identity : toSetString;
    function fromSetString(aStr) {
      if (isProtoString(aStr)) {
        return aStr.slice(1);
      }
      return aStr;
    }
    exports2.fromSetString = supportsNullProto ? identity : fromSetString;
    function isProtoString(s) {
      if (!s) {
        return false;
      }
      var length = s.length;
      if (length < 9) {
        return false;
      }
      if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
        return false;
      }
      for (var i = length - 10; i >= 0; i--) {
        if (s.charCodeAt(i) !== 36) {
          return false;
        }
      }
      return true;
    }
    function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
      var cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0 || onlyCompareOriginal) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByOriginalPositions = compareByOriginalPositions;
    function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {
      var cmp;
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0 || onlyCompareOriginal) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;
    function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
      var cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0 || onlyCompareGenerated) {
        return cmp;
      }
      cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
    function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {
      var cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0 || onlyCompareGenerated) {
        return cmp;
      }
      cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;
    function strcmp(aStr1, aStr2) {
      if (aStr1 === aStr2) {
        return 0;
      }
      if (aStr1 === null) {
        return 1;
      }
      if (aStr2 === null) {
        return -1;
      }
      if (aStr1 > aStr2) {
        return 1;
      }
      return -1;
    }
    function compareByGeneratedPositionsInflated(mappingA, mappingB) {
      var cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
    function parseSourceMapInput(str) {
      return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
    }
    exports2.parseSourceMapInput = parseSourceMapInput;
    function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
      sourceURL = sourceURL || "";
      if (sourceRoot) {
        if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
          sourceRoot += "/";
        }
        sourceURL = sourceRoot + sourceURL;
      }
      if (sourceMapURL) {
        var parsed = urlParse(sourceMapURL);
        if (!parsed) {
          throw new Error("sourceMapURL could not be parsed");
        }
        if (parsed.path) {
          var index = parsed.path.lastIndexOf("/");
          if (index >= 0) {
            parsed.path = parsed.path.substring(0, index + 1);
          }
        }
        sourceURL = join(urlGenerate(parsed), sourceURL);
      }
      return normalize(sourceURL);
    }
    exports2.computeSourceURL = computeSourceURL;
  }
});

// node_modules/source-map-js/lib/array-set.js
var require_array_set = __commonJS({
  "node_modules/source-map-js/lib/array-set.js"(exports2) {
    var util = require_util();
    var has = Object.prototype.hasOwnProperty;
    var hasNativeMap = typeof Map !== "undefined";
    function ArraySet() {
      this._array = [];
      this._set = hasNativeMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null);
    }
    ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
      var set = new ArraySet();
      for (var i = 0, len = aArray.length; i < len; i++) {
        set.add(aArray[i], aAllowDuplicates);
      }
      return set;
    };
    ArraySet.prototype.size = function ArraySet_size() {
      return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
    };
    ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
      var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
      var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
      var idx = this._array.length;
      if (!isDuplicate || aAllowDuplicates) {
        this._array.push(aStr);
      }
      if (!isDuplicate) {
        if (hasNativeMap) {
          this._set.set(aStr, idx);
        } else {
          this._set[sStr] = idx;
        }
      }
    };
    ArraySet.prototype.has = function ArraySet_has(aStr) {
      if (hasNativeMap) {
        return this._set.has(aStr);
      } else {
        var sStr = util.toSetString(aStr);
        return has.call(this._set, sStr);
      }
    };
    ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
      if (hasNativeMap) {
        var idx = this._set.get(aStr);
        if (idx >= 0) {
          return idx;
        }
      } else {
        var sStr = util.toSetString(aStr);
        if (has.call(this._set, sStr)) {
          return this._set[sStr];
        }
      }
      throw new Error('"' + aStr + '" is not in the set.');
    };
    ArraySet.prototype.at = function ArraySet_at(aIdx) {
      if (aIdx >= 0 && aIdx < this._array.length) {
        return this._array[aIdx];
      }
      throw new Error("No element indexed by " + aIdx);
    };
    ArraySet.prototype.toArray = function ArraySet_toArray() {
      return this._array.slice();
    };
    exports2.ArraySet = ArraySet;
  }
});

// node_modules/source-map-js/lib/mapping-list.js
var require_mapping_list = __commonJS({
  "node_modules/source-map-js/lib/mapping-list.js"(exports2) {
    var util = require_util();
    function generatedPositionAfter(mappingA, mappingB) {
      var lineA = mappingA.generatedLine;
      var lineB = mappingB.generatedLine;
      var columnA = mappingA.generatedColumn;
      var columnB = mappingB.generatedColumn;
      return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
    }
    function MappingList() {
      this._array = [];
      this._sorted = true;
      this._last = { generatedLine: -1, generatedColumn: 0 };
    }
    MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
      this._array.forEach(aCallback, aThisArg);
    };
    MappingList.prototype.add = function MappingList_add(aMapping) {
      if (generatedPositionAfter(this._last, aMapping)) {
        this._last = aMapping;
        this._array.push(aMapping);
      } else {
        this._sorted = false;
        this._array.push(aMapping);
      }
    };
    MappingList.prototype.toArray = function MappingList_toArray() {
      if (!this._sorted) {
        this._array.sort(util.compareByGeneratedPositionsInflated);
        this._sorted = true;
      }
      return this._array;
    };
    exports2.MappingList = MappingList;
  }
});

// node_modules/source-map-js/lib/source-map-generator.js
var require_source_map_generator = __commonJS({
  "node_modules/source-map-js/lib/source-map-generator.js"(exports2) {
    var base64VLQ = require_base64_vlq();
    var util = require_util();
    var ArraySet = require_array_set().ArraySet;
    var MappingList = require_mapping_list().MappingList;
    function SourceMapGenerator(aArgs) {
      if (!aArgs) {
        aArgs = {};
      }
      this._file = util.getArg(aArgs, "file", null);
      this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
      this._skipValidation = util.getArg(aArgs, "skipValidation", false);
      this._sources = new ArraySet();
      this._names = new ArraySet();
      this._mappings = new MappingList();
      this._sourcesContents = null;
    }
    SourceMapGenerator.prototype._version = 3;
    SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
      var sourceRoot = aSourceMapConsumer.sourceRoot;
      var generator = new SourceMapGenerator({
        file: aSourceMapConsumer.file,
        sourceRoot
      });
      aSourceMapConsumer.eachMapping(function(mapping) {
        var newMapping = {
          generated: {
            line: mapping.generatedLine,
            column: mapping.generatedColumn
          }
        };
        if (mapping.source != null) {
          newMapping.source = mapping.source;
          if (sourceRoot != null) {
            newMapping.source = util.relative(sourceRoot, newMapping.source);
          }
          newMapping.original = {
            line: mapping.originalLine,
            column: mapping.originalColumn
          };
          if (mapping.name != null) {
            newMapping.name = mapping.name;
          }
        }
        generator.addMapping(newMapping);
      });
      aSourceMapConsumer.sources.forEach(function(sourceFile) {
        var sourceRelative = sourceFile;
        if (sourceRoot !== null) {
          sourceRelative = util.relative(sourceRoot, sourceFile);
        }
        if (!generator._sources.has(sourceRelative)) {
          generator._sources.add(sourceRelative);
        }
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content != null) {
          generator.setSourceContent(sourceFile, content);
        }
      });
      return generator;
    };
    SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
      var generated = util.getArg(aArgs, "generated");
      var original = util.getArg(aArgs, "original", null);
      var source = util.getArg(aArgs, "source", null);
      var name = util.getArg(aArgs, "name", null);
      if (!this._skipValidation) {
        this._validateMapping(generated, original, source, name);
      }
      if (source != null) {
        source = String(source);
        if (!this._sources.has(source)) {
          this._sources.add(source);
        }
      }
      if (name != null) {
        name = String(name);
        if (!this._names.has(name)) {
          this._names.add(name);
        }
      }
      this._mappings.add({
        generatedLine: generated.line,
        generatedColumn: generated.column,
        originalLine: original != null && original.line,
        originalColumn: original != null && original.column,
        source,
        name
      });
    };
    SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
      var source = aSourceFile;
      if (this._sourceRoot != null) {
        source = util.relative(this._sourceRoot, source);
      }
      if (aSourceContent != null) {
        if (!this._sourcesContents) {
          this._sourcesContents = /* @__PURE__ */ Object.create(null);
        }
        this._sourcesContents[util.toSetString(source)] = aSourceContent;
      } else if (this._sourcesContents) {
        delete this._sourcesContents[util.toSetString(source)];
        if (Object.keys(this._sourcesContents).length === 0) {
          this._sourcesContents = null;
        }
      }
    };
    SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
      var sourceFile = aSourceFile;
      if (aSourceFile == null) {
        if (aSourceMapConsumer.file == null) {
          throw new Error(`SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`);
        }
        sourceFile = aSourceMapConsumer.file;
      }
      var sourceRoot = this._sourceRoot;
      if (sourceRoot != null) {
        sourceFile = util.relative(sourceRoot, sourceFile);
      }
      var newSources = new ArraySet();
      var newNames = new ArraySet();
      this._mappings.unsortedForEach(function(mapping) {
        if (mapping.source === sourceFile && mapping.originalLine != null) {
          var original = aSourceMapConsumer.originalPositionFor({
            line: mapping.originalLine,
            column: mapping.originalColumn
          });
          if (original.source != null) {
            mapping.source = original.source;
            if (aSourceMapPath != null) {
              mapping.source = util.join(aSourceMapPath, mapping.source);
            }
            if (sourceRoot != null) {
              mapping.source = util.relative(sourceRoot, mapping.source);
            }
            mapping.originalLine = original.line;
            mapping.originalColumn = original.column;
            if (original.name != null) {
              mapping.name = original.name;
            }
          }
        }
        var source = mapping.source;
        if (source != null && !newSources.has(source)) {
          newSources.add(source);
        }
        var name = mapping.name;
        if (name != null && !newNames.has(name)) {
          newNames.add(name);
        }
      }, this);
      this._sources = newSources;
      this._names = newNames;
      aSourceMapConsumer.sources.forEach(function(sourceFile2) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile2);
        if (content != null) {
          if (aSourceMapPath != null) {
            sourceFile2 = util.join(aSourceMapPath, sourceFile2);
          }
          if (sourceRoot != null) {
            sourceFile2 = util.relative(sourceRoot, sourceFile2);
          }
          this.setSourceContent(sourceFile2, content);
        }
      }, this);
    };
    SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
      if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
        throw new Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.");
      }
      if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
        return;
      } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
        return;
      } else {
        throw new Error("Invalid mapping: " + JSON.stringify({
          generated: aGenerated,
          source: aSource,
          original: aOriginal,
          name: aName
        }));
      }
    };
    SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
      var previousGeneratedColumn = 0;
      var previousGeneratedLine = 1;
      var previousOriginalColumn = 0;
      var previousOriginalLine = 0;
      var previousName = 0;
      var previousSource = 0;
      var result = "";
      var next;
      var mapping;
      var nameIdx;
      var sourceIdx;
      var mappings = this._mappings.toArray();
      for (var i = 0, len = mappings.length; i < len; i++) {
        mapping = mappings[i];
        next = "";
        if (mapping.generatedLine !== previousGeneratedLine) {
          previousGeneratedColumn = 0;
          while (mapping.generatedLine !== previousGeneratedLine) {
            next += ";";
            previousGeneratedLine++;
          }
        } else {
          if (i > 0) {
            if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
              continue;
            }
            next += ",";
          }
        }
        next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
        previousGeneratedColumn = mapping.generatedColumn;
        if (mapping.source != null) {
          sourceIdx = this._sources.indexOf(mapping.source);
          next += base64VLQ.encode(sourceIdx - previousSource);
          previousSource = sourceIdx;
          next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
          previousOriginalLine = mapping.originalLine - 1;
          next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
          previousOriginalColumn = mapping.originalColumn;
          if (mapping.name != null) {
            nameIdx = this._names.indexOf(mapping.name);
            next += base64VLQ.encode(nameIdx - previousName);
            previousName = nameIdx;
          }
        }
        result += next;
      }
      return result;
    };
    SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
      return aSources.map(function(source) {
        if (!this._sourcesContents) {
          return null;
        }
        if (aSourceRoot != null) {
          source = util.relative(aSourceRoot, source);
        }
        var key = util.toSetString(source);
        return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
      }, this);
    };
    SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
      var map = {
        version: this._version,
        sources: this._sources.toArray(),
        names: this._names.toArray(),
        mappings: this._serializeMappings()
      };
      if (this._file != null) {
        map.file = this._file;
      }
      if (this._sourceRoot != null) {
        map.sourceRoot = this._sourceRoot;
      }
      if (this._sourcesContents) {
        map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
      }
      return map;
    };
    SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
      return JSON.stringify(this.toJSON());
    };
    exports2.SourceMapGenerator = SourceMapGenerator;
  }
});

// node_modules/source-map-js/lib/binary-search.js
var require_binary_search = __commonJS({
  "node_modules/source-map-js/lib/binary-search.js"(exports2) {
    exports2.GREATEST_LOWER_BOUND = 1;
    exports2.LEAST_UPPER_BOUND = 2;
    function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
      var mid = Math.floor((aHigh - aLow) / 2) + aLow;
      var cmp = aCompare(aNeedle, aHaystack[mid], true);
      if (cmp === 0) {
        return mid;
      } else if (cmp > 0) {
        if (aHigh - mid > 1) {
          return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
        }
        if (aBias == exports2.LEAST_UPPER_BOUND) {
          return aHigh < aHaystack.length ? aHigh : -1;
        } else {
          return mid;
        }
      } else {
        if (mid - aLow > 1) {
          return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
        }
        if (aBias == exports2.LEAST_UPPER_BOUND) {
          return mid;
        } else {
          return aLow < 0 ? -1 : aLow;
        }
      }
    }
    exports2.search = function search(aNeedle, aHaystack, aCompare, aBias) {
      if (aHaystack.length === 0) {
        return -1;
      }
      var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports2.GREATEST_LOWER_BOUND);
      if (index < 0) {
        return -1;
      }
      while (index - 1 >= 0) {
        if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
          break;
        }
        --index;
      }
      return index;
    };
  }
});

// node_modules/source-map-js/lib/quick-sort.js
var require_quick_sort = __commonJS({
  "node_modules/source-map-js/lib/quick-sort.js"(exports2) {
    function SortTemplate(comparator) {
      function swap(ary, x, y) {
        var temp = ary[x];
        ary[x] = ary[y];
        ary[y] = temp;
      }
      function randomIntInRange(low, high) {
        return Math.round(low + Math.random() * (high - low));
      }
      function doQuickSort(ary, comparator2, p, r) {
        if (p < r) {
          var pivotIndex = randomIntInRange(p, r);
          var i = p - 1;
          swap(ary, pivotIndex, r);
          var pivot = ary[r];
          for (var j = p; j < r; j++) {
            if (comparator2(ary[j], pivot, false) <= 0) {
              i += 1;
              swap(ary, i, j);
            }
          }
          swap(ary, i + 1, j);
          var q = i + 1;
          doQuickSort(ary, comparator2, p, q - 1);
          doQuickSort(ary, comparator2, q + 1, r);
        }
      }
      return doQuickSort;
    }
    function cloneSort(comparator) {
      let template = SortTemplate.toString();
      let templateFn = new Function(`return ${template}`)();
      return templateFn(comparator);
    }
    var sortCache = /* @__PURE__ */ new WeakMap();
    exports2.quickSort = function(ary, comparator, start = 0) {
      let doQuickSort = sortCache.get(comparator);
      if (doQuickSort === void 0) {
        doQuickSort = cloneSort(comparator);
        sortCache.set(comparator, doQuickSort);
      }
      doQuickSort(ary, comparator, start, ary.length - 1);
    };
  }
});

// node_modules/source-map-js/lib/source-map-consumer.js
var require_source_map_consumer = __commonJS({
  "node_modules/source-map-js/lib/source-map-consumer.js"(exports2) {
    var util = require_util();
    var binarySearch = require_binary_search();
    var ArraySet = require_array_set().ArraySet;
    var base64VLQ = require_base64_vlq();
    var quickSort = require_quick_sort().quickSort;
    function SourceMapConsumer(aSourceMap, aSourceMapURL) {
      var sourceMap = aSourceMap;
      if (typeof aSourceMap === "string") {
        sourceMap = util.parseSourceMapInput(aSourceMap);
      }
      return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
    }
    SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
      return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
    };
    SourceMapConsumer.prototype._version = 3;
    SourceMapConsumer.prototype.__generatedMappings = null;
    Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
      configurable: true,
      enumerable: true,
      get: function() {
        if (!this.__generatedMappings) {
          this._parseMappings(this._mappings, this.sourceRoot);
        }
        return this.__generatedMappings;
      }
    });
    SourceMapConsumer.prototype.__originalMappings = null;
    Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
      configurable: true,
      enumerable: true,
      get: function() {
        if (!this.__originalMappings) {
          this._parseMappings(this._mappings, this.sourceRoot);
        }
        return this.__originalMappings;
      }
    });
    SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
      var c = aStr.charAt(index);
      return c === ";" || c === ",";
    };
    SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
      throw new Error("Subclasses must implement _parseMappings");
    };
    SourceMapConsumer.GENERATED_ORDER = 1;
    SourceMapConsumer.ORIGINAL_ORDER = 2;
    SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
    SourceMapConsumer.LEAST_UPPER_BOUND = 2;
    SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
      var context = aContext || null;
      var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
      var mappings;
      switch (order) {
        case SourceMapConsumer.GENERATED_ORDER:
          mappings = this._generatedMappings;
          break;
        case SourceMapConsumer.ORIGINAL_ORDER:
          mappings = this._originalMappings;
          break;
        default:
          throw new Error("Unknown order of iteration.");
      }
      var sourceRoot = this.sourceRoot;
      var boundCallback = aCallback.bind(context);
      var names = this._names;
      var sources = this._sources;
      var sourceMapURL = this._sourceMapURL;
      for (var i = 0, n = mappings.length; i < n; i++) {
        var mapping = mappings[i];
        var source = mapping.source === null ? null : sources.at(mapping.source);
        source = util.computeSourceURL(sourceRoot, source, sourceMapURL);
        boundCallback({
          source,
          generatedLine: mapping.generatedLine,
          generatedColumn: mapping.generatedColumn,
          originalLine: mapping.originalLine,
          originalColumn: mapping.originalColumn,
          name: mapping.name === null ? null : names.at(mapping.name)
        });
      }
    };
    SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
      var line = util.getArg(aArgs, "line");
      var needle = {
        source: util.getArg(aArgs, "source"),
        originalLine: line,
        originalColumn: util.getArg(aArgs, "column", 0)
      };
      needle.source = this._findSourceIndex(needle.source);
      if (needle.source < 0) {
        return [];
      }
      var mappings = [];
      var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND);
      if (index >= 0) {
        var mapping = this._originalMappings[index];
        if (aArgs.column === void 0) {
          var originalLine = mapping.originalLine;
          while (mapping && mapping.originalLine === originalLine) {
            mappings.push({
              line: util.getArg(mapping, "generatedLine", null),
              column: util.getArg(mapping, "generatedColumn", null),
              lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
            });
            mapping = this._originalMappings[++index];
          }
        } else {
          var originalColumn = mapping.originalColumn;
          while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
            mappings.push({
              line: util.getArg(mapping, "generatedLine", null),
              column: util.getArg(mapping, "generatedColumn", null),
              lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
            });
            mapping = this._originalMappings[++index];
          }
        }
      }
      return mappings;
    };
    exports2.SourceMapConsumer = SourceMapConsumer;
    function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
      var sourceMap = aSourceMap;
      if (typeof aSourceMap === "string") {
        sourceMap = util.parseSourceMapInput(aSourceMap);
      }
      var version = util.getArg(sourceMap, "version");
      var sources = util.getArg(sourceMap, "sources");
      var names = util.getArg(sourceMap, "names", []);
      var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
      var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
      var mappings = util.getArg(sourceMap, "mappings");
      var file = util.getArg(sourceMap, "file", null);
      if (version != this._version) {
        throw new Error("Unsupported version: " + version);
      }
      if (sourceRoot) {
        sourceRoot = util.normalize(sourceRoot);
      }
      sources = sources.map(String).map(util.normalize).map(function(source) {
        return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
      });
      this._names = ArraySet.fromArray(names.map(String), true);
      this._sources = ArraySet.fromArray(sources, true);
      this._absoluteSources = this._sources.toArray().map(function(s) {
        return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
      });
      this.sourceRoot = sourceRoot;
      this.sourcesContent = sourcesContent;
      this._mappings = mappings;
      this._sourceMapURL = aSourceMapURL;
      this.file = file;
    }
    BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
    BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
    BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
      var relativeSource = aSource;
      if (this.sourceRoot != null) {
        relativeSource = util.relative(this.sourceRoot, relativeSource);
      }
      if (this._sources.has(relativeSource)) {
        return this._sources.indexOf(relativeSource);
      }
      var i;
      for (i = 0; i < this._absoluteSources.length; ++i) {
        if (this._absoluteSources[i] == aSource) {
          return i;
        }
      }
      return -1;
    };
    BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
      var smc = Object.create(BasicSourceMapConsumer.prototype);
      var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
      var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
      smc.sourceRoot = aSourceMap._sourceRoot;
      smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot);
      smc.file = aSourceMap._file;
      smc._sourceMapURL = aSourceMapURL;
      smc._absoluteSources = smc._sources.toArray().map(function(s) {
        return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
      });
      var generatedMappings = aSourceMap._mappings.toArray().slice();
      var destGeneratedMappings = smc.__generatedMappings = [];
      var destOriginalMappings = smc.__originalMappings = [];
      for (var i = 0, length = generatedMappings.length; i < length; i++) {
        var srcMapping = generatedMappings[i];
        var destMapping = new Mapping();
        destMapping.generatedLine = srcMapping.generatedLine;
        destMapping.generatedColumn = srcMapping.generatedColumn;
        if (srcMapping.source) {
          destMapping.source = sources.indexOf(srcMapping.source);
          destMapping.originalLine = srcMapping.originalLine;
          destMapping.originalColumn = srcMapping.originalColumn;
          if (srcMapping.name) {
            destMapping.name = names.indexOf(srcMapping.name);
          }
          destOriginalMappings.push(destMapping);
        }
        destGeneratedMappings.push(destMapping);
      }
      quickSort(smc.__originalMappings, util.compareByOriginalPositions);
      return smc;
    };
    BasicSourceMapConsumer.prototype._version = 3;
    Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", {
      get: function() {
        return this._absoluteSources.slice();
      }
    });
    function Mapping() {
      this.generatedLine = 0;
      this.generatedColumn = 0;
      this.source = null;
      this.originalLine = null;
      this.originalColumn = null;
      this.name = null;
    }
    var compareGenerated = util.compareByGeneratedPositionsDeflatedNoLine;
    function sortGenerated(array, start) {
      let l = array.length;
      let n = array.length - start;
      if (n <= 1) {
        return;
      } else if (n == 2) {
        let a = array[start];
        let b = array[start + 1];
        if (compareGenerated(a, b) > 0) {
          array[start] = b;
          array[start + 1] = a;
        }
      } else if (n < 20) {
        for (let i = start; i < l; i++) {
          for (let j = i; j > start; j--) {
            let a = array[j - 1];
            let b = array[j];
            if (compareGenerated(a, b) <= 0) {
              break;
            }
            array[j - 1] = b;
            array[j] = a;
          }
        }
      } else {
        quickSort(array, compareGenerated, start);
      }
    }
    BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
      var generatedLine = 1;
      var previousGeneratedColumn = 0;
      var previousOriginalLine = 0;
      var previousOriginalColumn = 0;
      var previousSource = 0;
      var previousName = 0;
      var length = aStr.length;
      var index = 0;
      var cachedSegments = {};
      var temp = {};
      var originalMappings = [];
      var generatedMappings = [];
      var mapping, str, segment, end, value;
      let subarrayStart = 0;
      while (index < length) {
        if (aStr.charAt(index) === ";") {
          generatedLine++;
          index++;
          previousGeneratedColumn = 0;
          sortGenerated(generatedMappings, subarrayStart);
          subarrayStart = generatedMappings.length;
        } else if (aStr.charAt(index) === ",") {
          index++;
        } else {
          mapping = new Mapping();
          mapping.generatedLine = generatedLine;
          for (end = index; end < length; end++) {
            if (this._charIsMappingSeparator(aStr, end)) {
              break;
            }
          }
          str = aStr.slice(index, end);
          segment = [];
          while (index < end) {
            base64VLQ.decode(aStr, index, temp);
            value = temp.value;
            index = temp.rest;
            segment.push(value);
          }
          if (segment.length === 2) {
            throw new Error("Found a source, but no line and column");
          }
          if (segment.length === 3) {
            throw new Error("Found a source and line, but no column");
          }
          mapping.generatedColumn = previousGeneratedColumn + segment[0];
          previousGeneratedColumn = mapping.generatedColumn;
          if (segment.length > 1) {
            mapping.source = previousSource + segment[1];
            previousSource += segment[1];
            mapping.originalLine = previousOriginalLine + segment[2];
            previousOriginalLine = mapping.originalLine;
            mapping.originalLine += 1;
            mapping.originalColumn = previousOriginalColumn + segment[3];
            previousOriginalColumn = mapping.originalColumn;
            if (segment.length > 4) {
              mapping.name = previousName + segment[4];
              previousName += segment[4];
            }
          }
          generatedMappings.push(mapping);
          if (typeof mapping.originalLine === "number") {
            let currentSource = mapping.source;
            while (originalMappings.length <= currentSource) {
              originalMappings.push(null);
            }
            if (originalMappings[currentSource] === null) {
              originalMappings[currentSource] = [];
            }
            originalMappings[currentSource].push(mapping);
          }
        }
      }
      sortGenerated(generatedMappings, subarrayStart);
      this.__generatedMappings = generatedMappings;
      for (var i = 0; i < originalMappings.length; i++) {
        if (originalMappings[i] != null) {
          quickSort(originalMappings[i], util.compareByOriginalPositionsNoSource);
        }
      }
      this.__originalMappings = [].concat(...originalMappings);
    };
    BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
      if (aNeedle[aLineName] <= 0) {
        throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
      }
      if (aNeedle[aColumnName] < 0) {
        throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
      }
      return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
    };
    BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
      for (var index = 0; index < this._generatedMappings.length; ++index) {
        var mapping = this._generatedMappings[index];
        if (index + 1 < this._generatedMappings.length) {
          var nextMapping = this._generatedMappings[index + 1];
          if (mapping.generatedLine === nextMapping.generatedLine) {
            mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
            continue;
          }
        }
        mapping.lastGeneratedColumn = Infinity;
      }
    };
    BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
      var needle = {
        generatedLine: util.getArg(aArgs, "line"),
        generatedColumn: util.getArg(aArgs, "column")
      };
      var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
      if (index >= 0) {
        var mapping = this._generatedMappings[index];
        if (mapping.generatedLine === needle.generatedLine) {
          var source = util.getArg(mapping, "source", null);
          if (source !== null) {
            source = this._sources.at(source);
            source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
          }
          var name = util.getArg(mapping, "name", null);
          if (name !== null) {
            name = this._names.at(name);
          }
          return {
            source,
            line: util.getArg(mapping, "originalLine", null),
            column: util.getArg(mapping, "originalColumn", null),
            name
          };
        }
      }
      return {
        source: null,
        line: null,
        column: null,
        name: null
      };
    };
    BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
      if (!this.sourcesContent) {
        return false;
      }
      return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
        return sc == null;
      });
    };
    BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
      if (!this.sourcesContent) {
        return null;
      }
      var index = this._findSourceIndex(aSource);
      if (index >= 0) {
        return this.sourcesContent[index];
      }
      var relativeSource = aSource;
      if (this.sourceRoot != null) {
        relativeSource = util.relative(this.sourceRoot, relativeSource);
      }
      var url;
      if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
        var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
        if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) {
          return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
        }
        if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) {
          return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
        }
      }
      if (nullOnMissing) {
        return null;
      } else {
        throw new Error('"' + relativeSource + '" is not in the SourceMap.');
      }
    };
    BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
      var source = util.getArg(aArgs, "source");
      source = this._findSourceIndex(source);
      if (source < 0) {
        return {
          line: null,
          column: null,
          lastColumn: null
        };
      }
      var needle = {
        source,
        originalLine: util.getArg(aArgs, "line"),
        originalColumn: util.getArg(aArgs, "column")
      };
      var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
      if (index >= 0) {
        var mapping = this._originalMappings[index];
        if (mapping.source === needle.source) {
          return {
            line: util.getArg(mapping, "generatedLine", null),
            column: util.getArg(mapping, "generatedColumn", null),
            lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
          };
        }
      }
      return {
        line: null,
        column: null,
        lastColumn: null
      };
    };
    exports2.BasicSourceMapConsumer = BasicSourceMapConsumer;
    function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
      var sourceMap = aSourceMap;
      if (typeof aSourceMap === "string") {
        sourceMap = util.parseSourceMapInput(aSourceMap);
      }
      var version = util.getArg(sourceMap, "version");
      var sections = util.getArg(sourceMap, "sections");
      if (version != this._version) {
        throw new Error("Unsupported version: " + version);
      }
      this._sources = new ArraySet();
      this._names = new ArraySet();
      var lastOffset = {
        line: -1,
        column: 0
      };
      this._sections = sections.map(function(s) {
        if (s.url) {
          throw new Error("Support for url field in sections not implemented.");
        }
        var offset = util.getArg(s, "offset");
        var offsetLine = util.getArg(offset, "line");
        var offsetColumn = util.getArg(offset, "column");
        if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
          throw new Error("Section offsets must be ordered and non-overlapping.");
        }
        lastOffset = offset;
        return {
          generatedOffset: {
            generatedLine: offsetLine + 1,
            generatedColumn: offsetColumn + 1
          },
          consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
        };
      });
    }
    IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
    IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
    IndexedSourceMapConsumer.prototype._version = 3;
    Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", {
      get: function() {
        var sources = [];
        for (var i = 0; i < this._sections.length; i++) {
          for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
            sources.push(this._sections[i].consumer.sources[j]);
          }
        }
        return sources;
      }
    });
    IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
      var needle = {
        generatedLine: util.getArg(aArgs, "line"),
        generatedColumn: util.getArg(aArgs, "column")
      };
      var sectionIndex = binarySearch.search(needle, this._sections, function(needle2, section2) {
        var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine;
        if (cmp) {
          return cmp;
        }
        return needle2.generatedColumn - section2.generatedOffset.generatedColumn;
      });
      var section = this._sections[sectionIndex];
      if (!section) {
        return {
          source: null,
          line: null,
          column: null,
          name: null
        };
      }
      return section.consumer.originalPositionFor({
        line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
        column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
        bias: aArgs.bias
      });
    };
    IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
      return this._sections.every(function(s) {
        return s.consumer.hasContentsOfAllSources();
      });
    };
    IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
      for (var i = 0; i < this._sections.length; i++) {
        var section = this._sections[i];
        var content = section.consumer.sourceContentFor(aSource, true);
        if (content) {
          return content;
        }
      }
      if (nullOnMissing) {
        return null;
      } else {
        throw new Error('"' + aSource + '" is not in the SourceMap.');
      }
    };
    IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
      for (var i = 0; i < this._sections.length; i++) {
        var section = this._sections[i];
        if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) {
          continue;
        }
        var generatedPosition = section.consumer.generatedPositionFor(aArgs);
        if (generatedPosition) {
          var ret = {
            line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
            column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
          };
          return ret;
        }
      }
      return {
        line: null,
        column: null
      };
    };
    IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
      this.__generatedMappings = [];
      this.__originalMappings = [];
      for (var i = 0; i < this._sections.length; i++) {
        var section = this._sections[i];
        var sectionMappings = section.consumer._generatedMappings;
        for (var j = 0; j < sectionMappings.length; j++) {
          var mapping = sectionMappings[j];
          var source = section.consumer._sources.at(mapping.source);
          source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
          this._sources.add(source);
          source = this._sources.indexOf(source);
          var name = null;
          if (mapping.name) {
            name = section.consumer._names.at(mapping.name);
            this._names.add(name);
            name = this._names.indexOf(name);
          }
          var adjustedMapping = {
            source,
            generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
            generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
            originalLine: mapping.originalLine,
            originalColumn: mapping.originalColumn,
            name
          };
          this.__generatedMappings.push(adjustedMapping);
          if (typeof adjustedMapping.originalLine === "number") {
            this.__originalMappings.push(adjustedMapping);
          }
        }
      }
      quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
      quickSort(this.__originalMappings, util.compareByOriginalPositions);
    };
    exports2.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
  }
});

// node_modules/source-map-js/lib/source-node.js
var require_source_node = __commonJS({
  "node_modules/source-map-js/lib/source-node.js"(exports2) {
    var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
    var util = require_util();
    var REGEX_NEWLINE = /(\r?\n)/;
    var NEWLINE_CODE = 10;
    var isSourceNode = "$$$isSourceNode$$$";
    function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
      this.children = [];
      this.sourceContents = {};
      this.line = aLine == null ? null : aLine;
      this.column = aColumn == null ? null : aColumn;
      this.source = aSource == null ? null : aSource;
      this.name = aName == null ? null : aName;
      this[isSourceNode] = true;
      if (aChunks != null)
        this.add(aChunks);
    }
    SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
      var node = new SourceNode();
      var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
      var remainingLinesIndex = 0;
      var shiftNextLine = function() {
        var lineContents = getNextLine();
        var newLine = getNextLine() || "";
        return lineContents + newLine;
        function getNextLine() {
          return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0;
        }
      };
      var lastGeneratedLine = 1, lastGeneratedColumn = 0;
      var lastMapping = null;
      aSourceMapConsumer.eachMapping(function(mapping) {
        if (lastMapping !== null) {
          if (lastGeneratedLine < mapping.generatedLine) {
            addMappingWithCode(lastMapping, shiftNextLine());
            lastGeneratedLine++;
            lastGeneratedColumn = 0;
          } else {
            var nextLine = remainingLines[remainingLinesIndex] || "";
            var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
            remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
            lastGeneratedColumn = mapping.generatedColumn;
            addMappingWithCode(lastMapping, code);
            lastMapping = mapping;
            return;
          }
        }
        while (lastGeneratedLine < mapping.generatedLine) {
          node.add(shiftNextLine());
          lastGeneratedLine++;
        }
        if (lastGeneratedColumn < mapping.generatedColumn) {
          var nextLine = remainingLines[remainingLinesIndex] || "";
          node.add(nextLine.substr(0, mapping.generatedColumn));
          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
          lastGeneratedColumn = mapping.generatedColumn;
        }
        lastMapping = mapping;
      }, this);
      if (remainingLinesIndex < remainingLines.length) {
        if (lastMapping) {
          addMappingWithCode(lastMapping, shiftNextLine());
        }
        node.add(remainingLines.splice(remainingLinesIndex).join(""));
      }
      aSourceMapConsumer.sources.forEach(function(sourceFile) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content != null) {
          if (aRelativePath != null) {
            sourceFile = util.join(aRelativePath, sourceFile);
          }
          node.setSourceContent(sourceFile, content);
        }
      });
      return node;
      function addMappingWithCode(mapping, code) {
        if (mapping === null || mapping.source === void 0) {
          node.add(code);
        } else {
          var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
          node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name));
        }
      }
    };
    SourceNode.prototype.add = function SourceNode_add(aChunk) {
      if (Array.isArray(aChunk)) {
        aChunk.forEach(function(chunk) {
          this.add(chunk);
        }, this);
      } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
        if (aChunk) {
          this.children.push(aChunk);
        }
      } else {
        throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
      }
      return this;
    };
    SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
      if (Array.isArray(aChunk)) {
        for (var i = aChunk.length - 1; i >= 0; i--) {
          this.prepend(aChunk[i]);
        }
      } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
        this.children.unshift(aChunk);
      } else {
        throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
      }
      return this;
    };
    SourceNode.prototype.walk = function SourceNode_walk(aFn) {
      var chunk;
      for (var i = 0, len = this.children.length; i < len; i++) {
        chunk = this.children[i];
        if (chunk[isSourceNode]) {
          chunk.walk(aFn);
        } else {
          if (chunk !== "") {
            aFn(chunk, {
              source: this.source,
              line: this.line,
              column: this.column,
              name: this.name
            });
          }
        }
      }
    };
    SourceNode.prototype.join = function SourceNode_join(aSep) {
      var newChildren;
      var i;
      var len = this.children.length;
      if (len > 0) {
        newChildren = [];
        for (i = 0; i < len - 1; i++) {
          newChildren.push(this.children[i]);
          newChildren.push(aSep);
        }
        newChildren.push(this.children[i]);
        this.children = newChildren;
      }
      return this;
    };
    SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
      var lastChild = this.children[this.children.length - 1];
      if (lastChild[isSourceNode]) {
        lastChild.replaceRight(aPattern, aReplacement);
      } else if (typeof lastChild === "string") {
        this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
      } else {
        this.children.push("".replace(aPattern, aReplacement));
      }
      return this;
    };
    SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
      this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
    };
    SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
      for (var i = 0, len = this.children.length; i < len; i++) {
        if (this.children[i][isSourceNode]) {
          this.children[i].walkSourceContents(aFn);
        }
      }
      var sources = Object.keys(this.sourceContents);
      for (var i = 0, len = sources.length; i < len; i++) {
        aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
      }
    };
    SourceNode.prototype.toString = function SourceNode_toString() {
      var str = "";
      this.walk(function(chunk) {
        str += chunk;
      });
      return str;
    };
    SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
      var generated = {
        code: "",
        line: 1,
        column: 0
      };
      var map = new SourceMapGenerator(aArgs);
      var sourceMappingActive = false;
      var lastOriginalSource = null;
      var lastOriginalLine = null;
      var lastOriginalColumn = null;
      var lastOriginalName = null;
      this.walk(function(chunk, original) {
        generated.code += chunk;
        if (original.source !== null && original.line !== null && original.column !== null) {
          if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
            map.addMapping({
              source: original.source,
              original: {
                line: original.line,
                column: original.column
              },
              generated: {
                line: generated.line,
                column: generated.column
              },
              name: original.name
            });
          }
          lastOriginalSource = original.source;
          lastOriginalLine = original.line;
          lastOriginalColumn = original.column;
          lastOriginalName = original.name;
          sourceMappingActive = true;
        } else if (sourceMappingActive) {
          map.addMapping({
            generated: {
              line: generated.line,
              column: generated.column
            }
          });
          lastOriginalSource = null;
          sourceMappingActive = false;
        }
        for (var idx = 0, length = chunk.length; idx < length; idx++) {
          if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
            generated.line++;
            generated.column = 0;
            if (idx + 1 === length) {
              lastOriginalSource = null;
              sourceMappingActive = false;
            } else if (sourceMappingActive) {
              map.addMapping({
                source: original.source,
                original: {
                  line: original.line,
                  column: original.column
                },
                generated: {
                  line: generated.line,
                  column: generated.column
                },
                name: original.name
              });
            }
          } else {
            generated.column++;
          }
        }
      });
      this.walkSourceContents(function(sourceFile, sourceContent) {
        map.setSourceContent(sourceFile, sourceContent);
      });
      return { code: generated.code, map };
    };
    exports2.SourceNode = SourceNode;
  }
});

// node_modules/source-map-js/source-map.js
var require_source_map = __commonJS({
  "node_modules/source-map-js/source-map.js"(exports2) {
    exports2.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
    exports2.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
    exports2.SourceNode = require_source_node().SourceNode;
  }
});

// node_modules/nanoid/non-secure/index.cjs
var require_non_secure = __commonJS({
  "node_modules/nanoid/non-secure/index.cjs"(exports2, module2) {
    var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
    var customAlphabet = (alphabet, defaultSize = 21) => {
      return (size = defaultSize) => {
        let id = "";
        let i = size;
        while (i--) {
          id += alphabet[Math.random() * alphabet.length | 0];
        }
        return id;
      };
    };
    var nanoid = (size = 21) => {
      let id = "";
      let i = size;
      while (i--) {
        id += urlAlphabet[Math.random() * 64 | 0];
      }
      return id;
    };
    module2.exports = { nanoid, customAlphabet };
  }
});

// node_modules/postcss/lib/previous-map.js
var require_previous_map = __commonJS({
  "node_modules/postcss/lib/previous-map.js"(exports2, module2) {
    "use strict";
    var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
    var { existsSync, readFileSync } = require("fs");
    var { dirname, join } = require("path");
    function fromBase64(str) {
      if (Buffer) {
        return Buffer.from(str, "base64").toString();
      } else {
        return window.atob(str);
      }
    }
    var PreviousMap = class {
      constructor(css, opts) {
        if (opts.map === false)
          return;
        this.loadAnnotation(css);
        this.inline = this.startWith(this.annotation, "data:");
        let prev = opts.map ? opts.map.prev : void 0;
        let text = this.loadMap(opts.from, prev);
        if (!this.mapFile && opts.from) {
          this.mapFile = opts.from;
        }
        if (this.mapFile)
          this.root = dirname(this.mapFile);
        if (text)
          this.text = text;
      }
      consumer() {
        if (!this.consumerCache) {
          this.consumerCache = new SourceMapConsumer(this.text);
        }
        return this.consumerCache;
      }
      withContent() {
        return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
      }
      startWith(string, start) {
        if (!string)
          return false;
        return string.substr(0, start.length) === start;
      }
      getAnnotationURL(sourceMapString) {
        return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
      }
      loadAnnotation(css) {
        let comments = css.match(/\/\*\s*# sourceMappingURL=/gm);
        if (!comments)
          return;
        let start = css.lastIndexOf(comments.pop());
        let end = css.indexOf("*/", start);
        if (start > -1 && end > -1) {
          this.annotation = this.getAnnotationURL(css.substring(start, end));
        }
      }
      decodeInline(text) {
        let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
        let baseUri = /^data:application\/json;base64,/;
        let charsetUri = /^data:application\/json;charset=utf-?8,/;
        let uri = /^data:application\/json,/;
        if (charsetUri.test(text) || uri.test(text)) {
          return decodeURIComponent(text.substr(RegExp.lastMatch.length));
        }
        if (baseCharsetUri.test(text) || baseUri.test(text)) {
          return fromBase64(text.substr(RegExp.lastMatch.length));
        }
        let encoding = text.match(/data:application\/json;([^,]+),/)[1];
        throw new Error("Unsupported source map encoding " + encoding);
      }
      loadFile(path) {
        this.root = dirname(path);
        if (existsSync(path)) {
          this.mapFile = path;
          return readFileSync(path, "utf-8").toString().trim();
        }
      }
      loadMap(file, prev) {
        if (prev === false)
          return false;
        if (prev) {
          if (typeof prev === "string") {
            return prev;
          } else if (typeof prev === "function") {
            let prevPath = prev(file);
            if (prevPath) {
              let map = this.loadFile(prevPath);
              if (!map) {
                throw new Error("Unable to load previous source map: " + prevPath.toString());
              }
              return map;
            }
          } else if (prev instanceof SourceMapConsumer) {
            return SourceMapGenerator.fromSourceMap(prev).toString();
          } else if (prev instanceof SourceMapGenerator) {
            return prev.toString();
          } else if (this.isMap(prev)) {
            return JSON.stringify(prev);
          } else {
            throw new Error("Unsupported previous source map format: " + prev.toString());
          }
        } else if (this.inline) {
          return this.decodeInline(this.annotation);
        } else if (this.annotation) {
          let map = this.annotation;
          if (file)
            map = join(dirname(file), map);
          return this.loadFile(map);
        }
      }
      isMap(map) {
        if (typeof map !== "object")
          return false;
        return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
      }
    };
    module2.exports = PreviousMap;
    PreviousMap.default = PreviousMap;
  }
});

// node_modules/postcss/lib/input.js
var require_input = __commonJS({
  "node_modules/postcss/lib/input.js"(exports2, module2) {
    "use strict";
    var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
    var { fileURLToPath, pathToFileURL } = require("url");
    var { resolve, isAbsolute } = require("path");
    var { nanoid } = require_non_secure();
    var terminalHighlight = require_terminal_highlight();
    var CssSyntaxError = require_css_syntax_error();
    var PreviousMap = require_previous_map();
    var fromOffsetCache = Symbol("fromOffsetCache");
    var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
    var pathAvailable = Boolean(resolve && isAbsolute);
    var Input = class {
      constructor(css, opts = {}) {
        if (css === null || typeof css === "undefined" || typeof css === "object" && !css.toString) {
          throw new Error(`PostCSS received ${css} instead of CSS string`);
        }
        this.css = css.toString();
        if (this.css[0] === "\uFEFF" || this.css[0] === "\uFFFE") {
          this.hasBOM = true;
          this.css = this.css.slice(1);
        } else {
          this.hasBOM = false;
        }
        if (opts.from) {
          if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) {
            this.file = opts.from;
          } else {
            this.file = resolve(opts.from);
          }
        }
        if (pathAvailable && sourceMapAvailable) {
          let map = new PreviousMap(this.css, opts);
          if (map.text) {
            this.map = map;
            let file = map.consumer().file;
            if (!this.file && file)
              this.file = this.mapResolve(file);
          }
        }
        if (!this.file) {
          this.id = "<input css " + nanoid(6) + ">";
        }
        if (this.map)
          this.map.file = this.from;
      }
      fromOffset(offset) {
        let lastLine, lineToIndex;
        if (!this[fromOffsetCache]) {
          let lines = this.css.split("\n");
          lineToIndex = new Array(lines.length);
          let prevIndex = 0;
          for (let i = 0, l = lines.length; i < l; i++) {
            lineToIndex[i] = prevIndex;
            prevIndex += lines[i].length + 1;
          }
          this[fromOffsetCache] = lineToIndex;
        } else {
          lineToIndex = this[fromOffsetCache];
        }
        lastLine = lineToIndex[lineToIndex.length - 1];
        let min = 0;
        if (offset >= lastLine) {
          min = lineToIndex.length - 1;
        } else {
          let max = lineToIndex.length - 2;
          let mid;
          while (min < max) {
            mid = min + (max - min >> 1);
            if (offset < lineToIndex[mid]) {
              max = mid - 1;
            } else if (offset >= lineToIndex[mid + 1]) {
              min = mid + 1;
            } else {
              min = mid;
              break;
            }
          }
        }
        return {
          line: min + 1,
          col: offset - lineToIndex[min] + 1
        };
      }
      error(message, line, column, opts = {}) {
        let result, endLine, endColumn;
        if (line && typeof line === "object") {
          let start = line;
          let end = column;
          if (typeof line.offset === "number") {
            let pos = this.fromOffset(start.offset);
            line = pos.line;
            column = pos.col;
          } else {
            line = start.line;
            column = start.column;
          }
          if (typeof end.offset === "number") {
            let pos = this.fromOffset(end.offset);
            endLine = pos.line;
            endColumn = pos.col;
          } else {
            endLine = end.line;
            endColumn = end.column;
          }
        } else if (!column) {
          let pos = this.fromOffset(line);
          line = pos.line;
          column = pos.col;
        }
        let origin = this.origin(line, column, endLine, endColumn);
        if (origin) {
          result = new CssSyntaxError(message, origin.endLine === void 0 ? origin.line : { line: origin.line, column: origin.column }, origin.endLine === void 0 ? origin.column : { line: origin.endLine, column: origin.endColumn }, origin.source, origin.file, opts.plugin);
        } else {
          result = new CssSyntaxError(message, endLine === void 0 ? line : { line, column }, endLine === void 0 ? column : { line: endLine, column: endColumn }, this.css, this.file, opts.plugin);
        }
        result.input = { line, column, endLine, endColumn, source: this.css };
        if (this.file) {
          if (pathToFileURL) {
            result.input.url = pathToFileURL(this.file).toString();
          }
          result.input.file = this.file;
        }
        return result;
      }
      origin(line, column, endLine, endColumn) {
        if (!this.map)
          return false;
        let consumer = this.map.consumer();
        let from = consumer.originalPositionFor({ line, column });
        if (!from.source)
          return false;
        let to;
        if (typeof endLine === "number") {
          to = consumer.originalPositionFor({ line: endLine, column: endColumn });
        }
        let fromUrl;
        if (isAbsolute(from.source)) {
          fromUrl = pathToFileURL(from.source);
        } else {
          fromUrl = new URL(from.source, this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile));
        }
        let result = {
          url: fromUrl.toString(),
          line: from.line,
          column: from.column,
          endLine: to && to.line,
          endColumn: to && to.column
        };
        if (fromUrl.protocol === "file:") {
          if (fileURLToPath) {
            result.file = fileURLToPath(fromUrl);
          } else {
            throw new Error(`file: protocol is not available in this PostCSS build`);
          }
        }
        let source = consumer.sourceContentFor(from.source);
        if (source)
          result.source = source;
        return result;
      }
      mapResolve(file) {
        if (/^\w+:\/\//.test(file)) {
          return file;
        }
        return resolve(this.map.consumer().sourceRoot || this.map.root || ".", file);
      }
      get from() {
        return this.file || this.id;
      }
      toJSON() {
        let json = {};
        for (let name of ["hasBOM", "css", "file", "id"]) {
          if (this[name] != null) {
            json[name] = this[name];
          }
        }
        if (this.map) {
          json.map = { ...this.map };
          if (json.map.consumerCache) {
            json.map.consumerCache = void 0;
          }
        }
        return json;
      }
    };
    module2.exports = Input;
    Input.default = Input;
    if (terminalHighlight && terminalHighlight.registerInput) {
      terminalHighlight.registerInput(Input);
    }
  }
});

// node_modules/postcss/lib/map-generator.js
var require_map_generator = __commonJS({
  "node_modules/postcss/lib/map-generator.js"(exports2, module2) {
    "use strict";
    var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
    var { dirname, resolve, relative, sep } = require("path");
    var { pathToFileURL } = require("url");
    var Input = require_input();
    var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
    var pathAvailable = Boolean(dirname && resolve && relative && sep);
    var MapGenerator = class {
      constructor(stringify, root, opts, cssString) {
        this.stringify = stringify;
        this.mapOpts = opts.map || {};
        this.root = root;
        this.opts = opts;
        this.css = cssString;
      }
      isMap() {
        if (typeof this.opts.map !== "undefined") {
          return !!this.opts.map;
        }
        return this.previous().length > 0;
      }
      previous() {
        if (!this.previousMaps) {
          this.previousMaps = [];
          if (this.root) {
            this.root.walk((node) => {
              if (node.source && node.source.input.map) {
                let map = node.source.input.map;
                if (!this.previousMaps.includes(map)) {
                  this.previousMaps.push(map);
                }
              }
            });
          } else {
            let input = new Input(this.css, this.opts);
            if (input.map)
              this.previousMaps.push(input.map);
          }
        }
        return this.previousMaps;
      }
      isInline() {
        if (typeof this.mapOpts.inline !== "undefined") {
          return this.mapOpts.inline;
        }
        let annotation = this.mapOpts.annotation;
        if (typeof annotation !== "undefined" && annotation !== true) {
          return false;
        }
        if (this.previous().length) {
          return this.previous().some((i) => i.inline);
        }
        return true;
      }
      isSourcesContent() {
        if (typeof this.mapOpts.sourcesContent !== "undefined") {
          return this.mapOpts.sourcesContent;
        }
        if (this.previous().length) {
          return this.previous().some((i) => i.withContent());
        }
        return true;
      }
      clearAnnotation() {
        if (this.mapOpts.annotation === false)
          return;
        if (this.root) {
          let node;
          for (let i = this.root.nodes.length - 1; i >= 0; i--) {
            node = this.root.nodes[i];
            if (node.type !== "comment")
              continue;
            if (node.text.indexOf("# sourceMappingURL=") === 0) {
              this.root.removeChild(i);
            }
          }
        } else if (this.css) {
          this.css = this.css.replace(/(\n)?\/\*#[\S\s]*?\*\/$/gm, "");
        }
      }
      setSourcesContent() {
        let already = {};
        if (this.root) {
          this.root.walk((node) => {
            if (node.source) {
              let from = node.source.input.from;
              if (from && !already[from]) {
                already[from] = true;
                this.map.setSourceContent(this.toUrl(this.path(from)), node.source.input.css);
              }
            }
          });
        } else if (this.css) {
          let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
          this.map.setSourceContent(from, this.css);
        }
      }
      applyPrevMaps() {
        for (let prev of this.previous()) {
          let from = this.toUrl(this.path(prev.file));
          let root = prev.root || dirname(prev.file);
          let map;
          if (this.mapOpts.sourcesContent === false) {
            map = new SourceMapConsumer(prev.text);
            if (map.sourcesContent) {
              map.sourcesContent = map.sourcesContent.map(() => null);
            }
          } else {
            map = prev.consumer();
          }
          this.map.applySourceMap(map, from, this.toUrl(this.path(root)));
        }
      }
      isAnnotation() {
        if (this.isInline()) {
          return true;
        }
        if (typeof this.mapOpts.annotation !== "undefined") {
          return this.mapOpts.annotation;
        }
        if (this.previous().length) {
          return this.previous().some((i) => i.annotation);
        }
        return true;
      }
      toBase64(str) {
        if (Buffer) {
          return Buffer.from(str).toString("base64");
        } else {
          return window.btoa(unescape(encodeURIComponent(str)));
        }
      }
      addAnnotation() {
        let content;
        if (this.isInline()) {
          content = "data:application/json;base64," + this.toBase64(this.map.toString());
        } else if (typeof this.mapOpts.annotation === "string") {
          content = this.mapOpts.annotation;
        } else if (typeof this.mapOpts.annotation === "function") {
          content = this.mapOpts.annotation(this.opts.to, this.root);
        } else {
          content = this.outputFile() + ".map";
        }
        let eol = "\n";
        if (this.css.includes("\r\n"))
          eol = "\r\n";
        this.css += eol + "/*# sourceMappingURL=" + content + " */";
      }
      outputFile() {
        if (this.opts.to) {
          return this.path(this.opts.to);
        } else if (this.opts.from) {
          return this.path(this.opts.from);
        } else {
          return "to.css";
        }
      }
      generateMap() {
        if (this.root) {
          this.generateString();
        } else if (this.previous().length === 1) {
          let prev = this.previous()[0].consumer();
          prev.file = this.outputFile();
          this.map = SourceMapGenerator.fromSourceMap(prev);
        } else {
          this.map = new SourceMapGenerator({ file: this.outputFile() });
          this.map.addMapping({
            source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>",
            generated: { line: 1, column: 0 },
            original: { line: 1, column: 0 }
          });
        }
        if (this.isSourcesContent())
          this.setSourcesContent();
        if (this.root && this.previous().length > 0)
          this.applyPrevMaps();
        if (this.isAnnotation())
          this.addAnnotation();
        if (this.isInline()) {
          return [this.css];
        } else {
          return [this.css, this.map];
        }
      }
      path(file) {
        if (file.indexOf("<") === 0)
          return file;
        if (/^\w+:\/\//.test(file))
          return file;
        if (this.mapOpts.absolute)
          return file;
        let from = this.opts.to ? dirname(this.opts.to) : ".";
        if (typeof this.mapOpts.annotation === "string") {
          from = dirname(resolve(from, this.mapOpts.annotation));
        }
        file = relative(from, file);
        return file;
      }
      toUrl(path) {
        if (sep === "\\") {
          path = path.replace(/\\/g, "/");
        }
        return encodeURI(path).replace(/[#?]/g, encodeURIComponent);
      }
      sourcePath(node) {
        if (this.mapOpts.from) {
          return this.toUrl(this.mapOpts.from);
        } else if (this.mapOpts.absolute) {
          if (pathToFileURL) {
            return pathToFileURL(node.source.input.from).toString();
          } else {
            throw new Error("`map.absolute` option is not available in this PostCSS build");
          }
        } else {
          return this.toUrl(this.path(node.source.input.from));
        }
      }
      generateString() {
        this.css = "";
        this.map = new SourceMapGenerator({ file: this.outputFile() });
        let line = 1;
        let column = 1;
        let noSource = "<no source>";
        let mapping = {
          source: "",
          generated: { line: 0, column: 0 },
          original: { line: 0, column: 0 }
        };
        let lines, last;
        this.stringify(this.root, (str, node, type) => {
          this.css += str;
          if (node && type !== "end") {
            mapping.generated.line = line;
            mapping.generated.column = column - 1;
            if (node.source && node.source.start) {
              mapping.source = this.sourcePath(node);
              mapping.original.line = node.source.start.line;
              mapping.original.column = node.source.start.column - 1;
              this.map.addMapping(mapping);
            } else {
              mapping.source = noSource;
              mapping.original.line = 1;
              mapping.original.column = 0;
              this.map.addMapping(mapping);
            }
          }
          lines = str.match(/\n/g);
          if (lines) {
            line += lines.length;
            last = str.lastIndexOf("\n");
            column = str.length - last;
          } else {
            column += str.length;
          }
          if (node && type !== "start") {
            let p = node.parent || { raws: {} };
            if (node.type !== "decl" || node !== p.last || p.raws.semicolon) {
              if (node.source && node.source.end) {
                mapping.source = this.sourcePath(node);
                mapping.original.line = node.source.end.line;
                mapping.original.column = node.source.end.column - 1;
                mapping.generated.line = line;
                mapping.generated.column = column - 2;
                this.map.addMapping(mapping);
              } else {
                mapping.source = noSource;
                mapping.original.line = 1;
                mapping.original.column = 0;
                mapping.generated.line = line;
                mapping.generated.column = column - 1;
                this.map.addMapping(mapping);
              }
            }
          }
        });
      }
      generate() {
        this.clearAnnotation();
        if (pathAvailable && sourceMapAvailable && this.isMap()) {
          return this.generateMap();
        } else {
          let result = "";
          this.stringify(this.root, (i) => {
            result += i;
          });
          return [result];
        }
      }
    };
    module2.exports = MapGenerator;
  }
});

// node_modules/postcss/lib/comment.js
var require_comment = __commonJS({
  "node_modules/postcss/lib/comment.js"(exports2, module2) {
    "use strict";
    var Node = require_node();
    var Comment = class extends Node {
      constructor(defaults) {
        super(defaults);
        this.type = "comment";
      }
    };
    module2.exports = Comment;
    Comment.default = Comment;
  }
});

// node_modules/postcss/lib/container.js
var require_container = __commonJS({
  "node_modules/postcss/lib/container.js"(exports2, module2) {
    "use strict";
    var { isClean, my } = require_symbols();
    var Declaration = require_declaration();
    var Comment = require_comment();
    var Node = require_node();
    var parse;
    var Rule;
    var AtRule;
    function cleanSource(nodes) {
      return nodes.map((i) => {
        if (i.nodes)
          i.nodes = cleanSource(i.nodes);
        delete i.source;
        return i;
      });
    }
    function markDirtyUp(node) {
      node[isClean] = false;
      if (node.proxyOf.nodes) {
        for (let i of node.proxyOf.nodes) {
          markDirtyUp(i);
        }
      }
    }
    var Container = class extends Node {
      push(child) {
        child.parent = this;
        this.proxyOf.nodes.push(child);
        return this;
      }
      each(callback) {
        if (!this.proxyOf.nodes)
          return void 0;
        let iterator = this.getIterator();
        let index, result;
        while (this.indexes[iterator] < this.proxyOf.nodes.length) {
          index = this.indexes[iterator];
          result = callback(this.proxyOf.nodes[index], index);
          if (result === false)
            break;
          this.indexes[iterator] += 1;
        }
        delete this.indexes[iterator];
        return result;
      }
      walk(callback) {
        return this.each((child, i) => {
          let result;
          try {
            result = callback(child, i);
          } catch (e) {
            throw child.addToError(e);
          }
          if (result !== false && child.walk) {
            result = child.walk(callback);
          }
          return result;
        });
      }
      walkDecls(prop, callback) {
        if (!callback) {
          callback = prop;
          return this.walk((child, i) => {
            if (child.type === "decl") {
              return callback(child, i);
            }
          });
        }
        if (prop instanceof RegExp) {
          return this.walk((child, i) => {
            if (child.type === "decl" && prop.test(child.prop)) {
              return callback(child, i);
            }
          });
        }
        return this.walk((child, i) => {
          if (child.type === "decl" && child.prop === prop) {
            return callback(child, i);
          }
        });
      }
      walkRules(selector, callback) {
        if (!callback) {
          callback = selector;
          return this.walk((child, i) => {
            if (child.type === "rule") {
              return callback(child, i);
            }
          });
        }
        if (selector instanceof RegExp) {
          return this.walk((child, i) => {
            if (child.type === "rule" && selector.test(child.selector)) {
              return callback(child, i);
            }
          });
        }
        return this.walk((child, i) => {
          if (child.type === "rule" && child.selector === selector) {
            return callback(child, i);
          }
        });
      }
      walkAtRules(name, callback) {
        if (!callback) {
          callback = name;
          return this.walk((child, i) => {
            if (child.type === "atrule") {
              return callback(child, i);
            }
          });
        }
        if (name instanceof RegExp) {
          return this.walk((child, i) => {
            if (child.type === "atrule" && name.test(child.name)) {
              return callback(child, i);
            }
          });
        }
        return this.walk((child, i) => {
          if (child.type === "atrule" && child.name === name) {
            return callback(child, i);
          }
        });
      }
      walkComments(callback) {
        return this.walk((child, i) => {
          if (child.type === "comment") {
            return callback(child, i);
          }
        });
      }
      append(...children) {
        for (let child of children) {
          let nodes = this.normalize(child, this.last);
          for (let node of nodes)
            this.proxyOf.nodes.push(node);
        }
        this.markDirty();
        return this;
      }
      prepend(...children) {
        children = children.reverse();
        for (let child of children) {
          let nodes = this.normalize(child, this.first, "prepend").reverse();
          for (let node of nodes)
            this.proxyOf.nodes.unshift(node);
          for (let id in this.indexes) {
            this.indexes[id] = this.indexes[id] + nodes.length;
          }
        }
        this.markDirty();
        return this;
      }
      cleanRaws(keepBetween) {
        super.cleanRaws(keepBetween);
        if (this.nodes) {
          for (let node of this.nodes)
            node.cleanRaws(keepBetween);
        }
      }
      insertBefore(exist, add) {
        exist = this.index(exist);
        let type = exist === 0 ? "prepend" : false;
        let nodes = this.normalize(add, this.proxyOf.nodes[exist], type).reverse();
        for (let node of nodes)
          this.proxyOf.nodes.splice(exist, 0, node);
        let index;
        for (let id in this.indexes) {
          index = this.indexes[id];
          if (exist <= index) {
            this.indexes[id] = index + nodes.length;
          }
        }
        this.markDirty();
        return this;
      }
      insertAfter(exist, add) {
        exist = this.index(exist);
        let nodes = this.normalize(add, this.proxyOf.nodes[exist]).reverse();
        for (let node of nodes)
          this.proxyOf.nodes.splice(exist + 1, 0, node);
        let index;
        for (let id in this.indexes) {
          index = this.indexes[id];
          if (exist < index) {
            this.indexes[id] = index + nodes.length;
          }
        }
        this.markDirty();
        return this;
      }
      removeChild(child) {
        child = this.index(child);
        this.proxyOf.nodes[child].parent = void 0;
        this.proxyOf.nodes.splice(child, 1);
        let index;
        for (let id in this.indexes) {
          index = this.indexes[id];
          if (index >= child) {
            this.indexes[id] = index - 1;
          }
        }
        this.markDirty();
        return this;
      }
      removeAll() {
        for (let node of this.proxyOf.nodes)
          node.parent = void 0;
        this.proxyOf.nodes = [];
        this.markDirty();
        return this;
      }
      replaceValues(pattern, opts, callback) {
        if (!callback) {
          callback = opts;
          opts = {};
        }
        this.walkDecls((decl) => {
          if (opts.props && !opts.props.includes(decl.prop))
            return;
          if (opts.fast && !decl.value.includes(opts.fast))
            return;
          decl.value = decl.value.replace(pattern, callback);
        });
        this.markDirty();
        return this;
      }
      every(condition) {
        return this.nodes.every(condition);
      }
      some(condition) {
        return this.nodes.some(condition);
      }
      index(child) {
        if (typeof child === "number")
          return child;
        if (child.proxyOf)
          child = child.proxyOf;
        return this.proxyOf.nodes.indexOf(child);
      }
      get first() {
        if (!this.proxyOf.nodes)
          return void 0;
        return this.proxyOf.nodes[0];
      }
      get last() {
        if (!this.proxyOf.nodes)
          return void 0;
        return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
      }
      normalize(nodes, sample) {
        if (typeof nodes === "string") {
          nodes = cleanSource(parse(nodes).nodes);
        } else if (Array.isArray(nodes)) {
          nodes = nodes.slice(0);
          for (let i of nodes) {
            if (i.parent)
              i.parent.removeChild(i, "ignore");
          }
        } else if (nodes.type === "root" && this.type !== "document") {
          nodes = nodes.nodes.slice(0);
          for (let i of nodes) {
            if (i.parent)
              i.parent.removeChild(i, "ignore");
          }
        } else if (nodes.type) {
          nodes = [nodes];
        } else if (nodes.prop) {
          if (typeof nodes.value === "undefined") {
            throw new Error("Value field is missed in node creation");
          } else if (typeof nodes.value !== "string") {
            nodes.value = String(nodes.value);
          }
          nodes = [new Declaration(nodes)];
        } else if (nodes.selector) {
          nodes = [new Rule(nodes)];
        } else if (nodes.name) {
          nodes = [new AtRule(nodes)];
        } else if (nodes.text) {
          nodes = [new Comment(nodes)];
        } else {
          throw new Error("Unknown node type in node creation");
        }
        let processed = nodes.map((i) => {
          if (!i[my])
            Container.rebuild(i);
          i = i.proxyOf;
          if (i.parent)
            i.parent.removeChild(i);
          if (i[isClean])
            markDirtyUp(i);
          if (typeof i.raws.before === "undefined") {
            if (sample && typeof sample.raws.before !== "undefined") {
              i.raws.before = sample.raws.before.replace(/\S/g, "");
            }
          }
          i.parent = this.proxyOf;
          return i;
        });
        return processed;
      }
      getProxyProcessor() {
        return {
          set(node, prop, value) {
            if (node[prop] === value)
              return true;
            node[prop] = value;
            if (prop === "name" || prop === "params" || prop === "selector") {
              node.markDirty();
            }
            return true;
          },
          get(node, prop) {
            if (prop === "proxyOf") {
              return node;
            } else if (!node[prop]) {
              return node[prop];
            } else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) {
              return (...args) => {
                return node[prop](...args.map((i) => {
                  if (typeof i === "function") {
                    return (child, index) => i(child.toProxy(), index);
                  } else {
                    return i;
                  }
                }));
              };
            } else if (prop === "every" || prop === "some") {
              return (cb) => {
                return node[prop]((child, ...other) => cb(child.toProxy(), ...other));
              };
            } else if (prop === "root") {
              return () => node.root().toProxy();
            } else if (prop === "nodes") {
              return node.nodes.map((i) => i.toProxy());
            } else if (prop === "first" || prop === "last") {
              return node[prop].toProxy();
            } else {
              return node[prop];
            }
          }
        };
      }
      getIterator() {
        if (!this.lastEach)
          this.lastEach = 0;
        if (!this.indexes)
          this.indexes = {};
        this.lastEach += 1;
        let iterator = this.lastEach;
        this.indexes[iterator] = 0;
        return iterator;
      }
    };
    Container.registerParse = (dependant) => {
      parse = dependant;
    };
    Container.registerRule = (dependant) => {
      Rule = dependant;
    };
    Container.registerAtRule = (dependant) => {
      AtRule = dependant;
    };
    module2.exports = Container;
    Container.default = Container;
    Container.rebuild = (node) => {
      if (node.type === "atrule") {
        Object.setPrototypeOf(node, AtRule.prototype);
      } else if (node.type === "rule") {
        Object.setPrototypeOf(node, Rule.prototype);
      } else if (node.type === "decl") {
        Object.setPrototypeOf(node, Declaration.prototype);
      } else if (node.type === "comment") {
        Object.setPrototypeOf(node, Comment.prototype);
      }
      node[my] = true;
      if (node.nodes) {
        node.nodes.forEach((child) => {
          Container.rebuild(child);
        });
      }
    };
  }
});

// node_modules/postcss/lib/document.js
var require_document = __commonJS({
  "node_modules/postcss/lib/document.js"(exports2, module2) {
    "use strict";
    var Container = require_container();
    var LazyResult;
    var Processor;
    var Document = class extends Container {
      constructor(defaults) {
        super({ type: "document", ...defaults });
        if (!this.nodes) {
          this.nodes = [];
        }
      }
      toResult(opts = {}) {
        let lazy = new LazyResult(new Processor(), this, opts);
        return lazy.stringify();
      }
    };
    Document.registerLazyResult = (dependant) => {
      LazyResult = dependant;
    };
    Document.registerProcessor = (dependant) => {
      Processor = dependant;
    };
    module2.exports = Document;
    Document.default = Document;
  }
});

// node_modules/postcss/lib/warn-once.js
var require_warn_once = __commonJS({
  "node_modules/postcss/lib/warn-once.js"(exports2, module2) {
    "use strict";
    var printed = {};
    module2.exports = function warnOnce(message) {
      if (printed[message])
        return;
      printed[message] = true;
      if (typeof console !== "undefined" && console.warn) {
        console.warn(message);
      }
    };
  }
});

// node_modules/postcss/lib/warning.js
var require_warning = __commonJS({
  "node_modules/postcss/lib/warning.js"(exports2, module2) {
    "use strict";
    var Warning = class {
      constructor(text, opts = {}) {
        this.type = "warning";
        this.text = text;
        if (opts.node && opts.node.source) {
          let range = opts.node.rangeBy(opts);
          this.line = range.start.line;
          this.column = range.start.column;
          this.endLine = range.end.line;
          this.endColumn = range.end.column;
        }
        for (let opt in opts)
          this[opt] = opts[opt];
      }
      toString() {
        if (this.node) {
          return this.node.error(this.text, {
            plugin: this.plugin,
            index: this.index,
            word: this.word
          }).message;
        }
        if (this.plugin) {
          return this.plugin + ": " + this.text;
        }
        return this.text;
      }
    };
    module2.exports = Warning;
    Warning.default = Warning;
  }
});

// node_modules/postcss/lib/result.js
var require_result = __commonJS({
  "node_modules/postcss/lib/result.js"(exports2, module2) {
    "use strict";
    var Warning = require_warning();
    var Result = class {
      constructor(processor, root, opts) {
        this.processor = processor;
        this.messages = [];
        this.root = root;
        this.opts = opts;
        this.css = void 0;
        this.map = void 0;
      }
      toString() {
        return this.css;
      }
      warn(text, opts = {}) {
        if (!opts.plugin) {
          if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
            opts.plugin = this.lastPlugin.postcssPlugin;
          }
        }
        let warning = new Warning(text, opts);
        this.messages.push(warning);
        return warning;
      }
      warnings() {
        return this.messages.filter((i) => i.type === "warning");
      }
      get content() {
        return this.css;
      }
    };
    module2.exports = Result;
    Result.default = Result;
  }
});

// node_modules/postcss/lib/at-rule.js
var require_at_rule = __commonJS({
  "node_modules/postcss/lib/at-rule.js"(exports2, module2) {
    "use strict";
    var Container = require_container();
    var AtRule = class extends Container {
      constructor(defaults) {
        super(defaults);
        this.type = "atrule";
      }
      append(...children) {
        if (!this.proxyOf.nodes)
          this.nodes = [];
        return super.append(...children);
      }
      prepend(...children) {
        if (!this.proxyOf.nodes)
          this.nodes = [];
        return super.prepend(...children);
      }
    };
    module2.exports = AtRule;
    AtRule.default = AtRule;
    Container.registerAtRule(AtRule);
  }
});

// node_modules/postcss/lib/root.js
var require_root = __commonJS({
  "node_modules/postcss/lib/root.js"(exports2, module2) {
    "use strict";
    var Container = require_container();
    var LazyResult;
    var Processor;
    var Root = class extends Container {
      constructor(defaults) {
        super(defaults);
        this.type = "root";
        if (!this.nodes)
          this.nodes = [];
      }
      removeChild(child, ignore) {
        let index = this.index(child);
        if (!ignore && index === 0 && this.nodes.length > 1) {
          this.nodes[1].raws.before = this.nodes[index].raws.before;
        }
        return super.removeChild(child);
      }
      normalize(child, sample, type) {
        let nodes = super.normalize(child);
        if (sample) {
          if (type === "prepend") {
            if (this.nodes.length > 1) {
              sample.raws.before = this.nodes[1].raws.before;
            } else {
              delete sample.raws.before;
            }
          } else if (this.first !== sample) {
            for (let node of nodes) {
              node.raws.before = sample.raws.before;
            }
          }
        }
        return nodes;
      }
      toResult(opts = {}) {
        let lazy = new LazyResult(new Processor(), this, opts);
        return lazy.stringify();
      }
    };
    Root.registerLazyResult = (dependant) => {
      LazyResult = dependant;
    };
    Root.registerProcessor = (dependant) => {
      Processor = dependant;
    };
    module2.exports = Root;
    Root.default = Root;
  }
});

// node_modules/postcss/lib/list.js
var require_list = __commonJS({
  "node_modules/postcss/lib/list.js"(exports2, module2) {
    "use strict";
    var list = {
      split(string, separators, last) {
        let array = [];
        let current = "";
        let split = false;
        let func = 0;
        let quote = false;
        let escape = false;
        for (let letter of string) {
          if (escape) {
            escape = false;
          } else if (letter === "\\") {
            escape = true;
          } else if (quote) {
            if (letter === quote) {
              quote = false;
            }
          } else if (letter === '"' || letter === "'") {
            quote = letter;
          } else if (letter === "(") {
            func += 1;
          } else if (letter === ")") {
            if (func > 0)
              func -= 1;
          } else if (func === 0) {
            if (separators.includes(letter))
              split = true;
          }
          if (split) {
            if (current !== "")
              array.push(current.trim());
            current = "";
            split = false;
          } else {
            current += letter;
          }
        }
        if (last || current !== "")
          array.push(current.trim());
        return array;
      },
      space(string) {
        let spaces = [" ", "\n", "	"];
        return list.split(string, spaces);
      },
      comma(string) {
        return list.split(string, [","], true);
      }
    };
    module2.exports = list;
    list.default = list;
  }
});

// node_modules/postcss/lib/rule.js
var require_rule = __commonJS({
  "node_modules/postcss/lib/rule.js"(exports2, module2) {
    "use strict";
    var Container = require_container();
    var list = require_list();
    var Rule = class extends Container {
      constructor(defaults) {
        super(defaults);
        this.type = "rule";
        if (!this.nodes)
          this.nodes = [];
      }
      get selectors() {
        return list.comma(this.selector);
      }
      set selectors(values) {
        let match = this.selector ? this.selector.match(/,\s*/) : null;
        let sep = match ? match[0] : "," + this.raw("between", "beforeOpen");
        this.selector = values.join(sep);
      }
    };
    module2.exports = Rule;
    Rule.default = Rule;
    Container.registerRule(Rule);
  }
});

// node_modules/postcss/lib/parser.js
var require_parser = __commonJS({
  "node_modules/postcss/lib/parser.js"(exports2, module2) {
    "use strict";
    var Declaration = require_declaration();
    var tokenizer = require_tokenize();
    var Comment = require_comment();
    var AtRule = require_at_rule();
    var Root = require_root();
    var Rule = require_rule();
    var SAFE_COMMENT_NEIGHBOR = {
      empty: true,
      space: true
    };
    function findLastWithPosition(tokens) {
      for (let i = tokens.length - 1; i >= 0; i--) {
        let token = tokens[i];
        let pos = token[3] || token[2];
        if (pos)
          return pos;
      }
    }
    var Parser = class {
      constructor(input) {
        this.input = input;
        this.root = new Root();
        this.current = this.root;
        this.spaces = "";
        this.semicolon = false;
        this.customProperty = false;
        this.createTokenizer();
        this.root.source = { input, start: { offset: 0, line: 1, column: 1 } };
      }
      createTokenizer() {
        this.tokenizer = tokenizer(this.input);
      }
      parse() {
        let token;
        while (!this.tokenizer.endOfFile()) {
          token = this.tokenizer.nextToken();
          switch (token[0]) {
            case "space":
              this.spaces += token[1];
              break;
            case ";":
              this.freeSemicolon(token);
              break;
            case "}":
              this.end(token);
              break;
            case "comment":
              this.comment(token);
              break;
            case "at-word":
              this.atrule(token);
              break;
            case "{":
              this.emptyRule(token);
              break;
            default:
              this.other(token);
              break;
          }
        }
        this.endFile();
      }
      comment(token) {
        let node = new Comment();
        this.init(node, token[2]);
        node.source.end = this.getPosition(token[3] || token[2]);
        let text = token[1].slice(2, -2);
        if (/^\s*$/.test(text)) {
          node.text = "";
          node.raws.left = text;
          node.raws.right = "";
        } else {
          let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
          node.text = match[2];
          node.raws.left = match[1];
          node.raws.right = match[3];
        }
      }
      emptyRule(token) {
        let node = new Rule();
        this.init(node, token[2]);
        node.selector = "";
        node.raws.between = "";
        this.current = node;
      }
      other(start) {
        let end = false;
        let type = null;
        let colon = false;
        let bracket = null;
        let brackets = [];
        let customProperty = start[1].startsWith("--");
        let tokens = [];
        let token = start;
        while (token) {
          type = token[0];
          tokens.push(token);
          if (type === "(" || type === "[") {
            if (!bracket)
              bracket = token;
            brackets.push(type === "(" ? ")" : "]");
          } else if (customProperty && colon && type === "{") {
            if (!bracket)
              bracket = token;
            brackets.push("}");
          } else if (brackets.length === 0) {
            if (type === ";") {
              if (colon) {
                this.decl(tokens, customProperty);
                return;
              } else {
                break;
              }
            } else if (type === "{") {
              this.rule(tokens);
              return;
            } else if (type === "}") {
              this.tokenizer.back(tokens.pop());
              end = true;
              break;
            } else if (type === ":") {
              colon = true;
            }
          } else if (type === brackets[brackets.length - 1]) {
            brackets.pop();
            if (brackets.length === 0)
              bracket = null;
          }
          token = this.tokenizer.nextToken();
        }
        if (this.tokenizer.endOfFile())
          end = true;
        if (brackets.length > 0)
          this.unclosedBracket(bracket);
        if (end && colon) {
          if (!customProperty) {
            while (tokens.length) {
              token = tokens[tokens.length - 1][0];
              if (token !== "space" && token !== "comment")
                break;
              this.tokenizer.back(tokens.pop());
            }
          }
          this.decl(tokens, customProperty);
        } else {
          this.unknownWord(tokens);
        }
      }
      rule(tokens) {
        tokens.pop();
        let node = new Rule();
        this.init(node, tokens[0][2]);
        node.raws.between = this.spacesAndCommentsFromEnd(tokens);
        this.raw(node, "selector", tokens);
        this.current = node;
      }
      decl(tokens, customProperty) {
        let node = new Declaration();
        this.init(node, tokens[0][2]);
        let last = tokens[tokens.length - 1];
        if (last[0] === ";") {
          this.semicolon = true;
          tokens.pop();
        }
        node.source.end = this.getPosition(last[3] || last[2] || findLastWithPosition(tokens));
        while (tokens[0][0] !== "word") {
          if (tokens.length === 1)
            this.unknownWord(tokens);
          node.raws.before += tokens.shift()[1];
        }
        node.source.start = this.getPosition(tokens[0][2]);
        node.prop = "";
        while (tokens.length) {
          let type = tokens[0][0];
          if (type === ":" || type === "space" || type === "comment") {
            break;
          }
          node.prop += tokens.shift()[1];
        }
        node.raws.between = "";
        let token;
        while (tokens.length) {
          token = tokens.shift();
          if (token[0] === ":") {
            node.raws.between += token[1];
            break;
          } else {
            if (token[0] === "word" && /\w/.test(token[1])) {
              this.unknownWord([token]);
            }
            node.raws.between += token[1];
          }
        }
        if (node.prop[0] === "_" || node.prop[0] === "*") {
          node.raws.before += node.prop[0];
          node.prop = node.prop.slice(1);
        }
        let firstSpaces = [];
        let next;
        while (tokens.length) {
          next = tokens[0][0];
          if (next !== "space" && next !== "comment")
            break;
          firstSpaces.push(tokens.shift());
        }
        this.precheckMissedSemicolon(tokens);
        for (let i = tokens.length - 1; i >= 0; i--) {
          token = tokens[i];
          if (token[1].toLowerCase() === "!important") {
            node.important = true;
            let string = this.stringFrom(tokens, i);
            string = this.spacesFromEnd(tokens) + string;
            if (string !== " !important")
              node.raws.important = string;
            break;
          } else if (token[1].toLowerCase() === "important") {
            let cache = tokens.slice(0);
            let str = "";
            for (let j = i; j > 0; j--) {
              let type = cache[j][0];
              if (str.trim().indexOf("!") === 0 && type !== "space") {
                break;
              }
              str = cache.pop()[1] + str;
            }
            if (str.trim().indexOf("!") === 0) {
              node.important = true;
              node.raws.important = str;
              tokens = cache;
            }
          }
          if (token[0] !== "space" && token[0] !== "comment") {
            break;
          }
        }
        let hasWord = tokens.some((i) => i[0] !== "space" && i[0] !== "comment");
        if (hasWord) {
          node.raws.between += firstSpaces.map((i) => i[1]).join("");
          firstSpaces = [];
        }
        this.raw(node, "value", firstSpaces.concat(tokens), customProperty);
        if (node.value.includes(":") && !customProperty) {
          this.checkMissedSemicolon(tokens);
        }
      }
      atrule(token) {
        let node = new AtRule();
        node.name = token[1].slice(1);
        if (node.name === "") {
          this.unnamedAtrule(node, token);
        }
        this.init(node, token[2]);
        let type;
        let prev;
        let shift;
        let last = false;
        let open = false;
        let params = [];
        let brackets = [];
        while (!this.tokenizer.endOfFile()) {
          token = this.tokenizer.nextToken();
          type = token[0];
          if (type === "(" || type === "[") {
            brackets.push(type === "(" ? ")" : "]");
          } else if (type === "{" && brackets.length > 0) {
            brackets.push("}");
          } else if (type === brackets[brackets.length - 1]) {
            brackets.pop();
          }
          if (brackets.length === 0) {
            if (type === ";") {
              node.source.end = this.getPosition(token[2]);
              this.semicolon = true;
              break;
            } else if (type === "{") {
              open = true;
              break;
            } else if (type === "}") {
              if (params.length > 0) {
                shift = params.length - 1;
                prev = params[shift];
                while (prev && prev[0] === "space") {
                  prev = params[--shift];
                }
                if (prev) {
                  node.source.end = this.getPosition(prev[3] || prev[2]);
                }
              }
              this.end(token);
              break;
            } else {
              params.push(token);
            }
          } else {
            params.push(token);
          }
          if (this.tokenizer.endOfFile()) {
            last = true;
            break;
          }
        }
        node.raws.between = this.spacesAndCommentsFromEnd(params);
        if (params.length) {
          node.raws.afterName = this.spacesAndCommentsFromStart(params);
          this.raw(node, "params", params);
          if (last) {
            token = params[params.length - 1];
            node.source.end = this.getPosition(token[3] || token[2]);
            this.spaces = node.raws.between;
            node.raws.between = "";
          }
        } else {
          node.raws.afterName = "";
          node.params = "";
        }
        if (open) {
          node.nodes = [];
          this.current = node;
        }
      }
      end(token) {
        if (this.current.nodes && this.current.nodes.length) {
          this.current.raws.semicolon = this.semicolon;
        }
        this.semicolon = false;
        this.current.raws.after = (this.current.raws.after || "") + this.spaces;
        this.spaces = "";
        if (this.current.parent) {
          this.current.source.end = this.getPosition(token[2]);
          this.current = this.current.parent;
        } else {
          this.unexpectedClose(token);
        }
      }
      endFile() {
        if (this.current.parent)
          this.unclosedBlock();
        if (this.current.nodes && this.current.nodes.length) {
          this.current.raws.semicolon = this.semicolon;
        }
        this.current.raws.after = (this.current.raws.after || "") + this.spaces;
      }
      freeSemicolon(token) {
        this.spaces += token[1];
        if (this.current.nodes) {
          let prev = this.current.nodes[this.current.nodes.length - 1];
          if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
            prev.raws.ownSemicolon = this.spaces;
            this.spaces = "";
          }
        }
      }
      getPosition(offset) {
        let pos = this.input.fromOffset(offset);
        return {
          offset,
          line: pos.line,
          column: pos.col
        };
      }
      init(node, offset) {
        this.current.push(node);
        node.source = {
          start: this.getPosition(offset),
          input: this.input
        };
        node.raws.before = this.spaces;
        this.spaces = "";
        if (node.type !== "comment")
          this.semicolon = false;
      }
      raw(node, prop, tokens, customProperty) {
        let token, type;
        let length = tokens.length;
        let value = "";
        let clean = true;
        let next, prev;
        for (let i = 0; i < length; i += 1) {
          token = tokens[i];
          type = token[0];
          if (type === "space" && i === length - 1 && !customProperty) {
            clean = false;
          } else if (type === "comment") {
            prev = tokens[i - 1] ? tokens[i - 1][0] : "empty";
            next = tokens[i + 1] ? tokens[i + 1][0] : "empty";
            if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
              if (value.slice(-1) === ",") {
                clean = false;
              } else {
                value += token[1];
              }
            } else {
              clean = false;
            }
          } else {
            value += token[1];
          }
        }
        if (!clean) {
          let raw = tokens.reduce((all, i) => all + i[1], "");
          node.raws[prop] = { value, raw };
        }
        node[prop] = value;
      }
      spacesAndCommentsFromEnd(tokens) {
        let lastTokenType;
        let spaces = "";
        while (tokens.length) {
          lastTokenType = tokens[tokens.length - 1][0];
          if (lastTokenType !== "space" && lastTokenType !== "comment")
            break;
          spaces = tokens.pop()[1] + spaces;
        }
        return spaces;
      }
      spacesAndCommentsFromStart(tokens) {
        let next;
        let spaces = "";
        while (tokens.length) {
          next = tokens[0][0];
          if (next !== "space" && next !== "comment")
            break;
          spaces += tokens.shift()[1];
        }
        return spaces;
      }
      spacesFromEnd(tokens) {
        let lastTokenType;
        let spaces = "";
        while (tokens.length) {
          lastTokenType = tokens[tokens.length - 1][0];
          if (lastTokenType !== "space")
            break;
          spaces = tokens.pop()[1] + spaces;
        }
        return spaces;
      }
      stringFrom(tokens, from) {
        let result = "";
        for (let i = from; i < tokens.length; i++) {
          result += tokens[i][1];
        }
        tokens.splice(from, tokens.length - from);
        return result;
      }
      colon(tokens) {
        let brackets = 0;
        let token, type, prev;
        for (let [i, element] of tokens.entries()) {
          token = element;
          type = token[0];
          if (type === "(") {
            brackets += 1;
          }
          if (type === ")") {
            brackets -= 1;
          }
          if (brackets === 0 && type === ":") {
            if (!prev) {
              this.doubleColon(token);
            } else if (prev[0] === "word" && prev[1] === "progid") {
              continue;
            } else {
              return i;
            }
          }
          prev = token;
        }
        return false;
      }
      unclosedBracket(bracket) {
        throw this.input.error("Unclosed bracket", { offset: bracket[2] }, { offset: bracket[2] + 1 });
      }
      unknownWord(tokens) {
        throw this.input.error("Unknown word", { offset: tokens[0][2] }, { offset: tokens[0][2] + tokens[0][1].length });
      }
      unexpectedClose(token) {
        throw this.input.error("Unexpected }", { offset: token[2] }, { offset: token[2] + 1 });
      }
      unclosedBlock() {
        let pos = this.current.source.start;
        throw this.input.error("Unclosed block", pos.line, pos.column);
      }
      doubleColon(token) {
        throw this.input.error("Double colon", { offset: token[2] }, { offset: token[2] + token[1].length });
      }
      unnamedAtrule(node, token) {
        throw this.input.error("At-rule without name", { offset: token[2] }, { offset: token[2] + token[1].length });
      }
      precheckMissedSemicolon() {
      }
      checkMissedSemicolon(tokens) {
        let colon = this.colon(tokens);
        if (colon === false)
          return;
        let founded = 0;
        let token;
        for (let j = colon - 1; j >= 0; j--) {
          token = tokens[j];
          if (token[0] !== "space") {
            founded += 1;
            if (founded === 2)
              break;
          }
        }
        throw this.input.error("Missed semicolon", token[0] === "word" ? token[3] + 1 : token[2]);
      }
    };
    module2.exports = Parser;
  }
});

// node_modules/postcss/lib/parse.js
var require_parse = __commonJS({
  "node_modules/postcss/lib/parse.js"(exports2, module2) {
    "use strict";
    var Container = require_container();
    var Parser = require_parser();
    var Input = require_input();
    function parse(css, opts) {
      let input = new Input(css, opts);
      let parser = new Parser(input);
      try {
        parser.parse();
      } catch (e) {
        if (process.env.NODE_ENV !== "production") {
          if (e.name === "CssSyntaxError" && opts && opts.from) {
            if (/\.scss$/i.test(opts.from)) {
              e.message += "\nYou tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser";
            } else if (/\.sass/i.test(opts.from)) {
              e.message += "\nYou tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser";
            } else if (/\.less$/i.test(opts.from)) {
              e.message += "\nYou tried to parse Less with the standard CSS parser; try again with the postcss-less parser";
            }
          }
        }
        throw e;
      }
      return parser.root;
    }
    module2.exports = parse;
    parse.default = parse;
    Container.registerParse(parse);
  }
});

// node_modules/postcss/lib/lazy-result.js
var require_lazy_result = __commonJS({
  "node_modules/postcss/lib/lazy-result.js"(exports2, module2) {
    "use strict";
    var { isClean, my } = require_symbols();
    var MapGenerator = require_map_generator();
    var stringify = require_stringify();
    var Container = require_container();
    var Document = require_document();
    var warnOnce = require_warn_once();
    var Result = require_result();
    var parse = require_parse();
    var Root = require_root();
    var TYPE_TO_CLASS_NAME = {
      document: "Document",
      root: "Root",
      atrule: "AtRule",
      rule: "Rule",
      decl: "Declaration",
      comment: "Comment"
    };
    var PLUGIN_PROPS = {
      postcssPlugin: true,
      prepare: true,
      Once: true,
      Document: true,
      Root: true,
      Declaration: true,
      Rule: true,
      AtRule: true,
      Comment: true,
      DeclarationExit: true,
      RuleExit: true,
      AtRuleExit: true,
      CommentExit: true,
      RootExit: true,
      DocumentExit: true,
      OnceExit: true
    };
    var NOT_VISITORS = {
      postcssPlugin: true,
      prepare: true,
      Once: true
    };
    var CHILDREN = 0;
    function isPromise(obj) {
      return typeof obj === "object" && typeof obj.then === "function";
    }
    function getEvents(node) {
      let key = false;
      let type = TYPE_TO_CLASS_NAME[node.type];
      if (node.type === "decl") {
        key = node.prop.toLowerCase();
      } else if (node.type === "atrule") {
        key = node.name.toLowerCase();
      }
      if (key && node.append) {
        return [
          type,
          type + "-" + key,
          CHILDREN,
          type + "Exit",
          type + "Exit-" + key
        ];
      } else if (key) {
        return [type, type + "-" + key, type + "Exit", type + "Exit-" + key];
      } else if (node.append) {
        return [type, CHILDREN, type + "Exit"];
      } else {
        return [type, type + "Exit"];
      }
    }
    function toStack(node) {
      let events;
      if (node.type === "document") {
        events = ["Document", CHILDREN, "DocumentExit"];
      } else if (node.type === "root") {
        events = ["Root", CHILDREN, "RootExit"];
      } else {
        events = getEvents(node);
      }
      return {
        node,
        events,
        eventIndex: 0,
        visitors: [],
        visitorIndex: 0,
        iterator: 0
      };
    }
    function cleanMarks(node) {
      node[isClean] = false;
      if (node.nodes)
        node.nodes.forEach((i) => cleanMarks(i));
      return node;
    }
    var postcss = {};
    var LazyResult = class {
      constructor(processor, css, opts) {
        this.stringified = false;
        this.processed = false;
        let root;
        if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) {
          root = cleanMarks(css);
        } else if (css instanceof LazyResult || css instanceof Result) {
          root = cleanMarks(css.root);
          if (css.map) {
            if (typeof opts.map === "undefined")
              opts.map = {};
            if (!opts.map.inline)
              opts.map.inline = false;
            opts.map.prev = css.map;
          }
        } else {
          let parser = parse;
          if (opts.syntax)
            parser = opts.syntax.parse;
          if (opts.parser)
            parser = opts.parser;
          if (parser.parse)
            parser = parser.parse;
          try {
            root = parser(css, opts);
          } catch (error) {
            this.processed = true;
            this.error = error;
          }
          if (root && !root[my]) {
            Container.rebuild(root);
          }
        }
        this.result = new Result(processor, root, opts);
        this.helpers = { ...postcss, result: this.result, postcss };
        this.plugins = this.processor.plugins.map((plugin) => {
          if (typeof plugin === "object" && plugin.prepare) {
            return { ...plugin, ...plugin.prepare(this.result) };
          } else {
            return plugin;
          }
        });
      }
      get [Symbol.toStringTag]() {
        return "LazyResult";
      }
      get processor() {
        return this.result.processor;
      }
      get opts() {
        return this.result.opts;
      }
      get css() {
        return this.stringify().css;
      }
      get content() {
        return this.stringify().content;
      }
      get map() {
        return this.stringify().map;
      }
      get root() {
        return this.sync().root;
      }
      get messages() {
        return this.sync().messages;
      }
      warnings() {
        return this.sync().warnings();
      }
      toString() {
        return this.css;
      }
      then(onFulfilled, onRejected) {
        if (process.env.NODE_ENV !== "production") {
          if (!("from" in this.opts)) {
            warnOnce("Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning.");
          }
        }
        return this.async().then(onFulfilled, onRejected);
      }
      catch(onRejected) {
        return this.async().catch(onRejected);
      }
      finally(onFinally) {
        return this.async().then(onFinally, onFinally);
      }
      async() {
        if (this.error)
          return Promise.reject(this.error);
        if (this.processed)
          return Promise.resolve(this.result);
        if (!this.processing) {
          this.processing = this.runAsync();
        }
        return this.processing;
      }
      sync() {
        if (this.error)
          throw this.error;
        if (this.processed)
          return this.result;
        this.processed = true;
        if (this.processing) {
          throw this.getAsyncError();
        }
        for (let plugin of this.plugins) {
          let promise = this.runOnRoot(plugin);
          if (isPromise(promise)) {
            throw this.getAsyncError();
          }
        }
        this.prepareVisitors();
        if (this.hasListener) {
          let root = this.result.root;
          while (!root[isClean]) {
            root[isClean] = true;
            this.walkSync(root);
          }
          if (this.listeners.OnceExit) {
            if (root.type === "document") {
              for (let subRoot of root.nodes) {
                this.visitSync(this.listeners.OnceExit, subRoot);
              }
            } else {
              this.visitSync(this.listeners.OnceExit, root);
            }
          }
        }
        return this.result;
      }
      stringify() {
        if (this.error)
          throw this.error;
        if (this.stringified)
          return this.result;
        this.stringified = true;
        this.sync();
        let opts = this.result.opts;
        let str = stringify;
        if (opts.syntax)
          str = opts.syntax.stringify;
        if (opts.stringifier)
          str = opts.stringifier;
        if (str.stringify)
          str = str.stringify;
        let map = new MapGenerator(str, this.result.root, this.result.opts);
        let data = map.generate();
        this.result.css = data[0];
        this.result.map = data[1];
        return this.result;
      }
      walkSync(node) {
        node[isClean] = true;
        let events = getEvents(node);
        for (let event of events) {
          if (event === CHILDREN) {
            if (node.nodes) {
              node.each((child) => {
                if (!child[isClean])
                  this.walkSync(child);
              });
            }
          } else {
            let visitors = this.listeners[event];
            if (visitors) {
              if (this.visitSync(visitors, node.toProxy()))
                return;
            }
          }
        }
      }
      visitSync(visitors, node) {
        for (let [plugin, visitor] of visitors) {
          this.result.lastPlugin = plugin;
          let promise;
          try {
            promise = visitor(node, this.helpers);
          } catch (e) {
            throw this.handleError(e, node.proxyOf);
          }
          if (node.type !== "root" && node.type !== "document" && !node.parent) {
            return true;
          }
          if (isPromise(promise)) {
            throw this.getAsyncError();
          }
        }
      }
      runOnRoot(plugin) {
        this.result.lastPlugin = plugin;
        try {
          if (typeof plugin === "object" && plugin.Once) {
            if (this.result.root.type === "document") {
              let roots = this.result.root.nodes.map((root) => plugin.Once(root, this.helpers));
              if (isPromise(roots[0])) {
                return Promise.all(roots);
              }
              return roots;
            }
            return plugin.Once(this.result.root, this.helpers);
          } else if (typeof plugin === "function") {
            return plugin(this.result.root, this.result);
          }
        } catch (error) {
          throw this.handleError(error);
        }
      }
      getAsyncError() {
        throw new Error("Use process(css).then(cb) to work with async plugins");
      }
      handleError(error, node) {
        let plugin = this.result.lastPlugin;
        try {
          if (node)
            node.addToError(error);
          this.error = error;
          if (error.name === "CssSyntaxError" && !error.plugin) {
            error.plugin = plugin.postcssPlugin;
            error.setMessage();
          } else if (plugin.postcssVersion) {
            if (process.env.NODE_ENV !== "production") {
              let pluginName = plugin.postcssPlugin;
              let pluginVer = plugin.postcssVersion;
              let runtimeVer = this.result.processor.version;
              let a = pluginVer.split(".");
              let b = runtimeVer.split(".");
              if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
                console.error("Unknown error from PostCSS plugin. Your current PostCSS version is " + runtimeVer + ", but " + pluginName + " uses " + pluginVer + ". Perhaps this is the source of the error below.");
              }
            }
          }
        } catch (err) {
          if (console && console.error)
            console.error(err);
        }
        return error;
      }
      async runAsync() {
        this.plugin = 0;
        for (let i = 0; i < this.plugins.length; i++) {
          let plugin = this.plugins[i];
          let promise = this.runOnRoot(plugin);
          if (isPromise(promise)) {
            try {
              await promise;
            } catch (error) {
              throw this.handleError(error);
            }
          }
        }
        this.prepareVisitors();
        if (this.hasListener) {
          let root = this.result.root;
          while (!root[isClean]) {
            root[isClean] = true;
            let stack = [toStack(root)];
            while (stack.length > 0) {
              let promise = this.visitTick(stack);
              if (isPromise(promise)) {
                try {
                  await promise;
                } catch (e) {
                  let node = stack[stack.length - 1].node;
                  throw this.handleError(e, node);
                }
              }
            }
          }
          if (this.listeners.OnceExit) {
            for (let [plugin, visitor] of this.listeners.OnceExit) {
              this.result.lastPlugin = plugin;
              try {
                if (root.type === "document") {
                  let roots = root.nodes.map((subRoot) => visitor(subRoot, this.helpers));
                  await Promise.all(roots);
                } else {
                  await visitor(root, this.helpers);
                }
              } catch (e) {
                throw this.handleError(e);
              }
            }
          }
        }
        this.processed = true;
        return this.stringify();
      }
      prepareVisitors() {
        this.listeners = {};
        let add = (plugin, type, cb) => {
          if (!this.listeners[type])
            this.listeners[type] = [];
          this.listeners[type].push([plugin, cb]);
        };
        for (let plugin of this.plugins) {
          if (typeof plugin === "object") {
            for (let event in plugin) {
              if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
                throw new Error(`Unknown event ${event} in ${plugin.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`);
              }
              if (!NOT_VISITORS[event]) {
                if (typeof plugin[event] === "object") {
                  for (let filter in plugin[event]) {
                    if (filter === "*") {
                      add(plugin, event, plugin[event][filter]);
                    } else {
                      add(plugin, event + "-" + filter.toLowerCase(), plugin[event][filter]);
                    }
                  }
                } else if (typeof plugin[event] === "function") {
                  add(plugin, event, plugin[event]);
                }
              }
            }
          }
        }
        this.hasListener = Object.keys(this.listeners).length > 0;
      }
      visitTick(stack) {
        let visit = stack[stack.length - 1];
        let { node, visitors } = visit;
        if (node.type !== "root" && node.type !== "document" && !node.parent) {
          stack.pop();
          return;
        }
        if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
          let [plugin, visitor] = visitors[visit.visitorIndex];
          visit.visitorIndex += 1;
          if (visit.visitorIndex === visitors.length) {
            visit.visitors = [];
            visit.visitorIndex = 0;
          }
          this.result.lastPlugin = plugin;
          try {
            return visitor(node.toProxy(), this.helpers);
          } catch (e) {
            throw this.handleError(e, node);
          }
        }
        if (visit.iterator !== 0) {
          let iterator = visit.iterator;
          let child;
          while (child = node.nodes[node.indexes[iterator]]) {
            node.indexes[iterator] += 1;
            if (!child[isClean]) {
              child[isClean] = true;
              stack.push(toStack(child));
              return;
            }
          }
          visit.iterator = 0;
          delete node.indexes[iterator];
        }
        let events = visit.events;
        while (visit.eventIndex < events.length) {
          let event = events[visit.eventIndex];
          visit.eventIndex += 1;
          if (event === CHILDREN) {
            if (node.nodes && node.nodes.length) {
              node[isClean] = true;
              visit.iterator = node.getIterator();
            }
            return;
          } else if (this.listeners[event]) {
            visit.visitors = this.listeners[event];
            return;
          }
        }
        stack.pop();
      }
    };
    LazyResult.registerPostcss = (dependant) => {
      postcss = dependant;
    };
    module2.exports = LazyResult;
    LazyResult.default = LazyResult;
    Root.registerLazyResult(LazyResult);
    Document.registerLazyResult(LazyResult);
  }
});

// node_modules/postcss/lib/no-work-result.js
var require_no_work_result = __commonJS({
  "node_modules/postcss/lib/no-work-result.js"(exports2, module2) {
    "use strict";
    var MapGenerator = require_map_generator();
    var stringify = require_stringify();
    var warnOnce = require_warn_once();
    var parse = require_parse();
    var Result = require_result();
    var NoWorkResult = class {
      constructor(processor, css, opts) {
        css = css.toString();
        this.stringified = false;
        this._processor = processor;
        this._css = css;
        this._opts = opts;
        this._map = void 0;
        let root;
        let str = stringify;
        this.result = new Result(this._processor, root, this._opts);
        this.result.css = css;
        let self2 = this;
        Object.defineProperty(this.result, "root", {
          get() {
            return self2.root;
          }
        });
        let map = new MapGenerator(str, root, this._opts, css);
        if (map.isMap()) {
          let [generatedCSS, generatedMap] = map.generate();
          if (generatedCSS) {
            this.result.css = generatedCSS;
          }
          if (generatedMap) {
            this.result.map = generatedMap;
          }
        }
      }
      get [Symbol.toStringTag]() {
        return "NoWorkResult";
      }
      get processor() {
        return this.result.processor;
      }
      get opts() {
        return this.result.opts;
      }
      get css() {
        return this.result.css;
      }
      get content() {
        return this.result.css;
      }
      get map() {
        return this.result.map;
      }
      get root() {
        if (this._root) {
          return this._root;
        }
        let root;
        let parser = parse;
        try {
          root = parser(this._css, this._opts);
        } catch (error) {
          this.error = error;
        }
        if (this.error) {
          throw this.error;
        } else {
          this._root = root;
          return root;
        }
      }
      get messages() {
        return [];
      }
      warnings() {
        return [];
      }
      toString() {
        return this._css;
      }
      then(onFulfilled, onRejected) {
        if (process.env.NODE_ENV !== "production") {
          if (!("from" in this._opts)) {
            warnOnce("Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning.");
          }
        }
        return this.async().then(onFulfilled, onRejected);
      }
      catch(onRejected) {
        return this.async().catch(onRejected);
      }
      finally(onFinally) {
        return this.async().then(onFinally, onFinally);
      }
      async() {
        if (this.error)
          return Promise.reject(this.error);
        return Promise.resolve(this.result);
      }
      sync() {
        if (this.error)
          throw this.error;
        return this.result;
      }
    };
    module2.exports = NoWorkResult;
    NoWorkResult.default = NoWorkResult;
  }
});

// node_modules/postcss/lib/processor.js
var require_processor = __commonJS({
  "node_modules/postcss/lib/processor.js"(exports2, module2) {
    "use strict";
    var NoWorkResult = require_no_work_result();
    var LazyResult = require_lazy_result();
    var Document = require_document();
    var Root = require_root();
    var Processor = class {
      constructor(plugins = []) {
        this.version = "8.4.14";
        this.plugins = this.normalize(plugins);
      }
      use(plugin) {
        this.plugins = this.plugins.concat(this.normalize([plugin]));
        return this;
      }
      process(css, opts = {}) {
        if (this.plugins.length === 0 && typeof opts.parser === "undefined" && typeof opts.stringifier === "undefined" && typeof opts.syntax === "undefined") {
          return new NoWorkResult(this, css, opts);
        } else {
          return new LazyResult(this, css, opts);
        }
      }
      normalize(plugins) {
        let normalized = [];
        for (let i of plugins) {
          if (i.postcss === true) {
            i = i();
          } else if (i.postcss) {
            i = i.postcss;
          }
          if (typeof i === "object" && Array.isArray(i.plugins)) {
            normalized = normalized.concat(i.plugins);
          } else if (typeof i === "object" && i.postcssPlugin) {
            normalized.push(i);
          } else if (typeof i === "function") {
            normalized.push(i);
          } else if (typeof i === "object" && (i.parse || i.stringify)) {
            if (process.env.NODE_ENV !== "production") {
              throw new Error("PostCSS syntaxes cannot be used as plugins. Instead, please use one of the syntax/parser/stringifier options as outlined in your PostCSS runner documentation.");
            }
          } else {
            throw new Error(i + " is not a PostCSS plugin");
          }
        }
        return normalized;
      }
    };
    module2.exports = Processor;
    Processor.default = Processor;
    Root.registerProcessor(Processor);
    Document.registerProcessor(Processor);
  }
});

// node_modules/postcss/lib/fromJSON.js
var require_fromJSON = __commonJS({
  "node_modules/postcss/lib/fromJSON.js"(exports2, module2) {
    "use strict";
    var Declaration = require_declaration();
    var PreviousMap = require_previous_map();
    var Comment = require_comment();
    var AtRule = require_at_rule();
    var Input = require_input();
    var Root = require_root();
    var Rule = require_rule();
    function fromJSON(json, inputs) {
      if (Array.isArray(json))
        return json.map((n) => fromJSON(n));
      let { inputs: ownInputs, ...defaults } = json;
      if (ownInputs) {
        inputs = [];
        for (let input of ownInputs) {
          let inputHydrated = { ...input, __proto__: Input.prototype };
          if (inputHydrated.map) {
            inputHydrated.map = {
              ...inputHydrated.map,
              __proto__: PreviousMap.prototype
            };
          }
          inputs.push(inputHydrated);
        }
      }
      if (defaults.nodes) {
        defaults.nodes = json.nodes.map((n) => fromJSON(n, inputs));
      }
      if (defaults.source) {
        let { inputId, ...source } = defaults.source;
        defaults.source = source;
        if (inputId != null) {
          defaults.source.input = inputs[inputId];
        }
      }
      if (defaults.type === "root") {
        return new Root(defaults);
      } else if (defaults.type === "decl") {
        return new Declaration(defaults);
      } else if (defaults.type === "rule") {
        return new Rule(defaults);
      } else if (defaults.type === "comment") {
        return new Comment(defaults);
      } else if (defaults.type === "atrule") {
        return new AtRule(defaults);
      } else {
        throw new Error("Unknown node type: " + json.type);
      }
    }
    module2.exports = fromJSON;
    fromJSON.default = fromJSON;
  }
});

// node_modules/postcss/lib/postcss.js
var require_postcss = __commonJS({
  "node_modules/postcss/lib/postcss.js"(exports2, module2) {
    "use strict";
    var CssSyntaxError = require_css_syntax_error();
    var Declaration = require_declaration();
    var LazyResult = require_lazy_result();
    var Container = require_container();
    var Processor = require_processor();
    var stringify = require_stringify();
    var fromJSON = require_fromJSON();
    var Document = require_document();
    var Warning = require_warning();
    var Comment = require_comment();
    var AtRule = require_at_rule();
    var Result = require_result();
    var Input = require_input();
    var parse = require_parse();
    var list = require_list();
    var Rule = require_rule();
    var Root = require_root();
    var Node = require_node();
    function postcss(...plugins) {
      if (plugins.length === 1 && Array.isArray(plugins[0])) {
        plugins = plugins[0];
      }
      return new Processor(plugins);
    }
    postcss.plugin = function plugin(name, initializer) {
      let warningPrinted = false;
      function creator(...args) {
        if (console && console.warn && !warningPrinted) {
          warningPrinted = true;
          console.warn(name + ": postcss.plugin was deprecated. Migration guide:\nhttps://evilmartians.com/chronicles/postcss-8-plugin-migration");
          if (process.env.LANG && process.env.LANG.startsWith("cn")) {
            console.warn(name + ": \u91CC\u9762 postcss.plugin \u88AB\u5F03\u7528. \u8FC1\u79FB\u6307\u5357:\nhttps://www.w3ctech.com/topic/2226");
          }
        }
        let transformer = initializer(...args);
        transformer.postcssPlugin = name;
        transformer.postcssVersion = new Processor().version;
        return transformer;
      }
      let cache;
      Object.defineProperty(creator, "postcss", {
        get() {
          if (!cache)
            cache = creator();
          return cache;
        }
      });
      creator.process = function(css, processOpts, pluginOpts) {
        return postcss([creator(pluginOpts)]).process(css, processOpts);
      };
      return creator;
    };
    postcss.stringify = stringify;
    postcss.parse = parse;
    postcss.fromJSON = fromJSON;
    postcss.list = list;
    postcss.comment = (defaults) => new Comment(defaults);
    postcss.atRule = (defaults) => new AtRule(defaults);
    postcss.decl = (defaults) => new Declaration(defaults);
    postcss.rule = (defaults) => new Rule(defaults);
    postcss.root = (defaults) => new Root(defaults);
    postcss.document = (defaults) => new Document(defaults);
    postcss.CssSyntaxError = CssSyntaxError;
    postcss.Declaration = Declaration;
    postcss.Container = Container;
    postcss.Processor = Processor;
    postcss.Document = Document;
    postcss.Comment = Comment;
    postcss.Warning = Warning;
    postcss.AtRule = AtRule;
    postcss.Result = Result;
    postcss.Input = Input;
    postcss.Rule = Rule;
    postcss.Root = Root;
    postcss.Node = Node;
    LazyResult.registerPostcss(postcss);
    module2.exports = postcss;
    postcss.default = postcss;
  }
});

// node_modules/postcss-import/lib/join-media.js
var require_join_media = __commonJS({
  "node_modules/postcss-import/lib/join-media.js"(exports2, module2) {
    "use strict";
    module2.exports = function(parentMedia, childMedia) {
      if (!parentMedia.length && childMedia.length)
        return childMedia;
      if (parentMedia.length && !childMedia.length)
        return parentMedia;
      if (!parentMedia.length && !childMedia.length)
        return [];
      const media = [];
      parentMedia.forEach((parentItem) => {
        childMedia.forEach((childItem) => {
          if (parentItem !== childItem)
            media.push(`${parentItem} and ${childItem}`);
        });
      });
      return media;
    };
  }
});

// node_modules/postcss-import/lib/join-layer.js
var require_join_layer = __commonJS({
  "node_modules/postcss-import/lib/join-layer.js"(exports2, module2) {
    "use strict";
    module2.exports = function(parentLayer, childLayer) {
      if (!parentLayer.length && childLayer.length)
        return childLayer;
      if (parentLayer.length && !childLayer.length)
        return parentLayer;
      if (!parentLayer.length && !childLayer.length)
        return [];
      return parentLayer.concat(childLayer);
    };
  }
});

// node_modules/resolve/lib/homedir.js
var require_homedir = __commonJS({
  "node_modules/resolve/lib/homedir.js"(exports2, module2) {
    "use strict";
    var os = require("os");
    module2.exports = os.homedir || function homedir() {
      var home = process.env.HOME;
      var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
      if (process.platform === "win32") {
        return process.env.USERPROFILE || process.env.HOMEDRIVE + process.env.HOMEPATH || home || null;
      }
      if (process.platform === "darwin") {
        return home || (user ? "/Users/" + user : null);
      }
      if (process.platform === "linux") {
        return home || (process.getuid() === 0 ? "/root" : user ? "/home/" + user : null);
      }
      return home || null;
    };
  }
});

// node_modules/resolve/lib/caller.js
var require_caller = __commonJS({
  "node_modules/resolve/lib/caller.js"(exports2, module2) {
    module2.exports = function() {
      var origPrepareStackTrace = Error.prepareStackTrace;
      Error.prepareStackTrace = function(_, stack2) {
        return stack2;
      };
      var stack = new Error().stack;
      Error.prepareStackTrace = origPrepareStackTrace;
      return stack[2].getFileName();
    };
  }
});

// node_modules/path-parse/index.js
var require_path_parse = __commonJS({
  "node_modules/path-parse/index.js"(exports2, module2) {
    "use strict";
    var isWindows = process.platform === "win32";
    var splitWindowsRe = /^(((?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?[\\\/]?)(?:[^\\\/]*[\\\/])*)((\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))[\\\/]*$/;
    var win32 = {};
    function win32SplitPath(filename) {
      return splitWindowsRe.exec(filename).slice(1);
    }
    win32.parse = function(pathString) {
      if (typeof pathString !== "string") {
        throw new TypeError("Parameter 'pathString' must be a string, not " + typeof pathString);
      }
      var allParts = win32SplitPath(pathString);
      if (!allParts || allParts.length !== 5) {
        throw new TypeError("Invalid path '" + pathString + "'");
      }
      return {
        root: allParts[1],
        dir: allParts[0] === allParts[1] ? allParts[0] : allParts[0].slice(0, -1),
        base: allParts[2],
        ext: allParts[4],
        name: allParts[3]
      };
    };
    var splitPathRe = /^((\/?)(?:[^\/]*\/)*)((\.{1,2}|[^\/]+?|)(\.[^.\/]*|))[\/]*$/;
    var posix = {};
    function posixSplitPath(filename) {
      return splitPathRe.exec(filename).slice(1);
    }
    posix.parse = function(pathString) {
      if (typeof pathString !== "string") {
        throw new TypeError("Parameter 'pathString' must be a string, not " + typeof pathString);
      }
      var allParts = posixSplitPath(pathString);
      if (!allParts || allParts.length !== 5) {
        throw new TypeError("Invalid path '" + pathString + "'");
      }
      return {
        root: allParts[1],
        dir: allParts[0].slice(0, -1),
        base: allParts[2],
        ext: allParts[4],
        name: allParts[3]
      };
    };
    if (isWindows)
      module2.exports = win32.parse;
    else
      module2.exports = posix.parse;
    module2.exports.posix = posix.parse;
    module2.exports.win32 = win32.parse;
  }
});

// node_modules/resolve/lib/node-modules-paths.js
var require_node_modules_paths = __commonJS({
  "node_modules/resolve/lib/node-modules-paths.js"(exports2, module2) {
    var path = require("path");
    var parse = path.parse || require_path_parse();
    var getNodeModulesDirs = function getNodeModulesDirs2(absoluteStart, modules) {
      var prefix = "/";
      if (/^([A-Za-z]:)/.test(absoluteStart)) {
        prefix = "";
      } else if (/^\\\\/.test(absoluteStart)) {
        prefix = "\\\\";
      }
      var paths = [absoluteStart];
      var parsed = parse(absoluteStart);
      while (parsed.dir !== paths[paths.length - 1]) {
        paths.push(parsed.dir);
        parsed = parse(parsed.dir);
      }
      return paths.reduce(function(dirs, aPath) {
        return dirs.concat(modules.map(function(moduleDir) {
          return path.resolve(prefix, aPath, moduleDir);
        }));
      }, []);
    };
    module2.exports = function nodeModulesPaths(start, opts, request) {
      var modules = opts && opts.moduleDirectory ? [].concat(opts.moduleDirectory) : ["node_modules"];
      if (opts && typeof opts.paths === "function") {
        return opts.paths(request, start, function() {
          return getNodeModulesDirs(start, modules);
        }, opts);
      }
      var dirs = getNodeModulesDirs(start, modules);
      return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
    };
  }
});

// node_modules/resolve/lib/normalize-options.js
var require_normalize_options = __commonJS({
  "node_modules/resolve/lib/normalize-options.js"(exports2, module2) {
    module2.exports = function(x, opts) {
      return opts || {};
    };
  }
});

// node_modules/function-bind/implementation.js
var require_implementation = __commonJS({
  "node_modules/function-bind/implementation.js"(exports2, module2) {
    "use strict";
    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
    var slice = Array.prototype.slice;
    var toStr = Object.prototype.toString;
    var funcType = "[object Function]";
    module2.exports = function bind(that) {
      var target = this;
      if (typeof target !== "function" || toStr.call(target) !== funcType) {
        throw new TypeError(ERROR_MESSAGE + target);
      }
      var args = slice.call(arguments, 1);
      var bound;
      var binder = function() {
        if (this instanceof bound) {
          var result = target.apply(this, args.concat(slice.call(arguments)));
          if (Object(result) === result) {
            return result;
          }
          return this;
        } else {
          return target.apply(that, args.concat(slice.call(arguments)));
        }
      };
      var boundLength = Math.max(0, target.length - args.length);
      var boundArgs = [];
      for (var i = 0; i < boundLength; i++) {
        boundArgs.push("$" + i);
      }
      bound = Function("binder", "return function (" + boundArgs.join(",") + "){ return binder.apply(this,arguments); }")(binder);
      if (target.prototype) {
        var Empty = function Empty2() {
        };
        Empty.prototype = target.prototype;
        bound.prototype = new Empty();
        Empty.prototype = null;
      }
      return bound;
    };
  }
});

// node_modules/function-bind/index.js
var require_function_bind = __commonJS({
  "node_modules/function-bind/index.js"(exports2, module2) {
    "use strict";
    var implementation = require_implementation();
    module2.exports = Function.prototype.bind || implementation;
  }
});

// node_modules/has/src/index.js
var require_src = __commonJS({
  "node_modules/has/src/index.js"(exports2, module2) {
    "use strict";
    var bind = require_function_bind();
    module2.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
  }
});

// node_modules/is-core-module/core.json
var require_core = __commonJS({
  "node_modules/is-core-module/core.json"(exports2, module2) {
    module2.exports = {
      assert: true,
      "node:assert": [">= 14.18 && < 15", ">= 16"],
      "assert/strict": ">= 15",
      "node:assert/strict": ">= 16",
      async_hooks: ">= 8",
      "node:async_hooks": [">= 14.18 && < 15", ">= 16"],
      buffer_ieee754: ">= 0.5 && < 0.9.7",
      buffer: true,
      "node:buffer": [">= 14.18 && < 15", ">= 16"],
      child_process: true,
      "node:child_process": [">= 14.18 && < 15", ">= 16"],
      cluster: ">= 0.5",
      "node:cluster": [">= 14.18 && < 15", ">= 16"],
      console: true,
      "node:console": [">= 14.18 && < 15", ">= 16"],
      constants: true,
      "node:constants": [">= 14.18 && < 15", ">= 16"],
      crypto: true,
      "node:crypto": [">= 14.18 && < 15", ">= 16"],
      _debug_agent: ">= 1 && < 8",
      _debugger: "< 8",
      dgram: true,
      "node:dgram": [">= 14.18 && < 15", ">= 16"],
      diagnostics_channel: [">= 14.17 && < 15", ">= 15.1"],
      "node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
      dns: true,
      "node:dns": [">= 14.18 && < 15", ">= 16"],
      "dns/promises": ">= 15",
      "node:dns/promises": ">= 16",
      domain: ">= 0.7.12",
      "node:domain": [">= 14.18 && < 15", ">= 16"],
      events: true,
      "node:events": [">= 14.18 && < 15", ">= 16"],
      freelist: "< 6",
      fs: true,
      "node:fs": [">= 14.18 && < 15", ">= 16"],
      "fs/promises": [">= 10 && < 10.1", ">= 14"],
      "node:fs/promises": [">= 14.18 && < 15", ">= 16"],
      _http_agent: ">= 0.11.1",
      "node:_http_agent": [">= 14.18 && < 15", ">= 16"],
      _http_client: ">= 0.11.1",
      "node:_http_client": [">= 14.18 && < 15", ">= 16"],
      _http_common: ">= 0.11.1",
      "node:_http_common": [">= 14.18 && < 15", ">= 16"],
      _http_incoming: ">= 0.11.1",
      "node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
      _http_outgoing: ">= 0.11.1",
      "node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
      _http_server: ">= 0.11.1",
      "node:_http_server": [">= 14.18 && < 15", ">= 16"],
      http: true,
      "node:http": [">= 14.18 && < 15", ">= 16"],
      http2: ">= 8.8",
      "node:http2": [">= 14.18 && < 15", ">= 16"],
      https: true,
      "node:https": [">= 14.18 && < 15", ">= 16"],
      inspector: ">= 8",
      "node:inspector": [">= 14.18 && < 15", ">= 16"],
      _linklist: "< 8",
      module: true,
      "node:module": [">= 14.18 && < 15", ">= 16"],
      net: true,
      "node:net": [">= 14.18 && < 15", ">= 16"],
      "node-inspect/lib/_inspect": ">= 7.6 && < 12",
      "node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
      "node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
      os: true,
      "node:os": [">= 14.18 && < 15", ">= 16"],
      path: true,
      "node:path": [">= 14.18 && < 15", ">= 16"],
      "path/posix": ">= 15.3",
      "node:path/posix": ">= 16",
      "path/win32": ">= 15.3",
      "node:path/win32": ">= 16",
      perf_hooks: ">= 8.5",
      "node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
      process: ">= 1",
      "node:process": [">= 14.18 && < 15", ">= 16"],
      punycode: ">= 0.5",
      "node:punycode": [">= 14.18 && < 15", ">= 16"],
      querystring: true,
      "node:querystring": [">= 14.18 && < 15", ">= 16"],
      readline: true,
      "node:readline": [">= 14.18 && < 15", ">= 16"],
      "readline/promises": ">= 17",
      "node:readline/promises": ">= 17",
      repl: true,
      "node:repl": [">= 14.18 && < 15", ">= 16"],
      smalloc: ">= 0.11.5 && < 3",
      _stream_duplex: ">= 0.9.4",
      "node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
      _stream_transform: ">= 0.9.4",
      "node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
      _stream_wrap: ">= 1.4.1",
      "node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
      _stream_passthrough: ">= 0.9.4",
      "node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
      _stream_readable: ">= 0.9.4",
      "node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
      _stream_writable: ">= 0.9.4",
      "node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
      stream: true,
      "node:stream": [">= 14.18 && < 15", ">= 16"],
      "stream/consumers": ">= 16.7",
      "node:stream/consumers": ">= 16.7",
      "stream/promises": ">= 15",
      "node:stream/promises": ">= 16",
      "stream/web": ">= 16.5",
      "node:stream/web": ">= 16.5",
      string_decoder: true,
      "node:string_decoder": [">= 14.18 && < 15", ">= 16"],
      sys: [">= 0.4 && < 0.7", ">= 0.8"],
      "node:sys": [">= 14.18 && < 15", ">= 16"],
      timers: true,
      "node:timers": [">= 14.18 && < 15", ">= 16"],
      "timers/promises": ">= 15",
      "node:timers/promises": ">= 16",
      _tls_common: ">= 0.11.13",
      "node:_tls_common": [">= 14.18 && < 15", ">= 16"],
      _tls_legacy: ">= 0.11.3 && < 10",
      _tls_wrap: ">= 0.11.3",
      "node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
      tls: true,
      "node:tls": [">= 14.18 && < 15", ">= 16"],
      trace_events: ">= 10",
      "node:trace_events": [">= 14.18 && < 15", ">= 16"],
      tty: true,
      "node:tty": [">= 14.18 && < 15", ">= 16"],
      url: true,
      "node:url": [">= 14.18 && < 15", ">= 16"],
      util: true,
      "node:util": [">= 14.18 && < 15", ">= 16"],
      "util/types": ">= 15.3",
      "node:util/types": ">= 16",
      "v8/tools/arguments": ">= 10 && < 12",
      "v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      v8: ">= 1",
      "node:v8": [">= 14.18 && < 15", ">= 16"],
      vm: true,
      "node:vm": [">= 14.18 && < 15", ">= 16"],
      wasi: ">= 13.4 && < 13.5",
      worker_threads: ">= 11.7",
      "node:worker_threads": [">= 14.18 && < 15", ">= 16"],
      zlib: ">= 0.5",
      "node:zlib": [">= 14.18 && < 15", ">= 16"]
    };
  }
});

// node_modules/is-core-module/index.js
var require_is_core_module = __commonJS({
  "node_modules/is-core-module/index.js"(exports2, module2) {
    "use strict";
    var has = require_src();
    function specifierIncluded(current, specifier) {
      var nodeParts = current.split(".");
      var parts = specifier.split(" ");
      var op = parts.length > 1 ? parts[0] : "=";
      var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split(".");
      for (var i = 0; i < 3; ++i) {
        var cur = parseInt(nodeParts[i] || 0, 10);
        var ver = parseInt(versionParts[i] || 0, 10);
        if (cur === ver) {
          continue;
        }
        if (op === "<") {
          return cur < ver;
        }
        if (op === ">=") {
          return cur >= ver;
        }
        return false;
      }
      return op === ">=";
    }
    function matchesRange(current, range) {
      var specifiers = range.split(/ ?&& ?/);
      if (specifiers.length === 0) {
        return false;
      }
      for (var i = 0; i < specifiers.length; ++i) {
        if (!specifierIncluded(current, specifiers[i])) {
          return false;
        }
      }
      return true;
    }
    function versionIncluded(nodeVersion, specifierValue) {
      if (typeof specifierValue === "boolean") {
        return specifierValue;
      }
      var current = typeof nodeVersion === "undefined" ? process.versions && process.versions.node : nodeVersion;
      if (typeof current !== "string") {
        throw new TypeError(typeof nodeVersion === "undefined" ? "Unable to determine current node version" : "If provided, a valid node version is required");
      }
      if (specifierValue && typeof specifierValue === "object") {
        for (var i = 0; i < specifierValue.length; ++i) {
          if (matchesRange(current, specifierValue[i])) {
            return true;
          }
        }
        return false;
      }
      return matchesRange(current, specifierValue);
    }
    var data = require_core();
    module2.exports = function isCore(x, nodeVersion) {
      return has(data, x) && versionIncluded(nodeVersion, data[x]);
    };
  }
});

// node_modules/resolve/lib/async.js
var require_async = __commonJS({
  "node_modules/resolve/lib/async.js"(exports2, module2) {
    var fs = require("fs");
    var getHomedir = require_homedir();
    var path = require("path");
    var caller = require_caller();
    var nodeModulesPaths = require_node_modules_paths();
    var normalizeOptions = require_normalize_options();
    var isCore = require_is_core_module();
    var realpathFS = fs.realpath && typeof fs.realpath.native === "function" ? fs.realpath.native : fs.realpath;
    var homedir = getHomedir();
    var defaultPaths = function() {
      return [
        path.join(homedir, ".node_modules"),
        path.join(homedir, ".node_libraries")
      ];
    };
    var defaultIsFile = function isFile(file, cb) {
      fs.stat(file, function(err, stat) {
        if (!err) {
          return cb(null, stat.isFile() || stat.isFIFO());
        }
        if (err.code === "ENOENT" || err.code === "ENOTDIR")
          return cb(null, false);
        return cb(err);
      });
    };
    var defaultIsDir = function isDirectory(dir, cb) {
      fs.stat(dir, function(err, stat) {
        if (!err) {
          return cb(null, stat.isDirectory());
        }
        if (err.code === "ENOENT" || err.code === "ENOTDIR")
          return cb(null, false);
        return cb(err);
      });
    };
    var defaultRealpath = function realpath(x, cb) {
      realpathFS(x, function(realpathErr, realPath) {
        if (realpathErr && realpathErr.code !== "ENOENT")
          cb(realpathErr);
        else
          cb(null, realpathErr ? x : realPath);
      });
    };
    var maybeRealpath = function maybeRealpath2(realpath, x, opts, cb) {
      if (opts && opts.preserveSymlinks === false) {
        realpath(x, cb);
      } else {
        cb(null, x);
      }
    };
    var defaultReadPackage = function defaultReadPackage2(readFile, pkgfile, cb) {
      readFile(pkgfile, function(readFileErr, body) {
        if (readFileErr)
          cb(readFileErr);
        else {
          try {
            var pkg = JSON.parse(body);
            cb(null, pkg);
          } catch (jsonErr) {
            cb(null);
          }
        }
      });
    };
    var getPackageCandidates = function getPackageCandidates2(x, start, opts) {
      var dirs = nodeModulesPaths(start, opts, x);
      for (var i = 0; i < dirs.length; i++) {
        dirs[i] = path.join(dirs[i], x);
      }
      return dirs;
    };
    module2.exports = function resolve(x, options, callback) {
      var cb = callback;
      var opts = options;
      if (typeof options === "function") {
        cb = opts;
        opts = {};
      }
      if (typeof x !== "string") {
        var err = new TypeError("Path must be a string.");
        return process.nextTick(function() {
          cb(err);
        });
      }
      opts = normalizeOptions(x, opts);
      var isFile = opts.isFile || defaultIsFile;
      var isDirectory = opts.isDirectory || defaultIsDir;
      var readFile = opts.readFile || fs.readFile;
      var realpath = opts.realpath || defaultRealpath;
      var readPackage = opts.readPackage || defaultReadPackage;
      if (opts.readFile && opts.readPackage) {
        var conflictErr = new TypeError("`readFile` and `readPackage` are mutually exclusive.");
        return process.nextTick(function() {
          cb(conflictErr);
        });
      }
      var packageIterator = opts.packageIterator;
      var extensions = opts.extensions || [".js"];
      var includeCoreModules = opts.includeCoreModules !== false;
      var basedir = opts.basedir || path.dirname(caller());
      var parent = opts.filename || basedir;
      opts.paths = opts.paths || defaultPaths();
      var absoluteStart = path.resolve(basedir);
      maybeRealpath(realpath, absoluteStart, opts, function(err2, realStart) {
        if (err2)
          cb(err2);
        else
          init(realStart);
      });
      var res;
      function init(basedir2) {
        if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x)) {
          res = path.resolve(basedir2, x);
          if (x === "." || x === ".." || x.slice(-1) === "/")
            res += "/";
          if (/\/$/.test(x) && res === basedir2) {
            loadAsDirectory(res, opts.package, onfile);
          } else
            loadAsFile(res, opts.package, onfile);
        } else if (includeCoreModules && isCore(x)) {
          return cb(null, x);
        } else
          loadNodeModules(x, basedir2, function(err2, n, pkg) {
            if (err2)
              cb(err2);
            else if (n) {
              return maybeRealpath(realpath, n, opts, function(err3, realN) {
                if (err3) {
                  cb(err3);
                } else {
                  cb(null, realN, pkg);
                }
              });
            } else {
              var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
              moduleError.code = "MODULE_NOT_FOUND";
              cb(moduleError);
            }
          });
      }
      function onfile(err2, m, pkg) {
        if (err2)
          cb(err2);
        else if (m)
          cb(null, m, pkg);
        else
          loadAsDirectory(res, function(err3, d, pkg2) {
            if (err3)
              cb(err3);
            else if (d) {
              maybeRealpath(realpath, d, opts, function(err4, realD) {
                if (err4) {
                  cb(err4);
                } else {
                  cb(null, realD, pkg2);
                }
              });
            } else {
              var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
              moduleError.code = "MODULE_NOT_FOUND";
              cb(moduleError);
            }
          });
      }
      function loadAsFile(x2, thePackage, callback2) {
        var loadAsFilePackage = thePackage;
        var cb2 = callback2;
        if (typeof loadAsFilePackage === "function") {
          cb2 = loadAsFilePackage;
          loadAsFilePackage = void 0;
        }
        var exts = [""].concat(extensions);
        load(exts, x2, loadAsFilePackage);
        function load(exts2, x3, loadPackage) {
          if (exts2.length === 0)
            return cb2(null, void 0, loadPackage);
          var file = x3 + exts2[0];
          var pkg = loadPackage;
          if (pkg)
            onpkg(null, pkg);
          else
            loadpkg(path.dirname(file), onpkg);
          function onpkg(err2, pkg_, dir) {
            pkg = pkg_;
            if (err2)
              return cb2(err2);
            if (dir && pkg && opts.pathFilter) {
              var rfile = path.relative(dir, file);
              var rel = rfile.slice(0, rfile.length - exts2[0].length);
              var r = opts.pathFilter(pkg, x3, rel);
              if (r)
                return load([""].concat(extensions.slice()), path.resolve(dir, r), pkg);
            }
            isFile(file, onex);
          }
          function onex(err2, ex) {
            if (err2)
              return cb2(err2);
            if (ex)
              return cb2(null, file, pkg);
            load(exts2.slice(1), x3, pkg);
          }
        }
      }
      function loadpkg(dir, cb2) {
        if (dir === "" || dir === "/")
          return cb2(null);
        if (process.platform === "win32" && /^\w:[/\\]*$/.test(dir)) {
          return cb2(null);
        }
        if (/[/\\]node_modules[/\\]*$/.test(dir))
          return cb2(null);
        maybeRealpath(realpath, dir, opts, function(unwrapErr, pkgdir) {
          if (unwrapErr)
            return loadpkg(path.dirname(dir), cb2);
          var pkgfile = path.join(pkgdir, "package.json");
          isFile(pkgfile, function(err2, ex) {
            if (!ex)
              return loadpkg(path.dirname(dir), cb2);
            readPackage(readFile, pkgfile, function(err3, pkgParam) {
              if (err3)
                cb2(err3);
              var pkg = pkgParam;
              if (pkg && opts.packageFilter) {
                pkg = opts.packageFilter(pkg, pkgfile);
              }
              cb2(null, pkg, dir);
            });
          });
        });
      }
      function loadAsDirectory(x2, loadAsDirectoryPackage, callback2) {
        var cb2 = callback2;
        var fpkg = loadAsDirectoryPackage;
        if (typeof fpkg === "function") {
          cb2 = fpkg;
          fpkg = opts.package;
        }
        maybeRealpath(realpath, x2, opts, function(unwrapErr, pkgdir) {
          if (unwrapErr)
            return cb2(unwrapErr);
          var pkgfile = path.join(pkgdir, "package.json");
          isFile(pkgfile, function(err2, ex) {
            if (err2)
              return cb2(err2);
            if (!ex)
              return loadAsFile(path.join(x2, "index"), fpkg, cb2);
            readPackage(readFile, pkgfile, function(err3, pkgParam) {
              if (err3)
                return cb2(err3);
              var pkg = pkgParam;
              if (pkg && opts.packageFilter) {
                pkg = opts.packageFilter(pkg, pkgfile);
              }
              if (pkg && pkg.main) {
                if (typeof pkg.main !== "string") {
                  var mainError = new TypeError("package \u201C" + pkg.name + "\u201D `main` must be a string");
                  mainError.code = "INVALID_PACKAGE_MAIN";
                  return cb2(mainError);
                }
                if (pkg.main === "." || pkg.main === "./") {
                  pkg.main = "index";
                }
                loadAsFile(path.resolve(x2, pkg.main), pkg, function(err4, m, pkg2) {
                  if (err4)
                    return cb2(err4);
                  if (m)
                    return cb2(null, m, pkg2);
                  if (!pkg2)
                    return loadAsFile(path.join(x2, "index"), pkg2, cb2);
                  var dir = path.resolve(x2, pkg2.main);
                  loadAsDirectory(dir, pkg2, function(err5, n, pkg3) {
                    if (err5)
                      return cb2(err5);
                    if (n)
                      return cb2(null, n, pkg3);
                    loadAsFile(path.join(x2, "index"), pkg3, cb2);
                  });
                });
                return;
              }
              loadAsFile(path.join(x2, "/index"), pkg, cb2);
            });
          });
        });
      }
      function processDirs(cb2, dirs) {
        if (dirs.length === 0)
          return cb2(null, void 0);
        var dir = dirs[0];
        isDirectory(path.dirname(dir), isdir);
        function isdir(err2, isdir2) {
          if (err2)
            return cb2(err2);
          if (!isdir2)
            return processDirs(cb2, dirs.slice(1));
          loadAsFile(dir, opts.package, onfile2);
        }
        function onfile2(err2, m, pkg) {
          if (err2)
            return cb2(err2);
          if (m)
            return cb2(null, m, pkg);
          loadAsDirectory(dir, opts.package, ondir);
        }
        function ondir(err2, n, pkg) {
          if (err2)
            return cb2(err2);
          if (n)
            return cb2(null, n, pkg);
          processDirs(cb2, dirs.slice(1));
        }
      }
      function loadNodeModules(x2, start, cb2) {
        var thunk = function() {
          return getPackageCandidates(x2, start, opts);
        };
        processDirs(cb2, packageIterator ? packageIterator(x2, start, thunk, opts) : thunk());
      }
    };
  }
});

// node_modules/resolve/lib/core.json
var require_core2 = __commonJS({
  "node_modules/resolve/lib/core.json"(exports2, module2) {
    module2.exports = {
      assert: true,
      "node:assert": [">= 14.18 && < 15", ">= 16"],
      "assert/strict": ">= 15",
      "node:assert/strict": ">= 16",
      async_hooks: ">= 8",
      "node:async_hooks": [">= 14.18 && < 15", ">= 16"],
      buffer_ieee754: ">= 0.5 && < 0.9.7",
      buffer: true,
      "node:buffer": [">= 14.18 && < 15", ">= 16"],
      child_process: true,
      "node:child_process": [">= 14.18 && < 15", ">= 16"],
      cluster: ">= 0.5",
      "node:cluster": [">= 14.18 && < 15", ">= 16"],
      console: true,
      "node:console": [">= 14.18 && < 15", ">= 16"],
      constants: true,
      "node:constants": [">= 14.18 && < 15", ">= 16"],
      crypto: true,
      "node:crypto": [">= 14.18 && < 15", ">= 16"],
      _debug_agent: ">= 1 && < 8",
      _debugger: "< 8",
      dgram: true,
      "node:dgram": [">= 14.18 && < 15", ">= 16"],
      diagnostics_channel: [">= 14.17 && < 15", ">= 15.1"],
      "node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
      dns: true,
      "node:dns": [">= 14.18 && < 15", ">= 16"],
      "dns/promises": ">= 15",
      "node:dns/promises": ">= 16",
      domain: ">= 0.7.12",
      "node:domain": [">= 14.18 && < 15", ">= 16"],
      events: true,
      "node:events": [">= 14.18 && < 15", ">= 16"],
      freelist: "< 6",
      fs: true,
      "node:fs": [">= 14.18 && < 15", ">= 16"],
      "fs/promises": [">= 10 && < 10.1", ">= 14"],
      "node:fs/promises": [">= 14.18 && < 15", ">= 16"],
      _http_agent: ">= 0.11.1",
      "node:_http_agent": [">= 14.18 && < 15", ">= 16"],
      _http_client: ">= 0.11.1",
      "node:_http_client": [">= 14.18 && < 15", ">= 16"],
      _http_common: ">= 0.11.1",
      "node:_http_common": [">= 14.18 && < 15", ">= 16"],
      _http_incoming: ">= 0.11.1",
      "node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
      _http_outgoing: ">= 0.11.1",
      "node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
      _http_server: ">= 0.11.1",
      "node:_http_server": [">= 14.18 && < 15", ">= 16"],
      http: true,
      "node:http": [">= 14.18 && < 15", ">= 16"],
      http2: ">= 8.8",
      "node:http2": [">= 14.18 && < 15", ">= 16"],
      https: true,
      "node:https": [">= 14.18 && < 15", ">= 16"],
      inspector: ">= 8",
      "node:inspector": [">= 14.18 && < 15", ">= 16"],
      _linklist: "< 8",
      module: true,
      "node:module": [">= 14.18 && < 15", ">= 16"],
      net: true,
      "node:net": [">= 14.18 && < 15", ">= 16"],
      "node-inspect/lib/_inspect": ">= 7.6 && < 12",
      "node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
      "node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
      os: true,
      "node:os": [">= 14.18 && < 15", ">= 16"],
      path: true,
      "node:path": [">= 14.18 && < 15", ">= 16"],
      "path/posix": ">= 15.3",
      "node:path/posix": ">= 16",
      "path/win32": ">= 15.3",
      "node:path/win32": ">= 16",
      perf_hooks: ">= 8.5",
      "node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
      process: ">= 1",
      "node:process": [">= 14.18 && < 15", ">= 16"],
      punycode: ">= 0.5",
      "node:punycode": [">= 14.18 && < 15", ">= 16"],
      querystring: true,
      "node:querystring": [">= 14.18 && < 15", ">= 16"],
      readline: true,
      "node:readline": [">= 14.18 && < 15", ">= 16"],
      "readline/promises": ">= 17",
      "node:readline/promises": ">= 17",
      repl: true,
      "node:repl": [">= 14.18 && < 15", ">= 16"],
      smalloc: ">= 0.11.5 && < 3",
      _stream_duplex: ">= 0.9.4",
      "node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
      _stream_transform: ">= 0.9.4",
      "node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
      _stream_wrap: ">= 1.4.1",
      "node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
      _stream_passthrough: ">= 0.9.4",
      "node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
      _stream_readable: ">= 0.9.4",
      "node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
      _stream_writable: ">= 0.9.4",
      "node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
      stream: true,
      "node:stream": [">= 14.18 && < 15", ">= 16"],
      "stream/consumers": ">= 16.7",
      "node:stream/consumers": ">= 16.7",
      "stream/promises": ">= 15",
      "node:stream/promises": ">= 16",
      "stream/web": ">= 16.5",
      "node:stream/web": ">= 16.5",
      string_decoder: true,
      "node:string_decoder": [">= 14.18 && < 15", ">= 16"],
      sys: [">= 0.4 && < 0.7", ">= 0.8"],
      "node:sys": [">= 14.18 && < 15", ">= 16"],
      timers: true,
      "node:timers": [">= 14.18 && < 15", ">= 16"],
      "timers/promises": ">= 15",
      "node:timers/promises": ">= 16",
      _tls_common: ">= 0.11.13",
      "node:_tls_common": [">= 14.18 && < 15", ">= 16"],
      _tls_legacy: ">= 0.11.3 && < 10",
      _tls_wrap: ">= 0.11.3",
      "node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
      tls: true,
      "node:tls": [">= 14.18 && < 15", ">= 16"],
      trace_events: ">= 10",
      "node:trace_events": [">= 14.18 && < 15", ">= 16"],
      tty: true,
      "node:tty": [">= 14.18 && < 15", ">= 16"],
      url: true,
      "node:url": [">= 14.18 && < 15", ">= 16"],
      util: true,
      "node:util": [">= 14.18 && < 15", ">= 16"],
      "util/types": ">= 15.3",
      "node:util/types": ">= 16",
      "v8/tools/arguments": ">= 10 && < 12",
      "v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      v8: ">= 1",
      "node:v8": [">= 14.18 && < 15", ">= 16"],
      vm: true,
      "node:vm": [">= 14.18 && < 15", ">= 16"],
      wasi: ">= 13.4 && < 13.5",
      worker_threads: ">= 11.7",
      "node:worker_threads": [">= 14.18 && < 15", ">= 16"],
      zlib: ">= 0.5",
      "node:zlib": [">= 14.18 && < 15", ">= 16"]
    };
  }
});

// node_modules/resolve/lib/core.js
var require_core3 = __commonJS({
  "node_modules/resolve/lib/core.js"(exports2, module2) {
    var current = process.versions && process.versions.node && process.versions.node.split(".") || [];
    function specifierIncluded(specifier) {
      var parts = specifier.split(" ");
      var op = parts.length > 1 ? parts[0] : "=";
      var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split(".");
      for (var i = 0; i < 3; ++i) {
        var cur = parseInt(current[i] || 0, 10);
        var ver = parseInt(versionParts[i] || 0, 10);
        if (cur === ver) {
          continue;
        }
        if (op === "<") {
          return cur < ver;
        } else if (op === ">=") {
          return cur >= ver;
        }
        return false;
      }
      return op === ">=";
    }
    function matchesRange(range) {
      var specifiers = range.split(/ ?&& ?/);
      if (specifiers.length === 0) {
        return false;
      }
      for (var i = 0; i < specifiers.length; ++i) {
        if (!specifierIncluded(specifiers[i])) {
          return false;
        }
      }
      return true;
    }
    function versionIncluded(specifierValue) {
      if (typeof specifierValue === "boolean") {
        return specifierValue;
      }
      if (specifierValue && typeof specifierValue === "object") {
        for (var i = 0; i < specifierValue.length; ++i) {
          if (matchesRange(specifierValue[i])) {
            return true;
          }
        }
        return false;
      }
      return matchesRange(specifierValue);
    }
    var data = require_core2();
    var core = {};
    for (mod in data) {
      if (Object.prototype.hasOwnProperty.call(data, mod)) {
        core[mod] = versionIncluded(data[mod]);
      }
    }
    var mod;
    module2.exports = core;
  }
});

// node_modules/resolve/lib/is-core.js
var require_is_core = __commonJS({
  "node_modules/resolve/lib/is-core.js"(exports2, module2) {
    var isCoreModule = require_is_core_module();
    module2.exports = function isCore(x) {
      return isCoreModule(x);
    };
  }
});

// node_modules/resolve/lib/sync.js
var require_sync = __commonJS({
  "node_modules/resolve/lib/sync.js"(exports2, module2) {
    var isCore = require_is_core_module();
    var fs = require("fs");
    var path = require("path");
    var getHomedir = require_homedir();
    var caller = require_caller();
    var nodeModulesPaths = require_node_modules_paths();
    var normalizeOptions = require_normalize_options();
    var realpathFS = fs.realpathSync && typeof fs.realpathSync.native === "function" ? fs.realpathSync.native : fs.realpathSync;
    var homedir = getHomedir();
    var defaultPaths = function() {
      return [
        path.join(homedir, ".node_modules"),
        path.join(homedir, ".node_libraries")
      ];
    };
    var defaultIsFile = function isFile(file) {
      try {
        var stat = fs.statSync(file, { throwIfNoEntry: false });
      } catch (e) {
        if (e && (e.code === "ENOENT" || e.code === "ENOTDIR"))
          return false;
        throw e;
      }
      return !!stat && (stat.isFile() || stat.isFIFO());
    };
    var defaultIsDir = function isDirectory(dir) {
      try {
        var stat = fs.statSync(dir, { throwIfNoEntry: false });
      } catch (e) {
        if (e && (e.code === "ENOENT" || e.code === "ENOTDIR"))
          return false;
        throw e;
      }
      return !!stat && stat.isDirectory();
    };
    var defaultRealpathSync = function realpathSync(x) {
      try {
        return realpathFS(x);
      } catch (realpathErr) {
        if (realpathErr.code !== "ENOENT") {
          throw realpathErr;
        }
      }
      return x;
    };
    var maybeRealpathSync = function maybeRealpathSync2(realpathSync, x, opts) {
      if (opts && opts.preserveSymlinks === false) {
        return realpathSync(x);
      }
      return x;
    };
    var defaultReadPackageSync = function defaultReadPackageSync2(readFileSync, pkgfile) {
      var body = readFileSync(pkgfile);
      try {
        var pkg = JSON.parse(body);
        return pkg;
      } catch (jsonErr) {
      }
    };
    var getPackageCandidates = function getPackageCandidates2(x, start, opts) {
      var dirs = nodeModulesPaths(start, opts, x);
      for (var i = 0; i < dirs.length; i++) {
        dirs[i] = path.join(dirs[i], x);
      }
      return dirs;
    };
    module2.exports = function resolveSync(x, options) {
      if (typeof x !== "string") {
        throw new TypeError("Path must be a string.");
      }
      var opts = normalizeOptions(x, options);
      var isFile = opts.isFile || defaultIsFile;
      var readFileSync = opts.readFileSync || fs.readFileSync;
      var isDirectory = opts.isDirectory || defaultIsDir;
      var realpathSync = opts.realpathSync || defaultRealpathSync;
      var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
      if (opts.readFileSync && opts.readPackageSync) {
        throw new TypeError("`readFileSync` and `readPackageSync` are mutually exclusive.");
      }
      var packageIterator = opts.packageIterator;
      var extensions = opts.extensions || [".js"];
      var includeCoreModules = opts.includeCoreModules !== false;
      var basedir = opts.basedir || path.dirname(caller());
      var parent = opts.filename || basedir;
      opts.paths = opts.paths || defaultPaths();
      var absoluteStart = maybeRealpathSync(realpathSync, path.resolve(basedir), opts);
      if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x)) {
        var res = path.resolve(absoluteStart, x);
        if (x === "." || x === ".." || x.slice(-1) === "/")
          res += "/";
        var m = loadAsFileSync(res) || loadAsDirectorySync(res);
        if (m)
          return maybeRealpathSync(realpathSync, m, opts);
      } else if (includeCoreModules && isCore(x)) {
        return x;
      } else {
        var n = loadNodeModulesSync(x, absoluteStart);
        if (n)
          return maybeRealpathSync(realpathSync, n, opts);
      }
      var err = new Error("Cannot find module '" + x + "' from '" + parent + "'");
      err.code = "MODULE_NOT_FOUND";
      throw err;
      function loadAsFileSync(x2) {
        var pkg = loadpkg(path.dirname(x2));
        if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
          var rfile = path.relative(pkg.dir, x2);
          var r = opts.pathFilter(pkg.pkg, x2, rfile);
          if (r) {
            x2 = path.resolve(pkg.dir, r);
          }
        }
        if (isFile(x2)) {
          return x2;
        }
        for (var i = 0; i < extensions.length; i++) {
          var file = x2 + extensions[i];
          if (isFile(file)) {
            return file;
          }
        }
      }
      function loadpkg(dir) {
        if (dir === "" || dir === "/")
          return;
        if (process.platform === "win32" && /^\w:[/\\]*$/.test(dir)) {
          return;
        }
        if (/[/\\]node_modules[/\\]*$/.test(dir))
          return;
        var pkgfile = path.join(maybeRealpathSync(realpathSync, dir, opts), "package.json");
        if (!isFile(pkgfile)) {
          return loadpkg(path.dirname(dir));
        }
        var pkg = readPackageSync(readFileSync, pkgfile);
        if (pkg && opts.packageFilter) {
          pkg = opts.packageFilter(pkg, dir);
        }
        return { pkg, dir };
      }
      function loadAsDirectorySync(x2) {
        var pkgfile = path.join(maybeRealpathSync(realpathSync, x2, opts), "/package.json");
        if (isFile(pkgfile)) {
          try {
            var pkg = readPackageSync(readFileSync, pkgfile);
          } catch (e) {
          }
          if (pkg && opts.packageFilter) {
            pkg = opts.packageFilter(pkg, x2);
          }
          if (pkg && pkg.main) {
            if (typeof pkg.main !== "string") {
              var mainError = new TypeError("package \u201C" + pkg.name + "\u201D `main` must be a string");
              mainError.code = "INVALID_PACKAGE_MAIN";
              throw mainError;
            }
            if (pkg.main === "." || pkg.main === "./") {
              pkg.main = "index";
            }
            try {
              var m2 = loadAsFileSync(path.resolve(x2, pkg.main));
              if (m2)
                return m2;
              var n2 = loadAsDirectorySync(path.resolve(x2, pkg.main));
              if (n2)
                return n2;
            } catch (e) {
            }
          }
        }
        return loadAsFileSync(path.join(x2, "/index"));
      }
      function loadNodeModulesSync(x2, start) {
        var thunk = function() {
          return getPackageCandidates(x2, start, opts);
        };
        var dirs = packageIterator ? packageIterator(x2, start, thunk, opts) : thunk();
        for (var i = 0; i < dirs.length; i++) {
          var dir = dirs[i];
          if (isDirectory(path.dirname(dir))) {
            var m2 = loadAsFileSync(dir);
            if (m2)
              return m2;
            var n2 = loadAsDirectorySync(dir);
            if (n2)
              return n2;
          }
        }
      }
    };
  }
});

// node_modules/resolve/index.js
var require_resolve = __commonJS({
  "node_modules/resolve/index.js"(exports2, module2) {
    var async = require_async();
    async.core = require_core3();
    async.isCore = require_is_core();
    async.sync = require_sync();
    module2.exports = async;
  }
});

// node_modules/postcss-import/lib/resolve-id.js
var require_resolve_id = __commonJS({
  "node_modules/postcss-import/lib/resolve-id.js"(exports2, module2) {
    "use strict";
    var resolve = require_resolve();
    var moduleDirectories = ["web_modules", "node_modules"];
    function resolveModule(id, opts) {
      return new Promise((res, rej) => {
        resolve(id, opts, (err, path) => err ? rej(err) : res(path));
      });
    }
    module2.exports = function(id, base, options) {
      const paths = options.path;
      const resolveOpts = {
        basedir: base,
        moduleDirectory: moduleDirectories.concat(options.addModulesDirectories),
        paths,
        extensions: [".css"],
        packageFilter: function processPackage(pkg) {
          if (pkg.style)
            pkg.main = pkg.style;
          else if (!pkg.main || !/\.css$/.test(pkg.main))
            pkg.main = "index.css";
          return pkg;
        },
        preserveSymlinks: false
      };
      return resolveModule(`./${id}`, resolveOpts).catch(() => resolveModule(id, resolveOpts)).catch(() => {
        if (paths.indexOf(base) === -1)
          paths.unshift(base);
        throw new Error(`Failed to find '${id}'
  in [
    ${paths.join(",\n        ")}
  ]`);
      });
    };
  }
});

// node_modules/pify/index.js
var require_pify = __commonJS({
  "node_modules/pify/index.js"(exports2, module2) {
    "use strict";
    var processFn = function(fn, P, opts) {
      return function() {
        var that = this;
        var args = new Array(arguments.length);
        for (var i = 0; i < arguments.length; i++) {
          args[i] = arguments[i];
        }
        return new P(function(resolve, reject) {
          args.push(function(err, result) {
            if (err) {
              reject(err);
            } else if (opts.multiArgs) {
              var results = new Array(arguments.length - 1);
              for (var i2 = 1; i2 < arguments.length; i2++) {
                results[i2 - 1] = arguments[i2];
              }
              resolve(results);
            } else {
              resolve(result);
            }
          });
          fn.apply(that, args);
        });
      };
    };
    var pify = module2.exports = function(obj, P, opts) {
      if (typeof P !== "function") {
        opts = P;
        P = Promise;
      }
      opts = opts || {};
      opts.exclude = opts.exclude || [/.+Sync$/];
      var filter = function(key) {
        var match = function(pattern) {
          return typeof pattern === "string" ? key === pattern : pattern.test(key);
        };
        return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
      };
      var ret = typeof obj === "function" ? function() {
        if (opts.excludeMain) {
          return obj.apply(this, arguments);
        }
        return processFn(obj, P, opts).apply(this, arguments);
      } : {};
      return Object.keys(obj).reduce(function(ret2, key) {
        var x = obj[key];
        ret2[key] = typeof x === "function" && filter(key) ? processFn(x, P, opts) : x;
        return ret2;
      }, ret);
    };
    pify.all = pify;
  }
});

// node_modules/read-cache/index.js
var require_read_cache = __commonJS({
  "node_modules/read-cache/index.js"(exports2, module2) {
    var fs = require("fs");
    var path = require("path");
    var pify = require_pify();
    var stat = pify(fs.stat);
    var readFile = pify(fs.readFile);
    var resolve = path.resolve;
    var cache = /* @__PURE__ */ Object.create(null);
    function convert(content, encoding) {
      if (Buffer.isEncoding(encoding)) {
        return content.toString(encoding);
      }
      return content;
    }
    module2.exports = function(path2, encoding) {
      path2 = resolve(path2);
      return stat(path2).then(function(stats) {
        var item = cache[path2];
        if (item && item.mtime.getTime() === stats.mtime.getTime()) {
          return convert(item.content, encoding);
        }
        return readFile(path2).then(function(data) {
          cache[path2] = {
            mtime: stats.mtime,
            content: data
          };
          return convert(data, encoding);
        });
      }).catch(function(err) {
        cache[path2] = null;
        return Promise.reject(err);
      });
    };
    module2.exports.sync = function(path2, encoding) {
      path2 = resolve(path2);
      try {
        var stats = fs.statSync(path2);
        var item = cache[path2];
        if (item && item.mtime.getTime() === stats.mtime.getTime()) {
          return convert(item.content, encoding);
        }
        var data = fs.readFileSync(path2);
        cache[path2] = {
          mtime: stats.mtime,
          content: data
        };
        return convert(data, encoding);
      } catch (err) {
        cache[path2] = null;
        throw err;
      }
    };
    module2.exports.get = function(path2, encoding) {
      path2 = resolve(path2);
      if (cache[path2]) {
        return convert(cache[path2].content, encoding);
      }
      return null;
    };
    module2.exports.clear = function() {
      cache = /* @__PURE__ */ Object.create(null);
    };
  }
});

// node_modules/postcss-import/lib/load-content.js
var require_load_content = __commonJS({
  "node_modules/postcss-import/lib/load-content.js"(exports2, module2) {
    "use strict";
    var readCache = require_read_cache();
    module2.exports = (filename) => readCache(filename, "utf-8");
  }
});

// node_modules/postcss-import/lib/process-content.js
var require_process_content = __commonJS({
  "node_modules/postcss-import/lib/process-content.js"(exports2, module2) {
    "use strict";
    var path = require("path");
    var sugarss;
    module2.exports = function processContent(result, content, filename, options, postcss) {
      const { plugins } = options;
      const ext = path.extname(filename);
      const parserList = [];
      if (ext === ".sss") {
        if (!sugarss) {
          try {
            sugarss = require("sugarss");
          } catch {
          }
        }
        if (sugarss)
          return runPostcss(postcss, content, filename, plugins, [sugarss]);
      }
      if (result.opts.syntax && result.opts.syntax.parse) {
        parserList.push(result.opts.syntax.parse);
      }
      if (result.opts.parser)
        parserList.push(result.opts.parser);
      parserList.push(null);
      return runPostcss(postcss, content, filename, plugins, parserList);
    };
    function runPostcss(postcss, content, filename, plugins, parsers, index) {
      if (!index)
        index = 0;
      return postcss(plugins).process(content, {
        from: filename,
        parser: parsers[index]
      }).catch((err) => {
        index++;
        if (index === parsers.length)
          throw err;
        return runPostcss(postcss, content, filename, plugins, parsers, index);
      });
    }
  }
});

// node_modules/postcss-value-parser/lib/parse.js
var require_parse2 = __commonJS({
  "node_modules/postcss-value-parser/lib/parse.js"(exports2, module2) {
    var openParentheses = "(".charCodeAt(0);
    var closeParentheses = ")".charCodeAt(0);
    var singleQuote = "'".charCodeAt(0);
    var doubleQuote = '"'.charCodeAt(0);
    var backslash = "\\".charCodeAt(0);
    var slash = "/".charCodeAt(0);
    var comma = ",".charCodeAt(0);
    var colon = ":".charCodeAt(0);
    var star = "*".charCodeAt(0);
    var uLower = "u".charCodeAt(0);
    var uUpper = "U".charCodeAt(0);
    var plus = "+".charCodeAt(0);
    var isUnicodeRange = /^[a-f0-9?-]+$/i;
    module2.exports = function(input) {
      var tokens = [];
      var value = input;
      var next, quote, prev, token, escape, escapePos, whitespacePos, parenthesesOpenPos;
      var pos = 0;
      var code = value.charCodeAt(pos);
      var max = value.length;
      var stack = [{ nodes: tokens }];
      var balanced = 0;
      var parent;
      var name = "";
      var before = "";
      var after = "";
      while (pos < max) {
        if (code <= 32) {
          next = pos;
          do {
            next += 1;
            code = value.charCodeAt(next);
          } while (code <= 32);
          token = value.slice(pos, next);
          prev = tokens[tokens.length - 1];
          if (code === closeParentheses && balanced) {
            after = token;
          } else if (prev && prev.type === "div") {
            prev.after = token;
            prev.sourceEndIndex += token.length;
          } else if (code === comma || code === colon || code === slash && value.charCodeAt(next + 1) !== star && (!parent || parent && parent.type === "function" && parent.value !== "calc")) {
            before = token;
          } else {
            tokens.push({
              type: "space",
              sourceIndex: pos,
              sourceEndIndex: next,
              value: token
            });
          }
          pos = next;
        } else if (code === singleQuote || code === doubleQuote) {
          next = pos;
          quote = code === singleQuote ? "'" : '"';
          token = {
            type: "string",
            sourceIndex: pos,
            quote
          };
          do {
            escape = false;
            next = value.indexOf(quote, next + 1);
            if (~next) {
              escapePos = next;
              while (value.charCodeAt(escapePos - 1) === backslash) {
                escapePos -= 1;
                escape = !escape;
              }
            } else {
              value += quote;
              next = value.length - 1;
              token.unclosed = true;
            }
          } while (escape);
          token.value = value.slice(pos + 1, next);
          token.sourceEndIndex = token.unclosed ? next : next + 1;
          tokens.push(token);
          pos = next + 1;
          code = value.charCodeAt(pos);
        } else if (code === slash && value.charCodeAt(pos + 1) === star) {
          next = value.indexOf("*/", pos);
          token = {
            type: "comment",
            sourceIndex: pos,
            sourceEndIndex: next + 2
          };
          if (next === -1) {
            token.unclosed = true;
            next = value.length;
            token.sourceEndIndex = next;
          }
          token.value = value.slice(pos + 2, next);
          tokens.push(token);
          pos = next + 2;
          code = value.charCodeAt(pos);
        } else if ((code === slash || code === star) && parent && parent.type === "function" && parent.value === "calc") {
          token = value[pos];
          tokens.push({
            type: "word",
            sourceIndex: pos - before.length,
            sourceEndIndex: pos + token.length,
            value: token
          });
          pos += 1;
          code = value.charCodeAt(pos);
        } else if (code === slash || code === comma || code === colon) {
          token = value[pos];
          tokens.push({
            type: "div",
            sourceIndex: pos - before.length,
            sourceEndIndex: pos + token.length,
            value: token,
            before,
            after: ""
          });
          before = "";
          pos += 1;
          code = value.charCodeAt(pos);
        } else if (openParentheses === code) {
          next = pos;
          do {
            next += 1;
            code = value.charCodeAt(next);
          } while (code <= 32);
          parenthesesOpenPos = pos;
          token = {
            type: "function",
            sourceIndex: pos - name.length,
            value: name,
            before: value.slice(parenthesesOpenPos + 1, next)
          };
          pos = next;
          if (name === "url" && code !== singleQuote && code !== doubleQuote) {
            next -= 1;
            do {
              escape = false;
              next = value.indexOf(")", next + 1);
              if (~next) {
                escapePos = next;
                while (value.charCodeAt(escapePos - 1) === backslash) {
                  escapePos -= 1;
                  escape = !escape;
                }
              } else {
                value += ")";
                next = value.length - 1;
                token.unclosed = true;
              }
            } while (escape);
            whitespacePos = next;
            do {
              whitespacePos -= 1;
              code = value.charCodeAt(whitespacePos);
            } while (code <= 32);
            if (parenthesesOpenPos < whitespacePos) {
              if (pos !== whitespacePos + 1) {
                token.nodes = [
                  {
                    type: "word",
                    sourceIndex: pos,
                    sourceEndIndex: whitespacePos + 1,
                    value: value.slice(pos, whitespacePos + 1)
                  }
                ];
              } else {
                token.nodes = [];
              }
              if (token.unclosed && whitespacePos + 1 !== next) {
                token.after = "";
                token.nodes.push({
                  type: "space",
                  sourceIndex: whitespacePos + 1,
                  sourceEndIndex: next,
                  value: value.slice(whitespacePos + 1, next)
                });
              } else {
                token.after = value.slice(whitespacePos + 1, next);
                token.sourceEndIndex = next;
              }
            } else {
              token.after = "";
              token.nodes = [];
            }
            pos = next + 1;
            token.sourceEndIndex = token.unclosed ? next : pos;
            code = value.charCodeAt(pos);
            tokens.push(token);
          } else {
            balanced += 1;
            token.after = "";
            token.sourceEndIndex = pos + 1;
            tokens.push(token);
            stack.push(token);
            tokens = token.nodes = [];
            parent = token;
          }
          name = "";
        } else if (closeParentheses === code && balanced) {
          pos += 1;
          code = value.charCodeAt(pos);
          parent.after = after;
          parent.sourceEndIndex += after.length;
          after = "";
          balanced -= 1;
          stack[stack.length - 1].sourceEndIndex = pos;
          stack.pop();
          parent = stack[balanced];
          tokens = parent.nodes;
        } else {
          next = pos;
          do {
            if (code === backslash) {
              next += 1;
            }
            next += 1;
            code = value.charCodeAt(next);
          } while (next < max && !(code <= 32 || code === singleQuote || code === doubleQuote || code === comma || code === colon || code === slash || code === openParentheses || code === star && parent && parent.type === "function" && parent.value === "calc" || code === slash && parent.type === "function" && parent.value === "calc" || code === closeParentheses && balanced));
          token = value.slice(pos, next);
          if (openParentheses === code) {
            name = token;
          } else if ((uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) && plus === token.charCodeAt(1) && isUnicodeRange.test(token.slice(2))) {
            tokens.push({
              type: "unicode-range",
              sourceIndex: pos,
              sourceEndIndex: next,
              value: token
            });
          } else {
            tokens.push({
              type: "word",
              sourceIndex: pos,
              sourceEndIndex: next,
              value: token
            });
          }
          pos = next;
        }
      }
      for (pos = stack.length - 1; pos; pos -= 1) {
        stack[pos].unclosed = true;
        stack[pos].sourceEndIndex = value.length;
      }
      return stack[0].nodes;
    };
  }
});

// node_modules/postcss-value-parser/lib/walk.js
var require_walk = __commonJS({
  "node_modules/postcss-value-parser/lib/walk.js"(exports2, module2) {
    module2.exports = function walk(nodes, cb, bubble) {
      var i, max, node, result;
      for (i = 0, max = nodes.length; i < max; i += 1) {
        node = nodes[i];
        if (!bubble) {
          result = cb(node, i, nodes);
        }
        if (result !== false && node.type === "function" && Array.isArray(node.nodes)) {
          walk(node.nodes, cb, bubble);
        }
        if (bubble) {
          cb(node, i, nodes);
        }
      }
    };
  }
});

// node_modules/postcss-value-parser/lib/stringify.js
var require_stringify2 = __commonJS({
  "node_modules/postcss-value-parser/lib/stringify.js"(exports2, module2) {
    function stringifyNode(node, custom) {
      var type = node.type;
      var value = node.value;
      var buf;
      var customResult;
      if (custom && (customResult = custom(node)) !== void 0) {
        return customResult;
      } else if (type === "word" || type === "space") {
        return value;
      } else if (type === "string") {
        buf = node.quote || "";
        return buf + value + (node.unclosed ? "" : buf);
      } else if (type === "comment") {
        return "/*" + value + (node.unclosed ? "" : "*/");
      } else if (type === "div") {
        return (node.before || "") + value + (node.after || "");
      } else if (Array.isArray(node.nodes)) {
        buf = stringify(node.nodes, custom);
        if (type !== "function") {
          return buf;
        }
        return value + "(" + (node.before || "") + buf + (node.after || "") + (node.unclosed ? "" : ")");
      }
      return value;
    }
    function stringify(nodes, custom) {
      var result, i;
      if (Array.isArray(nodes)) {
        result = "";
        for (i = nodes.length - 1; ~i; i -= 1) {
          result = stringifyNode(nodes[i], custom) + result;
        }
        return result;
      }
      return stringifyNode(nodes, custom);
    }
    module2.exports = stringify;
  }
});

// node_modules/postcss-value-parser/lib/unit.js
var require_unit = __commonJS({
  "node_modules/postcss-value-parser/lib/unit.js"(exports2, module2) {
    var minus = "-".charCodeAt(0);
    var plus = "+".charCodeAt(0);
    var dot = ".".charCodeAt(0);
    var exp = "e".charCodeAt(0);
    var EXP = "E".charCodeAt(0);
    function likeNumber(value) {
      var code = value.charCodeAt(0);
      var nextCode;
      if (code === plus || code === minus) {
        nextCode = value.charCodeAt(1);
        if (nextCode >= 48 && nextCode <= 57) {
          return true;
        }
        var nextNextCode = value.charCodeAt(2);
        if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {
          return true;
        }
        return false;
      }
      if (code === dot) {
        nextCode = value.charCodeAt(1);
        if (nextCode >= 48 && nextCode <= 57) {
          return true;
        }
        return false;
      }
      if (code >= 48 && code <= 57) {
        return true;
      }
      return false;
    }
    module2.exports = function(value) {
      var pos = 0;
      var length = value.length;
      var code;
      var nextCode;
      var nextNextCode;
      if (length === 0 || !likeNumber(value)) {
        return false;
      }
      code = value.charCodeAt(pos);
      if (code === plus || code === minus) {
        pos++;
      }
      while (pos < length) {
        code = value.charCodeAt(pos);
        if (code < 48 || code > 57) {
          break;
        }
        pos += 1;
      }
      code = value.charCodeAt(pos);
      nextCode = value.charCodeAt(pos + 1);
      if (code === dot && nextCode >= 48 && nextCode <= 57) {
        pos += 2;
        while (pos < length) {
          code = value.charCodeAt(pos);
          if (code < 48 || code > 57) {
            break;
          }
          pos += 1;
        }
      }
      code = value.charCodeAt(pos);
      nextCode = value.charCodeAt(pos + 1);
      nextNextCode = value.charCodeAt(pos + 2);
      if ((code === exp || code === EXP) && (nextCode >= 48 && nextCode <= 57 || (nextCode === plus || nextCode === minus) && nextNextCode >= 48 && nextNextCode <= 57)) {
        pos += nextCode === plus || nextCode === minus ? 3 : 2;
        while (pos < length) {
          code = value.charCodeAt(pos);
          if (code < 48 || code > 57) {
            break;
          }
          pos += 1;
        }
      }
      return {
        number: value.slice(0, pos),
        unit: value.slice(pos)
      };
    };
  }
});

// node_modules/postcss-value-parser/lib/index.js
var require_lib = __commonJS({
  "node_modules/postcss-value-parser/lib/index.js"(exports2, module2) {
    var parse = require_parse2();
    var walk = require_walk();
    var stringify = require_stringify2();
    function ValueParser(value) {
      if (this instanceof ValueParser) {
        this.nodes = parse(value);
        return this;
      }
      return new ValueParser(value);
    }
    ValueParser.prototype.toString = function() {
      return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
    };
    ValueParser.prototype.walk = function(cb, bubble) {
      walk(this.nodes, cb, bubble);
      return this;
    };
    ValueParser.unit = require_unit();
    ValueParser.walk = walk;
    ValueParser.stringify = stringify;
    module2.exports = ValueParser;
  }
});

// node_modules/postcss-import/lib/parse-statements.js
var require_parse_statements = __commonJS({
  "node_modules/postcss-import/lib/parse-statements.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var { stringify } = valueParser;
    function split(params, start) {
      const list = [];
      const last = params.reduce((item, node, index) => {
        if (index < start)
          return "";
        if (node.type === "div" && node.value === ",") {
          list.push(item);
          return "";
        }
        return item + stringify(node);
      }, "");
      list.push(last);
      return list;
    }
    module2.exports = function(result, styles) {
      const statements = [];
      let nodes = [];
      styles.each((node) => {
        let stmt;
        if (node.type === "atrule") {
          if (node.name === "import")
            stmt = parseImport(result, node);
          else if (node.name === "media")
            stmt = parseMedia(result, node);
          else if (node.name === "charset")
            stmt = parseCharset(result, node);
        }
        if (stmt) {
          if (nodes.length) {
            statements.push({
              type: "nodes",
              nodes,
              media: [],
              layer: []
            });
            nodes = [];
          }
          statements.push(stmt);
        } else
          nodes.push(node);
      });
      if (nodes.length) {
        statements.push({
          type: "nodes",
          nodes,
          media: [],
          layer: []
        });
      }
      return statements;
    };
    function parseMedia(result, atRule) {
      const params = valueParser(atRule.params).nodes;
      return {
        type: "media",
        node: atRule,
        media: split(params, 0),
        layer: []
      };
    }
    function parseCharset(result, atRule) {
      if (atRule.prev()) {
        return result.warn("@charset must precede all other statements", {
          node: atRule
        });
      }
      return {
        type: "charset",
        node: atRule,
        media: [],
        layer: []
      };
    }
    function parseImport(result, atRule) {
      let prev = atRule.prev();
      if (prev) {
        do {
          if (prev.type !== "comment" && (prev.type !== "atrule" || prev.name !== "import" && prev.name !== "charset" && !(prev.name === "layer" && !prev.nodes))) {
            return result.warn("@import must precede all other statements (besides @charset or empty @layer)", { node: atRule });
          }
          prev = prev.prev();
        } while (prev);
      }
      if (atRule.nodes) {
        return result.warn("It looks like you didn't end your @import statement correctly. Child nodes are attached to it.", { node: atRule });
      }
      const params = valueParser(atRule.params).nodes;
      const stmt = {
        type: "import",
        node: atRule,
        media: [],
        layer: []
      };
      if (!params.length || (params[0].type !== "string" || !params[0].value) && (params[0].type !== "function" || params[0].value !== "url" || !params[0].nodes.length || !params[0].nodes[0].value)) {
        return result.warn(`Unable to find uri in '${atRule.toString()}'`, {
          node: atRule
        });
      }
      if (params[0].type === "string")
        stmt.uri = params[0].value;
      else
        stmt.uri = params[0].nodes[0].value;
      stmt.fullUri = stringify(params[0]);
      let remainder = params;
      if (remainder.length > 2) {
        if ((remainder[2].type === "word" || remainder[2].type === "function") && remainder[2].value === "layer") {
          if (remainder[1].type !== "space") {
            return result.warn("Invalid import layer statement", { node: atRule });
          }
          if (remainder[2].nodes) {
            stmt.layer = [stringify(remainder[2].nodes)];
          } else {
            stmt.layer = [""];
          }
          remainder = remainder.slice(2);
        }
      }
      if (remainder.length > 2) {
        if (remainder[1].type !== "space") {
          return result.warn("Invalid import media statement", { node: atRule });
        }
        stmt.media = split(remainder, 2);
      }
      return stmt;
    }
  }
});

// node_modules/postcss-import/index.js
var require_postcss_import = __commonJS({
  "node_modules/postcss-import/index.js"(exports2, module2) {
    "use strict";
    var path = require("path");
    var joinMedia = require_join_media();
    var joinLayer = require_join_layer();
    var resolveId = require_resolve_id();
    var loadContent = require_load_content();
    var processContent = require_process_content();
    var parseStatements = require_parse_statements();
    function AtImport(options) {
      options = {
        root: process.cwd(),
        path: [],
        skipDuplicates: true,
        resolve: resolveId,
        load: loadContent,
        plugins: [],
        addModulesDirectories: [],
        ...options
      };
      options.root = path.resolve(options.root);
      if (typeof options.path === "string")
        options.path = [options.path];
      if (!Array.isArray(options.path))
        options.path = [];
      options.path = options.path.map((p) => path.resolve(options.root, p));
      return {
        postcssPlugin: "postcss-import",
        Once(styles, { result, atRule, postcss }) {
          const state = {
            importedFiles: {},
            hashFiles: {}
          };
          if (styles.source && styles.source.input && styles.source.input.file) {
            state.importedFiles[styles.source.input.file] = {};
          }
          if (options.plugins && !Array.isArray(options.plugins)) {
            throw new Error("plugins option must be an array");
          }
          return parseStyles(result, styles, options, state, [], []).then((bundle) => {
            applyRaws(bundle);
            applyMedia(bundle);
            applyStyles(bundle, styles);
          });
          function applyRaws(bundle) {
            bundle.forEach((stmt, index) => {
              if (index === 0)
                return;
              if (stmt.parent) {
                const { before } = stmt.parent.node.raws;
                if (stmt.type === "nodes")
                  stmt.nodes[0].raws.before = before;
                else
                  stmt.node.raws.before = before;
              } else if (stmt.type === "nodes") {
                stmt.nodes[0].raws.before = stmt.nodes[0].raws.before || "\n";
              }
            });
          }
          function applyMedia(bundle) {
            bundle.forEach((stmt) => {
              if (!stmt.media.length && !stmt.layer.length || stmt.type === "charset") {
                return;
              }
              if (stmt.type === "import") {
                stmt.node.params = `${stmt.fullUri} ${stmt.media.join(", ")}`;
              } else if (stmt.type === "media") {
                stmt.node.params = stmt.media.join(", ");
              } else {
                const { nodes } = stmt;
                const { parent } = nodes[0];
                let outerAtRule;
                let innerAtRule;
                if (stmt.media.length && stmt.layer.length) {
                  const mediaNode = atRule({
                    name: "media",
                    params: stmt.media.join(", "),
                    source: parent.source
                  });
                  const layerNode = atRule({
                    name: "layer",
                    params: stmt.layer.filter((layer) => layer !== "").join("."),
                    source: parent.source
                  });
                  mediaNode.append(layerNode);
                  innerAtRule = layerNode;
                  outerAtRule = mediaNode;
                } else if (stmt.media.length) {
                  const mediaNode = atRule({
                    name: "media",
                    params: stmt.media.join(", "),
                    source: parent.source
                  });
                  innerAtRule = mediaNode;
                  outerAtRule = mediaNode;
                } else if (stmt.layer.length) {
                  const layerNode = atRule({
                    name: "layer",
                    params: stmt.layer.filter((layer) => layer !== "").join("."),
                    source: parent.source
                  });
                  innerAtRule = layerNode;
                  outerAtRule = layerNode;
                }
                parent.insertBefore(nodes[0], outerAtRule);
                nodes.forEach((node) => {
                  node.parent = void 0;
                });
                nodes[0].raws.before = nodes[0].raws.before || "\n";
                innerAtRule.append(nodes);
                stmt.type = "media";
                stmt.node = outerAtRule;
                delete stmt.nodes;
              }
            });
          }
          function applyStyles(bundle, styles2) {
            styles2.nodes = [];
            bundle.forEach((stmt) => {
              if (["charset", "import", "media"].includes(stmt.type)) {
                stmt.node.parent = void 0;
                styles2.append(stmt.node);
              } else if (stmt.type === "nodes") {
                stmt.nodes.forEach((node) => {
                  node.parent = void 0;
                  styles2.append(node);
                });
              }
            });
          }
          function parseStyles(result2, styles2, options2, state2, media, layer) {
            const statements = parseStatements(result2, styles2);
            return Promise.resolve(statements).then((stmts) => {
              return stmts.reduce((promise, stmt) => {
                return promise.then(() => {
                  stmt.media = joinMedia(media, stmt.media || []);
                  stmt.layer = joinLayer(layer, stmt.layer || []);
                  if (stmt.type !== "import" || /^(?:[a-z]+:)?\/\//i.test(stmt.uri)) {
                    return;
                  }
                  if (options2.filter && !options2.filter(stmt.uri)) {
                    return;
                  }
                  return resolveImportId(result2, stmt, options2, state2);
                });
              }, Promise.resolve());
            }).then(() => {
              let charset;
              const imports = [];
              const bundle = [];
              function handleCharset(stmt) {
                if (!charset)
                  charset = stmt;
                else if (stmt.node.params.toLowerCase() !== charset.node.params.toLowerCase()) {
                  throw new Error(`Incompatable @charset statements:
  ${stmt.node.params} specified in ${stmt.node.source.input.file}
  ${charset.node.params} specified in ${charset.node.source.input.file}`);
                }
              }
              statements.forEach((stmt) => {
                if (stmt.type === "charset")
                  handleCharset(stmt);
                else if (stmt.type === "import") {
                  if (stmt.children) {
                    stmt.children.forEach((child, index) => {
                      if (child.type === "import")
                        imports.push(child);
                      else if (child.type === "charset")
                        handleCharset(child);
                      else
                        bundle.push(child);
                      if (index === 0)
                        child.parent = stmt;
                    });
                  } else
                    imports.push(stmt);
                } else if (stmt.type === "media" || stmt.type === "nodes") {
                  bundle.push(stmt);
                }
              });
              return charset ? [charset, ...imports.concat(bundle)] : imports.concat(bundle);
            });
          }
          function resolveImportId(result2, stmt, options2, state2) {
            const atRule2 = stmt.node;
            let sourceFile;
            if (atRule2.source && atRule2.source.input && atRule2.source.input.file) {
              sourceFile = atRule2.source.input.file;
            }
            const base = sourceFile ? path.dirname(atRule2.source.input.file) : options2.root;
            return Promise.resolve(options2.resolve(stmt.uri, base, options2)).then((paths) => {
              if (!Array.isArray(paths))
                paths = [paths];
              return Promise.all(paths.map((file) => {
                return !path.isAbsolute(file) ? resolveId(file, base, options2) : file;
              }));
            }).then((resolved) => {
              resolved.forEach((file) => {
                result2.messages.push({
                  type: "dependency",
                  plugin: "postcss-import",
                  file,
                  parent: sourceFile
                });
              });
              return Promise.all(resolved.map((file) => {
                return loadImportContent(result2, stmt, file, options2, state2);
              }));
            }).then((result3) => {
              stmt.children = result3.reduce((result4, statements) => {
                return statements ? result4.concat(statements) : result4;
              }, []);
            });
          }
          function loadImportContent(result2, stmt, filename, options2, state2) {
            const atRule2 = stmt.node;
            const { media, layer } = stmt;
            if (options2.skipDuplicates) {
              if (state2.importedFiles[filename] && state2.importedFiles[filename][media]) {
                return;
              }
              if (!state2.importedFiles[filename])
                state2.importedFiles[filename] = {};
              state2.importedFiles[filename][media] = true;
            }
            return Promise.resolve(options2.load(filename, options2)).then((content) => {
              if (content.trim() === "") {
                result2.warn(`${filename} is empty`, { node: atRule2 });
                return;
              }
              if (state2.hashFiles[content] && state2.hashFiles[content][media])
                return;
              return processContent(result2, content, filename, options2, postcss).then((importedResult) => {
                const styles2 = importedResult.root;
                result2.messages = result2.messages.concat(importedResult.messages);
                if (options2.skipDuplicates) {
                  const hasImport = styles2.some((child) => {
                    return child.type === "atrule" && child.name === "import";
                  });
                  if (!hasImport) {
                    if (!state2.hashFiles[content])
                      state2.hashFiles[content] = {};
                    state2.hashFiles[content][media] = true;
                  }
                }
                return parseStyles(result2, styles2, options2, state2, media, layer);
              });
            });
          }
        }
      };
    }
    AtImport.postcss = true;
    module2.exports = AtImport;
  }
});

// node_modules/node-releases/data/processed/envs.json
var require_envs = __commonJS({
  "node_modules/node-releases/data/processed/envs.json"(exports2, module2) {
    module2.exports = [{ name: "nodejs", version: "0.2.0", date: "2011-08-26", lts: false, security: false }, { name: "nodejs", version: "0.3.0", date: "2011-08-26", lts: false, security: false }, { name: "nodejs", version: "0.4.0", date: "2011-08-26", lts: false, security: false }, { name: "nodejs", version: "0.5.0", date: "2011-08-26", lts: false, security: false }, { name: "nodejs", version: "0.6.0", date: "2011-11-04", lts: false, security: false }, { name: "nodejs", version: "0.7.0", date: "2012-01-17", lts: false, security: false }, { name: "nodejs", version: "0.8.0", date: "2012-06-22", lts: false, security: false }, { name: "nodejs", version: "0.9.0", date: "2012-07-20", lts: false, security: false }, { name: "nodejs", version: "0.10.0", date: "2013-03-11", lts: false, security: false }, { name: "nodejs", version: "0.11.0", date: "2013-03-28", lts: false, security: false }, { name: "nodejs", version: "0.12.0", date: "2015-02-06", lts: false, security: false }, { name: "nodejs", version: "4.0.0", date: "2015-09-08", lts: false, security: false }, { name: "nodejs", version: "4.1.0", date: "2015-09-17", lts: false, security: false }, { name: "nodejs", version: "4.2.0", date: "2015-10-12", lts: "Argon", security: false }, { name: "nodejs", version: "4.3.0", date: "2016-02-09", lts: "Argon", security: false }, { name: "nodejs", version: "4.4.0", date: "2016-03-08", lts: "Argon", security: false }, { name: "nodejs", version: "4.5.0", date: "2016-08-16", lts: "Argon", security: false }, { name: "nodejs", version: "4.6.0", date: "2016-09-27", lts: "Argon", security: true }, { name: "nodejs", version: "4.7.0", date: "2016-12-06", lts: "Argon", security: false }, { name: "nodejs", version: "4.8.0", date: "2017-02-21", lts: "Argon", security: false }, { name: "nodejs", version: "4.9.0", date: "2018-03-28", lts: "Argon", security: true }, { name: "nodejs", version: "5.0.0", date: "2015-10-29", lts: false, security: false }, { name: "nodejs", version: "5.1.0", date: "2015-11-17", lts: false, security: false }, { name: "nodejs", version: "5.2.0", date: "2015-12-09", lts: false, security: false }, { name: "nodejs", version: "5.3.0", date: "2015-12-15", lts: false, security: false }, { name: "nodejs", version: "5.4.0", date: "2016-01-06", lts: false, security: false }, { name: "nodejs", version: "5.5.0", date: "2016-01-21", lts: false, security: false }, { name: "nodejs", version: "5.6.0", date: "2016-02-09", lts: false, security: false }, { name: "nodejs", version: "5.7.0", date: "2016-02-23", lts: false, security: false }, { name: "nodejs", version: "5.8.0", date: "2016-03-09", lts: false, security: false }, { name: "nodejs", version: "5.9.0", date: "2016-03-16", lts: false, security: false }, { name: "nodejs", version: "5.10.0", date: "2016-04-01", lts: false, security: false }, { name: "nodejs", version: "5.11.0", date: "2016-04-21", lts: false, security: false }, { name: "nodejs", version: "5.12.0", date: "2016-06-23", lts: false, security: false }, { name: "nodejs", version: "6.0.0", date: "2016-04-26", lts: false, security: false }, { name: "nodejs", version: "6.1.0", date: "2016-05-05", lts: false, security: false }, { name: "nodejs", version: "6.2.0", date: "2016-05-17", lts: false, security: false }, { name: "nodejs", version: "6.3.0", date: "2016-07-06", lts: false, security: false }, { name: "nodejs", version: "6.4.0", date: "2016-08-12", lts: false, security: false }, { name: "nodejs", version: "6.5.0", date: "2016-08-26", lts: false, security: false }, { name: "nodejs", version: "6.6.0", date: "2016-09-14", lts: false, security: false }, { name: "nodejs", version: "6.7.0", date: "2016-09-27", lts: false, security: true }, { name: "nodejs", version: "6.8.0", date: "2016-10-12", lts: false, security: false }, { name: "nodejs", version: "6.9.0", date: "2016-10-18", lts: "Boron", security: false }, { name: "nodejs", version: "6.10.0", date: "2017-02-21", lts: "Boron", security: false }, { name: "nodejs", version: "6.11.0", date: "2017-06-06", lts: "Boron", security: false }, { name: "nodejs", version: "6.12.0", date: "2017-11-06", lts: "Boron", security: false }, { name: "nodejs", version: "6.13.0", date: "2018-02-10", lts: "Boron", security: false }, { name: "nodejs", version: "6.14.0", date: "2018-03-28", lts: "Boron", security: true }, { name: "nodejs", version: "6.15.0", date: "2018-11-27", lts: "Boron", security: true }, { name: "nodejs", version: "6.16.0", date: "2018-12-26", lts: "Boron", security: false }, { name: "nodejs", version: "6.17.0", date: "2019-02-28", lts: "Boron", security: true }, { name: "nodejs", version: "7.0.0", date: "2016-10-25", lts: false, security: false }, { name: "nodejs", version: "7.1.0", date: "2016-11-08", lts: false, security: false }, { name: "nodejs", version: "7.2.0", date: "2016-11-22", lts: false, security: false }, { name: "nodejs", version: "7.3.0", date: "2016-12-20", lts: false, security: false }, { name: "nodejs", version: "7.4.0", date: "2017-01-04", lts: false, security: false }, { name: "nodejs", version: "7.5.0", date: "2017-01-31", lts: false, security: false }, { name: "nodejs", version: "7.6.0", date: "2017-02-21", lts: false, security: false }, { name: "nodejs", version: "7.7.0", date: "2017-02-28", lts: false, security: false }, { name: "nodejs", version: "7.8.0", date: "2017-03-29", lts: false, security: false }, { name: "nodejs", version: "7.9.0", date: "2017-04-11", lts: false, security: false }, { name: "nodejs", version: "7.10.0", date: "2017-05-02", lts: false, security: false }, { name: "nodejs", version: "8.0.0", date: "2017-05-30", lts: false, security: false }, { name: "nodejs", version: "8.1.0", date: "2017-06-08", lts: false, security: false }, { name: "nodejs", version: "8.2.0", date: "2017-07-19", lts: false, security: false }, { name: "nodejs", version: "8.3.0", date: "2017-08-08", lts: false, security: false }, { name: "nodejs", version: "8.4.0", date: "2017-08-15", lts: false, security: false }, { name: "nodejs", version: "8.5.0", date: "2017-09-12", lts: false, security: false }, { name: "nodejs", version: "8.6.0", date: "2017-09-26", lts: false, security: false }, { name: "nodejs", version: "8.7.0", date: "2017-10-11", lts: false, security: false }, { name: "nodejs", version: "8.8.0", date: "2017-10-24", lts: false, security: false }, { name: "nodejs", version: "8.9.0", date: "2017-10-31", lts: "Carbon", security: false }, { name: "nodejs", version: "8.10.0", date: "2018-03-06", lts: "Carbon", security: false }, { name: "nodejs", version: "8.11.0", date: "2018-03-28", lts: "Carbon", security: true }, { name: "nodejs", version: "8.12.0", date: "2018-09-10", lts: "Carbon", security: false }, { name: "nodejs", version: "8.13.0", date: "2018-11-20", lts: "Carbon", security: false }, { name: "nodejs", version: "8.14.0", date: "2018-11-27", lts: "Carbon", security: true }, { name: "nodejs", version: "8.15.0", date: "2018-12-26", lts: "Carbon", security: false }, { name: "nodejs", version: "8.16.0", date: "2019-04-16", lts: "Carbon", security: false }, { name: "nodejs", version: "8.17.0", date: "2019-12-17", lts: "Carbon", security: true }, { name: "nodejs", version: "9.0.0", date: "2017-10-31", lts: false, security: false }, { name: "nodejs", version: "9.1.0", date: "2017-11-07", lts: false, security: false }, { name: "nodejs", version: "9.2.0", date: "2017-11-14", lts: false, security: false }, { name: "nodejs", version: "9.3.0", date: "2017-12-12", lts: false, security: false }, { name: "nodejs", version: "9.4.0", date: "2018-01-10", lts: false, security: false }, { name: "nodejs", version: "9.5.0", date: "2018-01-31", lts: false, security: false }, { name: "nodejs", version: "9.6.0", date: "2018-02-21", lts: false, security: false }, { name: "nodejs", version: "9.7.0", date: "2018-03-01", lts: false, security: false }, { name: "nodejs", version: "9.8.0", date: "2018-03-07", lts: false, security: false }, { name: "nodejs", version: "9.9.0", date: "2018-03-21", lts: false, security: false }, { name: "nodejs", version: "9.10.0", date: "2018-03-28", lts: false, security: true }, { name: "nodejs", version: "9.11.0", date: "2018-04-04", lts: false, security: false }, { name: "nodejs", version: "10.0.0", date: "2018-04-24", lts: false, security: false }, { name: "nodejs", version: "10.1.0", date: "2018-05-08", lts: false, security: false }, { name: "nodejs", version: "10.2.0", date: "2018-05-23", lts: false, security: false }, { name: "nodejs", version: "10.3.0", date: "2018-05-29", lts: false, security: false }, { name: "nodejs", version: "10.4.0", date: "2018-06-06", lts: false, security: false }, { name: "nodejs", version: "10.5.0", date: "2018-06-20", lts: false, security: false }, { name: "nodejs", version: "10.6.0", date: "2018-07-04", lts: false, security: false }, { name: "nodejs", version: "10.7.0", date: "2018-07-18", lts: false, security: false }, { name: "nodejs", version: "10.8.0", date: "2018-08-01", lts: false, security: false }, { name: "nodejs", version: "10.9.0", date: "2018-08-15", lts: false, security: false }, { name: "nodejs", version: "10.10.0", date: "2018-09-06", lts: false, security: false }, { name: "nodejs", version: "10.11.0", date: "2018-09-19", lts: false, security: false }, { name: "nodejs", version: "10.12.0", date: "2018-10-10", lts: false, security: false }, { name: "nodejs", version: "10.13.0", date: "2018-10-30", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.14.0", date: "2018-11-27", lts: "Dubnium", security: true }, { name: "nodejs", version: "10.15.0", date: "2018-12-26", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.16.0", date: "2019-05-28", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.17.0", date: "2019-10-22", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.18.0", date: "2019-12-17", lts: "Dubnium", security: true }, { name: "nodejs", version: "10.19.0", date: "2020-02-05", lts: "Dubnium", security: true }, { name: "nodejs", version: "10.20.0", date: "2020-03-26", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.21.0", date: "2020-06-02", lts: "Dubnium", security: true }, { name: "nodejs", version: "10.22.0", date: "2020-07-21", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.23.0", date: "2020-10-27", lts: "Dubnium", security: false }, { name: "nodejs", version: "10.24.0", date: "2021-02-23", lts: "Dubnium", security: true }, { name: "nodejs", version: "11.0.0", date: "2018-10-23", lts: false, security: false }, { name: "nodejs", version: "11.1.0", date: "2018-10-30", lts: false, security: false }, { name: "nodejs", version: "11.2.0", date: "2018-11-15", lts: false, security: false }, { name: "nodejs", version: "11.3.0", date: "2018-11-27", lts: false, security: true }, { name: "nodejs", version: "11.4.0", date: "2018-12-07", lts: false, security: false }, { name: "nodejs", version: "11.5.0", date: "2018-12-18", lts: false, security: false }, { name: "nodejs", version: "11.6.0", date: "2018-12-26", lts: false, security: false }, { name: "nodejs", version: "11.7.0", date: "2019-01-17", lts: false, security: false }, { name: "nodejs", version: "11.8.0", date: "2019-01-24", lts: false, security: false }, { name: "nodejs", version: "11.9.0", date: "2019-01-30", lts: false, security: false }, { name: "nodejs", version: "11.10.0", date: "2019-02-14", lts: false, security: false }, { name: "nodejs", version: "11.11.0", date: "2019-03-05", lts: false, security: false }, { name: "nodejs", version: "11.12.0", date: "2019-03-14", lts: false, security: false }, { name: "nodejs", version: "11.13.0", date: "2019-03-28", lts: false, security: false }, { name: "nodejs", version: "11.14.0", date: "2019-04-10", lts: false, security: false }, { name: "nodejs", version: "11.15.0", date: "2019-04-30", lts: false, security: false }, { name: "nodejs", version: "12.0.0", date: "2019-04-23", lts: false, security: false }, { name: "nodejs", version: "12.1.0", date: "2019-04-29", lts: false, security: false }, { name: "nodejs", version: "12.2.0", date: "2019-05-07", lts: false, security: false }, { name: "nodejs", version: "12.3.0", date: "2019-05-21", lts: false, security: false }, { name: "nodejs", version: "12.4.0", date: "2019-06-04", lts: false, security: false }, { name: "nodejs", version: "12.5.0", date: "2019-06-26", lts: false, security: false }, { name: "nodejs", version: "12.6.0", date: "2019-07-03", lts: false, security: false }, { name: "nodejs", version: "12.7.0", date: "2019-07-23", lts: false, security: false }, { name: "nodejs", version: "12.8.0", date: "2019-08-06", lts: false, security: false }, { name: "nodejs", version: "12.9.0", date: "2019-08-20", lts: false, security: false }, { name: "nodejs", version: "12.10.0", date: "2019-09-04", lts: false, security: false }, { name: "nodejs", version: "12.11.0", date: "2019-09-25", lts: false, security: false }, { name: "nodejs", version: "12.12.0", date: "2019-10-11", lts: false, security: false }, { name: "nodejs", version: "12.13.0", date: "2019-10-21", lts: "Erbium", security: false }, { name: "nodejs", version: "12.14.0", date: "2019-12-17", lts: "Erbium", security: true }, { name: "nodejs", version: "12.15.0", date: "2020-02-05", lts: "Erbium", security: true }, { name: "nodejs", version: "12.16.0", date: "2020-02-11", lts: "Erbium", security: false }, { name: "nodejs", version: "12.17.0", date: "2020-05-26", lts: "Erbium", security: false }, { name: "nodejs", version: "12.18.0", date: "2020-06-02", lts: "Erbium", security: true }, { name: "nodejs", version: "12.19.0", date: "2020-10-06", lts: "Erbium", security: false }, { name: "nodejs", version: "12.20.0", date: "2020-11-24", lts: "Erbium", security: false }, { name: "nodejs", version: "12.21.0", date: "2021-02-23", lts: "Erbium", security: true }, { name: "nodejs", version: "12.22.0", date: "2021-03-30", lts: "Erbium", security: false }, { name: "nodejs", version: "13.0.0", date: "2019-10-22", lts: false, security: false }, { name: "nodejs", version: "13.1.0", date: "2019-11-05", lts: false, security: false }, { name: "nodejs", version: "13.2.0", date: "2019-11-21", lts: false, security: false }, { name: "nodejs", version: "13.3.0", date: "2019-12-03", lts: false, security: false }, { name: "nodejs", version: "13.4.0", date: "2019-12-17", lts: false, security: true }, { name: "nodejs", version: "13.5.0", date: "2019-12-18", lts: false, security: false }, { name: "nodejs", version: "13.6.0", date: "2020-01-07", lts: false, security: false }, { name: "nodejs", version: "13.7.0", date: "2020-01-21", lts: false, security: false }, { name: "nodejs", version: "13.8.0", date: "2020-02-05", lts: false, security: true }, { name: "nodejs", version: "13.9.0", date: "2020-02-18", lts: false, security: false }, { name: "nodejs", version: "13.10.0", date: "2020-03-04", lts: false, security: false }, { name: "nodejs", version: "13.11.0", date: "2020-03-12", lts: false, security: false }, { name: "nodejs", version: "13.12.0", date: "2020-03-26", lts: false, security: false }, { name: "nodejs", version: "13.13.0", date: "2020-04-14", lts: false, security: false }, { name: "nodejs", version: "13.14.0", date: "2020-04-29", lts: false, security: false }, { name: "nodejs", version: "14.0.0", date: "2020-04-21", lts: false, security: false }, { name: "nodejs", version: "14.1.0", date: "2020-04-29", lts: false, security: false }, { name: "nodejs", version: "14.2.0", date: "2020-05-05", lts: false, security: false }, { name: "nodejs", version: "14.3.0", date: "2020-05-19", lts: false, security: false }, { name: "nodejs", version: "14.4.0", date: "2020-06-02", lts: false, security: true }, { name: "nodejs", version: "14.5.0", date: "2020-06-30", lts: false, security: false }, { name: "nodejs", version: "14.6.0", date: "2020-07-20", lts: false, security: false }, { name: "nodejs", version: "14.7.0", date: "2020-07-29", lts: false, security: false }, { name: "nodejs", version: "14.8.0", date: "2020-08-11", lts: false, security: false }, { name: "nodejs", version: "14.9.0", date: "2020-08-27", lts: false, security: false }, { name: "nodejs", version: "14.10.0", date: "2020-09-08", lts: false, security: false }, { name: "nodejs", version: "14.11.0", date: "2020-09-15", lts: false, security: true }, { name: "nodejs", version: "14.12.0", date: "2020-09-22", lts: false, security: false }, { name: "nodejs", version: "14.13.0", date: "2020-09-29", lts: false, security: false }, { name: "nodejs", version: "14.14.0", date: "2020-10-15", lts: false, security: false }, { name: "nodejs", version: "14.15.0", date: "2020-10-27", lts: "Fermium", security: false }, { name: "nodejs", version: "14.16.0", date: "2021-02-23", lts: "Fermium", security: true }, { name: "nodejs", version: "14.17.0", date: "2021-05-11", lts: "Fermium", security: false }, { name: "nodejs", version: "14.18.0", date: "2021-09-28", lts: "Fermium", security: false }, { name: "nodejs", version: "14.19.0", date: "2022-02-01", lts: "Fermium", security: false }, { name: "nodejs", version: "15.0.0", date: "2020-10-20", lts: false, security: false }, { name: "nodejs", version: "15.1.0", date: "2020-11-04", lts: false, security: false }, { name: "nodejs", version: "15.2.0", date: "2020-11-10", lts: false, security: false }, { name: "nodejs", version: "15.3.0", date: "2020-11-24", lts: false, security: false }, { name: "nodejs", version: "15.4.0", date: "2020-12-09", lts: false, security: false }, { name: "nodejs", version: "15.5.0", date: "2020-12-22", lts: false, security: false }, { name: "nodejs", version: "15.6.0", date: "2021-01-14", lts: false, security: false }, { name: "nodejs", version: "15.7.0", date: "2021-01-25", lts: false, security: false }, { name: "nodejs", version: "15.8.0", date: "2021-02-02", lts: false, security: false }, { name: "nodejs", version: "15.9.0", date: "2021-02-18", lts: false, security: false }, { name: "nodejs", version: "15.10.0", date: "2021-02-23", lts: false, security: true }, { name: "nodejs", version: "15.11.0", date: "2021-03-03", lts: false, security: false }, { name: "nodejs", version: "15.12.0", date: "2021-03-17", lts: false, security: false }, { name: "nodejs", version: "15.13.0", date: "2021-03-31", lts: false, security: false }, { name: "nodejs", version: "15.14.0", date: "2021-04-06", lts: false, security: false }, { name: "nodejs", version: "16.0.0", date: "2021-04-20", lts: false, security: false }, { name: "nodejs", version: "16.1.0", date: "2021-05-04", lts: false, security: false }, { name: "nodejs", version: "16.2.0", date: "2021-05-19", lts: false, security: false }, { name: "nodejs", version: "16.3.0", date: "2021-06-03", lts: false, security: false }, { name: "nodejs", version: "16.4.0", date: "2021-06-23", lts: false, security: false }, { name: "nodejs", version: "16.5.0", date: "2021-07-14", lts: false, security: false }, { name: "nodejs", version: "16.6.0", date: "2021-07-29", lts: false, security: true }, { name: "nodejs", version: "16.7.0", date: "2021-08-18", lts: false, security: false }, { name: "nodejs", version: "16.8.0", date: "2021-08-25", lts: false, security: false }, { name: "nodejs", version: "16.9.0", date: "2021-09-07", lts: false, security: false }, { name: "nodejs", version: "16.10.0", date: "2021-09-22", lts: false, security: false }, { name: "nodejs", version: "16.11.0", date: "2021-10-08", lts: false, security: false }, { name: "nodejs", version: "16.12.0", date: "2021-10-20", lts: false, security: false }, { name: "nodejs", version: "16.13.0", date: "2021-10-26", lts: "Gallium", security: false }, { name: "nodejs", version: "16.14.0", date: "2022-02-08", lts: "Gallium", security: false }, { name: "nodejs", version: "16.15.0", date: "2022-04-26", lts: "Gallium", security: false }, { name: "nodejs", version: "17.0.0", date: "2021-10-19", lts: false, security: false }, { name: "nodejs", version: "17.1.0", date: "2021-11-09", lts: false, security: false }, { name: "nodejs", version: "17.2.0", date: "2021-11-30", lts: false, security: false }, { name: "nodejs", version: "17.3.0", date: "2021-12-17", lts: false, security: false }, { name: "nodejs", version: "17.4.0", date: "2022-01-18", lts: false, security: false }, { name: "nodejs", version: "17.5.0", date: "2022-02-10", lts: false, security: false }, { name: "nodejs", version: "17.6.0", date: "2022-02-22", lts: false, security: false }, { name: "nodejs", version: "17.7.0", date: "2022-03-09", lts: false, security: false }, { name: "nodejs", version: "17.8.0", date: "2022-03-22", lts: false, security: false }, { name: "nodejs", version: "17.9.0", date: "2022-04-07", lts: false, security: false }, { name: "nodejs", version: "18.0.0", date: "2022-04-18", lts: false, security: false }];
  }
});

// node_modules/caniuse-lite/data/browsers.js
var require_browsers = __commonJS({
  "node_modules/caniuse-lite/data/browsers.js"(exports2, module2) {
    module2.exports = { A: "ie", B: "edge", C: "firefox", D: "chrome", E: "safari", F: "opera", G: "ios_saf", H: "op_mini", I: "android", J: "bb", K: "op_mob", L: "and_chr", M: "and_ff", N: "ie_mob", O: "and_uc", P: "samsung", Q: "and_qq", R: "baidu", S: "kaios" };
  }
});

// node_modules/caniuse-lite/dist/unpacker/browsers.js
var require_browsers2 = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/browsers.js"(exports2, module2) {
    module2.exports.browsers = require_browsers();
  }
});

// node_modules/caniuse-lite/data/browserVersions.js
var require_browserVersions = __commonJS({
  "node_modules/caniuse-lite/data/browserVersions.js"(exports2, module2) {
    module2.exports = { "0": "33", "1": "34", "2": "35", "3": "36", "4": "37", "5": "38", "6": "39", "7": "40", "8": "41", "9": "42", A: "10", B: "11", C: "12", D: "7", E: "8", F: "9", G: "15", H: "101", I: "4", J: "6", K: "13", L: "14", M: "16", N: "17", O: "18", P: "79", Q: "80", R: "81", S: "83", T: "84", U: "85", V: "86", W: "87", X: "100", Y: "64", Z: "88", a: "89", b: "90", c: "91", d: "92", e: "93", f: "94", g: "95", h: "96", i: "97", j: "98", k: "99", l: "5", m: "19", n: "20", o: "21", p: "22", q: "23", r: "24", s: "25", t: "26", u: "27", v: "28", w: "29", x: "30", y: "31", z: "32", AB: "43", BB: "44", CB: "45", DB: "46", EB: "47", FB: "48", GB: "49", HB: "50", IB: "51", JB: "52", KB: "53", LB: "54", MB: "55", NB: "56", OB: "57", PB: "58", QB: "60", RB: "62", SB: "63", TB: "65", UB: "66", VB: "67", WB: "68", XB: "69", YB: "70", ZB: "71", aB: "72", bB: "73", cB: "74", dB: "75", eB: "76", fB: "77", gB: "78", hB: "11.1", iB: "12.1", jB: "3", kB: "59", lB: "61", mB: "82", nB: "102", oB: "3.2", pB: "10.1", qB: "15.2-15.3", rB: "15.4", sB: "11.5", tB: "4.2-4.3", uB: "5.5", vB: "2", wB: "3.5", xB: "3.6", yB: "103", zB: "104", "0B": "3.1", "1B": "5.1", "2B": "6.1", "3B": "7.1", "4B": "9.1", "5B": "13.1", "6B": "14.1", "7B": "15.1", "8B": "TP", "9B": "9.5-9.6", AC: "10.0-10.1", BC: "10.5", CC: "10.6", DC: "11.6", EC: "4.0-4.1", FC: "5.0-5.1", GC: "6.0-6.1", HC: "7.0-7.1", IC: "8.1-8.4", JC: "9.0-9.2", KC: "9.3", LC: "10.0-10.2", MC: "10.3", NC: "11.0-11.2", OC: "11.3-11.4", PC: "12.0-12.1", QC: "12.2-12.5", RC: "13.0-13.1", SC: "13.2", TC: "13.3", UC: "13.4-13.7", VC: "14.0-14.4", WC: "14.5-14.8", XC: "15.0-15.1", YC: "all", ZC: "2.1", aC: "2.2", bC: "2.3", cC: "4.1", dC: "4.4", eC: "4.4.3-4.4.4", fC: "12.12", gC: "5.0-5.4", hC: "6.2-6.4", iC: "7.2-7.4", jC: "8.2", kC: "9.2", lC: "11.1-11.2", mC: "12.0", nC: "13.0", oC: "14.0", pC: "15.0", qC: "16.0", rC: "10.4", sC: "7.12", tC: "2.5" };
  }
});

// node_modules/caniuse-lite/dist/unpacker/browserVersions.js
var require_browserVersions2 = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/browserVersions.js"(exports2, module2) {
    module2.exports.browserVersions = require_browserVersions();
  }
});

// node_modules/caniuse-lite/data/agents.js
var require_agents = __commonJS({
  "node_modules/caniuse-lite/data/agents.js"(exports2, module2) {
    module2.exports = { A: { A: { J: 0.0131217, D: 621152e-8, E: 0.0426387, F: 0.063958, A: 0.0142129, B: 0.568515, uB: 9298e-6 }, B: "ms", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "uB", "J", "D", "E", "F", "A", "B", "", "", ""], E: "IE", F: { uB: 962323200, J: 998870400, D: 1161129600, E: 1237420800, F: 1300060800, A: 1346716800, B: 1381968e3 } }, B: { A: { C: 3939e-6, K: 4267e-6, L: 4268e-6, G: 0.070902, M: 0.027573, N: 7878e-6, O: 0.027573, P: 0, Q: 4298e-6, R: 944e-5, S: 4043e-6, T: 7878e-6, U: 3939e-6, V: 3939e-6, W: 7878e-6, Z: 4318e-6, a: 3939e-6, b: 4118e-6, c: 3939e-6, d: 0.011817, e: 4118e-6, f: 3939e-6, g: 7878e-6, h: 0.015756, i: 0.047268, j: 0.03939, k: 0.523887, X: 3.21422, H: 0.051207 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "C", "K", "L", "G", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "X", "H", "", "", ""], E: "Edge", F: { C: 1438128e3, K: 1447286400, L: 1470096e3, G: 1491868800, M: 1508198400, N: 1525046400, O: 1542067200, P: 1579046400, Q: 1581033600, R: 1586736e3, S: 1590019200, T: 1594857600, U: 1598486400, V: 1602201600, W: 1605830400, Z: 161136e4, a: 1614816e3, b: 1618358400, c: 1622073600, d: 1626912e3, e: 1630627200, f: 1632441600, g: 1634774400, h: 1637539200, i: 1641427200, j: 1643932800, k: 1646265600, X: 1649635200, H: 1651190400 }, D: { C: "ms", K: "ms", L: "ms", G: "ms", M: "ms", N: "ms", O: "ms" } }, C: { A: { "0": 9284e-6, "1": 4707e-6, "2": 9076e-6, "3": 7878e-6, "4": 4783e-6, "5": 4271e-6, "6": 4783e-6, "7": 487e-5, "8": 5029e-6, "9": 47e-4, vB: 4118e-6, jB: 4271e-6, I: 0.019695, l: 4879e-6, J: 0.020136, D: 5725e-6, E: 4525e-6, F: 533e-5, A: 4283e-6, B: 3939e-6, C: 4471e-6, K: 4486e-6, L: 453e-5, G: 8322e-6, M: 4417e-6, N: 4425e-6, O: 4161e-6, m: 4443e-6, n: 4283e-6, o: 8322e-6, p: 0.013698, q: 4161e-6, r: 8786e-6, s: 4118e-6, t: 4317e-6, u: 4393e-6, v: 4418e-6, w: 8834e-6, x: 8322e-6, y: 8928e-6, z: 4471e-6, AB: 0.043329, BB: 7878e-6, CB: 4356e-6, DB: 4525e-6, EB: 4293e-6, FB: 3939e-6, GB: 4538e-6, HB: 8282e-6, IB: 0.023634, JB: 0.082719, KB: 0.019695, LB: 0.011817, MB: 0.023634, NB: 0.019695, OB: 0.015756, PB: 3939e-6, kB: 7878e-6, QB: 7878e-6, lB: 4356e-6, RB: 4425e-6, SB: 8322e-6, Y: 415e-5, TB: 4267e-6, UB: 3939e-6, VB: 4267e-6, WB: 7878e-6, XB: 415e-5, YB: 4293e-6, ZB: 4425e-6, aB: 3939e-6, bB: 415e-5, cB: 415e-5, dB: 4318e-6, eB: 4356e-6, fB: 3939e-6, gB: 0.047268, P: 7878e-6, Q: 7878e-6, R: 0.015756, mB: 3939e-6, S: 3939e-6, T: 7878e-6, U: 4268e-6, V: 3939e-6, W: 7878e-6, Z: 0.011817, a: 0.011817, b: 7878e-6, c: 0.098475, d: 3939e-6, e: 0.011817, f: 0.047268, g: 0.015756, h: 0.023634, i: 0.031512, j: 0.598728, k: 1.68983, X: 0.019695, H: 0, nB: 0, wB: 8786e-6, xB: 487e-5 }, B: "moz", C: ["vB", "jB", "wB", "xB", "I", "l", "J", "D", "E", "F", "A", "B", "C", "K", "L", "G", "M", "N", "O", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "AB", "BB", "CB", "DB", "EB", "FB", "GB", "HB", "IB", "JB", "KB", "LB", "MB", "NB", "OB", "PB", "kB", "QB", "lB", "RB", "SB", "Y", "TB", "UB", "VB", "WB", "XB", "YB", "ZB", "aB", "bB", "cB", "dB", "eB", "fB", "gB", "P", "Q", "R", "mB", "S", "T", "U", "V", "W", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "X", "H", "nB", ""], E: "Firefox", F: { "0": 1413244800, "1": 1417392e3, "2": 1421107200, "3": 1424736e3, "4": 1428278400, "5": 1431475200, "6": 1435881600, "7": 1439251200, "8": 144288e4, "9": 1446508800, vB: 1161648e3, jB: 1213660800, wB: 124632e4, xB: 1264032e3, I: 1300752e3, l: 1308614400, J: 1313452800, D: 1317081600, E: 1317081600, F: 1320710400, A: 1324339200, B: 1327968e3, C: 1331596800, K: 1335225600, L: 1338854400, G: 1342483200, M: 1346112e3, N: 1349740800, O: 1353628800, m: 1357603200, n: 1361232e3, o: 1364860800, p: 1368489600, q: 1372118400, r: 1375747200, s: 1379376e3, t: 1386633600, u: 1391472e3, v: 1395100800, w: 1398729600, x: 1402358400, y: 1405987200, z: 1409616e3, AB: 1450137600, BB: 1453852800, CB: 1457395200, DB: 1461628800, EB: 1465257600, FB: 1470096e3, GB: 1474329600, HB: 1479168e3, IB: 1485216e3, JB: 1488844800, KB: 149256e4, LB: 1497312e3, MB: 1502150400, NB: 1506556800, OB: 1510617600, PB: 1516665600, kB: 1520985600, QB: 1525824e3, lB: 1529971200, RB: 1536105600, SB: 1540252800, Y: 1544486400, TB: 154872e4, UB: 1552953600, VB: 1558396800, WB: 1562630400, XB: 1567468800, YB: 1571788800, ZB: 1575331200, aB: 1578355200, bB: 1581379200, cB: 1583798400, dB: 1586304e3, eB: 1588636800, fB: 1591056e3, gB: 1593475200, P: 1595894400, Q: 1598313600, R: 1600732800, mB: 1603152e3, S: 1605571200, T: 1607990400, U: 1611619200, V: 1614038400, W: 1616457600, Z: 1618790400, a: 1622505600, b: 1626134400, c: 1628553600, d: 1630972800, e: 1633392e3, f: 1635811200, g: 1638835200, h: 1641859200, i: 1644364800, j: 1646697600, k: 1649116800, X: 1651536e3, H: null, nB: null } }, D: { A: { "0": 4118e-6, "1": 7878e-6, "2": 7878e-6, "3": 4335e-6, "4": 4464e-6, "5": 0.019695, "6": 7878e-6, "7": 0.019695, "8": 7878e-6, "9": 7878e-6, I: 4706e-6, l: 4879e-6, J: 4879e-6, D: 5591e-6, E: 5591e-6, F: 5591e-6, A: 4534e-6, B: 4464e-6, C: 0.010424, K: 83e-4, L: 4706e-6, G: 0.015087, M: 4393e-6, N: 4393e-6, O: 8652e-6, m: 8322e-6, n: 4393e-6, o: 4317e-6, p: 3939e-6, q: 8786e-6, r: 3939e-6, s: 4461e-6, t: 4141e-6, u: 4326e-6, v: 47e-4, w: 4538e-6, x: 8322e-6, y: 8596e-6, z: 4566e-6, AB: 0.011817, BB: 7878e-6, CB: 7878e-6, DB: 7878e-6, EB: 0.015756, FB: 0.027573, GB: 0.070902, HB: 7878e-6, IB: 0.011817, JB: 7878e-6, KB: 0.015756, LB: 7878e-6, MB: 0.011817, NB: 0.043329, OB: 0.011817, PB: 0.011817, kB: 0.011817, QB: 0.019695, lB: 0.015756, RB: 0.015756, SB: 0.015756, Y: 0.011817, TB: 0.019695, UB: 0.027573, VB: 0.015756, WB: 7878e-6, XB: 0.059085, YB: 0.027573, ZB: 0.011817, aB: 0.03939, bB: 0.011817, cB: 0.023634, dB: 0.063024, eB: 0.07878, fB: 0.015756, gB: 0.03939, P: 0.216645, Q: 0.059085, R: 0.043329, S: 0.126048, T: 0.066963, U: 0.074841, V: 0.074841, W: 0.102414, Z: 0.027573, a: 0.055146, b: 0.03939, c: 0.090597, d: 0.07878, e: 0.070902, f: 0.098475, g: 0.063024, h: 0.212706, i: 0.216645, j: 0.417534, k: 4.03354, X: 17.2016, H: 0.259974, nB: 0.015756, yB: 7878e-6, zB: 0 }, B: "webkit", C: ["", "", "", "", "I", "l", "J", "D", "E", "F", "A", "B", "C", "K", "L", "G", "M", "N", "O", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "AB", "BB", "CB", "DB", "EB", "FB", "GB", "HB", "IB", "JB", "KB", "LB", "MB", "NB", "OB", "PB", "kB", "QB", "lB", "RB", "SB", "Y", "TB", "UB", "VB", "WB", "XB", "YB", "ZB", "aB", "bB", "cB", "dB", "eB", "fB", "gB", "P", "Q", "R", "S", "T", "U", "V", "W", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "X", "H", "nB", "yB", "zB"], E: "Chrome", F: { "0": 1392940800, "1": 1397001600, "2": 1400544e3, "3": 1405468800, "4": 1409011200, "5": 141264e4, "6": 1416268800, "7": 1421798400, "8": 1425513600, "9": 1429401600, I: 1264377600, l: 1274745600, J: 1283385600, D: 1287619200, E: 1291248e3, F: 1296777600, A: 1299542400, B: 1303862400, C: 1307404800, K: 1312243200, L: 1316131200, G: 1316131200, M: 1319500800, N: 1323734400, O: 1328659200, m: 1332892800, n: 133704e4, o: 1340668800, p: 1343692800, q: 1348531200, r: 1352246400, s: 1357862400, t: 1361404800, u: 1364428800, v: 1369094400, w: 1374105600, x: 1376956800, y: 1384214400, z: 1389657600, AB: 143208e4, BB: 1437523200, CB: 1441152e3, DB: 1444780800, EB: 1449014400, FB: 1453248e3, GB: 1456963200, HB: 1460592e3, IB: 1464134400, JB: 1469059200, KB: 1472601600, LB: 1476230400, MB: 1480550400, NB: 1485302400, OB: 1489017600, PB: 149256e4, kB: 1496707200, QB: 1500940800, lB: 1504569600, RB: 1508198400, SB: 1512518400, Y: 1516752e3, TB: 1520294400, UB: 1523923200, VB: 1527552e3, WB: 1532390400, XB: 1536019200, YB: 1539648e3, ZB: 1543968e3, aB: 154872e4, bB: 1552348800, cB: 1555977600, dB: 1559606400, eB: 1564444800, fB: 1568073600, gB: 1571702400, P: 1575936e3, Q: 1580860800, R: 1586304e3, S: 1589846400, T: 1594684800, U: 1598313600, V: 1601942400, W: 1605571200, Z: 1611014400, a: 1614556800, b: 1618272e3, c: 1621987200, d: 1626739200, e: 1630368e3, f: 1632268800, g: 1634601600, h: 1637020800, i: 1641340800, j: 1643673600, k: 1646092800, X: 1648512e3, H: 1650931200, nB: null, yB: null, zB: null } }, E: { A: { I: 0, l: 8322e-6, J: 4656e-6, D: 4465e-6, E: 4356e-6, F: 4891e-6, A: 4425e-6, B: 4318e-6, C: 3939e-6, K: 0.03939, L: 0.181194, G: 0.074841, "0B": 0, oB: 8692e-6, "1B": 7878e-6, "2B": 456e-5, "3B": 4283e-6, "4B": 0.015756, pB: 0.011817, hB: 0.027573, iB: 0.055146, "5B": 0.401778, "6B": 0.59085, "7B": 0.145743, qB: 0.165438, rB: 1.01232, "8B": 0 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "0B", "oB", "I", "l", "1B", "J", "2B", "D", "3B", "E", "F", "4B", "A", "pB", "B", "hB", "C", "iB", "K", "5B", "L", "6B", "G", "7B", "qB", "rB", "8B", "", ""], E: "Safari", F: { "0B": 1205798400, oB: 1226534400, I: 1244419200, l: 1275868800, "1B": 131112e4, J: 1343174400, "2B": 13824e5, D: 13824e5, "3B": 1410998400, E: 1413417600, F: 1443657600, "4B": 1458518400, A: 1474329600, pB: 1490572800, B: 1505779200, hB: 1522281600, C: 1537142400, iB: 1553472e3, K: 1568851200, "5B": 1585008e3, L: 1600214400, "6B": 1619395200, G: 1632096e3, "7B": 1635292800, qB: 1639353600, rB: 1647216e3, "8B": null } }, F: { A: { "0": 5014e-6, "1": 9758e-6, "2": 4879e-6, "3": 7878e-6, "4": 4283e-6, "5": 4367e-6, "6": 4534e-6, "7": 7878e-6, "8": 4227e-6, "9": 4418e-6, F: 82e-4, B: 0.016581, C: 4317e-6, G: 685e-5, M: 685e-5, N: 685e-5, O: 5014e-6, m: 6015e-6, n: 4879e-6, o: 6597e-6, p: 6597e-6, q: 0.013434, r: 6702e-6, s: 6015e-6, t: 5595e-6, u: 4393e-6, v: 3939e-6, w: 4879e-6, x: 4879e-6, y: 3939e-6, z: 5152e-6, AB: 4161e-6, BB: 4227e-6, CB: 4725e-6, DB: 0.011817, EB: 8942e-6, FB: 4707e-6, GB: 4827e-6, HB: 4707e-6, IB: 4707e-6, JB: 4326e-6, KB: 8922e-6, LB: 0.014349, MB: 4425e-6, NB: 472e-5, OB: 4425e-6, PB: 4425e-6, QB: 472e-5, RB: 4532e-6, SB: 4566e-6, Y: 0.02283, TB: 867e-5, UB: 4656e-6, VB: 4642e-6, WB: 3939e-6, XB: 944e-5, YB: 4293e-6, ZB: 4293e-6, aB: 4298e-6, bB: 0.096692, cB: 4201e-6, dB: 4141e-6, eB: 4257e-6, fB: 3939e-6, gB: 8236e-6, P: 3939e-6, Q: 3939e-6, R: 8514e-6, mB: 3939e-6, S: 3939e-6, T: 0.169377, U: 0.634179, V: 0.011817, W: 0, "9B": 685e-5, AC: 0, BC: 8392e-6, CC: 4706e-6, hB: 6229e-6, sB: 4879e-6, DC: 8786e-6, iB: 472e-5 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "F", "9B", "AC", "BC", "CC", "B", "hB", "sB", "DC", "C", "iB", "G", "M", "N", "O", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "AB", "BB", "CB", "DB", "EB", "FB", "GB", "HB", "IB", "JB", "KB", "LB", "MB", "NB", "OB", "PB", "QB", "RB", "SB", "Y", "TB", "UB", "VB", "WB", "XB", "YB", "ZB", "aB", "bB", "cB", "dB", "eB", "fB", "gB", "P", "Q", "R", "mB", "S", "T", "U", "V", "W", "", ""], E: "Opera", F: { "0": 1445904e3, "1": 1449100800, "2": 1454371200, "3": 1457308800, "4": 146232e4, "5": 1465344e3, "6": 1470096e3, "7": 1474329600, "8": 1477267200, "9": 1481587200, F: 1150761600, "9B": 1223424e3, AC: 1251763200, BC: 1267488e3, CC: 1277942400, B: 1292457600, hB: 1302566400, sB: 1309219200, DC: 1323129600, C: 1323129600, iB: 1352073600, G: 1372723200, M: 1377561600, N: 1381104e3, O: 1386288e3, m: 1390867200, n: 1393891200, o: 1399334400, p: 1401753600, q: 1405987200, r: 1409616e3, s: 1413331200, t: 1417132800, u: 1422316800, v: 1425945600, w: 1430179200, x: 1433808e3, y: 1438646400, z: 1442448e3, AB: 1486425600, BB: 1490054400, CB: 1494374400, DB: 1498003200, EB: 1502236800, FB: 1506470400, GB: 1510099200, HB: 1515024e3, IB: 1517961600, JB: 1521676800, KB: 1525910400, LB: 1530144e3, MB: 1534982400, NB: 1537833600, OB: 1543363200, PB: 1548201600, QB: 1554768e3, RB: 1561593600, SB: 1566259200, Y: 1570406400, TB: 1573689600, UB: 1578441600, VB: 1583971200, WB: 1587513600, XB: 1592956800, YB: 1595894400, ZB: 1600128e3, aB: 1603238400, bB: 161352e4, cB: 1612224e3, dB: 1616544e3, eB: 1619568e3, fB: 1623715200, gB: 1627948800, P: 1631577600, Q: 1633392e3, R: 1635984e3, mB: 1638403200, S: 1642550400, T: 1644969600, U: 1647993600, V: 1650412800, W: null }, D: { F: "o", B: "o", C: "o", "9B": "o", AC: "o", BC: "o", CC: "o", hB: "o", sB: "o", DC: "o", iB: "o" } }, G: { A: { E: 0, oB: 0, EC: 0, tB: 300959e-8, FC: 451439e-8, GC: 0.0270863, HC: 0.0165528, IC: 752398e-8, JC: 0.0225719, KC: 0.0842686, LC: 0.0210671, MC: 0.103831, NC: 0.0511631, OC: 0.0346103, PC: 0.0331055, QC: 0.577842, RC: 0.0300959, SC: 0.0135432, TC: 0.0677158, UC: 0.212176, VC: 0.651577, WC: 1.82381, XC: 0.732836, qB: 5.15092, rB: 5.37964 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "oB", "EC", "tB", "FC", "GC", "HC", "E", "IC", "JC", "KC", "LC", "MC", "NC", "OC", "PC", "QC", "RC", "SC", "TC", "UC", "VC", "WC", "XC", "qB", "rB", "", "", ""], E: "Safari on iOS", F: { oB: 1270252800, EC: 1283904e3, tB: 1299628800, FC: 1331078400, GC: 1359331200, HC: 1394409600, E: 1410912e3, IC: 1413763200, JC: 1442361600, KC: 1458518400, LC: 1473724800, MC: 1490572800, NC: 1505779200, OC: 1522281600, PC: 1537142400, QC: 1553472e3, RC: 1568851200, SC: 1572220800, TC: 1580169600, UC: 1585008e3, VC: 1600214400, WC: 1619395200, XC: 1632096e3, qB: 1639353600, rB: 1647216e3 } }, H: { A: { YC: 1.07877 }, B: "o", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "YC", "", "", ""], E: "Opera Mini", F: { YC: 1426464e3 } }, I: { A: { jB: 0, I: 0.0207421, H: 0, ZC: 0, aC: 0, bC: 0, cC: 0.0207421, tB: 0.0725973, dC: 0, eC: 0.352616 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "ZC", "aC", "bC", "jB", "I", "cC", "tB", "dC", "eC", "H", "", "", ""], E: "Android Browser", F: { ZC: 1256515200, aC: 1274313600, bC: 1291593600, jB: 1298332800, I: 1318896e3, cC: 1341792e3, tB: 1374624e3, dC: 1386547200, eC: 1401667200, H: 1651017600 } }, J: { A: { D: 0, A: 0 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "D", "A", "", "", ""], E: "Blackberry Browser", F: { D: 1325376e3, A: 1359504e3 } }, K: { A: { A: 0, B: 0, C: 0, Y: 0.0111391, hB: 0, sB: 0, iB: 0 }, B: "o", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "A", "B", "hB", "sB", "C", "iB", "Y", "", "", ""], E: "Opera Mobile", F: { A: 1287100800, B: 1300752e3, hB: 1314835200, sB: 1318291200, C: 1330300800, iB: 1349740800, Y: 1613433600 }, D: { Y: "webkit" } }, L: { A: { H: 40.1569 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "H", "", "", ""], E: "Chrome for Android", F: { H: 1651017600 } }, M: { A: { X: 0.321233 }, B: "moz", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "X", "", "", ""], E: "Firefox for Android", F: { X: 1651536e3 } }, N: { A: { A: 0.0115934, B: 0.022664 }, B: "ms", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "A", "B", "", "", ""], E: "IE Mobile", F: { A: 1340150400, B: 1353456e3 } }, O: { A: { fC: 0.854601 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "fC", "", "", ""], E: "UC Browser for Android", F: { fC: 1471392e3 }, D: { fC: "webkit" } }, P: { A: { I: 0.219605, gC: 0.0103543, hC: 0.010304, iC: 0.0732015, jC: 0.0103584, kC: 0.0104574, pB: 0.0105043, lC: 0.0522868, mC: 0.0209147, nC: 0.0941162, oC: 0.125488, pC: 0.0836589, qC: 2.29016 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "I", "gC", "hC", "iC", "jC", "kC", "pB", "lC", "mC", "nC", "oC", "pC", "qC", "", "", ""], E: "Samsung Internet", F: { I: 1461024e3, gC: 1481846400, hC: 1509408e3, iC: 1528329600, jC: 1546128e3, kC: 1554163200, pB: 1567900800, lC: 1582588800, mC: 1593475200, nC: 1605657600, oC: 1618531200, pC: 1629072e3, qC: 1640736e3 } }, Q: { A: { rC: 0.169708 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "rC", "", "", ""], E: "QQ Browser", F: { rC: 1589846400 } }, R: { A: { sC: 0 }, B: "webkit", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "sC", "", "", ""], E: "Baidu Browser", F: { sC: 1491004800 } }, S: { A: { tC: 0.072732 }, B: "moz", C: ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "tC", "", "", ""], E: "KaiOS Browser", F: { tC: 1527811200 } } };
  }
});

// node_modules/caniuse-lite/dist/unpacker/agents.js
var require_agents2 = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/agents.js"(exports2, module2) {
    "use strict";
    var browsers = require_browsers2().browsers;
    var versions = require_browserVersions2().browserVersions;
    var agentsData = require_agents();
    function unpackBrowserVersions(versionsData) {
      return Object.keys(versionsData).reduce((usage, version) => {
        usage[versions[version]] = versionsData[version];
        return usage;
      }, {});
    }
    module2.exports.agents = Object.keys(agentsData).reduce((map, key) => {
      let versionsData = agentsData[key];
      map[browsers[key]] = Object.keys(versionsData).reduce((data, entry) => {
        if (entry === "A") {
          data.usage_global = unpackBrowserVersions(versionsData[entry]);
        } else if (entry === "C") {
          data.versions = versionsData[entry].reduce((list, version) => {
            if (version === "") {
              list.push(null);
            } else {
              list.push(versions[version]);
            }
            return list;
          }, []);
        } else if (entry === "D") {
          data.prefix_exceptions = unpackBrowserVersions(versionsData[entry]);
        } else if (entry === "E") {
          data.browser = versionsData[entry];
        } else if (entry === "F") {
          data.release_date = Object.keys(versionsData[entry]).reduce((map2, key2) => {
            map2[versions[key2]] = versionsData[entry][key2];
            return map2;
          }, {});
        } else {
          data.prefix = versionsData[entry];
        }
        return data;
      }, {});
      return map;
    }, {});
  }
});

// node_modules/node-releases/data/release-schedule/release-schedule.json
var require_release_schedule = __commonJS({
  "node_modules/node-releases/data/release-schedule/release-schedule.json"(exports2, module2) {
    module2.exports = { "v0.8": { start: "2012-06-25", end: "2014-07-31" }, "v0.10": { start: "2013-03-11", end: "2016-10-31" }, "v0.12": { start: "2015-02-06", end: "2016-12-31" }, v4: { start: "2015-09-08", lts: "2015-10-12", maintenance: "2017-04-01", end: "2018-04-30", codename: "Argon" }, v5: { start: "2015-10-29", maintenance: "2016-04-30", end: "2016-06-30" }, v6: { start: "2016-04-26", lts: "2016-10-18", maintenance: "2018-04-30", end: "2019-04-30", codename: "Boron" }, v7: { start: "2016-10-25", maintenance: "2017-04-30", end: "2017-06-30" }, v8: { start: "2017-05-30", lts: "2017-10-31", maintenance: "2019-01-01", end: "2019-12-31", codename: "Carbon" }, v9: { start: "2017-10-01", maintenance: "2018-04-01", end: "2018-06-30" }, v10: { start: "2018-04-24", lts: "2018-10-30", maintenance: "2020-05-19", end: "2021-04-30", codename: "Dubnium" }, v11: { start: "2018-10-23", maintenance: "2019-04-22", end: "2019-06-01" }, v12: { start: "2019-04-23", lts: "2019-10-21", maintenance: "2020-11-30", end: "2022-04-30", codename: "Erbium" }, v13: { start: "2019-10-22", maintenance: "2020-04-01", end: "2020-06-01" }, v14: { start: "2020-04-21", lts: "2020-10-27", maintenance: "2021-10-19", end: "2023-04-30", codename: "Fermium" }, v15: { start: "2020-10-20", maintenance: "2021-04-01", end: "2021-06-01" }, v16: { start: "2021-04-20", lts: "2021-10-26", maintenance: "2022-10-18", end: "2024-04-30", codename: "Gallium" }, v17: { start: "2021-10-19", maintenance: "2022-04-01", end: "2022-06-01" }, v18: { start: "2022-04-19", lts: "2022-10-25", maintenance: "2023-10-18", end: "2025-04-30", codename: "" }, v19: { start: "2022-10-18", maintenance: "2023-04-01", end: "2023-06-01" }, v20: { start: "2023-04-18", lts: "2023-10-24", maintenance: "2024-10-22", end: "2026-04-30", codename: "" } };
  }
});

// node_modules/electron-to-chromium/versions.js
var require_versions = __commonJS({
  "node_modules/electron-to-chromium/versions.js"(exports2, module2) {
    module2.exports = {
      "0.20": "39",
      "0.21": "41",
      "0.22": "41",
      "0.23": "41",
      "0.24": "41",
      "0.25": "42",
      "0.26": "42",
      "0.27": "43",
      "0.28": "43",
      "0.29": "43",
      "0.30": "44",
      "0.31": "45",
      "0.32": "45",
      "0.33": "45",
      "0.34": "45",
      "0.35": "45",
      "0.36": "47",
      "0.37": "49",
      "1.0": "49",
      "1.1": "50",
      "1.2": "51",
      "1.3": "52",
      "1.4": "53",
      "1.5": "54",
      "1.6": "56",
      "1.7": "58",
      "1.8": "59",
      "2.0": "61",
      "2.1": "61",
      "3.0": "66",
      "3.1": "66",
      "4.0": "69",
      "4.1": "69",
      "4.2": "69",
      "5.0": "73",
      "6.0": "76",
      "6.1": "76",
      "7.0": "78",
      "7.1": "78",
      "7.2": "78",
      "7.3": "78",
      "8.0": "80",
      "8.1": "80",
      "8.2": "80",
      "8.3": "80",
      "8.4": "80",
      "8.5": "80",
      "9.0": "83",
      "9.1": "83",
      "9.2": "83",
      "9.3": "83",
      "9.4": "83",
      "10.0": "85",
      "10.1": "85",
      "10.2": "85",
      "10.3": "85",
      "10.4": "85",
      "11.0": "87",
      "11.1": "87",
      "11.2": "87",
      "11.3": "87",
      "11.4": "87",
      "11.5": "87",
      "12.0": "89",
      "12.1": "89",
      "12.2": "89",
      "13.0": "91",
      "13.1": "91",
      "13.2": "91",
      "13.3": "91",
      "13.4": "91",
      "13.5": "91",
      "13.6": "91",
      "14.0": "93",
      "14.1": "93",
      "14.2": "93",
      "15.0": "94",
      "15.1": "94",
      "15.2": "94",
      "15.3": "94",
      "15.4": "94",
      "15.5": "94",
      "16.0": "96",
      "16.1": "96",
      "16.2": "96",
      "17.0": "98",
      "17.1": "98",
      "17.2": "98",
      "17.3": "98",
      "17.4": "98",
      "18.0": "100",
      "18.1": "100",
      "18.2": "100",
      "19.0": "102"
    };
  }
});

// node_modules/browserslist/error.js
var require_error = __commonJS({
  "node_modules/browserslist/error.js"(exports2, module2) {
    function BrowserslistError(message) {
      this.name = "BrowserslistError";
      this.message = message;
      this.browserslist = true;
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, BrowserslistError);
      }
    }
    BrowserslistError.prototype = Error.prototype;
    module2.exports = BrowserslistError;
  }
});

// node_modules/caniuse-lite/dist/lib/statuses.js
var require_statuses = __commonJS({
  "node_modules/caniuse-lite/dist/lib/statuses.js"(exports2, module2) {
    module2.exports = {
      1: "ls",
      2: "rec",
      3: "pr",
      4: "cr",
      5: "wd",
      6: "other",
      7: "unoff"
    };
  }
});

// node_modules/caniuse-lite/dist/lib/supported.js
var require_supported = __commonJS({
  "node_modules/caniuse-lite/dist/lib/supported.js"(exports2, module2) {
    module2.exports = {
      y: 1 << 0,
      n: 1 << 1,
      a: 1 << 2,
      p: 1 << 3,
      u: 1 << 4,
      x: 1 << 5,
      d: 1 << 6
    };
  }
});

// node_modules/caniuse-lite/dist/unpacker/feature.js
var require_feature = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/feature.js"(exports2, module2) {
    "use strict";
    var statuses = require_statuses();
    var supported = require_supported();
    var browsers = require_browsers2().browsers;
    var versions = require_browserVersions2().browserVersions;
    var MATH2LOG = Math.log(2);
    function unpackSupport(cipher) {
      let stats = Object.keys(supported).reduce((list, support) => {
        if (cipher & supported[support])
          list.push(support);
        return list;
      }, []);
      let notes = cipher >> 7;
      let notesArray = [];
      while (notes) {
        let note = Math.floor(Math.log(notes) / MATH2LOG) + 1;
        notesArray.unshift(`#${note}`);
        notes -= Math.pow(2, note - 1);
      }
      return stats.concat(notesArray).join(" ");
    }
    function unpackFeature(packed) {
      let unpacked = { status: statuses[packed.B], title: packed.C };
      unpacked.stats = Object.keys(packed.A).reduce((browserStats, key) => {
        let browser = packed.A[key];
        browserStats[browsers[key]] = Object.keys(browser).reduce((stats, support) => {
          let packedVersions = browser[support].split(" ");
          let unpacked2 = unpackSupport(support);
          packedVersions.forEach((v) => stats[versions[v]] = unpacked2);
          return stats;
        }, {});
        return browserStats;
      }, {});
      return unpacked;
    }
    module2.exports = unpackFeature;
    module2.exports.default = unpackFeature;
  }
});

// node_modules/caniuse-lite/dist/unpacker/region.js
var require_region = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/region.js"(exports2, module2) {
    "use strict";
    var browsers = require_browsers2().browsers;
    function unpackRegion(packed) {
      return Object.keys(packed).reduce((list, browser) => {
        let data = packed[browser];
        list[browsers[browser]] = Object.keys(data).reduce((memo, key) => {
          let stats = data[key];
          if (key === "_") {
            stats.split(" ").forEach((version) => memo[version] = null);
          } else {
            memo[key] = stats;
          }
          return memo;
        }, {});
        return list;
      }, {});
    }
    module2.exports = unpackRegion;
    module2.exports.default = unpackRegion;
  }
});

// node_modules/browserslist/node.js
var require_node2 = __commonJS({
  "node_modules/browserslist/node.js"(exports2, module2) {
    var feature = require_feature().default;
    var region = require_region().default;
    var path = require("path");
    var fs = require("fs");
    var BrowserslistError = require_error();
    var IS_SECTION = /^\s*\[(.+)]\s*$/;
    var CONFIG_PATTERN = /^browserslist-config-/;
    var SCOPED_CONFIG__PATTERN = /@[^/]+\/browserslist-config(-|$|\/)/;
    var TIME_TO_UPDATE_CANIUSE = 6 * 30 * 24 * 60 * 60 * 1e3;
    var FORMAT = "Browserslist config should be a string or an array of strings with browser queries";
    var dataTimeChecked = false;
    var filenessCache = {};
    var configCache = {};
    function checkExtend(name) {
      var use = " Use `dangerousExtend` option to disable.";
      if (!CONFIG_PATTERN.test(name) && !SCOPED_CONFIG__PATTERN.test(name)) {
        throw new BrowserslistError("Browserslist config needs `browserslist-config-` prefix. " + use);
      }
      if (name.replace(/^@[^/]+\//, "").indexOf(".") !== -1) {
        throw new BrowserslistError("`.` not allowed in Browserslist config name. " + use);
      }
      if (name.indexOf("node_modules") !== -1) {
        throw new BrowserslistError("`node_modules` not allowed in Browserslist config." + use);
      }
    }
    function isFile(file) {
      if (file in filenessCache) {
        return filenessCache[file];
      }
      var result = fs.existsSync(file) && fs.statSync(file).isFile();
      if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
        filenessCache[file] = result;
      }
      return result;
    }
    function eachParent(file, callback) {
      var dir = isFile(file) ? path.dirname(file) : file;
      var loc = path.resolve(dir);
      do {
        var result = callback(loc);
        if (typeof result !== "undefined")
          return result;
      } while (loc !== (loc = path.dirname(loc)));
      return void 0;
    }
    function check(section) {
      if (Array.isArray(section)) {
        for (var i = 0; i < section.length; i++) {
          if (typeof section[i] !== "string") {
            throw new BrowserslistError(FORMAT);
          }
        }
      } else if (typeof section !== "string") {
        throw new BrowserslistError(FORMAT);
      }
    }
    function pickEnv(config, opts) {
      if (typeof config !== "object")
        return config;
      var name;
      if (typeof opts.env === "string") {
        name = opts.env;
      } else if (process.env.BROWSERSLIST_ENV) {
        name = process.env.BROWSERSLIST_ENV;
      } else if (process.env.NODE_ENV) {
        name = process.env.NODE_ENV;
      } else {
        name = "production";
      }
      if (opts.throwOnMissing) {
        if (name && name !== "defaults" && !config[name]) {
          throw new BrowserslistError("Missing config for Browserslist environment `" + name + "`");
        }
      }
      return config[name] || config.defaults;
    }
    function parsePackage(file) {
      var config = JSON.parse(fs.readFileSync(file));
      if (config.browserlist && !config.browserslist) {
        throw new BrowserslistError("`browserlist` key instead of `browserslist` in " + file);
      }
      var list = config.browserslist;
      if (Array.isArray(list) || typeof list === "string") {
        list = { defaults: list };
      }
      for (var i in list) {
        check(list[i]);
      }
      return list;
    }
    function latestReleaseTime(agents) {
      var latest = 0;
      for (var name in agents) {
        var dates = agents[name].releaseDate || {};
        for (var key in dates) {
          if (latest < dates[key]) {
            latest = dates[key];
          }
        }
      }
      return latest * 1e3;
    }
    function normalizeStats(data, stats) {
      if (!data) {
        data = {};
      }
      if (stats && "dataByBrowser" in stats) {
        stats = stats.dataByBrowser;
      }
      if (typeof stats !== "object")
        return void 0;
      var normalized = {};
      for (var i in stats) {
        var versions = Object.keys(stats[i]);
        if (versions.length === 1 && data[i] && data[i].versions.length === 1) {
          var normal = data[i].versions[0];
          normalized[i] = {};
          normalized[i][normal] = stats[i][versions[0]];
        } else {
          normalized[i] = stats[i];
        }
      }
      return normalized;
    }
    function normalizeUsageData(usageData, data) {
      for (var browser in usageData) {
        var browserUsage = usageData[browser];
        if ("0" in browserUsage) {
          var versions = data[browser].versions;
          browserUsage[versions[versions.length - 1]] = browserUsage[0];
          delete browserUsage[0];
        }
      }
    }
    module2.exports = {
      loadQueries: function loadQueries(ctx, name) {
        if (!ctx.dangerousExtend && !process.env.BROWSERSLIST_DANGEROUS_EXTEND) {
          checkExtend(name);
        }
        var queries = require(require.resolve(name, { paths: [".", ctx.path] }));
        if (queries) {
          if (Array.isArray(queries)) {
            return queries;
          } else if (typeof queries === "object") {
            if (!queries.defaults)
              queries.defaults = [];
            return pickEnv(queries, ctx, name);
          }
        }
        throw new BrowserslistError("`" + name + "` config exports not an array of queries or an object of envs");
      },
      loadStat: function loadStat(ctx, name, data) {
        if (!ctx.dangerousExtend && !process.env.BROWSERSLIST_DANGEROUS_EXTEND) {
          checkExtend(name);
        }
        var stats = require(require.resolve(path.join(name, "browserslist-stats.json"), { paths: ["."] }));
        return normalizeStats(data, stats);
      },
      getStat: function getStat(opts, data) {
        var stats;
        if (opts.stats) {
          stats = opts.stats;
        } else if (process.env.BROWSERSLIST_STATS) {
          stats = process.env.BROWSERSLIST_STATS;
        } else if (opts.path && path.resolve && fs.existsSync) {
          stats = eachParent(opts.path, function(dir) {
            var file = path.join(dir, "browserslist-stats.json");
            return isFile(file) ? file : void 0;
          });
        }
        if (typeof stats === "string") {
          try {
            stats = JSON.parse(fs.readFileSync(stats));
          } catch (e) {
            throw new BrowserslistError("Can't read " + stats);
          }
        }
        return normalizeStats(data, stats);
      },
      loadConfig: function loadConfig(opts) {
        if (process.env.BROWSERSLIST) {
          return process.env.BROWSERSLIST;
        } else if (opts.config || process.env.BROWSERSLIST_CONFIG) {
          var file = opts.config || process.env.BROWSERSLIST_CONFIG;
          if (path.basename(file) === "package.json") {
            return pickEnv(parsePackage(file), opts);
          } else {
            return pickEnv(module2.exports.readConfig(file), opts);
          }
        } else if (opts.path) {
          return pickEnv(module2.exports.findConfig(opts.path), opts);
        } else {
          return void 0;
        }
      },
      loadCountry: function loadCountry(usage, country, data) {
        var code = country.replace(/[^\w-]/g, "");
        if (!usage[code]) {
          var compressed = require("caniuse-lite/data/regions/" + code + ".js");
          var usageData = region(compressed);
          normalizeUsageData(usageData, data);
          usage[country] = {};
          for (var i in usageData) {
            for (var j in usageData[i]) {
              usage[country][i + " " + j] = usageData[i][j];
            }
          }
        }
      },
      loadFeature: function loadFeature(features, name) {
        name = name.replace(/[^\w-]/g, "");
        if (features[name])
          return;
        var compressed = require("caniuse-lite/data/features/" + name + ".js");
        var stats = feature(compressed).stats;
        features[name] = {};
        for (var i in stats) {
          for (var j in stats[i]) {
            features[name][i + " " + j] = stats[i][j];
          }
        }
      },
      parseConfig: function parseConfig(string) {
        var result = { defaults: [] };
        var sections = ["defaults"];
        string.toString().replace(/#[^\n]*/g, "").split(/\n|,/).map(function(line) {
          return line.trim();
        }).filter(function(line) {
          return line !== "";
        }).forEach(function(line) {
          if (IS_SECTION.test(line)) {
            sections = line.match(IS_SECTION)[1].trim().split(" ");
            sections.forEach(function(section) {
              if (result[section]) {
                throw new BrowserslistError("Duplicate section " + section + " in Browserslist config");
              }
              result[section] = [];
            });
          } else {
            sections.forEach(function(section) {
              result[section].push(line);
            });
          }
        });
        return result;
      },
      readConfig: function readConfig(file) {
        if (!isFile(file)) {
          throw new BrowserslistError("Can't read " + file + " config");
        }
        return module2.exports.parseConfig(fs.readFileSync(file));
      },
      findConfig: function findConfig(from) {
        from = path.resolve(from);
        var passed = [];
        var resolved = eachParent(from, function(dir) {
          if (dir in configCache) {
            return configCache[dir];
          }
          passed.push(dir);
          var config = path.join(dir, "browserslist");
          var pkg = path.join(dir, "package.json");
          var rc = path.join(dir, ".browserslistrc");
          var pkgBrowserslist;
          if (isFile(pkg)) {
            try {
              pkgBrowserslist = parsePackage(pkg);
            } catch (e) {
              if (e.name === "BrowserslistError")
                throw e;
              console.warn("[Browserslist] Could not parse " + pkg + ". Ignoring it.");
            }
          }
          if (isFile(config) && pkgBrowserslist) {
            throw new BrowserslistError(dir + " contains both browserslist and package.json with browsers");
          } else if (isFile(rc) && pkgBrowserslist) {
            throw new BrowserslistError(dir + " contains both .browserslistrc and package.json with browsers");
          } else if (isFile(config) && isFile(rc)) {
            throw new BrowserslistError(dir + " contains both .browserslistrc and browserslist");
          } else if (isFile(config)) {
            return module2.exports.readConfig(config);
          } else if (isFile(rc)) {
            return module2.exports.readConfig(rc);
          } else {
            return pkgBrowserslist;
          }
        });
        if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
          passed.forEach(function(dir) {
            configCache[dir] = resolved;
          });
        }
        return resolved;
      },
      clearCaches: function clearCaches() {
        dataTimeChecked = false;
        filenessCache = {};
        configCache = {};
        this.cache = {};
      },
      oldDataWarning: function oldDataWarning(agentsObj) {
        if (dataTimeChecked)
          return;
        dataTimeChecked = true;
        if (process.env.BROWSERSLIST_IGNORE_OLD_DATA)
          return;
        var latest = latestReleaseTime(agentsObj);
        var halfYearAgo = Date.now() - TIME_TO_UPDATE_CANIUSE;
        if (latest !== 0 && latest < halfYearAgo) {
          console.warn("Browserslist: caniuse-lite is outdated. Please run:\n  npx browserslist@latest --update-db\n  Why you should do it regularly: https://github.com/browserslist/browserslist#browsers-data-updating");
        }
      },
      currentNode: function currentNode() {
        return "node " + process.versions.node;
      }
    };
  }
});

// node_modules/browserslist/index.js
var require_browserslist = __commonJS({
  "node_modules/browserslist/index.js"(exports2, module2) {
    var jsReleases = require_envs();
    var agents = require_agents2().agents;
    var jsEOL = require_release_schedule();
    var path = require("path");
    var e2c = require_versions();
    var BrowserslistError = require_error();
    var env = require_node2();
    var YEAR = 365.259641 * 24 * 60 * 60 * 1e3;
    var ANDROID_EVERGREEN_FIRST = 37;
    var QUERY_OR = 1;
    var QUERY_AND = 2;
    function isVersionsMatch(versionA, versionB) {
      return (versionA + ".").indexOf(versionB + ".") === 0;
    }
    function isEolReleased(name) {
      var version = name.slice(1);
      return browserslist.nodeVersions.some(function(i) {
        return isVersionsMatch(i, version);
      });
    }
    function normalize(versions) {
      return versions.filter(function(version) {
        return typeof version === "string";
      });
    }
    function normalizeElectron(version) {
      var versionToUse = version;
      if (version.split(".").length === 3) {
        versionToUse = version.split(".").slice(0, -1).join(".");
      }
      return versionToUse;
    }
    function nameMapper(name) {
      return function mapName(version) {
        return name + " " + version;
      };
    }
    function getMajor(version) {
      return parseInt(version.split(".")[0]);
    }
    function getMajorVersions(released, number) {
      if (released.length === 0)
        return [];
      var majorVersions = uniq(released.map(getMajor));
      var minimum = majorVersions[majorVersions.length - number];
      if (!minimum) {
        return released;
      }
      var selected = [];
      for (var i = released.length - 1; i >= 0; i--) {
        if (minimum > getMajor(released[i]))
          break;
        selected.unshift(released[i]);
      }
      return selected;
    }
    function uniq(array) {
      var filtered = [];
      for (var i = 0; i < array.length; i++) {
        if (filtered.indexOf(array[i]) === -1)
          filtered.push(array[i]);
      }
      return filtered;
    }
    function fillUsage(result, name, data) {
      for (var i in data) {
        result[name + " " + i] = data[i];
      }
    }
    function generateFilter(sign, version) {
      version = parseFloat(version);
      if (sign === ">") {
        return function(v) {
          return parseFloat(v) > version;
        };
      } else if (sign === ">=") {
        return function(v) {
          return parseFloat(v) >= version;
        };
      } else if (sign === "<") {
        return function(v) {
          return parseFloat(v) < version;
        };
      } else {
        return function(v) {
          return parseFloat(v) <= version;
        };
      }
    }
    function generateSemverFilter(sign, version) {
      version = version.split(".").map(parseSimpleInt);
      version[1] = version[1] || 0;
      version[2] = version[2] || 0;
      if (sign === ">") {
        return function(v) {
          v = v.split(".").map(parseSimpleInt);
          return compareSemver(v, version) > 0;
        };
      } else if (sign === ">=") {
        return function(v) {
          v = v.split(".").map(parseSimpleInt);
          return compareSemver(v, version) >= 0;
        };
      } else if (sign === "<") {
        return function(v) {
          v = v.split(".").map(parseSimpleInt);
          return compareSemver(version, v) > 0;
        };
      } else {
        return function(v) {
          v = v.split(".").map(parseSimpleInt);
          return compareSemver(version, v) >= 0;
        };
      }
    }
    function parseSimpleInt(x) {
      return parseInt(x);
    }
    function compare(a, b) {
      if (a < b)
        return -1;
      if (a > b)
        return 1;
      return 0;
    }
    function compareSemver(a, b) {
      return compare(parseInt(a[0]), parseInt(b[0])) || compare(parseInt(a[1] || "0"), parseInt(b[1] || "0")) || compare(parseInt(a[2] || "0"), parseInt(b[2] || "0"));
    }
    function semverFilterLoose(operator, range) {
      range = range.split(".").map(parseSimpleInt);
      if (typeof range[1] === "undefined") {
        range[1] = "x";
      }
      switch (operator) {
        case "<=":
          return function(version) {
            version = version.split(".").map(parseSimpleInt);
            return compareSemverLoose(version, range) <= 0;
          };
        case ">=":
        default:
          return function(version) {
            version = version.split(".").map(parseSimpleInt);
            return compareSemverLoose(version, range) >= 0;
          };
      }
    }
    function compareSemverLoose(version, range) {
      if (version[0] !== range[0]) {
        return version[0] < range[0] ? -1 : 1;
      }
      if (range[1] === "x") {
        return 0;
      }
      if (version[1] !== range[1]) {
        return version[1] < range[1] ? -1 : 1;
      }
      return 0;
    }
    function resolveVersion(data, version) {
      if (data.versions.indexOf(version) !== -1) {
        return version;
      } else if (browserslist.versionAliases[data.name][version]) {
        return browserslist.versionAliases[data.name][version];
      } else {
        return false;
      }
    }
    function normalizeVersion(data, version) {
      var resolved = resolveVersion(data, version);
      if (resolved) {
        return resolved;
      } else if (data.versions.length === 1) {
        return data.versions[0];
      } else {
        return false;
      }
    }
    function filterByYear(since, context) {
      since = since / 1e3;
      return Object.keys(agents).reduce(function(selected, name) {
        var data = byName(name, context);
        if (!data)
          return selected;
        var versions = Object.keys(data.releaseDate).filter(function(v) {
          var date = data.releaseDate[v];
          return date !== null && date >= since;
        });
        return selected.concat(versions.map(nameMapper(data.name)));
      }, []);
    }
    function cloneData(data) {
      return {
        name: data.name,
        versions: data.versions,
        released: data.released,
        releaseDate: data.releaseDate
      };
    }
    function mapVersions(data, map) {
      data.versions = data.versions.map(function(i2) {
        return map[i2] || i2;
      });
      data.released = data.versions.map(function(i2) {
        return map[i2] || i2;
      });
      var fixedDate = {};
      for (var i in data.releaseDate) {
        fixedDate[map[i] || i] = data.releaseDate[i];
      }
      data.releaseDate = fixedDate;
      return data;
    }
    function byName(name, context) {
      name = name.toLowerCase();
      name = browserslist.aliases[name] || name;
      if (context.mobileToDesktop && browserslist.desktopNames[name]) {
        var desktop = browserslist.data[browserslist.desktopNames[name]];
        if (name === "android") {
          return normalizeAndroidData(cloneData(browserslist.data[name]), desktop);
        } else {
          var cloned = cloneData(desktop);
          cloned.name = name;
          if (name === "op_mob") {
            cloned = mapVersions(cloned, { "10.0-10.1": "10" });
          }
          return cloned;
        }
      }
      return browserslist.data[name];
    }
    function normalizeAndroidVersions(androidVersions, chromeVersions) {
      var firstEvergreen = ANDROID_EVERGREEN_FIRST;
      var last = chromeVersions[chromeVersions.length - 1];
      return androidVersions.filter(function(version) {
        return /^(?:[2-4]\.|[34]$)/.test(version);
      }).concat(chromeVersions.slice(firstEvergreen - last - 1));
    }
    function normalizeAndroidData(android, chrome) {
      android.released = normalizeAndroidVersions(android.released, chrome.released);
      android.versions = normalizeAndroidVersions(android.versions, chrome.versions);
      return android;
    }
    function checkName(name, context) {
      var data = byName(name, context);
      if (!data)
        throw new BrowserslistError("Unknown browser " + name);
      return data;
    }
    function unknownQuery(query) {
      return new BrowserslistError("Unknown browser query `" + query + "`. Maybe you are using old Browserslist or made typo in query.");
    }
    function filterAndroid(list, versions, context) {
      if (context.mobileToDesktop)
        return list;
      var released = browserslist.data.android.released;
      var last = released[released.length - 1];
      var diff = last - ANDROID_EVERGREEN_FIRST - versions;
      if (diff > 0) {
        return list.slice(-1);
      } else {
        return list.slice(diff - 1);
      }
    }
    function resolve(queries, context) {
      if (Array.isArray(queries)) {
        queries = flatten(queries.map(parse));
      } else {
        queries = parse(queries);
      }
      return queries.reduce(function(result, query, index) {
        var selection = query.queryString;
        var isExclude = selection.indexOf("not ") === 0;
        if (isExclude) {
          if (index === 0) {
            throw new BrowserslistError("Write any browsers query (for instance, `defaults`) before `" + selection + "`");
          }
          selection = selection.slice(4);
        }
        for (var i = 0; i < QUERIES.length; i++) {
          var type = QUERIES[i];
          var match = selection.match(type.regexp);
          if (match) {
            var args = [context].concat(match.slice(1));
            var array = type.select.apply(browserslist, args).map(function(j) {
              var parts = j.split(" ");
              if (parts[1] === "0") {
                return parts[0] + " " + byName(parts[0], context).versions[0];
              } else {
                return j;
              }
            });
            switch (query.type) {
              case QUERY_AND:
                if (isExclude) {
                  return result.filter(function(j) {
                    return array.indexOf(j) === -1;
                  });
                } else {
                  return result.filter(function(j) {
                    return array.indexOf(j) !== -1;
                  });
                }
              case QUERY_OR:
              default:
                if (isExclude) {
                  var filter = {};
                  array.forEach(function(j) {
                    filter[j] = true;
                  });
                  return result.filter(function(j) {
                    return !filter[j];
                  });
                }
                return result.concat(array);
            }
          }
        }
        throw unknownQuery(selection);
      }, []);
    }
    var cache = {};
    function browserslist(queries, opts) {
      if (typeof opts === "undefined")
        opts = {};
      if (typeof opts.path === "undefined") {
        opts.path = path.resolve ? path.resolve(".") : ".";
      }
      if (typeof queries === "undefined" || queries === null) {
        var config = browserslist.loadConfig(opts);
        if (config) {
          queries = config;
        } else {
          queries = browserslist.defaults;
        }
      }
      if (!(typeof queries === "string" || Array.isArray(queries))) {
        throw new BrowserslistError("Browser queries must be an array or string. Got " + typeof queries + ".");
      }
      var context = {
        ignoreUnknownVersions: opts.ignoreUnknownVersions,
        dangerousExtend: opts.dangerousExtend,
        mobileToDesktop: opts.mobileToDesktop,
        path: opts.path,
        env: opts.env
      };
      env.oldDataWarning(browserslist.data);
      var stats = env.getStat(opts, browserslist.data);
      if (stats) {
        context.customUsage = {};
        for (var browser in stats) {
          fillUsage(context.customUsage, browser, stats[browser]);
        }
      }
      var cacheKey = JSON.stringify([queries, context]);
      if (cache[cacheKey])
        return cache[cacheKey];
      var result = uniq(resolve(queries, context)).sort(function(name1, name2) {
        name1 = name1.split(" ");
        name2 = name2.split(" ");
        if (name1[0] === name2[0]) {
          var version1 = name1[1].split("-")[0];
          var version2 = name2[1].split("-")[0];
          return compareSemver(version2.split("."), version1.split("."));
        } else {
          return compare(name1[0], name2[0]);
        }
      });
      if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
        cache[cacheKey] = result;
      }
      return result;
    }
    function parse(queries) {
      var qs = [];
      do {
        queries = doMatch(queries, qs);
      } while (queries);
      return qs;
    }
    function doMatch(string, qs) {
      var or = /^(?:,\s*|\s+or\s+)(.*)/i;
      var and = /^\s+and\s+(.*)/i;
      return find(string, function(parsed, n, max) {
        if (and.test(parsed)) {
          qs.unshift({ type: QUERY_AND, queryString: parsed.match(and)[1] });
          return true;
        } else if (or.test(parsed)) {
          qs.unshift({ type: QUERY_OR, queryString: parsed.match(or)[1] });
          return true;
        } else if (n === max) {
          qs.unshift({ type: QUERY_OR, queryString: parsed.trim() });
          return true;
        }
        return false;
      });
    }
    function find(string, predicate) {
      for (var n = 1, max = string.length; n <= max; n++) {
        var parsed = string.substr(-n, n);
        if (predicate(parsed, n, max)) {
          return string.slice(0, -n);
        }
      }
      return "";
    }
    function flatten(array) {
      if (!Array.isArray(array))
        return [array];
      return array.reduce(function(a, b) {
        return a.concat(flatten(b));
      }, []);
    }
    browserslist.cache = {};
    browserslist.data = {};
    browserslist.usage = {
      global: {},
      custom: null
    };
    browserslist.defaults = ["> 0.5%", "last 2 versions", "Firefox ESR", "not dead"];
    browserslist.aliases = {
      fx: "firefox",
      ff: "firefox",
      ios: "ios_saf",
      explorer: "ie",
      blackberry: "bb",
      explorermobile: "ie_mob",
      operamini: "op_mini",
      operamobile: "op_mob",
      chromeandroid: "and_chr",
      firefoxandroid: "and_ff",
      ucandroid: "and_uc",
      qqandroid: "and_qq"
    };
    browserslist.desktopNames = {
      and_chr: "chrome",
      and_ff: "firefox",
      ie_mob: "ie",
      op_mob: "opera",
      android: "chrome"
    };
    browserslist.versionAliases = {};
    browserslist.clearCaches = env.clearCaches;
    browserslist.parseConfig = env.parseConfig;
    browserslist.readConfig = env.readConfig;
    browserslist.findConfig = env.findConfig;
    browserslist.loadConfig = env.loadConfig;
    browserslist.coverage = function(browsers, stats) {
      var data;
      if (typeof stats === "undefined") {
        data = browserslist.usage.global;
      } else if (stats === "my stats") {
        var opts = {};
        opts.path = path.resolve ? path.resolve(".") : ".";
        var customStats = env.getStat(opts);
        if (!customStats) {
          throw new BrowserslistError("Custom usage statistics was not provided");
        }
        data = {};
        for (var browser in customStats) {
          fillUsage(data, browser, customStats[browser]);
        }
      } else if (typeof stats === "string") {
        if (stats.length > 2) {
          stats = stats.toLowerCase();
        } else {
          stats = stats.toUpperCase();
        }
        env.loadCountry(browserslist.usage, stats, browserslist.data);
        data = browserslist.usage[stats];
      } else {
        if ("dataByBrowser" in stats) {
          stats = stats.dataByBrowser;
        }
        data = {};
        for (var name in stats) {
          for (var version in stats[name]) {
            data[name + " " + version] = stats[name][version];
          }
        }
      }
      return browsers.reduce(function(all, i) {
        var usage = data[i];
        if (usage === void 0) {
          usage = data[i.replace(/ \S+$/, " 0")];
        }
        return all + (usage || 0);
      }, 0);
    };
    function nodeQuery(context, version) {
      var matched = browserslist.nodeVersions.filter(function(i) {
        return isVersionsMatch(i, version);
      });
      if (matched.length === 0) {
        if (context.ignoreUnknownVersions) {
          return [];
        } else {
          throw new BrowserslistError("Unknown version " + version + " of Node.js");
        }
      }
      return ["node " + matched[matched.length - 1]];
    }
    function sinceQuery(context, year, month, date) {
      year = parseInt(year);
      month = parseInt(month || "01") - 1;
      date = parseInt(date || "01");
      return filterByYear(Date.UTC(year, month, date, 0, 0, 0), context);
    }
    function coverQuery(context, coverage, statMode) {
      coverage = parseFloat(coverage);
      var usage = browserslist.usage.global;
      if (statMode) {
        if (statMode.match(/^my\s+stats$/i)) {
          if (!context.customUsage) {
            throw new BrowserslistError("Custom usage statistics was not provided");
          }
          usage = context.customUsage;
        } else {
          var place;
          if (statMode.length === 2) {
            place = statMode.toUpperCase();
          } else {
            place = statMode.toLowerCase();
          }
          env.loadCountry(browserslist.usage, place, browserslist.data);
          usage = browserslist.usage[place];
        }
      }
      var versions = Object.keys(usage).sort(function(a, b) {
        return usage[b] - usage[a];
      });
      var coveraged = 0;
      var result = [];
      var version;
      for (var i = 0; i < versions.length; i++) {
        version = versions[i];
        if (usage[version] === 0)
          break;
        coveraged += usage[version];
        result.push(version);
        if (coveraged >= coverage)
          break;
      }
      return result;
    }
    var QUERIES = [
      {
        regexp: /^last\s+(\d+)\s+major\s+versions?$/i,
        select: function(context, versions) {
          return Object.keys(agents).reduce(function(selected, name) {
            var data = byName(name, context);
            if (!data)
              return selected;
            var list = getMajorVersions(data.released, versions);
            list = list.map(nameMapper(data.name));
            if (data.name === "android") {
              list = filterAndroid(list, versions, context);
            }
            return selected.concat(list);
          }, []);
        }
      },
      {
        regexp: /^last\s+(\d+)\s+versions?$/i,
        select: function(context, versions) {
          return Object.keys(agents).reduce(function(selected, name) {
            var data = byName(name, context);
            if (!data)
              return selected;
            var list = data.released.slice(-versions);
            list = list.map(nameMapper(data.name));
            if (data.name === "android") {
              list = filterAndroid(list, versions, context);
            }
            return selected.concat(list);
          }, []);
        }
      },
      {
        regexp: /^last\s+(\d+)\s+electron\s+major\s+versions?$/i,
        select: function(context, versions) {
          var validVersions = getMajorVersions(Object.keys(e2c), versions);
          return validVersions.map(function(i) {
            return "chrome " + e2c[i];
          });
        }
      },
      {
        regexp: /^last\s+(\d+)\s+node\s+major\s+versions?$/i,
        select: function(context, versions) {
          return getMajorVersions(browserslist.nodeVersions, versions).map(function(version) {
            return "node " + version;
          });
        }
      },
      {
        regexp: /^last\s+(\d+)\s+(\w+)\s+major\s+versions?$/i,
        select: function(context, versions, name) {
          var data = checkName(name, context);
          var validVersions = getMajorVersions(data.released, versions);
          var list = validVersions.map(nameMapper(data.name));
          if (data.name === "android") {
            list = filterAndroid(list, versions, context);
          }
          return list;
        }
      },
      {
        regexp: /^last\s+(\d+)\s+electron\s+versions?$/i,
        select: function(context, versions) {
          return Object.keys(e2c).slice(-versions).map(function(i) {
            return "chrome " + e2c[i];
          });
        }
      },
      {
        regexp: /^last\s+(\d+)\s+node\s+versions?$/i,
        select: function(context, versions) {
          return browserslist.nodeVersions.slice(-versions).map(function(version) {
            return "node " + version;
          });
        }
      },
      {
        regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
        select: function(context, versions, name) {
          var data = checkName(name, context);
          var list = data.released.slice(-versions).map(nameMapper(data.name));
          if (data.name === "android") {
            list = filterAndroid(list, versions, context);
          }
          return list;
        }
      },
      {
        regexp: /^unreleased\s+versions$/i,
        select: function(context) {
          return Object.keys(agents).reduce(function(selected, name) {
            var data = byName(name, context);
            if (!data)
              return selected;
            var list = data.versions.filter(function(v) {
              return data.released.indexOf(v) === -1;
            });
            list = list.map(nameMapper(data.name));
            return selected.concat(list);
          }, []);
        }
      },
      {
        regexp: /^unreleased\s+electron\s+versions?$/i,
        select: function() {
          return [];
        }
      },
      {
        regexp: /^unreleased\s+(\w+)\s+versions?$/i,
        select: function(context, name) {
          var data = checkName(name, context);
          return data.versions.filter(function(v) {
            return data.released.indexOf(v) === -1;
          }).map(nameMapper(data.name));
        }
      },
      {
        regexp: /^last\s+(\d*.?\d+)\s+years?$/i,
        select: function(context, years) {
          return filterByYear(Date.now() - YEAR * years, context);
        }
      },
      {
        regexp: /^since (\d+)$/i,
        select: sinceQuery
      },
      {
        regexp: /^since (\d+)-(\d+)$/i,
        select: sinceQuery
      },
      {
        regexp: /^since (\d+)-(\d+)-(\d+)$/i,
        select: sinceQuery
      },
      {
        regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%$/,
        select: function(context, sign, popularity) {
          popularity = parseFloat(popularity);
          var usage = browserslist.usage.global;
          return Object.keys(usage).reduce(function(result, version) {
            if (sign === ">") {
              if (usage[version] > popularity) {
                result.push(version);
              }
            } else if (sign === "<") {
              if (usage[version] < popularity) {
                result.push(version);
              }
            } else if (sign === "<=") {
              if (usage[version] <= popularity) {
                result.push(version);
              }
            } else if (usage[version] >= popularity) {
              result.push(version);
            }
            return result;
          }, []);
        }
      },
      {
        regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+my\s+stats$/,
        select: function(context, sign, popularity) {
          popularity = parseFloat(popularity);
          if (!context.customUsage) {
            throw new BrowserslistError("Custom usage statistics was not provided");
          }
          var usage = context.customUsage;
          return Object.keys(usage).reduce(function(result, version) {
            var percentage = usage[version];
            if (percentage == null) {
              return result;
            }
            if (sign === ">") {
              if (percentage > popularity) {
                result.push(version);
              }
            } else if (sign === "<") {
              if (percentage < popularity) {
                result.push(version);
              }
            } else if (sign === "<=") {
              if (percentage <= popularity) {
                result.push(version);
              }
            } else if (percentage >= popularity) {
              result.push(version);
            }
            return result;
          }, []);
        }
      },
      {
        regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+(\S+)\s+stats$/,
        select: function(context, sign, popularity, name) {
          popularity = parseFloat(popularity);
          var stats = env.loadStat(context, name, browserslist.data);
          if (stats) {
            context.customUsage = {};
            for (var browser in stats) {
              fillUsage(context.customUsage, browser, stats[browser]);
            }
          }
          if (!context.customUsage) {
            throw new BrowserslistError("Custom usage statistics was not provided");
          }
          var usage = context.customUsage;
          return Object.keys(usage).reduce(function(result, version) {
            var percentage = usage[version];
            if (percentage == null) {
              return result;
            }
            if (sign === ">") {
              if (percentage > popularity) {
                result.push(version);
              }
            } else if (sign === "<") {
              if (percentage < popularity) {
                result.push(version);
              }
            } else if (sign === "<=") {
              if (percentage <= popularity) {
                result.push(version);
              }
            } else if (percentage >= popularity) {
              result.push(version);
            }
            return result;
          }, []);
        }
      },
      {
        regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+((alt-)?\w\w)$/,
        select: function(context, sign, popularity, place) {
          popularity = parseFloat(popularity);
          if (place.length === 2) {
            place = place.toUpperCase();
          } else {
            place = place.toLowerCase();
          }
          env.loadCountry(browserslist.usage, place, browserslist.data);
          var usage = browserslist.usage[place];
          return Object.keys(usage).reduce(function(result, version) {
            var percentage = usage[version];
            if (percentage == null) {
              return result;
            }
            if (sign === ">") {
              if (percentage > popularity) {
                result.push(version);
              }
            } else if (sign === "<") {
              if (percentage < popularity) {
                result.push(version);
              }
            } else if (sign === "<=") {
              if (percentage <= popularity) {
                result.push(version);
              }
            } else if (percentage >= popularity) {
              result.push(version);
            }
            return result;
          }, []);
        }
      },
      {
        regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%$/i,
        select: coverQuery
      },
      {
        regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(my\s+stats|(alt-)?\w\w)$/i,
        select: coverQuery
      },
      {
        regexp: /^supports\s+([\w-]+)$/,
        select: function(context, feature) {
          env.loadFeature(browserslist.cache, feature);
          var features = browserslist.cache[feature];
          return Object.keys(features).reduce(function(result, version) {
            var flags = features[version];
            if (flags.indexOf("y") >= 0 || flags.indexOf("a") >= 0) {
              result.push(version);
            }
            return result;
          }, []);
        }
      },
      {
        regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
        select: function(context, from, to) {
          var fromToUse = normalizeElectron(from);
          var toToUse = normalizeElectron(to);
          if (!e2c[fromToUse]) {
            throw new BrowserslistError("Unknown version " + from + " of electron");
          }
          if (!e2c[toToUse]) {
            throw new BrowserslistError("Unknown version " + to + " of electron");
          }
          from = parseFloat(from);
          to = parseFloat(to);
          return Object.keys(e2c).filter(function(i) {
            var parsed = parseFloat(i);
            return parsed >= from && parsed <= to;
          }).map(function(i) {
            return "chrome " + e2c[i];
          });
        }
      },
      {
        regexp: /^node\s+([\d.]+)\s*-\s*([\d.]+)$/i,
        select: function(context, from, to) {
          return browserslist.nodeVersions.filter(semverFilterLoose(">=", from)).filter(semverFilterLoose("<=", to)).map(function(v) {
            return "node " + v;
          });
        }
      },
      {
        regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
        select: function(context, name, from, to) {
          var data = checkName(name, context);
          from = parseFloat(normalizeVersion(data, from) || from);
          to = parseFloat(normalizeVersion(data, to) || to);
          function filter(v) {
            var parsed = parseFloat(v);
            return parsed >= from && parsed <= to;
          }
          return data.released.filter(filter).map(nameMapper(data.name));
        }
      },
      {
        regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
        select: function(context, sign, version) {
          var versionToUse = normalizeElectron(version);
          return Object.keys(e2c).filter(generateFilter(sign, versionToUse)).map(function(i) {
            return "chrome " + e2c[i];
          });
        }
      },
      {
        regexp: /^node\s*(>=?|<=?)\s*([\d.]+)$/i,
        select: function(context, sign, version) {
          return browserslist.nodeVersions.filter(generateSemverFilter(sign, version)).map(function(v) {
            return "node " + v;
          });
        }
      },
      {
        regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/,
        select: function(context, name, sign, version) {
          var data = checkName(name, context);
          var alias = browserslist.versionAliases[data.name][version];
          if (alias) {
            version = alias;
          }
          return data.released.filter(generateFilter(sign, version)).map(function(v) {
            return data.name + " " + v;
          });
        }
      },
      {
        regexp: /^(firefox|ff|fx)\s+esr$/i,
        select: function() {
          return ["firefox 91"];
        }
      },
      {
        regexp: /(operamini|op_mini)\s+all/i,
        select: function() {
          return ["op_mini all"];
        }
      },
      {
        regexp: /^electron\s+([\d.]+)$/i,
        select: function(context, version) {
          var versionToUse = normalizeElectron(version);
          var chrome = e2c[versionToUse];
          if (!chrome) {
            throw new BrowserslistError("Unknown version " + version + " of electron");
          }
          return ["chrome " + chrome];
        }
      },
      {
        regexp: /^node\s+(\d+)$/i,
        select: nodeQuery
      },
      {
        regexp: /^node\s+(\d+\.\d+)$/i,
        select: nodeQuery
      },
      {
        regexp: /^node\s+(\d+\.\d+\.\d+)$/i,
        select: nodeQuery
      },
      {
        regexp: /^current\s+node$/i,
        select: function(context) {
          return [env.currentNode(resolve, context)];
        }
      },
      {
        regexp: /^maintained\s+node\s+versions$/i,
        select: function(context) {
          var now = Date.now();
          var queries = Object.keys(jsEOL).filter(function(key) {
            return now < Date.parse(jsEOL[key].end) && now > Date.parse(jsEOL[key].start) && isEolReleased(key);
          }).map(function(key) {
            return "node " + key.slice(1);
          });
          return resolve(queries, context);
        }
      },
      {
        regexp: /^phantomjs\s+1.9$/i,
        select: function() {
          return ["safari 5"];
        }
      },
      {
        regexp: /^phantomjs\s+2.1$/i,
        select: function() {
          return ["safari 6"];
        }
      },
      {
        regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
        select: function(context, name, version) {
          if (/^tp$/i.test(version))
            version = "TP";
          var data = checkName(name, context);
          var alias = normalizeVersion(data, version);
          if (alias) {
            version = alias;
          } else {
            if (version.indexOf(".") === -1) {
              alias = version + ".0";
            } else {
              alias = version.replace(/\.0$/, "");
            }
            alias = normalizeVersion(data, alias);
            if (alias) {
              version = alias;
            } else if (context.ignoreUnknownVersions) {
              return [];
            } else {
              throw new BrowserslistError("Unknown version " + version + " of " + name);
            }
          }
          return [data.name + " " + version];
        }
      },
      {
        regexp: /^browserslist config$/i,
        select: function(context) {
          return browserslist(void 0, context);
        }
      },
      {
        regexp: /^extends (.+)$/i,
        select: function(context, name) {
          return resolve(env.loadQueries(context, name), context);
        }
      },
      {
        regexp: /^defaults$/i,
        select: function(context) {
          return resolve(browserslist.defaults, context);
        }
      },
      {
        regexp: /^dead$/i,
        select: function(context) {
          var dead = [
            "Baidu >= 0",
            "ie <= 10",
            "ie_mob <= 11",
            "bb <= 10",
            "op_mob <= 12.1",
            "samsung 4"
          ];
          return resolve(dead, context);
        }
      },
      {
        regexp: /^(\w+)$/i,
        select: function(context, name) {
          if (byName(name, context)) {
            throw new BrowserslistError("Specify versions in Browserslist query for browser " + name);
          } else {
            throw unknownQuery(name);
          }
        }
      }
    ];
    (function() {
      for (var name in agents) {
        var browser = agents[name];
        browserslist.data[name] = {
          name,
          versions: normalize(agents[name].versions),
          released: normalize(agents[name].versions.slice(0, -3)),
          releaseDate: agents[name].release_date
        };
        fillUsage(browserslist.usage.global, name, browser.usage_global);
        browserslist.versionAliases[name] = {};
        for (var i = 0; i < browser.versions.length; i++) {
          var full = browser.versions[i];
          if (!full)
            continue;
          if (full.indexOf("-") !== -1) {
            var interval = full.split("-");
            for (var j = 0; j < interval.length; j++) {
              browserslist.versionAliases[name][interval[j]] = full;
            }
          }
        }
      }
      browserslist.versionAliases.op_mob["59"] = "58";
      browserslist.nodeVersions = jsReleases.map(function(release) {
        return release.version;
      });
    })();
    module2.exports = browserslist;
  }
});

// node_modules/caniuse-lite/data/features/aac.js
var require_aac = __commonJS({
  "node_modules/caniuse-lite/data/features/aac.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB", "132": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F", "16": "A B" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "132": "X" }, N: { "1": "A", "2": "B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "132": "tC" } }, B: 6, C: "AAC audio file format" };
  }
});

// node_modules/caniuse-lite/data/features/abortcontroller.js
var require_abortcontroller = __commonJS({
  "node_modules/caniuse-lite/data/features/abortcontroller.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G" }, C: { "1": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB wB xB" }, D: { "1": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB" }, E: { "1": "K L G iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB", "130": "C hB" }, F: { "1": "KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "kC pB lC mC nC oC pC qC", "2": "I gC hC iC jC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "AbortController & AbortSignal" };
  }
});

// node_modules/caniuse-lite/data/features/ac3-ec3.js
var require_ac3_ec3 = __commonJS({
  "node_modules/caniuse-lite/data/features/ac3-ec3.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O", "2": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC", "132": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D", "132": "A" }, K: { "2": "A B C Y hB sB", "132": "iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "132": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "AC-3 (Dolby Digital) and EC-3 (Dolby Digital Plus) codecs" };
  }
});

// node_modules/caniuse-lite/data/features/accelerometer.js
var require_accelerometer = __commonJS({
  "node_modules/caniuse-lite/data/features/accelerometer.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB", "194": "PB kB QB lB RB SB Y TB UB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "Accelerometer" };
  }
});

// node_modules/caniuse-lite/data/features/addeventlistener.js
var require_addeventlistener = __commonJS({
  "node_modules/caniuse-lite/data/features/addeventlistener.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "130": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "257": "vB jB I l J wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "EventTarget.addEventListener()" };
  }
});

// node_modules/caniuse-lite/data/features/alternate-stylesheet.js
var require_alternate_stylesheet = __commonJS({
  "node_modules/caniuse-lite/data/features/alternate-stylesheet.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "E F A B", "2": "J D uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "F B C 9B AC BC CC hB sB DC iB", "16": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "16": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "2": "Y", "16": "A B C hB sB iB" }, L: { "16": "H" }, M: { "16": "X" }, N: { "16": "A B" }, O: { "16": "fC" }, P: { "16": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "16": "sC" }, S: { "1": "tC" } }, B: 1, C: "Alternate stylesheet" };
  }
});

// node_modules/caniuse-lite/data/features/ambient-light.js
var require_ambient_light = __commonJS({
  "node_modules/caniuse-lite/data/features/ambient-light.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K", "132": "L G M N O", "322": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB", "132": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB", "194": "QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB", "322": "PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB 9B AC BC CC hB sB DC iB", "322": "bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "132": "tC" } }, B: 4, C: "Ambient Light Sensor" };
  }
});

// node_modules/caniuse-lite/data/features/apng.js
var require_apng = __commonJS({
  "node_modules/caniuse-lite/data/features/apng.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB" }, D: { "1": "kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB" }, E: { "1": "E F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B 3B" }, F: { "1": "B C DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "0 1 2 3 4 5 6 7 8 9 F G M N O m n o p q r s t u v w x y z AB BB CB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I gC hC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 7, C: "Animated PNG (APNG)" };
  }
});

// node_modules/caniuse-lite/data/features/array-find-index.js
var require_array_find_index = __commonJS({
  "node_modules/caniuse-lite/data/features/array-find-index.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r wB xB" }, D: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB" }, E: { "1": "E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w x y 9B AC BC CC hB sB DC iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D", "16": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Array.prototype.findIndex" };
  }
});

// node_modules/caniuse-lite/data/features/array-find.js
var require_array_find = __commonJS({
  "node_modules/caniuse-lite/data/features/array-find.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "16": "C K L" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r wB xB" }, D: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB" }, E: { "1": "E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w x y 9B AC BC CC hB sB DC iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D", "16": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Array.prototype.find" };
  }
});

// node_modules/caniuse-lite/data/features/array-flat.js
var require_array_flat = __commonJS({
  "node_modules/caniuse-lite/data/features/array-flat.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB wB xB" }, D: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB" }, E: { "1": "C K L G iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB hB" }, F: { "1": "NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB 9B AC BC CC hB sB DC iB" }, G: { "1": "PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pB lC mC nC oC pC qC", "2": "I gC hC iC jC kC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "flat & flatMap array methods" };
  }
});

// node_modules/caniuse-lite/data/features/array-includes.js
var require_array_includes = __commonJS({
  "node_modules/caniuse-lite/data/features/array-includes.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Array.prototype.includes" };
  }
});

// node_modules/caniuse-lite/data/features/arrow-functions.js
var require_arrow_functions = __commonJS({
  "node_modules/caniuse-lite/data/features/arrow-functions.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB" }, D: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w x y 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Arrow functions" };
  }
});

// node_modules/caniuse-lite/data/features/asmjs.js
var require_asmjs = __commonJS({
  "node_modules/caniuse-lite/data/features/asmjs.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O", "132": "P Q R S T U V W Z a b c d e f g h i j k X H", "322": "C" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB" }, D: { "2": "I l J D E F A B C K L G M N O m n o p q r s t u", "132": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "132": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "132": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "132": "Y" }, L: { "132": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I", "132": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "132": "rC" }, R: { "132": "sC" }, S: { "1": "tC" } }, B: 6, C: "asm.js" };
  }
});

// node_modules/caniuse-lite/data/features/async-clipboard.js
var require_async_clipboard = __commonJS({
  "node_modules/caniuse-lite/data/features/async-clipboard.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB wB xB", "132": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB", "66": "PB kB QB lB" }, E: { "1": "L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB" }, F: { "1": "GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC", "260": "VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "260": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "260": "Y" }, L: { "1": "H" }, M: { "132": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC", "260": "kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Asynchronous Clipboard API" };
  }
});

// node_modules/caniuse-lite/data/features/async-functions.js
var require_async_functions = __commonJS({
  "node_modules/caniuse-lite/data/features/async-functions.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K", "194": "L" }, C: { "1": "JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB wB xB" }, D: { "1": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B", "514": "pB" }, F: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC", "514": "MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I gC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Async functions" };
  }
});

// node_modules/caniuse-lite/data/features/atob-btoa.js
var require_atob_btoa = __commonJS({
  "node_modules/caniuse-lite/data/features/atob-btoa.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "2": "F 9B AC", "16": "BC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "16": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Base64 encoding and decoding" };
  }
});

// node_modules/caniuse-lite/data/features/audio-api.js
var require_audio_api = __commonJS({
  "node_modules/caniuse-lite/data/features/audio-api.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r wB xB" }, D: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K", "33": "0 L G M N O m n o p q r s t u v w x y z" }, E: { "1": "G 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "33": "J D E F A B C K L 2B 3B 4B pB hB iB 5B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "G M N O m n o" }, G: { "1": "WC XC qB rB", "2": "oB EC tB FC", "33": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "Web Audio API" };
  }
});

// node_modules/caniuse-lite/data/features/audio.js
var require_audio = __commonJS({
  "node_modules/caniuse-lite/data/features/audio.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "132": "I l J D E F A B C K L G M N O m wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F", "4": "9B AC" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "2": "ZC aC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Audio element" };
  }
});

// node_modules/caniuse-lite/data/features/audiotracks.js
var require_audiotracks = __commonJS({
  "node_modules/caniuse-lite/data/features/audiotracks.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O", "322": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "194": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB", "322": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B" }, F: { "2": "F B C G M N O m n o p q r s t u v w x y 9B AC BC CC hB sB DC iB", "322": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "322": "H" }, M: { "2": "X" }, N: { "1": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "194": "tC" } }, B: 1, C: "Audio Tracks" };
  }
});

// node_modules/caniuse-lite/data/features/autofocus.js
var require_autofocus = __commonJS({
  "node_modules/caniuse-lite/data/features/autofocus.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "2": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 1, C: "Autofocus attribute" };
  }
});

// node_modules/caniuse-lite/data/features/auxclick.js
var require_auxclick = __commonJS({
  "node_modules/caniuse-lite/data/features/auxclick.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB wB xB", "129": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "Auxclick" };
  }
});

// node_modules/caniuse-lite/data/features/av1.js
var require_av1 = __commonJS({
  "node_modules/caniuse-lite/data/features/av1.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N", "194": "O" }, C: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB wB xB", "66": "MB NB OB PB kB QB lB RB SB Y", "260": "TB", "516": "UB" }, D: { "1": "YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB", "66": "VB WB XB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1090": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "mC nC oC pC qC", "2": "I gC hC iC jC kC pB lC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "AV1 video format" };
  }
});

// node_modules/caniuse-lite/data/features/avif.js
var require_avif = __commonJS({
  "node_modules/caniuse-lite/data/features/avif.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB wB xB", "194": "fB gB P Q R mB S T U V W Z a b c d", "257": "e f g h i j k X H nB" }, D: { "1": "U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "oC pC qC", "2": "I gC hC iC jC kC pB lC mC nC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "AVIF image format" };
  }
});

// node_modules/caniuse-lite/data/features/background-attachment.js
var require_background_attachment = __commonJS({
  "node_modules/caniuse-lite/data/features/background-attachment.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "132": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "132": "vB jB I l J D E F A B C K L G M N O m n o p q r wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J D E F A B C 1B 2B 3B 4B pB hB iB", "132": "I K 0B oB 5B", "2050": "L G 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "132": "F 9B AC" }, G: { "2": "oB EC tB", "772": "E FC GC HC IC JC KC LC MC NC OC PC QC", "2050": "RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC dC eC", "132": "cC tB" }, J: { "260": "D A" }, K: { "1": "B C hB sB iB", "2": "Y", "132": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "2": "I", "1028": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1028": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS background-attachment" };
  }
});

// node_modules/caniuse-lite/data/features/background-clip-text.js
var require_background_clip_text = __commonJS({
  "node_modules/caniuse-lite/data/features/background-clip-text.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "G M N O", "33": "C K L P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB wB xB" }, D: { "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "L G 6B 7B qB rB 8B", "16": "0B oB", "33": "I l J D E F A B C K 1B 2B 3B 4B pB hB iB 5B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "VC WC XC qB rB", "16": "oB EC tB FC", "33": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC" }, H: { "2": "YC" }, I: { "16": "jB ZC aC bC", "33": "I H cC tB dC eC" }, J: { "33": "D A" }, K: { "16": "A B C hB sB iB", "33": "Y" }, L: { "33": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "33": "fC" }, P: { "33": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "33": "rC" }, R: { "33": "sC" }, S: { "1": "tC" } }, B: 7, C: "Background-clip: text" };
  }
});

// node_modules/caniuse-lite/data/features/background-img-opts.js
var require_background_img_opts = __commonJS({
  "node_modules/caniuse-lite/data/features/background-img-opts.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB", "36": "xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "516": "I l J D E F A B C K L" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "772": "I l J 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B", "36": "AC" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "4": "oB EC tB GC", "516": "FC" }, H: { "132": "YC" }, I: { "1": "H dC eC", "36": "ZC", "516": "jB I cC tB", "548": "aC bC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS3 Background-image options" };
  }
});

// node_modules/caniuse-lite/data/features/background-position-x-y.js
var require_background_position_x_y = __commonJS({
  "node_modules/caniuse-lite/data/features/background-position-x-y.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 7, C: "background-position-x & background-position-y" };
  }
});

// node_modules/caniuse-lite/data/features/background-repeat-round-space.js
var require_background_repeat_round_space = __commonJS({
  "node_modules/caniuse-lite/data/features/background-repeat-round-space.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E uB", "132": "F" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w x y" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F G M N O 9B AC" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 4, C: "CSS background-repeat round and space" };
  }
});

// node_modules/caniuse-lite/data/features/background-sync.js
var require_background_sync = __commonJS({
  "node_modules/caniuse-lite/data/features/background-sync.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X wB xB", "16": "H nB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Background Sync API" };
  }
});

// node_modules/caniuse-lite/data/features/battery-status.js
var require_battery_status = __commonJS({
  "node_modules/caniuse-lite/data/features/battery-status.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "AB BB CB DB EB FB GB HB IB", "2": "vB jB I l J D E F JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "132": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z", "164": "A B C K L G" }, D: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "66": "4" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Battery Status API" };
  }
});

// node_modules/caniuse-lite/data/features/beacon.js
var require_beacon = __commonJS({
  "node_modules/caniuse-lite/data/features/beacon.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x wB xB" }, D: { "1": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Beacon API" };
  }
});

// node_modules/caniuse-lite/data/features/beforeafterprint.js
var require_beforeafterprint = __commonJS({
  "node_modules/caniuse-lite/data/features/beforeafterprint.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "16": "uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l wB xB" }, D: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB iB" }, F: { "1": "HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB 9B AC BC CC hB sB DC iB" }, G: { "1": "RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "16": "A B" }, O: { "16": "fC" }, P: { "2": "gC hC iC jC kC pB lC mC nC oC pC qC", "16": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 1, C: "Printing Events" };
  }
});

// node_modules/caniuse-lite/data/features/bigint.js
var require_bigint = __commonJS({
  "node_modules/caniuse-lite/data/features/bigint.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y wB xB", "194": "TB UB VB" }, D: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB" }, E: { "1": "L G 6B 7B qB rB 8B", "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB 5B" }, F: { "1": "LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB 9B AC BC CC hB sB DC iB" }, G: { "1": "VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "kC pB lC mC nC oC pC qC", "2": "I gC hC iC jC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "BigInt" };
  }
});

// node_modules/caniuse-lite/data/features/blobbuilder.js
var require_blobbuilder = __commonJS({
  "node_modules/caniuse-lite/data/features/blobbuilder.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l wB xB", "36": "J D E F A B C" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D", "36": "E F A B C K L G M N O m" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B C 9B AC BC CC hB sB DC" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC" }, H: { "2": "YC" }, I: { "1": "H", "2": "ZC aC bC", "36": "jB I cC tB dC eC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y iB", "2": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Blob constructing" };
  }
});

// node_modules/caniuse-lite/data/features/bloburls.js
var require_bloburls = __commonJS({
  "node_modules/caniuse-lite/data/features/bloburls.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "129": "A B" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "129": "C K L" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D", "33": "E F A B C K L G M N O m n o p" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "33": "J" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC", "33": "GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB ZC aC bC", "33": "I cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Blob URLs" };
  }
});

// node_modules/caniuse-lite/data/features/border-image.js
var require_border_image = __commonJS({
  "node_modules/caniuse-lite/data/features/border-image.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "129": "C K" }, C: { "1": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "260": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB", "804": "I l J D E F A B C K L wB xB" }, D: { "1": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "260": "IB JB KB LB MB", "388": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB", "1412": "G M N O m n o p q r s t u v w", "1956": "I l J D E F A B C K L" }, E: { "1": "rB 8B", "129": "A B C K L G 4B pB hB iB 5B 6B 7B qB", "1412": "J D E F 2B 3B", "1956": "I l 0B oB 1B" }, F: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F 9B AC", "260": "5 6 7 8 9", "388": "0 1 2 3 4 G M N O m n o p q r s t u v w x y z", "1796": "BC CC", "1828": "B C hB sB DC iB" }, G: { "1": "rB", "129": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB", "1412": "E GC HC IC JC", "1956": "oB EC tB FC" }, H: { "1828": "YC" }, I: { "1": "H", "388": "dC eC", "1956": "jB I ZC aC bC cC tB" }, J: { "1412": "A", "1924": "D" }, K: { "1": "Y", "2": "A", "1828": "B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "388": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "260": "gC hC", "388": "I" }, Q: { "260": "rC" }, R: { "260": "sC" }, S: { "260": "tC" } }, B: 4, C: "CSS3 Border images" };
  }
});

// node_modules/caniuse-lite/data/features/border-radius.js
var require_border_radius = __commonJS({
  "node_modules/caniuse-lite/data/features/border-radius.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "257": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB", "289": "jB wB xB", "292": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "I" }, E: { "1": "l D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "33": "I 0B oB", "129": "J 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "33": "oB" }, H: { "2": "YC" }, I: { "1": "jB I H aC bC cC tB dC eC", "33": "ZC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "257": "tC" } }, B: 4, C: "CSS3 Border-radius (rounded corners)" };
  }
});

// node_modules/caniuse-lite/data/features/broadcastchannel.js
var require_broadcastchannel = __commonJS({
  "node_modules/caniuse-lite/data/features/broadcastchannel.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB" }, E: { "1": "rB 8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I gC hC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 1, C: "BroadcastChannel" };
  }
});

// node_modules/caniuse-lite/data/features/brotli.js
var require_brotli = __commonJS({
  "node_modules/caniuse-lite/data/features/brotli.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L" }, C: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB wB xB" }, D: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB", "194": "GB", "257": "HB" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "513": "B C hB iB" }, F: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "194": "3 4" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 6, C: "Brotli Accept-Encoding/Content-Encoding" };
  }
});

// node_modules/caniuse-lite/data/features/calc.js
var require_calc = __commonJS({
  "node_modules/caniuse-lite/data/features/calc.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "260": "F", "516": "A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "33": "I l J D E F A B C K L G" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O", "33": "m n o p q r s" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "33": "J" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC", "33": "GC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB", "132": "dC eC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "calc() as CSS unit value" };
  }
});

// node_modules/caniuse-lite/data/features/canvas-blending.js
var require_canvas_blending = __commonJS({
  "node_modules/caniuse-lite/data/features/canvas-blending.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Canvas blend modes" };
  }
});

// node_modules/caniuse-lite/data/features/canvas-text.js
var require_canvas_text = __commonJS({
  "node_modules/caniuse-lite/data/features/canvas-text.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "uB", "8": "J D E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "8": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "8": "F 9B AC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "8": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Text API for Canvas" };
  }
});

// node_modules/caniuse-lite/data/features/canvas.js
var require_canvas = __commonJS({
  "node_modules/caniuse-lite/data/features/canvas.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "uB", "8": "J D E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "132": "vB jB wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "132": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "260": "YC" }, I: { "1": "jB I H cC tB dC eC", "132": "ZC aC bC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Canvas (basic support)" };
  }
});

// node_modules/caniuse-lite/data/features/ch-unit.js
var require_ch_unit = __commonJS({
  "node_modules/caniuse-lite/data/features/ch-unit.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "132": "F A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "ch (character) unit" };
  }
});

// node_modules/caniuse-lite/data/features/chacha20-poly1305.js
var require_chacha20_poly1305 = __commonJS({
  "node_modules/caniuse-lite/data/features/chacha20-poly1305.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB wB xB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "129": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC", "16": "eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "ChaCha20-Poly1305 cipher suites for TLS" };
  }
});

// node_modules/caniuse-lite/data/features/channel-messaging.js
var require_channel_messaging = __commonJS({
  "node_modules/caniuse-lite/data/features/channel-messaging.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s wB xB", "194": "0 1 2 3 4 5 6 7 t u v w x y z" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "2": "F 9B AC", "16": "BC" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Channel messaging" };
  }
});

// node_modules/caniuse-lite/data/features/childnode-remove.js
var require_childnode_remove = __commonJS({
  "node_modules/caniuse-lite/data/features/childnode-remove.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "16": "C" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "16": "J" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "ChildNode.remove()" };
  }
});

// node_modules/caniuse-lite/data/features/classlist.js
var require_classlist = __commonJS({
  "node_modules/caniuse-lite/data/features/classlist.js"(exports2, module2) {
    module2.exports = { A: { A: { "8": "J D E F uB", "1924": "A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "8": "vB jB wB", "516": "r s", "772": "I l J D E F A B C K L G M N O m n o p q xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "8": "I l J D", "516": "r s t u", "772": "q", "900": "E F A B C K L G M N O m n o p" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "I l 0B oB", "900": "J 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "8": "F B 9B AC BC CC hB", "900": "C sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "8": "oB EC tB", "900": "FC GC" }, H: { "900": "YC" }, I: { "1": "H dC eC", "8": "ZC aC bC", "900": "jB I cC tB" }, J: { "1": "A", "900": "D" }, K: { "1": "Y", "8": "A B", "900": "C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "900": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "classList (DOMTokenList)" };
  }
});

// node_modules/caniuse-lite/data/features/client-hints-dpr-width-viewport.js
var require_client_hints_dpr_width_viewport = __commonJS({
  "node_modules/caniuse-lite/data/features/client-hints-dpr-width-viewport.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 6, C: "Client Hints: DPR, Width, Viewport-Width" };
  }
});

// node_modules/caniuse-lite/data/features/clipboard.js
var require_clipboard = __commonJS({
  "node_modules/caniuse-lite/data/features/clipboard.js"(exports2, module2) {
    module2.exports = { A: { A: { "2436": "J D E F A B uB" }, B: { "260": "N O", "2436": "C K L G M", "8196": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB", "772": "0 1 2 3 4 5 6 7 p q r s t u v w x y z", "4100": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "I l J D E F A B C", "2564": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z", "8196": "PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "10244": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB" }, E: { "1": "C K L G iB 5B 6B 7B qB rB 8B", "16": "0B oB", "2308": "A B pB hB", "2820": "I l J D E F 1B 2B 3B 4B" }, F: { "2": "F B 9B AC BC CC hB sB DC", "16": "C", "516": "iB", "2564": "G M N O m n o p q r s t u v w", "8196": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "10244": "0 1 2 3 4 5 6 7 8 9 x y z AB BB" }, G: { "1": "PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB", "2820": "E FC GC HC IC JC KC LC MC NC OC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "260": "H", "2308": "dC eC" }, J: { "2": "D", "2308": "A" }, K: { "2": "A B C hB sB", "16": "iB", "260": "Y" }, L: { "8196": "H" }, M: { "1028": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2052": "gC hC", "2308": "I", "8196": "iC jC kC pB lC mC nC oC pC qC" }, Q: { "10244": "rC" }, R: { "2052": "sC" }, S: { "4100": "tC" } }, B: 5, C: "Synchronous Clipboard API" };
  }
});

// node_modules/caniuse-lite/data/features/colr-v1.js
var require_colr_v1 = __commonJS({
  "node_modules/caniuse-lite/data/features/colr-v1.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "j k X H", "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i wB xB", "258": "j k X H nB" }, D: { "1": "j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a", "194": "b c d e f g h i" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "16": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "COLR/CPAL(v1) Font Formats" };
  }
});

// node_modules/caniuse-lite/data/features/colr.js
var require_colr = __commonJS({
  "node_modules/caniuse-lite/data/features/colr.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "257": "F A B" }, B: { "1": "C K L G M N O", "513": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB", "513": "ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "L G 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "129": "B C K hB iB 5B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB 9B AC BC CC hB sB DC iB", "513": "PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "16": "A B" }, O: { "1": "fC" }, P: { "1": "pB lC mC nC oC pC qC", "2": "I gC hC iC jC kC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "COLR/CPAL(v0) Font Formats" };
  }
});

// node_modules/caniuse-lite/data/features/comparedocumentposition.js
var require_comparedocumentposition = __commonJS({
  "node_modules/caniuse-lite/data/features/comparedocumentposition.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "16": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L", "132": "G M N O m n o p q r s t u v w" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "16": "I l J 0B oB", "132": "D E F 2B 3B 4B", "260": "1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "16": "F B 9B AC BC CC hB sB", "132": "G M" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB", "132": "E EC tB FC GC HC IC JC KC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "16": "ZC aC", "132": "jB I bC cC tB" }, J: { "132": "D A" }, K: { "1": "C Y iB", "16": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Node.compareDocumentPosition()" };
  }
});

// node_modules/caniuse-lite/data/features/console-basic.js
var require_console_basic = __commonJS({
  "node_modules/caniuse-lite/data/features/console-basic.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D uB", "132": "E F" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "2": "F 9B AC BC CC" }, G: { "1": "oB EC tB FC", "513": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "4097": "YC" }, I: { "1025": "jB I H ZC aC bC cC tB dC eC" }, J: { "258": "D A" }, K: { "2": "A", "258": "B C hB sB iB", "1025": "Y" }, L: { "1025": "H" }, M: { "2049": "X" }, N: { "258": "A B" }, O: { "258": "fC" }, P: { "1025": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1025": "sC" }, S: { "1": "tC" } }, B: 1, C: "Basic console logging functions" };
  }
});

// node_modules/caniuse-lite/data/features/console-time.js
var require_console_time = __commonJS({
  "node_modules/caniuse-lite/data/features/console-time.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "2": "F 9B AC BC CC", "16": "B" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "Y", "16": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "console.time and console.timeEnd" };
  }
});

// node_modules/caniuse-lite/data/features/const.js
var require_const = __commonJS({
  "node_modules/caniuse-lite/data/features/const.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "2052": "B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "132": "vB jB I l J D E F A B C wB xB", "260": "0 1 2 K L G M N O m n o p q r s t u v w x y z" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "260": "I l J D E F A B C K L G M N O m n", "772": "0 1 2 3 4 5 6 7 o p q r s t u v w x y z", "1028": "8 9 AB BB CB DB EB FB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "260": "I l A 0B oB pB", "772": "J D E F 1B 2B 3B 4B" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F 9B", "132": "B AC BC CC hB sB", "644": "C DC iB", "772": "G M N O m n o p q r s t u", "1028": "0 1 2 v w x y z" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "260": "oB EC tB LC MC", "772": "E FC GC HC IC JC KC" }, H: { "644": "YC" }, I: { "1": "H", "16": "ZC aC", "260": "bC", "772": "jB I cC tB dC eC" }, J: { "772": "D A" }, K: { "1": "Y", "132": "A B hB sB", "644": "C iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "1028": "I" }, Q: { "1": "rC" }, R: { "1028": "sC" }, S: { "1": "tC" } }, B: 6, C: "const" };
  }
});

// node_modules/caniuse-lite/data/features/constraint-validation.js
var require_constraint_validation = __commonJS({
  "node_modules/caniuse-lite/data/features/constraint-validation.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "900": "A B" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "388": "L G M", "900": "C K" }, C: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "260": "GB HB", "388": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB", "900": "I l J D E F A B C K L G M N O m n o p q r s t u v" }, D: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L", "388": "0 1 2 3 4 5 6 s t u v w x y z", "900": "G M N O m n o p q r" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB", "388": "E F 3B 4B", "900": "J D 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F B 9B AC BC CC hB sB", "388": "G M N O m n o p q r s t", "900": "C DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB", "388": "E HC IC JC KC", "900": "FC GC" }, H: { "2": "YC" }, I: { "1": "H", "16": "jB ZC aC bC", "388": "dC eC", "900": "I cC tB" }, J: { "16": "D", "388": "A" }, K: { "1": "Y", "16": "A B hB sB", "900": "C iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "900": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "388": "tC" } }, B: 1, C: "Constraint Validation API" };
  }
});

// node_modules/caniuse-lite/data/features/contenteditable.js
var require_contenteditable = __commonJS({
  "node_modules/caniuse-lite/data/features/contenteditable.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB", "4": "jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "D A" }, K: { "1": "Y iB", "2": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "contenteditable attribute (basic support)" };
  }
});

// node_modules/caniuse-lite/data/features/contentsecuritypolicy.js
var require_contentsecuritypolicy = __commonJS({
  "node_modules/caniuse-lite/data/features/contentsecuritypolicy.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "132": "A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "129": "I l J D E F A B C K L G M N O m n o p" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K", "257": "L G M N O m n o p q r" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB", "257": "J 2B", "260": "1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB", "257": "GC", "260": "FC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D", "257": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "257": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Content Security Policy 1.0" };
  }
});

// node_modules/caniuse-lite/data/features/contentsecuritypolicy2.js
var require_contentsecuritypolicy2 = __commonJS({
  "node_modules/caniuse-lite/data/features/contentsecuritypolicy2.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L", "4100": "G M N O" }, C: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x wB xB", "132": "0 1 y z", "260": "2", "516": "3 4 5 6 7 8 9 AB BB" }, D: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "1028": "3 4 5", "2052": "6" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p 9B AC BC CC hB sB DC iB", "1028": "q r s", "2052": "t" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "Content Security Policy Level 2" };
  }
});

// node_modules/caniuse-lite/data/features/cookie-store-api.js
var require_cookie_store_api = __commonJS({
  "node_modules/caniuse-lite/data/features/cookie-store-api.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "W Z a b c d e f g h i j k X H", "2": "C K L G M N O", "194": "P Q R S T U V" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB", "194": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB 9B AC BC CC hB sB DC iB", "194": "IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "oC pC qC", "2": "I gC hC iC jC kC pB lC mC nC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Cookie Store API" };
  }
});

// node_modules/caniuse-lite/data/features/cors.js
var require_cors = __commonJS({
  "node_modules/caniuse-lite/data/features/cors.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D uB", "132": "A", "260": "E F" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB", "1025": "lB RB SB Y TB UB VB WB XB YB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l J D E F A B C" }, E: { "2": "0B oB", "513": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "644": "I l 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC hB sB DC" }, G: { "513": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "644": "oB EC tB FC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "132": "jB I ZC aC bC cC tB" }, J: { "1": "A", "132": "D" }, K: { "1": "C Y iB", "2": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "132": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Cross-Origin Resource Sharing" };
  }
});

// node_modules/caniuse-lite/data/features/createimagebitmap.js
var require_createimagebitmap = __commonJS({
  "node_modules/caniuse-lite/data/features/createimagebitmap.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "1028": "e f g h i j k X H nB", "3076": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d" }, D: { "1": "kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB", "132": "HB IB", "260": "JB KB", "516": "LB MB NB OB PB" }, E: { "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B 6B", "4100": "G 7B qB rB 8B" }, F: { "1": "DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "132": "4 5", "260": "6 7", "516": "8 9 AB BB CB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC", "4100": "XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "3076": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "16": "I gC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "3076": "tC" } }, B: 1, C: "createImageBitmap" };
  }
});

// node_modules/caniuse-lite/data/features/credential-management.js
var require_credential_management = __commonJS({
  "node_modules/caniuse-lite/data/features/credential-management.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB", "66": "FB GB HB", "129": "IB JB KB LB MB NB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB 9B AC BC CC hB sB DC iB" }, G: { "1": "VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I gC hC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Credential Management API" };
  }
});

// node_modules/caniuse-lite/data/features/cryptography.js
var require_cryptography = __commonJS({
  "node_modules/caniuse-lite/data/features/cryptography.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "8": "J D E F A", "164": "B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "513": "C K L G M N O" }, C: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "8": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y wB xB", "66": "0 z" }, D: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "8": "0 1 2 3 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "8": "I l J D 0B oB 1B 2B", "289": "E F A 3B 4B pB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "8": "F B C G M N O m n o p q 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "8": "oB EC tB FC GC HC", "289": "E IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "8": "jB I ZC aC bC cC tB dC eC" }, J: { "8": "D A" }, K: { "1": "Y", "8": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "8": "A", "164": "B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "Web Cryptography" };
  }
});

// node_modules/caniuse-lite/data/features/css-all.js
var require_css_all = __commonJS({
  "node_modules/caniuse-lite/data/features/css-all.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t wB xB" }, D: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q 9B AC BC CC hB sB DC iB" }, G: { "1": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC" }, H: { "2": "YC" }, I: { "1": "H eC", "2": "jB I ZC aC bC cC tB dC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS all property" };
  }
});

// node_modules/caniuse-lite/data/features/css-animation.js
var require_css_animation = __commonJS({
  "node_modules/caniuse-lite/data/features/css-animation.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I wB xB", "33": "l J D E F A B C K L G" }, D: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB", "33": "J D E 1B 2B 3B", "292": "I l" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC hB sB DC", "33": "C G M N O m n o p q r s t u v w" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "33": "E GC HC IC", "164": "oB EC tB FC" }, H: { "2": "YC" }, I: { "1": "H", "33": "I cC tB dC eC", "164": "jB ZC aC bC" }, J: { "33": "D A" }, K: { "1": "Y iB", "2": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "33": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS Animation" };
  }
});

// node_modules/caniuse-lite/data/features/css-any-link.js
var require_css_any_link = __commonJS({
  "node_modules/caniuse-lite/data/features/css-any-link.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "16": "vB", "33": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB wB xB" }, D: { "1": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "I l J 0B oB 1B", "33": "D E 2B 3B" }, F: { "1": "JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB FC", "33": "E GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "16": "jB I ZC aC bC cC tB", "33": "dC eC" }, J: { "16": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "33": "fC" }, P: { "1": "kC pB lC mC nC oC pC qC", "16": "I", "33": "gC hC iC jC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "33": "tC" } }, B: 5, C: "CSS :any-link selector" };
  }
});

// node_modules/caniuse-lite/data/features/css-appearance.js
var require_css_appearance = __commonJS({
  "node_modules/caniuse-lite/data/features/css-appearance.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "T U V W Z a b c d e f g h i j k X H", "33": "S", "164": "P Q R", "388": "C K L G M N O" }, C: { "1": "Q R mB S T U V W Z a b c d e f g h i j k X H nB", "164": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P", "676": "0 1 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "S", "164": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R" }, E: { "1": "rB 8B", "164": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "1": "bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "YB ZB aB", "164": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB" }, G: { "1": "rB", "164": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "1": "H", "164": "jB I ZC aC bC cC tB dC eC" }, J: { "164": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A", "388": "B" }, O: { "164": "fC" }, P: { "164": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "164": "rC" }, R: { "164": "sC" }, S: { "164": "tC" } }, B: 5, C: "CSS Appearance" };
  }
});

// node_modules/caniuse-lite/data/features/css-at-counter-style.js
var require_css_at_counter_style = __commonJS({
  "node_modules/caniuse-lite/data/features/css-at-counter-style.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b", "132": "c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "132": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b", "132": "c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB 9B AC BC CC hB sB DC iB", "132": "fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "132": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "132": "Y" }, L: { "132": "H" }, M: { "132": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC", "132": "qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "132": "tC" } }, B: 4, C: "CSS Counter Styles" };
  }
});

// node_modules/caniuse-lite/data/features/css-autofill.js
var require_css_autofill = __commonJS({
  "node_modules/caniuse-lite/data/features/css-autofill.js"(exports2, module2) {
    module2.exports = { A: { D: { "1": "h i j k X H nB yB zB", "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g" }, L: { "1": "H" }, B: { "1": "h i j k X H", "2": "C K L G M N O", "33": "P Q R S T U V W Z a b c d e f g" }, C: { "1": "V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U wB xB" }, M: { "1": "X" }, A: { "2": "J D E F A B uB" }, F: { "1": "mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R" }, K: { "2": "A B C hB sB iB", "33": "Y" }, E: { "1": "G 7B qB rB", "2": "8B", "33": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B 6B" }, G: { "1": "XC qB rB", "33": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC" }, P: { "33": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, I: { "1": "H", "33": "jB I ZC aC bC cC tB dC eC" } }, B: 6, C: ":autofill CSS pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-backdrop-filter.js
var require_css_backdrop_filter = __commonJS({
  "node_modules/caniuse-lite/data/features/css-backdrop-filter.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M", "257": "N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB wB xB", "578": "YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB", "194": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB" }, E: { "2": "I l J D E 0B oB 1B 2B 3B", "33": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "194": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB" }, G: { "2": "E oB EC tB FC GC HC IC", "33": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "578": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "mC nC oC pC qC", "2": "I", "194": "gC hC iC jC kC pB lC" }, Q: { "194": "rC" }, R: { "194": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS Backdrop Filter" };
  }
});

// node_modules/caniuse-lite/data/features/css-background-offsets.js
var require_css_background_offsets = __commonJS({
  "node_modules/caniuse-lite/data/features/css-background-offsets.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS background-position edge offsets" };
  }
});

// node_modules/caniuse-lite/data/features/css-backgroundblendmode.js
var require_css_backgroundblendmode = __commonJS({
  "node_modules/caniuse-lite/data/features/css-backgroundblendmode.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w wB xB" }, D: { "1": "2 3 4 5 6 7 8 9 AB BB CB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "260": "DB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B", "132": "E F A 3B 4B" }, F: { "1": "1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o 9B AC BC CC hB sB DC iB", "260": "0" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC", "132": "E IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS background-blend-mode" };
  }
});

// node_modules/caniuse-lite/data/features/css-boxdecorationbreak.js
var require_css_boxdecorationbreak = __commonJS({
  "node_modules/caniuse-lite/data/features/css-boxdecorationbreak.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "164": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y wB xB" }, D: { "2": "I l J D E F A B C K L G M N O m n o", "164": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J 0B oB 1B", "164": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F 9B AC BC CC", "129": "B C hB sB DC iB", "164": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "oB EC tB FC GC", "164": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "132": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "164": "H dC eC" }, J: { "2": "D", "164": "A" }, K: { "2": "A", "129": "B C hB sB iB", "164": "Y" }, L: { "164": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "164": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "164": "rC" }, R: { "164": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS box-decoration-break" };
  }
});

// node_modules/caniuse-lite/data/features/css-boxshadow.js
var require_css_boxshadow = __commonJS({
  "node_modules/caniuse-lite/data/features/css-boxshadow.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "33": "wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "I l J D E F" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "33": "l", "164": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "33": "EC tB", "164": "oB" }, H: { "2": "YC" }, I: { "1": "I H cC tB dC eC", "164": "jB ZC aC bC" }, J: { "1": "A", "33": "D" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS3 Box-shadow" };
  }
});

// node_modules/caniuse-lite/data/features/css-canvas.js
var require_css_canvas = __commonJS({
  "node_modules/caniuse-lite/data/features/css-canvas.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB" }, E: { "2": "0B oB", "33": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "2 3 4 5 6 7 8 9 F B C AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "33": "0 1 G M N O m n o p q r s t u v w x y z" }, G: { "33": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "H", "33": "jB I ZC aC bC cC tB dC eC" }, J: { "33": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "gC hC iC jC kC pB lC mC nC oC pC qC", "33": "I" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS Canvas Drawings" };
  }
});

// node_modules/caniuse-lite/data/features/css-caret-color.js
var require_css_caret_color = __commonJS({
  "node_modules/caniuse-lite/data/features/css-caret-color.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB wB xB" }, D: { "1": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB" }, F: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I gC hC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "CSS caret-color" };
  }
});

// node_modules/caniuse-lite/data/features/css-cascade-layers.js
var require_css_cascade_layers = __commonJS({
  "node_modules/caniuse-lite/data/features/css-cascade-layers.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "k X H", "2": "C K L G M N O P Q R S T U V W Z a b c d e f g", "322": "h i j" }, C: { "1": "i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e wB xB", "194": "f g h" }, D: { "1": "k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g", "322": "h i j" }, E: { "1": "rB 8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "1": "V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U 9B AC BC CC hB sB DC iB" }, G: { "1": "rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Cascade Layers" };
  }
});

// node_modules/caniuse-lite/data/features/css-case-insensitive.js
var require_css_case_insensitive = __commonJS({
  "node_modules/caniuse-lite/data/features/css-case-insensitive.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB wB xB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 5, C: "Case-insensitive CSS attribute selectors" };
  }
});

// node_modules/caniuse-lite/data/features/css-clip-path.js
var require_css_clip_path = __commonJS({
  "node_modules/caniuse-lite/data/features/css-clip-path.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N", "260": "P Q R S T U V W Z a b c d e f g h i j k X H", "3138": "O" }, C: { "1": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "132": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB wB xB", "644": "EB FB GB HB IB JB KB" }, D: { "2": "I l J D E F A B C K L G M N O m n o p q", "260": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "292": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB" }, E: { "2": "I l J 0B oB 1B 2B", "260": "L G 5B 6B 7B qB rB 8B", "292": "D E F A B C K 3B 4B pB hB iB" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "260": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "292": "0 1 2 3 4 5 6 7 8 G M N O m n o p q r s t u v w x y z" }, G: { "2": "oB EC tB FC GC", "260": "RC SC TC UC VC WC XC qB rB", "292": "E HC IC JC KC LC MC NC OC PC QC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "260": "H", "292": "dC eC" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "260": "Y" }, L: { "260": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "292": "fC" }, P: { "292": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "292": "rC" }, R: { "260": "sC" }, S: { "644": "tC" } }, B: 4, C: "CSS clip-path property (for HTML)" };
  }
});

// node_modules/caniuse-lite/data/features/css-color-adjust.js
var require_css_color_adjust = __commonJS({
  "node_modules/caniuse-lite/data/features/css-color-adjust.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "33": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB wB xB" }, D: { "16": "I l J D E F A B C K L G M N O", "33": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l 0B oB 1B", "33": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "16": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "16": "jB I ZC aC bC cC tB dC eC", "33": "H" }, J: { "16": "D A" }, K: { "2": "A B C hB sB iB", "33": "Y" }, L: { "16": "H" }, M: { "1": "X" }, N: { "16": "A B" }, O: { "16": "fC" }, P: { "16": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "33": "rC" }, R: { "16": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS color-adjust" };
  }
});

// node_modules/caniuse-lite/data/features/css-color-function.js
var require_css_color_function = __commonJS({
  "node_modules/caniuse-lite/data/features/css-color-function.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "G 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B", "132": "B C K L pB hB iB 5B 6B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC", "132": "MC NC OC PC QC RC SC TC UC VC WC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS color() function" };
  }
});

// node_modules/caniuse-lite/data/features/css-conic-gradients.js
var require_css_conic_gradients = __commonJS({
  "node_modules/caniuse-lite/data/features/css-conic-gradients.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB wB xB", "578": "dB eB fB gB P Q R mB" }, D: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB", "194": "kB QB lB RB SB Y TB UB VB WB" }, E: { "1": "K L G iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB 9B AC BC CC hB sB DC iB", "194": "DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB" }, G: { "1": "QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pB lC mC nC oC pC qC", "2": "I gC hC iC jC kC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Conical Gradients" };
  }
});

// node_modules/caniuse-lite/data/features/css-container-queries.js
var require_css_container_queries = __commonJS({
  "node_modules/caniuse-lite/data/features/css-container-queries.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d", "194": "e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c", "194": "e f g h i j k X H nB yB zB", "450": "d" }, E: { "1": "8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB 9B AC BC CC hB sB DC iB", "194": "P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Container Queries" };
  }
});

// node_modules/caniuse-lite/data/features/css-containment.js
var require_css_containment = __commonJS({
  "node_modules/caniuse-lite/data/features/css-containment.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "194": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB" }, D: { "1": "JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "66": "IB" }, E: { "1": "rB 8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "66": "5 6" }, G: { "1": "rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I gC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "194": "tC" } }, B: 2, C: "CSS Containment" };
  }
});

// node_modules/caniuse-lite/data/features/css-content-visibility.js
var require_css_content_visibility = __commonJS({
  "node_modules/caniuse-lite/data/features/css-content-visibility.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O P Q R S T" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "oC pC qC", "2": "I gC hC iC jC kC pB lC mC nC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS content-visibility" };
  }
});

// node_modules/caniuse-lite/data/features/css-counters.js
var require_css_counters = __commonJS({
  "node_modules/caniuse-lite/data/features/css-counters.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "E F A B", "2": "J D uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS Counters" };
  }
});

// node_modules/caniuse-lite/data/features/css-crisp-edges.js
var require_css_crisp_edges = __commonJS({
  "node_modules/caniuse-lite/data/features/css-crisp-edges.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J uB", "2340": "D E F A B" }, B: { "2": "C K L G M N O", "1025": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "e f g h i j k X H nB", "2": "vB jB wB", "513": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d", "545": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y xB" }, D: { "2": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "1025": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "164": "J", "4644": "D E F 2B 3B 4B" }, F: { "2": "F B G M N O m n o p q r s t u 9B AC BC CC hB sB", "545": "C DC iB", "1025": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB", "4260": "FC GC", "4644": "E HC IC JC KC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "1025": "H" }, J: { "2": "D", "4260": "A" }, K: { "2": "A B hB sB", "545": "C iB", "1025": "Y" }, L: { "1025": "H" }, M: { "545": "X" }, N: { "2340": "A B" }, O: { "1": "fC" }, P: { "1025": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1025": "rC" }, R: { "1025": "sC" }, S: { "4097": "tC" } }, B: 7, C: "Crisp edges/pixelated images" };
  }
});

// node_modules/caniuse-lite/data/features/css-cross-fade.js
var require_css_cross_fade = __commonJS({
  "node_modules/caniuse-lite/data/features/css-cross-fade.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "33": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "I l J D E F A B C K L G M", "33": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB", "33": "J D E F 1B 2B 3B 4B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB", "33": "E FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "33": "H dC eC" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "33": "Y" }, L: { "33": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "33": "fC" }, P: { "33": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "33": "rC" }, R: { "33": "sC" }, S: { "2": "tC" } }, B: 4, C: "CSS Cross-Fade Function" };
  }
});

// node_modules/caniuse-lite/data/features/css-default-pseudo.js
var require_css_default_pseudo = __commonJS({
  "node_modules/caniuse-lite/data/features/css-default-pseudo.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "16": "vB jB wB xB" }, D: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L", "132": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB", "132": "J D E F A 1B 2B 3B 4B" }, F: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F B 9B AC BC CC hB sB", "132": "0 1 2 3 4 G M N O m n o p q r s t u v w x y z", "260": "C DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB FC GC", "132": "E HC IC JC KC LC" }, H: { "260": "YC" }, I: { "1": "H", "16": "jB ZC aC bC", "132": "I cC tB dC eC" }, J: { "16": "D", "132": "A" }, K: { "1": "Y", "16": "A B C hB sB", "260": "iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "132": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "132": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 7, C: ":default CSS pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-descendant-gtgt.js
var require_css_descendant_gtgt = __commonJS({
  "node_modules/caniuse-lite/data/features/css-descendant-gtgt.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O Q R S T U V W Z a b c d e f g h i j k X H", "16": "P" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "B", "2": "I l J D E F A C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Explicit descendant combinator >>" };
  }
});

// node_modules/caniuse-lite/data/features/css-deviceadaptation.js
var require_css_deviceadaptation = __commonJS({
  "node_modules/caniuse-lite/data/features/css-deviceadaptation.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "164": "A B" }, B: { "66": "P Q R S T U V W Z a b c d e f g h i j k X H", "164": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "I l J D E F A B C K L G M N O m n o p q r s t u v", "66": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "66": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "292": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A Y", "292": "B C hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "164": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "66": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Device Adaptation" };
  }
});

// node_modules/caniuse-lite/data/features/css-dir-pseudo.js
var require_css_dir_pseudo = __commonJS({
  "node_modules/caniuse-lite/data/features/css-dir-pseudo.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M wB xB", "33": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b", "194": "c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "33": "tC" } }, B: 5, C: ":dir() CSS pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-display-contents.js
var require_css_display_contents = __commonJS({
  "node_modules/caniuse-lite/data/features/css-display-contents.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "a b c d e f g h i j k X H", "2": "C K L G M N O", "260": "P Q R S T U V W Z" }, C: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "260": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB" }, D: { "1": "a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB", "194": "PB kB QB lB RB SB Y", "260": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z" }, E: { "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB", "260": "L G 5B 6B 7B qB rB 8B", "772": "C K hB iB" }, F: { "1": "eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB 9B AC BC CC hB sB DC iB", "260": "JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC", "260": "UC VC WC XC qB rB", "772": "OC PC QC RC SC TC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pC qC", "2": "I gC hC iC jC", "260": "kC pB lC mC nC oC" }, Q: { "260": "rC" }, R: { "2": "sC" }, S: { "260": "tC" } }, B: 5, C: "CSS display: contents" };
  }
});

// node_modules/caniuse-lite/data/features/css-element-function.js
var require_css_element_function = __commonJS({
  "node_modules/caniuse-lite/data/features/css-element-function.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "164": "vB jB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "33": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "33": "tC" } }, B: 5, C: "CSS element() function" };
  }
});

// node_modules/caniuse-lite/data/features/css-env-function.js
var require_css_env_function = __commonJS({
  "node_modules/caniuse-lite/data/features/css-env-function.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y wB xB" }, D: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "132": "B" }, F: { "1": "NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC", "132": "NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pB lC mC nC oC pC qC", "2": "I gC hC iC jC kC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS Environment Variables env()" };
  }
});

// node_modules/caniuse-lite/data/features/css-exclusions.js
var require_css_exclusions = __commonJS({
  "node_modules/caniuse-lite/data/features/css-exclusions.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "33": "A B" }, B: { "2": "P Q R S T U V W Z a b c d e f g h i j k X H", "33": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "33": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Exclusions Level 1" };
  }
});

// node_modules/caniuse-lite/data/features/css-featurequeries.js
var require_css_featurequeries = __commonJS({
  "node_modules/caniuse-lite/data/features/css-featurequeries.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B C 9B AC BC CC hB sB DC" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS Feature Queries" };
  }
});

// node_modules/caniuse-lite/data/features/css-file-selector-button.js
var require_css_file_selector_button = __commonJS({
  "node_modules/caniuse-lite/data/features/css-file-selector-button.js"(exports2, module2) {
    module2.exports = { A: { D: { "1": "a b c d e f g h i j k X H nB yB zB", "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z" }, L: { "1": "H" }, B: { "1": "a b c d e f g h i j k X H", "33": "C K L G M N O P Q R S T U V W Z" }, C: { "1": "mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R wB xB" }, M: { "1": "X" }, A: { "2": "J D E F uB", "33": "A B" }, F: { "1": "dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB" }, K: { "1": "Y", "2": "A B C hB sB iB" }, E: { "1": "G 6B 7B qB rB", "2": "8B", "33": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B" }, G: { "1": "WC XC qB rB", "33": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC" }, P: { "1": "pC qC", "33": "I gC hC iC jC kC pB lC mC nC oC" }, I: { "1": "H", "33": "jB I ZC aC bC cC tB dC eC" } }, B: 6, C: "::file-selector-button CSS pseudo-element" };
  }
});

// node_modules/caniuse-lite/data/features/css-filter-function.js
var require_css_filter_function = __commonJS({
  "node_modules/caniuse-lite/data/features/css-filter-function.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B", "33": "F" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC", "33": "JC KC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS filter() function" };
  }
});

// node_modules/caniuse-lite/data/features/css-filters.js
var require_css_filters = __commonJS({
  "node_modules/caniuse-lite/data/features/css-filters.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "1028": "K L G M N O", "1346": "C" }, C: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB", "196": "1", "516": "0 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z xB" }, D: { "1": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N", "33": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "33": "J D E F 2B 3B" }, F: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 G M N O m n o p q r s t u v w x y z" }, G: { "1": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC", "33": "E GC HC IC JC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB", "33": "dC eC" }, J: { "2": "D", "33": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "33": "I gC hC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS Filter Effects" };
  }
});

// node_modules/caniuse-lite/data/features/css-first-letter.js
var require_css_first_letter = __commonJS({
  "node_modules/caniuse-lite/data/features/css-first-letter.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "16": "uB", "516": "E", "1540": "J D" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "132": "jB", "260": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "l J D E", "132": "I" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "l 0B", "132": "I oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "16": "F 9B", "260": "B AC BC CC hB sB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "jB I H cC tB dC eC", "16": "ZC aC", "132": "bC" }, J: { "1": "D A" }, K: { "1": "C Y iB", "260": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "::first-letter CSS pseudo-element selector" };
  }
});

// node_modules/caniuse-lite/data/features/css-first-line.js
var require_css_first_line = __commonJS({
  "node_modules/caniuse-lite/data/features/css-first-line.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "132": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS first-line pseudo-element" };
  }
});

// node_modules/caniuse-lite/data/features/css-fixed.js
var require_css_fixed = __commonJS({
  "node_modules/caniuse-lite/data/features/css-fixed.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "D E F A B", "2": "uB", "8": "J" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B pB hB iB 5B 6B 7B qB rB 8B", "1025": "4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB", "132": "FC GC HC" }, H: { "2": "YC" }, I: { "1": "jB H dC eC", "260": "ZC aC bC", "513": "I cC tB" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS position:fixed" };
  }
});

// node_modules/caniuse-lite/data/features/css-focus-visible.js
var require_css_focus_visible = __commonJS({
  "node_modules/caniuse-lite/data/features/css-focus-visible.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "V W Z a b c d e f g h i j k X H", "2": "C K L G M N O", "328": "P Q R S T U" }, C: { "1": "U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "161": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T" }, D: { "1": "V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB", "328": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U" }, E: { "1": "rB 8B", "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B 6B", "578": "G 7B qB" }, F: { "1": "aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB 9B AC BC CC hB sB DC iB", "328": "UB VB WB XB YB ZB" }, G: { "1": "rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC", "578": "XC qB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "oC pC qC", "2": "I gC hC iC jC kC pB lC mC nC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "161": "tC" } }, B: 7, C: ":focus-visible CSS pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-focus-within.js
var require_css_focus_within = __commonJS({
  "node_modules/caniuse-lite/data/features/css-focus-within.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB wB xB" }, D: { "1": "QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB", "194": "kB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB 9B AC BC CC hB sB DC iB", "194": "DB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "1": "rC" }, R: { "16": "sC" }, S: { "2": "tC" } }, B: 7, C: ":focus-within CSS pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-font-palette.js
var require_css_font_palette = __commonJS({
  "node_modules/caniuse-lite/data/features/css-font-palette.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X" }, E: { "1": "rB 8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS font-palette" };
  }
});

// node_modules/caniuse-lite/data/features/css-font-rendering-controls.js
var require_css_font_rendering_controls = __commonJS({
  "node_modules/caniuse-lite/data/features/css-font-rendering-controls.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB wB xB", "194": "DB EB FB GB HB IB JB KB LB MB NB OB" }, D: { "1": "QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB", "66": "GB HB IB JB KB LB MB NB OB PB kB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB" }, F: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "66": "3 4 5 6 7 8 9 AB BB CB DB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I", "66": "gC hC iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "194": "tC" } }, B: 5, C: "CSS font-display" };
  }
});

// node_modules/caniuse-lite/data/features/css-font-stretch.js
var require_css_font_stretch = __commonJS({
  "node_modules/caniuse-lite/data/features/css-font-stretch.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E wB xB" }, D: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB" }, F: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS font-stretch" };
  }
});

// node_modules/caniuse-lite/data/features/css-gencontent.js
var require_css_gencontent = __commonJS({
  "node_modules/caniuse-lite/data/features/css-gencontent.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D uB", "132": "E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS Generated content for pseudo-elements" };
  }
});

// node_modules/caniuse-lite/data/features/css-gradients.js
var require_css_gradients = __commonJS({
  "node_modules/caniuse-lite/data/features/css-gradients.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB", "260": "0 1 2 M N O m n o p q r s t u v w x y z", "292": "I l J D E F A B C K L G xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "A B C K L G M N O m n o p q r s", "548": "I l J D E F" }, E: { "1": "rB 8B", "2": "0B oB", "260": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB", "292": "J 1B", "804": "I l" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC", "33": "C DC", "164": "hB sB" }, G: { "1": "rB", "260": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB", "292": "FC GC", "804": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "33": "I cC tB", "548": "jB ZC aC bC" }, J: { "1": "A", "548": "D" }, K: { "1": "Y iB", "2": "A B", "33": "C", "164": "hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS Gradients" };
  }
});

// node_modules/caniuse-lite/data/features/css-grid.js
var require_css_grid = __commonJS({
  "node_modules/caniuse-lite/data/features/css-grid.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "8": "F", "292": "A B" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "292": "C K L G" }, C: { "1": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O wB xB", "8": "0 1 2 3 4 5 6 m n o p q r s t u v w x y z", "584": "7 8 9 AB BB CB DB EB FB GB HB IB", "1025": "JB KB" }, D: { "1": "PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r", "8": "s t u v", "200": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB", "1025": "OB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "8": "J D E F A 2B 3B 4B" }, F: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u 9B AC BC CC hB sB DC iB", "200": "0 1 2 3 4 5 6 7 8 9 v w x y z AB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC", "8": "E GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC", "8": "tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "292": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "gC", "8": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS Grid Layout (level 1)" };
  }
});

// node_modules/caniuse-lite/data/features/css-hanging-punctuation.js
var require_css_hanging_punctuation = __commonJS({
  "node_modules/caniuse-lite/data/features/css-hanging-punctuation.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS hanging-punctuation" };
  }
});

// node_modules/caniuse-lite/data/features/css-has.js
var require_css_has = __commonJS({
  "node_modules/caniuse-lite/data/features/css-has.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X", "194": "H nB yB zB" }, E: { "1": "rB 8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: ":has() CSS relational pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-hyphenate.js
var require_css_hyphenate = __commonJS({
  "node_modules/caniuse-lite/data/features/css-hyphenate.js"(exports2, module2) {
    module2.exports = { A: { A: { "16": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "16": "C K L G M N O" }, C: { "16": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB" }, E: { "16": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "16": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "16": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "16": "YC" }, I: { "16": "jB I H ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "16": "A B C Y hB sB iB" }, L: { "16": "H" }, M: { "16": "X" }, N: { "16": "A B" }, O: { "16": "fC" }, P: { "16": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "16": "rC" }, R: { "16": "sC" }, S: { "16": "tC" } }, B: 5, C: "CSS4 Hyphenation" };
  }
});

// node_modules/caniuse-lite/data/features/css-hyphens.js
var require_css_hyphens = __commonJS({
  "node_modules/caniuse-lite/data/features/css-hyphens.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "33": "A B" }, B: { "33": "C K L G M N O", "132": "P Q R S T U V W", "260": "Z a b c d e f g h i j k X H" }, C: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l wB xB", "33": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, D: { "1": "Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB", "132": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W" }, E: { "2": "I l 0B oB", "33": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "132": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "oB EC", "33": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "4": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I", "132": "gC" }, Q: { "2": "rC" }, R: { "132": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS Hyphenation" };
  }
});

// node_modules/caniuse-lite/data/features/css-image-orientation.js
var require_css_image_orientation = __commonJS({
  "node_modules/caniuse-lite/data/features/css-image-orientation.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "a b c d e f g h i j k X H", "2": "C K L G M N O P Q", "257": "R S T U V W Z" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s wB xB" }, D: { "1": "a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q", "257": "R S T U V W Z" }, E: { "1": "L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB" }, F: { "1": "WB XB YB ZB aB", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB 9B AC BC CC hB sB DC iB", "257": "bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "VC WC XC qB rB", "132": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "nC oC pC qC", "2": "I gC hC iC jC kC pB lC mC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS3 image-orientation" };
  }
});

// node_modules/caniuse-lite/data/features/css-image-set.js
var require_css_image_set = __commonJS({
  "node_modules/caniuse-lite/data/features/css-image-set.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "164": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U wB xB", "66": "V W", "257": "a b c d e f g h i j k X H nB", "772": "Z" }, D: { "2": "I l J D E F A B C K L G M N O m n", "164": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l 0B oB 1B", "132": "A B C K pB hB iB 5B", "164": "J D E F 2B 3B 4B", "516": "L G 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "164": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "oB EC tB FC", "132": "LC MC NC OC PC QC RC SC TC UC", "164": "E GC HC IC JC KC", "516": "VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "164": "H dC eC" }, J: { "2": "D", "164": "A" }, K: { "2": "A B C hB sB iB", "164": "Y" }, L: { "164": "H" }, M: { "257": "X" }, N: { "2": "A B" }, O: { "164": "fC" }, P: { "164": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "164": "rC" }, R: { "164": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS image-set" };
  }
});

// node_modules/caniuse-lite/data/features/css-in-out-of-range.js
var require_css_in_out_of_range = __commonJS({
  "node_modules/caniuse-lite/data/features/css-in-out-of-range.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C", "260": "K L G M N O" }, C: { "1": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB", "516": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB" }, D: { "1": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I", "16": "l J D E F A B C K L", "260": "JB", "772": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "16": "l", "772": "J D E F A 1B 2B 3B 4B" }, F: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F 9B", "260": "6 B C AC BC CC hB sB DC iB", "772": "0 1 2 3 4 5 G M N O m n o p q r s t u v w x y z" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB", "772": "E FC GC HC IC JC KC LC" }, H: { "132": "YC" }, I: { "1": "H", "2": "jB ZC aC bC", "260": "I cC tB dC eC" }, J: { "2": "D", "260": "A" }, K: { "1": "Y", "260": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "260": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "516": "tC" } }, B: 5, C: ":in-range and :out-of-range CSS pseudo-classes" };
  }
});

// node_modules/caniuse-lite/data/features/css-indeterminate-pseudo.js
var require_css_indeterminate_pseudo = __commonJS({
  "node_modules/caniuse-lite/data/features/css-indeterminate-pseudo.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "132": "A B", "388": "F" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C K L G M N O" }, C: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "16": "vB jB wB xB", "132": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "388": "I l" }, D: { "1": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L", "132": "0 1 2 3 4 5 G M N O m n o p q r s t u v w x y z" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "16": "I l J 0B oB", "132": "D E F A 2B 3B 4B", "388": "1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F B 9B AC BC CC hB sB", "132": "G M N O m n o p q r s", "516": "C DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB FC GC", "132": "E HC IC JC KC LC" }, H: { "516": "YC" }, I: { "1": "H", "16": "jB ZC aC bC eC", "132": "dC", "388": "I cC tB" }, J: { "16": "D", "132": "A" }, K: { "1": "Y", "16": "A B C hB sB", "516": "iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "132": "tC" } }, B: 7, C: ":indeterminate CSS pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-initial-letter.js
var require_css_initial_letter = __commonJS({
  "node_modules/caniuse-lite/data/features/css-initial-letter.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E 0B oB 1B 2B 3B", "4": "F", "164": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC", "164": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Initial Letter" };
  }
});

// node_modules/caniuse-lite/data/features/css-initial-value.js
var require_css_initial_value = __commonJS({
  "node_modules/caniuse-lite/data/features/css-initial-value.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "33": "I l J D E F A B C K L G M N O wB xB", "164": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS initial value" };
  }
});

// node_modules/caniuse-lite/data/features/css-lch-lab.js
var require_css_lch_lab = __commonJS({
  "node_modules/caniuse-lite/data/features/css-lch-lab.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "G 7B qB rB 8B", "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B 6B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "LCH and Lab color values" };
  }
});

// node_modules/caniuse-lite/data/features/css-letter-spacing.js
var require_css_letter_spacing = __commonJS({
  "node_modules/caniuse-lite/data/features/css-letter-spacing.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "16": "uB", "132": "J D E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l J D E F A B C K L G M N O m n o p q r s t u v w" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B", "132": "I l J oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F 9B", "132": "B C G M AC BC CC hB sB DC iB" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "16": "ZC aC", "132": "jB I bC cC tB" }, J: { "132": "D A" }, K: { "1": "Y", "132": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "letter-spacing CSS property" };
  }
});

// node_modules/caniuse-lite/data/features/css-line-clamp.js
var require_css_line_clamp = __commonJS({
  "node_modules/caniuse-lite/data/features/css-line-clamp.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M", "33": "P Q R S T U V W Z a b c d e f g h i j k X H", "129": "N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB wB xB", "33": "WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "16": "I l J D E F A B C K", "33": "0 1 2 3 4 5 6 7 8 9 L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I 0B oB", "33": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "oB EC tB", "33": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "16": "ZC aC", "33": "jB I H bC cC tB dC eC" }, J: { "33": "D A" }, K: { "2": "A B C hB sB iB", "33": "Y" }, L: { "33": "H" }, M: { "33": "X" }, N: { "2": "A B" }, O: { "33": "fC" }, P: { "33": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "33": "rC" }, R: { "33": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS line-clamp" };
  }
});

// node_modules/caniuse-lite/data/features/css-logical-props.js
var require_css_logical_props = __commonJS({
  "node_modules/caniuse-lite/data/features/css-logical-props.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "a b c d e f g h i j k X H", "2": "C K L G M N O", "1028": "W Z", "1540": "P Q R S T U V" }, C: { "1": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB", "164": "0 1 2 3 4 5 6 7 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "1540": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB" }, D: { "1": "a b c d e f g h i j k X H nB yB zB", "292": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB", "1028": "W Z", "1540": "XB YB ZB aB bB cB dB eB fB gB P Q R S T U V" }, E: { "1": "G 7B qB rB 8B", "292": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB", "1028": "6B", "1540": "K L iB 5B" }, F: { "1": "eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "292": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB", "1028": "cB dB", "1540": "NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB" }, G: { "1": "XC qB rB", "292": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC", "1028": "WC", "1540": "QC RC SC TC UC VC" }, H: { "2": "YC" }, I: { "1": "H", "292": "jB I ZC aC bC cC tB dC eC" }, J: { "292": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "292": "fC" }, P: { "1": "pC qC", "292": "I gC hC iC jC kC", "1540": "pB lC mC nC oC" }, Q: { "1540": "rC" }, R: { "1540": "sC" }, S: { "1540": "tC" } }, B: 5, C: "CSS Logical Properties" };
  }
});

// node_modules/caniuse-lite/data/features/css-marker-pseudo.js
var require_css_marker_pseudo = __commonJS({
  "node_modules/caniuse-lite/data/features/css-marker-pseudo.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "V W Z a b c d e f g h i j k X H", "2": "C K L G M N O P Q R S T U" }, C: { "1": "WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB wB xB" }, D: { "1": "V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U" }, E: { "1": "8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB", "129": "C K L G hB iB 5B 6B 7B qB rB" }, F: { "1": "aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "oC pC qC", "2": "I gC hC iC jC kC pB lC mC nC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS ::marker pseudo-element" };
  }
});

// node_modules/caniuse-lite/data/features/css-masks.js
var require_css_masks = __commonJS({
  "node_modules/caniuse-lite/data/features/css-masks.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M", "164": "P Q R S T U V W Z a b c d e f g h i j k X H", "3138": "N", "12292": "O" }, C: { "1": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "260": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB wB xB" }, D: { "164": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "rB 8B", "2": "0B oB", "164": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "164": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "rB", "164": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "164": "H dC eC", "676": "jB I ZC aC bC cC tB" }, J: { "164": "D A" }, K: { "2": "A B C hB sB iB", "164": "Y" }, L: { "164": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "164": "fC" }, P: { "164": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "164": "rC" }, R: { "164": "sC" }, S: { "260": "tC" } }, B: 4, C: "CSS Masks" };
  }
});

// node_modules/caniuse-lite/data/features/css-matches-pseudo.js
var require_css_matches_pseudo = __commonJS({
  "node_modules/caniuse-lite/data/features/css-matches-pseudo.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "Z a b c d e f g h i j k X H", "2": "C K L G M N O", "1220": "P Q R S T U V W" }, C: { "1": "gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "16": "vB jB wB xB", "548": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB" }, D: { "1": "Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L", "164": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y", "196": "TB UB VB", "1220": "WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W" }, E: { "1": "L G 6B 7B qB rB 8B", "2": "I 0B oB", "16": "l", "164": "J D E 1B 2B 3B", "260": "F A B C K 4B pB hB iB 5B" }, F: { "1": "dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "164": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB", "196": "JB KB LB", "1220": "MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB" }, G: { "1": "VC WC XC qB rB", "16": "oB EC tB FC GC", "164": "E HC IC", "260": "JC KC LC MC NC OC PC QC RC SC TC UC" }, H: { "2": "YC" }, I: { "1": "H", "16": "jB ZC aC bC", "164": "I cC tB dC eC" }, J: { "16": "D", "164": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "164": "fC" }, P: { "1": "pC qC", "164": "I gC hC iC jC kC pB lC mC nC oC" }, Q: { "1220": "rC" }, R: { "164": "sC" }, S: { "548": "tC" } }, B: 5, C: ":is() CSS pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-math-functions.js
var require_css_math_functions = __commonJS({
  "node_modules/caniuse-lite/data/features/css-math-functions.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB wB xB" }, D: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB" }, E: { "1": "L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB", "132": "C K hB iB" }, F: { "1": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB 9B AC BC CC hB sB DC iB" }, G: { "1": "UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC", "132": "OC PC QC RC SC TC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "mC nC oC pC qC", "2": "I gC hC iC jC kC pB lC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS math functions min(), max() and clamp()" };
  }
});

// node_modules/caniuse-lite/data/features/css-media-interaction.js
var require_css_media_interaction = __commonJS({
  "node_modules/caniuse-lite/data/features/css-media-interaction.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB wB xB" }, D: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "Media Queries: interaction media features" };
  }
});

// node_modules/caniuse-lite/data/features/css-media-resolution.js
var require_css_media_resolution = __commonJS({
  "node_modules/caniuse-lite/data/features/css-media-resolution.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "132": "F A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "260": "I l J D E F A B C K L G wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "548": "I l J D E F A B C K L G M N O m n o p q r s t u v" }, E: { "1": "8B", "2": "0B oB", "548": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F", "548": "B C 9B AC BC CC hB sB DC" }, G: { "16": "oB", "548": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "132": "YC" }, I: { "1": "H dC eC", "16": "ZC aC", "548": "jB I bC cC tB" }, J: { "548": "D A" }, K: { "1": "Y iB", "548": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "Media Queries: resolution feature" };
  }
});

// node_modules/caniuse-lite/data/features/css-media-scripting.js
var require_css_media_scripting = __commonJS({
  "node_modules/caniuse-lite/data/features/css-media-scripting.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "16": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB wB xB", "16": "JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H", "16": "nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Media Queries: scripting media feature" };
  }
});

// node_modules/caniuse-lite/data/features/css-mediaqueries.js
var require_css_mediaqueries = __commonJS({
  "node_modules/caniuse-lite/data/features/css-mediaqueries.js"(exports2, module2) {
    module2.exports = { A: { A: { "8": "J D E uB", "129": "F A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "129": "I l J D E F A B C K L G M N O m n o p q r s" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "129": "I l J 1B", "388": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "129": "oB EC tB FC GC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "129": "jB I ZC aC bC cC tB" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "129": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS3 Media Queries" };
  }
});

// node_modules/caniuse-lite/data/features/css-mixblendmode.js
var require_css_mixblendmode = __commonJS({
  "node_modules/caniuse-lite/data/features/css-mixblendmode.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y wB xB" }, D: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v", "194": "0 1 2 3 4 5 6 7 w x y z" }, E: { "2": "I l J D 0B oB 1B 2B", "260": "E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v 9B AC BC CC hB sB DC iB" }, G: { "2": "oB EC tB FC GC HC", "260": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Blending of HTML/SVG elements" };
  }
});

// node_modules/caniuse-lite/data/features/css-motion-paths.js
var require_css_motion_paths = __commonJS({
  "node_modules/caniuse-lite/data/features/css-motion-paths.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB wB xB" }, D: { "1": "DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "194": "AB BB CB" }, E: { "1": "8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w 9B AC BC CC hB sB DC iB", "194": "x y z" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Motion Path" };
  }
});

// node_modules/caniuse-lite/data/features/css-namespaces.js
var require_css_namespaces = __commonJS({
  "node_modules/caniuse-lite/data/features/css-namespaces.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS namespaces" };
  }
});

// node_modules/caniuse-lite/data/features/css-nesting.js
var require_css_nesting = __commonJS({
  "node_modules/caniuse-lite/data/features/css-nesting.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Nesting" };
  }
});

// node_modules/caniuse-lite/data/features/css-not-sel-list.js
var require_css_not_sel_list = __commonJS({
  "node_modules/caniuse-lite/data/features/css-not-sel-list.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "Z a b c d e f g h i j k X H", "2": "C K L G M N O Q R S T U V W", "16": "P" }, C: { "1": "T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S wB xB" }, D: { "1": "Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pC qC", "2": "I gC hC iC jC kC pB lC mC nC oC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "selector list argument of :not()" };
  }
});

// node_modules/caniuse-lite/data/features/css-nth-child-of.js
var require_css_nth_child_of = __commonJS({
  "node_modules/caniuse-lite/data/features/css-nth-child-of.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "selector list argument of :nth-child and :nth-last-child CSS pseudo-classes" };
  }
});

// node_modules/caniuse-lite/data/features/css-opacity.js
var require_css_opacity = __commonJS({
  "node_modules/caniuse-lite/data/features/css-opacity.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "4": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS3 Opacity" };
  }
});

// node_modules/caniuse-lite/data/features/css-optional-pseudo.js
var require_css_optional_pseudo = __commonJS({
  "node_modules/caniuse-lite/data/features/css-optional-pseudo.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F 9B", "132": "B C AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "132": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "Y", "132": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 7, C: ":optional CSS pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-overflow-anchor.js
var require_css_overflow_anchor = __commonJS({
  "node_modules/caniuse-lite/data/features/css-overflow-anchor.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB wB xB" }, D: { "1": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS overflow-anchor (Scroll Anchoring)" };
  }
});

// node_modules/caniuse-lite/data/features/css-overflow-overlay.js
var require_css_overflow_overlay = __commonJS({
  "node_modules/caniuse-lite/data/features/css-overflow-overlay.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "I l J D E F A B 1B 2B 3B 4B pB hB", "16": "0B oB", "130": "C K L G iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC", "16": "oB", "130": "PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS overflow: overlay" };
  }
});

// node_modules/caniuse-lite/data/features/css-overflow.js
var require_css_overflow = __commonJS({
  "node_modules/caniuse-lite/data/features/css-overflow.js"(exports2, module2) {
    module2.exports = { A: { A: { "388": "J D E F A B uB" }, B: { "1": "b c d e f g h i j k X H", "260": "P Q R S T U V W Z a", "388": "C K L G M N O" }, C: { "1": "R mB S T U V W Z a b c d e f g h i j k X H nB", "260": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q", "388": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB wB xB" }, D: { "1": "b c d e f g h i j k X H nB yB zB", "260": "WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a", "388": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB" }, E: { "1": "8B", "260": "L G 5B 6B 7B qB rB", "388": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB" }, F: { "260": "MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "388": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB 9B AC BC CC hB sB DC iB" }, G: { "260": "UC VC WC XC qB rB", "388": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC" }, H: { "388": "YC" }, I: { "1": "H", "388": "jB I ZC aC bC cC tB dC eC" }, J: { "388": "D A" }, K: { "1": "Y", "388": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "388": "A B" }, O: { "388": "fC" }, P: { "1": "pC qC", "388": "I gC hC iC jC kC pB lC mC nC oC" }, Q: { "388": "rC" }, R: { "388": "sC" }, S: { "388": "tC" } }, B: 5, C: "CSS overflow property" };
  }
});

// node_modules/caniuse-lite/data/features/css-overscroll-behavior.js
var require_css_overscroll_behavior = __commonJS({
  "node_modules/caniuse-lite/data/features/css-overscroll-behavior.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "132": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C K L G M N", "516": "O" }, C: { "1": "kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB wB xB" }, D: { "1": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB", "260": "SB Y" }, E: { "1": "8B", "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B", "1090": "G 6B 7B qB rB" }, F: { "1": "JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB 9B AC BC CC hB sB DC iB", "260": "HB IB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC", "1090": "WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "2": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS overscroll-behavior" };
  }
});

// node_modules/caniuse-lite/data/features/css-page-break.js
var require_css_page_break = __commonJS({
  "node_modules/caniuse-lite/data/features/css-page-break.js"(exports2, module2) {
    module2.exports = { A: { A: { "388": "A B", "900": "J D E F uB" }, B: { "388": "C K L G M N O", "900": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "772": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "900": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y wB xB" }, D: { "900": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "772": "A", "900": "I l J D E F B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "16": "F 9B", "129": "B C AC BC CC hB sB DC iB", "900": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "900": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "129": "YC" }, I: { "900": "jB I H ZC aC bC cC tB dC eC" }, J: { "900": "D A" }, K: { "129": "A B C hB sB iB", "900": "Y" }, L: { "900": "H" }, M: { "900": "X" }, N: { "388": "A B" }, O: { "900": "fC" }, P: { "900": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "900": "rC" }, R: { "900": "sC" }, S: { "900": "tC" } }, B: 2, C: "CSS page-break properties" };
  }
});

// node_modules/caniuse-lite/data/features/css-paged-media.js
var require_css_paged_media = __commonJS({
  "node_modules/caniuse-lite/data/features/css-paged-media.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D uB", "132": "E F A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C K L G M N O" }, C: { "2": "vB jB I l J D E F A B C K L G M N O wB xB", "132": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "132": "F B C 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "16": "YC" }, I: { "16": "jB I H ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "16": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "132": "X" }, N: { "258": "A B" }, O: { "258": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "132": "tC" } }, B: 5, C: "CSS Paged Media (@page)" };
  }
});

// node_modules/caniuse-lite/data/features/css-paint-api.js
var require_css_paint_api = __commonJS({
  "node_modules/caniuse-lite/data/features/css-paint-api.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y" }, E: { "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB", "194": "K L G iB 5B 6B 7B qB rB 8B" }, F: { "1": "JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Paint API" };
  }
});

// node_modules/caniuse-lite/data/features/css-placeholder-shown.js
var require_css_placeholder_shown = __commonJS({
  "node_modules/caniuse-lite/data/features/css-placeholder-shown.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "292": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "164": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB" }, D: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "164": "tC" } }, B: 5, C: ":placeholder-shown CSS pseudo-class" };
  }
});

// node_modules/caniuse-lite/data/features/css-placeholder.js
var require_css_placeholder = __commonJS({
  "node_modules/caniuse-lite/data/features/css-placeholder.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "36": "C K L G M N O" }, C: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O wB xB", "33": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB" }, D: { "1": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "36": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "36": "l J D E F A 1B 2B 3B 4B" }, F: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "36": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC", "36": "E tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "36": "jB I ZC aC bC cC tB dC eC" }, J: { "36": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "36": "A B" }, O: { "1": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "36": "I gC hC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "33": "tC" } }, B: 5, C: "::placeholder CSS pseudo-element" };
  }
});

// node_modules/caniuse-lite/data/features/css-print-color-adjust.js
var require_css_print_color_adjust = __commonJS({
  "node_modules/caniuse-lite/data/features/css-print-color-adjust.js"(exports2, module2) {
    module2.exports = { A: { D: { "2": "I l J D E F A B C K L G M", "33": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, L: { "33": "H" }, B: { "2": "C K L G M N O", "33": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB wB xB", "33": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h" }, M: { "1": "X" }, A: { "2": "J D E F A B uB" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, K: { "2": "A B C hB sB iB", "33": "Y" }, E: { "1": "rB", "2": "I l 0B oB 1B 8B", "33": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB" }, G: { "1": "rB", "2": "oB EC tB FC", "33": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, P: { "33": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, I: { "2": "jB I ZC aC bC cC tB", "33": "H dC eC" } }, B: 6, C: "print-color-adjust property" };
  }
});

// node_modules/caniuse-lite/data/features/css-read-only-write.js
var require_css_read_only_write = __commonJS({
  "node_modules/caniuse-lite/data/features/css-read-only-write.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C" }, C: { "1": "gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "16": "vB", "33": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB wB xB" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L", "132": "0 1 2 G M N O m n o p q r s t u v w x y z" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B oB", "132": "I l J D E 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F B 9B AC BC CC hB", "132": "C G M N O m n o p sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC", "132": "E tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "16": "ZC aC", "132": "jB I bC cC tB dC eC" }, J: { "1": "A", "132": "D" }, K: { "1": "Y", "2": "A B hB", "132": "C sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "33": "tC" } }, B: 1, C: "CSS :read-only and :read-write selectors" };
  }
});

// node_modules/caniuse-lite/data/features/css-rebeccapurple.js
var require_css_rebeccapurple = __commonJS({
  "node_modules/caniuse-lite/data/features/css-rebeccapurple.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "132": "B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B", "16": "2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r 9B AC BC CC hB sB DC iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Rebeccapurple color" };
  }
});

// node_modules/caniuse-lite/data/features/css-reflections.js
var require_css_reflections = __commonJS({
  "node_modules/caniuse-lite/data/features/css-reflections.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "33": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "0B oB", "33": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "33": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "33": "jB I H ZC aC bC cC tB dC eC" }, J: { "33": "D A" }, K: { "2": "A B C hB sB iB", "33": "Y" }, L: { "33": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "33": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "33": "rC" }, R: { "33": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS Reflections" };
  }
});

// node_modules/caniuse-lite/data/features/css-regions.js
var require_css_regions = __commonJS({
  "node_modules/caniuse-lite/data/features/css-regions.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "420": "A B" }, B: { "2": "P Q R S T U V W Z a b c d e f g h i j k X H", "420": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "2 3 4 5 6 7 8 9 I l J D E F A B C K L AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "36": "G M N O", "66": "0 1 m n o p q r s t u v w x y z" }, E: { "2": "I l J C K L G 0B oB 1B hB iB 5B 6B 7B qB rB 8B", "33": "D E F A B 2B 3B 4B pB" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "oB EC tB FC GC OC PC QC RC SC TC UC VC WC XC qB rB", "33": "E HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "420": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Regions" };
  }
});

// node_modules/caniuse-lite/data/features/css-repeating-gradients.js
var require_css_repeating_gradients = __commonJS({
  "node_modules/caniuse-lite/data/features/css-repeating-gradients.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB", "33": "I l J D E F A B C K L G xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F", "33": "A B C K L G M N O m n o p q r s" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB", "33": "J 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC", "33": "C DC", "36": "hB sB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB", "33": "FC GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB ZC aC bC", "33": "I cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y iB", "2": "A B", "33": "C", "36": "hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS Repeating Gradients" };
  }
});

// node_modules/caniuse-lite/data/features/css-resize.js
var require_css_resize = __commonJS({
  "node_modules/caniuse-lite/data/features/css-resize.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "33": "I" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC", "132": "iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 4, C: "CSS resize property" };
  }
});

// node_modules/caniuse-lite/data/features/css-revert-value.js
var require_css_revert_value = __commonJS({
  "node_modules/caniuse-lite/data/features/css-revert-value.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O P Q R S" }, C: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB wB xB" }, D: { "1": "T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B" }, F: { "1": "bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB 9B AC BC CC hB sB DC iB" }, G: { "1": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "oC pC qC", "2": "I gC hC iC jC kC pB lC mC nC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS revert value" };
  }
});

// node_modules/caniuse-lite/data/features/css-rrggbbaa.js
var require_css_rrggbbaa = __commonJS({
  "node_modules/caniuse-lite/data/features/css-rrggbbaa.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB wB xB" }, D: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB", "194": "JB KB LB MB NB OB PB kB QB lB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "194": "6 7 8 9 AB BB CB DB EB FB GB HB IB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I", "194": "gC hC iC" }, Q: { "2": "rC" }, R: { "194": "sC" }, S: { "2": "tC" } }, B: 7, C: "#rrggbbaa hex color notation" };
  }
});

// node_modules/caniuse-lite/data/features/css-scroll-behavior.js
var require_css_scroll_behavior = __commonJS({
  "node_modules/caniuse-lite/data/features/css-scroll-behavior.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "129": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "129": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "450": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB" }, E: { "1": "rB 8B", "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB 5B", "578": "L G 6B 7B qB" }, F: { "2": "F B C G M N O m n o p q r s t u 9B AC BC CC hB sB DC iB", "129": "FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "450": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB" }, G: { "1": "rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC", "578": "WC XC qB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "129": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "129": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Scroll-behavior" };
  }
});

// node_modules/caniuse-lite/data/features/css-scroll-timeline.js
var require_css_scroll_timeline = __commonJS({
  "node_modules/caniuse-lite/data/features/css-scroll-timeline.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a", "194": "b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T", "194": "Z a b c d e f g h i j k X H nB yB zB", "322": "U V W" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB 9B AC BC CC hB sB DC iB", "194": "dB eB fB gB P Q R mB S T U V W", "322": "bB cB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS @scroll-timeline" };
  }
});

// node_modules/caniuse-lite/data/features/css-scrollbar.js
var require_css_scrollbar = __commonJS({
  "node_modules/caniuse-lite/data/features/css-scrollbar.js"(exports2, module2) {
    module2.exports = { A: { A: { "132": "J D E F A B uB" }, B: { "2": "C K L G M N O", "292": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB wB xB", "3074": "SB", "4100": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "292": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "16": "I l 0B oB", "292": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "292": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "VC WC XC qB rB", "16": "oB EC tB FC GC", "292": "HC", "804": "E IC JC KC LC MC NC OC PC QC RC SC TC UC" }, H: { "2": "YC" }, I: { "16": "ZC aC", "292": "jB I H bC cC tB dC eC" }, J: { "292": "D A" }, K: { "2": "A B C hB sB iB", "292": "Y" }, L: { "292": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "292": "fC" }, P: { "292": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "292": "rC" }, R: { "292": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS scrollbar styling" };
  }
});

// node_modules/caniuse-lite/data/features/css-sel2.js
var require_css_sel2 = __commonJS({
  "node_modules/caniuse-lite/data/features/css-sel2.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "D E F A B", "2": "uB", "8": "J" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS 2.1 selectors" };
  }
});

// node_modules/caniuse-lite/data/features/css-sel3.js
var require_css_sel3 = __commonJS({
  "node_modules/caniuse-lite/data/features/css-sel3.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "uB", "8": "J", "132": "D E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS3 selectors" };
  }
});

// node_modules/caniuse-lite/data/features/css-selection.js
var require_css_selection = __commonJS({
  "node_modules/caniuse-lite/data/features/css-selection.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "33": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "C Y sB iB", "16": "A B hB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "33": "tC" } }, B: 5, C: "::selection CSS pseudo-element" };
  }
});

// node_modules/caniuse-lite/data/features/css-shapes.js
var require_css_shapes = __commonJS({
  "node_modules/caniuse-lite/data/features/css-shapes.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB wB xB", "322": "IB JB KB LB MB NB OB PB kB QB lB" }, D: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "194": "1 2 3" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B", "33": "E F A 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC", "33": "E IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 4, C: "CSS Shapes Level 1" };
  }
});

// node_modules/caniuse-lite/data/features/css-snappoints.js
var require_css_snappoints = __commonJS({
  "node_modules/caniuse-lite/data/features/css-snappoints.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "6308": "A", "6436": "B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "6436": "C K L G M N O" }, C: { "1": "WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "2052": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB" }, D: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB", "8258": "UB VB WB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B", "3108": "F A 4B pB" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB 9B AC BC CC hB sB DC iB", "8258": "LB MB NB OB PB QB RB SB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC", "3108": "JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pB lC mC nC oC pC qC", "2": "I gC hC iC jC kC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2052": "tC" } }, B: 4, C: "CSS Scroll Snap" };
  }
});

// node_modules/caniuse-lite/data/features/css-sticky.js
var require_css_sticky = __commonJS({
  "node_modules/caniuse-lite/data/features/css-sticky.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "c d e f g h i j k X H", "2": "C K L G", "1028": "P Q R S T U V W Z a b", "4100": "M N O" }, C: { "1": "kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s wB xB", "194": "t u v w x y", "516": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB" }, D: { "1": "c d e f g h i j k X H nB yB zB", "2": "4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p AB BB CB DB EB FB GB HB IB", "322": "0 1 2 3 q r s t u v w x y z JB KB LB MB", "1028": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B", "33": "E F A B C 3B 4B pB hB iB", "2084": "D 2B" }, F: { "1": "gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "322": "6 7 8", "1028": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB" }, G: { "1": "RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC", "33": "E IC JC KC LC MC NC OC PC QC", "2084": "GC HC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1028": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I gC" }, Q: { "1028": "rC" }, R: { "2": "sC" }, S: { "516": "tC" } }, B: 5, C: "CSS position:sticky" };
  }
});

// node_modules/caniuse-lite/data/features/css-subgrid.js
var require_css_subgrid = __commonJS({
  "node_modules/caniuse-lite/data/features/css-subgrid.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Subgrid" };
  }
});

// node_modules/caniuse-lite/data/features/css-supports-api.js
var require_css_supports_api = __commonJS({
  "node_modules/caniuse-lite/data/features/css-supports-api.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L G M N O" }, C: { "1": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m wB xB", "66": "n o", "260": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB" }, D: { "1": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u", "260": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC", "132": "iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "132": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB", "132": "iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS.supports() API" };
  }
});

// node_modules/caniuse-lite/data/features/css-table.js
var require_css_table = __commonJS({
  "node_modules/caniuse-lite/data/features/css-table.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "E F A B", "2": "J D uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "132": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS Table display" };
  }
});

// node_modules/caniuse-lite/data/features/css-text-align-last.js
var require_css_text_align_last = __commonJS({
  "node_modules/caniuse-lite/data/features/css-text-align-last.js"(exports2, module2) {
    module2.exports = { A: { A: { "132": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "4": "C K L G M N O" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B wB xB", "33": "0 1 2 3 4 5 6 7 8 9 C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB" }, D: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "322": "2 3 4 5 6 7 8 9 AB BB CB DB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o 9B AC BC CC hB sB DC iB", "578": "0 p q r s t u v w x y z" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "33": "tC" } }, B: 5, C: "CSS3 text-align-last" };
  }
});

// node_modules/caniuse-lite/data/features/css-text-indent.js
var require_css_text_indent = __commonJS({
  "node_modules/caniuse-lite/data/features/css-text-indent.js"(exports2, module2) {
    module2.exports = { A: { A: { "132": "J D E F A B uB" }, B: { "132": "C K L G M N O", "388": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "132": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "132": "0 1 2 3 4 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "388": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "132": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "132": "F B C G M N O m n o p q r 9B AC BC CC hB sB DC iB", "388": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "132": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "132": "YC" }, I: { "132": "jB I ZC aC bC cC tB dC eC", "388": "H" }, J: { "132": "D A" }, K: { "132": "A B C hB sB iB", "388": "Y" }, L: { "388": "H" }, M: { "132": "X" }, N: { "132": "A B" }, O: { "132": "fC" }, P: { "132": "I", "388": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "388": "rC" }, R: { "388": "sC" }, S: { "132": "tC" } }, B: 5, C: "CSS text-indent" };
  }
});

// node_modules/caniuse-lite/data/features/css-text-justify.js
var require_css_text_justify = __commonJS({
  "node_modules/caniuse-lite/data/features/css-text-justify.js"(exports2, module2) {
    module2.exports = { A: { A: { "16": "J D uB", "132": "E F A B" }, B: { "132": "C K L G M N O", "322": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB wB xB", "1025": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "1602": "LB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "322": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C G M N O m n o p q r s t u v w 9B AC BC CC hB sB DC iB", "322": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "322": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "322": "Y" }, L: { "322": "H" }, M: { "1025": "X" }, N: { "132": "A B" }, O: { "2": "fC" }, P: { "2": "I", "322": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "322": "rC" }, R: { "322": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS text-justify" };
  }
});

// node_modules/caniuse-lite/data/features/css-text-orientation.js
var require_css_text_orientation = __commonJS({
  "node_modules/caniuse-lite/data/features/css-text-orientation.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "194": "5 6 7" }, D: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB" }, E: { "1": "L G 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B", "16": "A", "33": "B C K pB hB iB 5B" }, F: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS text-orientation" };
  }
});

// node_modules/caniuse-lite/data/features/css-text-spacing.js
var require_css_text_spacing = __commonJS({
  "node_modules/caniuse-lite/data/features/css-text-spacing.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D uB", "161": "E F A B" }, B: { "2": "P Q R S T U V W Z a b c d e f g h i j k X H", "161": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "16": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS Text 4 text-spacing" };
  }
});

// node_modules/caniuse-lite/data/features/css-textshadow.js
var require_css_textshadow = __commonJS({
  "node_modules/caniuse-lite/data/features/css-textshadow.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "129": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "129": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "260": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "4": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "A", "4": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "129": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS3 Text-shadow" };
  }
});

// node_modules/caniuse-lite/data/features/css-touch-action-2.js
var require_css_touch_action_2 = __commonJS({
  "node_modules/caniuse-lite/data/features/css-touch-action-2.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "132": "B", "164": "A" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB", "260": "MB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "260": "9" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "132": "B", "164": "A" }, O: { "2": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "16": "I" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS touch-action level 2 values" };
  }
});

// node_modules/caniuse-lite/data/features/css-touch-action.js
var require_css_touch_action = __commonJS({
  "node_modules/caniuse-lite/data/features/css-touch-action.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F uB", "289": "A" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB", "194": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB", "1025": "JB KB LB MB NB" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p 9B AC BC CC hB sB DC iB" }, G: { "1": "RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC", "516": "KC LC MC NC OC PC QC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "289": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "194": "tC" } }, B: 2, C: "CSS touch-action property" };
  }
});

// node_modules/caniuse-lite/data/features/css-transitions.js
var require_css_transitions = __commonJS({
  "node_modules/caniuse-lite/data/features/css-transitions.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "33": "l J D E F A B C K L G", "164": "I" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "I l J D E F A B C K L G M N O m n o p q r s" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "33": "J 1B", "164": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F 9B AC", "33": "C", "164": "B BC CC hB sB DC" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "33": "GC", "164": "oB EC tB FC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "33": "jB I ZC aC bC cC tB" }, J: { "1": "A", "33": "D" }, K: { "1": "Y iB", "33": "C", "164": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS3 Transitions" };
  }
});

// node_modules/caniuse-lite/data/features/css-unicode-bidi.js
var require_css_unicode_bidi = __commonJS({
  "node_modules/caniuse-lite/data/features/css-unicode-bidi.js"(exports2, module2) {
    module2.exports = { A: { A: { "132": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C K L G M N O" }, C: { "1": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "33": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB", "132": "vB jB I l J D E F wB xB", "292": "A B C K L G M" }, D: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l J D E F A B C K L G M", "548": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB" }, E: { "132": "I l J D E 0B oB 1B 2B 3B", "548": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "132": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "132": "E oB EC tB FC GC HC IC", "548": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "16": "YC" }, I: { "1": "H", "16": "jB I ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "1": "Y", "16": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "16": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "16": "I" }, Q: { "16": "rC" }, R: { "16": "sC" }, S: { "33": "tC" } }, B: 4, C: "CSS unicode-bidi property" };
  }
});

// node_modules/caniuse-lite/data/features/css-unset-value.js
var require_css_unset_value = __commonJS({
  "node_modules/caniuse-lite/data/features/css-unset-value.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t wB xB" }, D: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u 9B AC BC CC hB sB DC iB" }, G: { "1": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS unset value" };
  }
});

// node_modules/caniuse-lite/data/features/css-variables.js
var require_css_variables = __commonJS({
  "node_modules/caniuse-lite/data/features/css-variables.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L", "260": "G" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x wB xB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB", "194": "FB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B", "260": "4B" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "194": "2" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC", "260": "KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS Variables (Custom Properties)" };
  }
});

// node_modules/caniuse-lite/data/features/css-when-else.js
var require_css_when_else = __commonJS({
  "node_modules/caniuse-lite/data/features/css-when-else.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "CSS @when / @else conditional rules" };
  }
});

// node_modules/caniuse-lite/data/features/css-widows-orphans.js
var require_css_widows_orphans = __commonJS({
  "node_modules/caniuse-lite/data/features/css-widows-orphans.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D uB", "129": "E F" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "129": "F B 9B AC BC CC hB sB DC" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y iB", "2": "A B C hB sB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 2, C: "CSS widows & orphans" };
  }
});

// node_modules/caniuse-lite/data/features/css-width-stretch.js
var require_css_width_stretch = __commonJS({
  "node_modules/caniuse-lite/data/features/css-width-stretch.js"(exports2, module2) {
    module2.exports = { A: { D: { "2": "I l J D E F A B C K L G M N O m n o", "33": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, L: { "33": "H" }, B: { "2": "C K L G M N O", "33": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB", "33": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, M: { "33": "X" }, A: { "2": "J D E F A B uB" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, K: { "2": "A B C hB sB iB", "33": "Y" }, E: { "2": "I l J 0B oB 1B 2B 8B", "33": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB" }, G: { "2": "oB EC tB FC GC", "33": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, P: { "2": "I", "33": "gC hC iC jC kC pB lC mC nC oC pC qC" }, I: { "2": "jB I ZC aC bC cC tB", "33": "H dC eC" } }, B: 6, C: "width: stretch property" };
  }
});

// node_modules/caniuse-lite/data/features/css-writing-mode.js
var require_css_writing_mode = __commonJS({
  "node_modules/caniuse-lite/data/features/css-writing-mode.js"(exports2, module2) {
    module2.exports = { A: { A: { "132": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "322": "3 4 5 6 7" }, D: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J", "16": "D", "33": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "16": "l", "33": "J D E F A 1B 2B 3B 4B pB" }, F: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 G M N O m n o p q r s t u v w x y z" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB", "33": "E FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "ZC aC bC", "33": "jB I cC tB dC eC" }, J: { "33": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "36": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "33": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS writing-mode property" };
  }
});

// node_modules/caniuse-lite/data/features/css-zoom.js
var require_css_zoom = __commonJS({
  "node_modules/caniuse-lite/data/features/css-zoom.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D uB", "129": "E F A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "129": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS zoom" };
  }
});

// node_modules/caniuse-lite/data/features/css3-attr.js
var require_css3_attr = __commonJS({
  "node_modules/caniuse-lite/data/features/css3-attr.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "CSS3 attr() function for all properties" };
  }
});

// node_modules/caniuse-lite/data/features/css3-boxsizing.js
var require_css3_boxsizing = __commonJS({
  "node_modules/caniuse-lite/data/features/css3-boxsizing.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "E F A B", "8": "J D uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "33": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "I l J D E F" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "33": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "33": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "I H cC tB dC eC", "33": "jB ZC aC bC" }, J: { "1": "A", "33": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS3 Box-sizing" };
  }
});

// node_modules/caniuse-lite/data/features/css3-colors.js
var require_css3_colors = __commonJS({
  "node_modules/caniuse-lite/data/features/css3-colors.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "4": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W AC BC CC hB sB DC iB", "2": "F", "4": "9B" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS3 Colors" };
  }
});

// node_modules/caniuse-lite/data/features/css3-cursors-grab.js
var require_css3_cursors_grab = __commonJS({
  "node_modules/caniuse-lite/data/features/css3-cursors-grab.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "33": "vB jB I l J D E F A B C K L G M N O m n o p q r s t wB xB" }, D: { "1": "WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "33": "I l J D E F A 0B oB 1B 2B 3B 4B pB" }, F: { "1": "C MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F B 9B AC BC CC hB sB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "33": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "33": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 3, C: "CSS grab & grabbing cursors" };
  }
});

// node_modules/caniuse-lite/data/features/css3-cursors-newer.js
var require_css3_cursors_newer = __commonJS({
  "node_modules/caniuse-lite/data/features/css3-cursors-newer.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "33": "vB jB I l J D E F A B C K L G M N O m n o p q wB xB" }, D: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "0 1 2 3 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "33": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F B 9B AC BC CC hB sB", "33": "G M N O m n o p q" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "33": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "CSS3 Cursors: zoom-in & zoom-out" };
  }
});

// node_modules/caniuse-lite/data/features/css3-cursors.js
var require_css3_cursors = __commonJS({
  "node_modules/caniuse-lite/data/features/css3-cursors.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "132": "J D E uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "4": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "4": "I" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "4": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "260": "F B C 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D", "16": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "CSS3 Cursors (original values)" };
  }
});

// node_modules/caniuse-lite/data/features/css3-tabsize.js
var require_css3_tabsize = __commonJS({
  "node_modules/caniuse-lite/data/features/css3-tabsize.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "c d e f g h i j k X H nB", "2": "vB jB wB xB", "33": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b", "164": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB" }, D: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n", "132": "0 1 2 3 4 5 6 7 8 o p q r s t u v w x y z" }, E: { "1": "L G 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B", "132": "D E F A B C K 2B 3B 4B pB hB iB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F 9B AC BC", "132": "G M N O m n o p q r s t u v", "164": "B C CC hB sB DC iB" }, G: { "1": "UC VC WC XC qB rB", "2": "oB EC tB FC GC", "132": "E HC IC JC KC LC MC NC OC PC QC RC SC TC" }, H: { "164": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB", "132": "dC eC" }, J: { "132": "D A" }, K: { "1": "Y", "2": "A", "164": "B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "164": "tC" } }, B: 5, C: "CSS3 tab-size" };
  }
});

// node_modules/caniuse-lite/data/features/currentcolor.js
var require_currentcolor = __commonJS({
  "node_modules/caniuse-lite/data/features/currentcolor.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS currentColor value" };
  }
});

// node_modules/caniuse-lite/data/features/custom-elements.js
var require_custom_elements = __commonJS({
  "node_modules/caniuse-lite/data/features/custom-elements.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "8": "A B" }, B: { "1": "P", "2": "Q R S T U V W Z a b c d e f g h i j k X H", "8": "C K L G M N O" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "66": "q r s t u v w", "72": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P", "2": "I l J D E F A B C K L G M N O m n o p q r s t Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "66": "u v w x y z" }, E: { "2": "I l 0B oB 1B", "8": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB", "2": "F B C VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "66": "G M N O m" }, G: { "2": "oB EC tB FC GC", "8": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "eC", "2": "jB I H ZC aC bC cC tB dC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC", "2": "nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "72": "tC" } }, B: 7, C: "Custom Elements (deprecated V0 spec)" };
  }
});

// node_modules/caniuse-lite/data/features/custom-elementsv1.js
var require_custom_elementsv1 = __commonJS({
  "node_modules/caniuse-lite/data/features/custom-elementsv1.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "8": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "8": "C K L G M N O" }, C: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w wB xB", "8": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB", "456": "HB IB JB KB LB MB NB OB PB", "712": "kB QB lB RB" }, D: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB", "8": "JB KB", "132": "LB MB NB OB PB kB QB lB RB SB Y TB UB" }, E: { "2": "I l J D 0B oB 1B 2B 3B", "8": "E F A 4B", "132": "B C K L G pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "132": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC", "132": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I", "132": "gC" }, Q: { "132": "rC" }, R: { "132": "sC" }, S: { "8": "tC" } }, B: 1, C: "Custom Elements (V1)" };
  }
});

// node_modules/caniuse-lite/data/features/customevent.js
var require_customevent = __commonJS({
  "node_modules/caniuse-lite/data/features/customevent.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "132": "F A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l wB xB", "132": "J D E F A" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I", "16": "l J D E K L", "388": "F A B C" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "16": "l J", "388": "1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F 9B AC BC CC", "132": "B hB sB" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "EC", "16": "oB tB", "388": "FC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "ZC aC bC", "388": "jB I cC tB" }, J: { "1": "A", "388": "D" }, K: { "1": "C Y iB", "2": "A", "132": "B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "CustomEvent" };
  }
});

// node_modules/caniuse-lite/data/features/datalist.js
var require_datalist = __commonJS({
  "node_modules/caniuse-lite/data/features/datalist.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "8": "J D E F", "260": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L G", "1284": "M N O" }, C: { "8": "vB jB wB xB", "4612": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "8": "I l J D E F A B C K L G M N O m", "132": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB" }, E: { "1": "K L G iB 5B 6B 7B qB rB 8B", "8": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB" }, F: { "1": "F B C Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "132": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB" }, G: { "8": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC", "2049": "QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H eC", "8": "jB I ZC aC bC cC tB dC" }, J: { "1": "A", "8": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "516": "X" }, N: { "8": "A B" }, O: { "8": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "132": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 1, C: "Datalist element" };
  }
});

// node_modules/caniuse-lite/data/features/dataset.js
var require_dataset = __commonJS({
  "node_modules/caniuse-lite/data/features/dataset.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "4": "J D E F A uB" }, B: { "1": "C K L G M", "129": "N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "4": "vB jB I l wB xB", "129": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "CB DB EB FB GB HB IB JB KB LB", "4": "I l J", "129": "0 1 2 3 4 5 6 7 8 9 D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "4": "I l 0B oB", "129": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 C z hB sB DC iB", "4": "F B 9B AC BC CC", "129": "9 G M N O m n o p q r s t u v w x y AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "4": "oB EC tB", "129": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "4": "YC" }, I: { "4": "ZC aC bC", "129": "jB I H cC tB dC eC" }, J: { "129": "D A" }, K: { "1": "C hB sB iB", "4": "A B", "129": "Y" }, L: { "129": "H" }, M: { "129": "X" }, N: { "1": "B", "4": "A" }, O: { "129": "fC" }, P: { "129": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "129": "sC" }, S: { "1": "tC" } }, B: 1, C: "dataset & data-* attributes" };
  }
});

// node_modules/caniuse-lite/data/features/datauri.js
var require_datauri = __commonJS({
  "node_modules/caniuse-lite/data/features/datauri.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D uB", "132": "E", "260": "F A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K G M N O", "772": "L" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "260": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Data URIs" };
  }
});

// node_modules/caniuse-lite/data/features/date-tolocaledatestring.js
var require_date_tolocaledatestring = __commonJS({
  "node_modules/caniuse-lite/data/features/date-tolocaledatestring.js"(exports2, module2) {
    module2.exports = { A: { A: { "16": "uB", "132": "J D E F A B" }, B: { "1": "O P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C K L G M N" }, C: { "1": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "132": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB", "260": "JB KB LB MB", "772": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB" }, D: { "1": "YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l J D E F A B C K L G M N O m n o p q", "260": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB", "772": "0 1 2 3 4 r s t u v w x y z" }, E: { "1": "C K L G iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB", "132": "J D E F A 1B 2B 3B 4B", "260": "B pB hB" }, F: { "1": "OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F B C 9B AC BC CC hB sB DC", "132": "iB", "260": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB", "772": "G M N O m n o p q r" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB FC", "132": "E GC HC IC JC KC LC" }, H: { "132": "YC" }, I: { "1": "H", "16": "jB ZC aC bC", "132": "I cC tB", "772": "dC eC" }, J: { "132": "D A" }, K: { "1": "Y", "16": "A B C hB sB", "132": "iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "260": "fC" }, P: { "1": "kC pB lC mC nC oC pC qC", "260": "I gC hC iC jC" }, Q: { "260": "rC" }, R: { "132": "sC" }, S: { "132": "tC" } }, B: 6, C: "Date.prototype.toLocaleDateString" };
  }
});

// node_modules/caniuse-lite/data/features/decorators.js
var require_decorators = __commonJS({
  "node_modules/caniuse-lite/data/features/decorators.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Decorators" };
  }
});

// node_modules/caniuse-lite/data/features/details.js
var require_details = __commonJS({
  "node_modules/caniuse-lite/data/features/details.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "F A B uB", "8": "J D E" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB", "8": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB wB xB", "194": "EB FB" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "8": "I l J D E F A B", "257": "0 1 2 m n o p q r s t u v w x y z", "769": "C K L G M N O" }, E: { "1": "C K L G iB 5B 6B 7B qB rB 8B", "8": "I l 0B oB 1B", "257": "J D E F A 2B 3B 4B", "1025": "B pB hB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "C hB sB DC iB", "8": "F B 9B AC BC CC" }, G: { "1": "E GC HC IC JC KC OC PC QC RC SC TC UC VC WC XC qB rB", "8": "oB EC tB FC", "1025": "LC MC NC" }, H: { "8": "YC" }, I: { "1": "I H cC tB dC eC", "8": "jB ZC aC bC" }, J: { "1": "A", "8": "D" }, K: { "1": "Y", "8": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "769": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Details & Summary elements" };
  }
});

// node_modules/caniuse-lite/data/features/deviceorientation.js
var require_deviceorientation = __commonJS({
  "node_modules/caniuse-lite/data/features/deviceorientation.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "132": "B" }, B: { "1": "C K L G M N O", "4": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB wB", "4": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "8": "I l xB" }, D: { "2": "I l J", "4": "0 1 2 3 4 5 6 7 8 9 D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "4": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "oB EC", "4": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "ZC aC bC", "4": "jB I H cC tB dC eC" }, J: { "2": "D", "4": "A" }, K: { "1": "C iB", "2": "A B hB sB", "4": "Y" }, L: { "4": "H" }, M: { "4": "X" }, N: { "1": "B", "2": "A" }, O: { "4": "fC" }, P: { "4": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "4": "rC" }, R: { "4": "sC" }, S: { "4": "tC" } }, B: 4, C: "DeviceOrientation & DeviceMotion events" };
  }
});

// node_modules/caniuse-lite/data/features/devicepixelratio.js
var require_devicepixelratio = __commonJS({
  "node_modules/caniuse-lite/data/features/devicepixelratio.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F B 9B AC BC CC hB sB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "C Y iB", "2": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Window.devicePixelRatio" };
  }
});

// node_modules/caniuse-lite/data/features/dialog.js
var require_dialog = __commonJS({
  "node_modules/caniuse-lite/data/features/dialog.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB wB xB", "194": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P", "1218": "Q R mB S T U V W Z a b c d e f g h i" }, D: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w x y", "322": "0 1 2 3 z" }, E: { "1": "rB 8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O 9B AC BC CC hB sB DC iB", "578": "m n o p q" }, G: { "1": "rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 1, C: "Dialog element" };
  }
});

// node_modules/caniuse-lite/data/features/dispatchevent.js
var require_dispatchevent = __commonJS({
  "node_modules/caniuse-lite/data/features/dispatchevent.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "16": "uB", "129": "F A", "130": "J D E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "16": "F" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "129": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "EventTarget.dispatchEvent" };
  }
});

// node_modules/caniuse-lite/data/features/dnssec.js
var require_dnssec = __commonJS({
  "node_modules/caniuse-lite/data/features/dnssec.js"(exports2, module2) {
    module2.exports = { A: { A: { "132": "J D E F A B uB" }, B: { "132": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "132": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "132": "0 1 2 3 4 5 6 7 8 9 I l y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "388": "J D E F A B C K L G M N O m n o p q r s t u v w x" }, E: { "132": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "132": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "132": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "132": "YC" }, I: { "132": "jB I H ZC aC bC cC tB dC eC" }, J: { "132": "D A" }, K: { "132": "A B C Y hB sB iB" }, L: { "132": "H" }, M: { "132": "X" }, N: { "132": "A B" }, O: { "132": "fC" }, P: { "132": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "132": "rC" }, R: { "132": "sC" }, S: { "132": "tC" } }, B: 6, C: "DNSSEC and DANE" };
  }
});

// node_modules/caniuse-lite/data/features/do-not-track.js
var require_do_not_track = __commonJS({
  "node_modules/caniuse-lite/data/features/do-not-track.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "164": "F A", "260": "B" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L G M" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E wB xB", "516": "F A B C K L G M N O m n o p q r s t u v w x y" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p" }, E: { "1": "J A B C 1B 4B pB hB", "2": "I l K L G 0B oB iB 5B 6B 7B qB rB 8B", "1028": "D E F 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC hB sB DC" }, G: { "1": "JC KC LC MC NC OC PC", "2": "oB EC tB FC GC QC RC SC TC UC VC WC XC qB rB", "1028": "E HC IC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "16": "D", "1028": "A" }, K: { "1": "Y iB", "16": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "164": "A", "260": "B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Do Not Track API" };
  }
});

// node_modules/caniuse-lite/data/features/document-currentscript.js
var require_document_currentscript = __commonJS({
  "node_modules/caniuse-lite/data/features/document-currentscript.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v" }, E: { "1": "E F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G 9B AC BC CC hB sB DC iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "document.currentScript" };
  }
});

// node_modules/caniuse-lite/data/features/document-evaluate-xpath.js
var require_document_evaluate_xpath = __commonJS({
  "node_modules/caniuse-lite/data/features/document-evaluate-xpath.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "16": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "16": "F" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 7, C: "document.evaluate & XPath" };
  }
});

// node_modules/caniuse-lite/data/features/document-execcommand.js
var require_document_execcommand = __commonJS({
  "node_modules/caniuse-lite/data/features/document-execcommand.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W AC BC CC hB sB DC iB", "16": "F 9B" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC", "16": "tB FC GC" }, H: { "2": "YC" }, I: { "1": "H cC tB dC eC", "2": "jB I ZC aC bC" }, J: { "1": "A", "2": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "2": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 7, C: "Document.execCommand()" };
  }
});

// node_modules/caniuse-lite/data/features/document-policy.js
var require_document_policy = __commonJS({
  "node_modules/caniuse-lite/data/features/document-policy.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T", "132": "U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T", "132": "U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB 9B AC BC CC hB sB DC iB", "132": "ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "132": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "132": "Y" }, L: { "132": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Document Policy" };
  }
});

// node_modules/caniuse-lite/data/features/document-scrollingelement.js
var require_document_scrollingelement = __commonJS({
  "node_modules/caniuse-lite/data/features/document-scrollingelement.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "16": "C K" }, C: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB wB xB" }, D: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w x 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "document.scrollingElement" };
  }
});

// node_modules/caniuse-lite/data/features/documenthead.js
var require_documenthead = __commonJS({
  "node_modules/caniuse-lite/data/features/documenthead.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "16": "l" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "2": "F 9B AC BC CC" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "document.head" };
  }
});

// node_modules/caniuse-lite/data/features/dom-manip-convenience.js
var require_dom_manip_convenience = __commonJS({
  "node_modules/caniuse-lite/data/features/dom-manip-convenience.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB wB xB" }, D: { "1": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB", "194": "JB KB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "194": "7" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I gC" }, Q: { "194": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "DOM manipulation convenience methods" };
  }
});

// node_modules/caniuse-lite/data/features/dom-range.js
var require_dom_range = __commonJS({
  "node_modules/caniuse-lite/data/features/dom-range.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "uB", "8": "J D E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Document Object Model Range" };
  }
});

// node_modules/caniuse-lite/data/features/domcontentloaded.js
var require_domcontentloaded = __commonJS({
  "node_modules/caniuse-lite/data/features/domcontentloaded.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "DOMContentLoaded" };
  }
});

// node_modules/caniuse-lite/data/features/domfocusin-domfocusout-events.js
var require_domfocusin_domfocusout_events = __commonJS({
  "node_modules/caniuse-lite/data/features/domfocusin-domfocusout-events.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L G M N O m n o p q r s" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "16": "l" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "16": "F B 9B AC BC CC hB sB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB FC GC" }, H: { "16": "YC" }, I: { "1": "I H cC tB dC eC", "16": "jB ZC aC bC" }, J: { "16": "D A" }, K: { "1": "Y", "16": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "16": "A B" }, O: { "16": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "DOMFocusIn & DOMFocusOut events" };
  }
});

// node_modules/caniuse-lite/data/features/dommatrix.js
var require_dommatrix = __commonJS({
  "node_modules/caniuse-lite/data/features/dommatrix.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "132": "A B" }, B: { "132": "C K L G M N O", "1028": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "1028": "XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2564": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB", "3076": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB" }, D: { "16": "I l J D", "132": "0 1 2 3 4 5 6 7 8 9 F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB", "388": "E", "1028": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "16": "I 0B oB", "132": "l J D E F A 1B 2B 3B 4B pB", "1028": "B C K L G hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "132": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB", "1028": "FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "16": "oB EC tB", "132": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "132": "I cC tB dC eC", "292": "jB ZC aC bC", "1028": "H" }, J: { "16": "D", "132": "A" }, K: { "2": "A B C hB sB iB", "1028": "Y" }, L: { "1028": "H" }, M: { "1028": "X" }, N: { "132": "A B" }, O: { "132": "fC" }, P: { "132": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "132": "rC" }, R: { "132": "sC" }, S: { "2564": "tC" } }, B: 4, C: "DOMMatrix" };
  }
});

// node_modules/caniuse-lite/data/features/download.js
var require_download = __commonJS({
  "node_modules/caniuse-lite/data/features/download.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Download attribute" };
  }
});

// node_modules/caniuse-lite/data/features/dragndrop.js
var require_dragndrop = __commonJS({
  "node_modules/caniuse-lite/data/features/dragndrop.js"(exports2, module2) {
    module2.exports = { A: { A: { "644": "J D E F uB", "772": "A B" }, B: { "1": "O P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L G M N" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "8": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "8": "F B 9B AC BC CC hB sB DC" }, G: { "1": "XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "1025": "H" }, J: { "2": "D A" }, K: { "1": "iB", "8": "A B C hB sB", "1025": "Y" }, L: { "1025": "H" }, M: { "2": "X" }, N: { "1": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "Drag and Drop" };
  }
});

// node_modules/caniuse-lite/data/features/element-closest.js
var require_element_closest = __commonJS({
  "node_modules/caniuse-lite/data/features/element-closest.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L" }, C: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Element.closest()" };
  }
});

// node_modules/caniuse-lite/data/features/element-from-point.js
var require_element_from_point = __commonJS({
  "node_modules/caniuse-lite/data/features/element-from-point.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "16": "uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "16": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "16": "F 9B AC BC CC" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "C Y iB", "16": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "document.elementFromPoint()" };
  }
});

// node_modules/caniuse-lite/data/features/element-scroll-methods.js
var require_element_scroll_methods = __commonJS({
  "node_modules/caniuse-lite/data/features/element-scroll-methods.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB" }, E: { "1": "L G 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B", "132": "A B C K pB hB iB 5B" }, F: { "1": "FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB 9B AC BC CC hB sB DC iB" }, G: { "1": "WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC", "132": "LC MC NC OC PC QC RC SC TC UC VC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 5, C: "Scroll methods on elements (scroll, scrollTo, scrollBy)" };
  }
});

// node_modules/caniuse-lite/data/features/eme.js
var require_eme = __commonJS({
  "node_modules/caniuse-lite/data/features/eme.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "164": "B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "132": "2 3 4 5 6 7 8" }, E: { "1": "C K L G iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B", "164": "D E F A B 3B 4B pB hB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o 9B AC BC CC hB sB DC iB", "132": "p q r s t u v" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "16": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 2, C: "Encrypted Media Extensions" };
  }
});

// node_modules/caniuse-lite/data/features/eot.js
var require_eot = __commonJS({
  "node_modules/caniuse-lite/data/features/eot.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "2": "uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "EOT - Embedded OpenType fonts" };
  }
});

// node_modules/caniuse-lite/data/features/es5.js
var require_es5 = __commonJS({
  "node_modules/caniuse-lite/data/features/es5.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D uB", "260": "F", "1026": "E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "4": "vB jB wB xB", "132": "I l J D E F A B C K L G M N O m n" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "4": "I l J D E F A B C K L G M N O", "132": "m n o p" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "4": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "4": "F B C 9B AC BC CC hB sB DC", "132": "iB" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "4": "oB EC tB FC" }, H: { "132": "YC" }, I: { "1": "H dC eC", "4": "jB ZC aC bC", "132": "cC tB", "900": "I" }, J: { "1": "A", "4": "D" }, K: { "1": "Y", "4": "A B C hB sB", "132": "iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "ECMAScript 5" };
  }
});

// node_modules/caniuse-lite/data/features/es6-class.js
var require_es6_class = __commonJS({
  "node_modules/caniuse-lite/data/features/es6-class.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C" }, C: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB wB xB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "132": "9 AB BB CB DB EB FB" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v 9B AC BC CC hB sB DC iB", "132": "0 1 2 w x y z" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "ES6 classes" };
  }
});

// node_modules/caniuse-lite/data/features/es6-generators.js
var require_es6_generators = __commonJS({
  "node_modules/caniuse-lite/data/features/es6-generators.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s wB xB" }, D: { "1": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "ES6 Generators" };
  }
});

// node_modules/caniuse-lite/data/features/es6-module-dynamic-import.js
var require_es6_module_dynamic_import = __commonJS({
  "node_modules/caniuse-lite/data/features/es6-module-dynamic-import.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB wB xB", "194": "UB" }, D: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB" }, F: { "1": "HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "JavaScript modules: dynamic import()" };
  }
});

// node_modules/caniuse-lite/data/features/es6-module.js
var require_es6_module = __commonJS({
  "node_modules/caniuse-lite/data/features/es6-module.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L", "4097": "M N O", "4290": "G" }, C: { "1": "QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB wB xB", "322": "LB MB NB OB PB kB" }, D: { "1": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB", "194": "QB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B", "3076": "pB" }, F: { "1": "FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB 9B AC BC CC hB sB DC iB", "194": "EB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC", "3076": "MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "JavaScript modules via script tag" };
  }
});

// node_modules/caniuse-lite/data/features/es6-number.js
var require_es6_number = __commonJS({
  "node_modules/caniuse-lite/data/features/es6-number.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G wB xB", "132": "M N O m n o p q r", "260": "s t u v w x", "516": "y" }, D: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O", "1028": "0 m n o p q r s t u v w x y z" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "1028": "G M N O m n" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC", "1028": "cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "ES6 Number" };
  }
});

// node_modules/caniuse-lite/data/features/es6-string-includes.js
var require_es6_string_includes = __commonJS({
  "node_modules/caniuse-lite/data/features/es6-string-includes.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "String.prototype.includes" };
  }
});

// node_modules/caniuse-lite/data/features/es6.js
var require_es6 = __commonJS({
  "node_modules/caniuse-lite/data/features/es6.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "388": "B" }, B: { "257": "P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L", "769": "G M N O" }, C: { "2": "vB jB I l wB xB", "4": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB", "257": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "I l J D E F A B C K L G M N O m n", "4": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "257": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B", "4": "E F 3B 4B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "4": "0 1 2 3 4 G M N O m n o p q r s t u v w x y z", "257": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC", "4": "E HC IC JC KC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "4": "dC eC", "257": "H" }, J: { "2": "D", "4": "A" }, K: { "2": "A B C hB sB iB", "257": "Y" }, L: { "257": "H" }, M: { "257": "X" }, N: { "2": "A", "388": "B" }, O: { "257": "fC" }, P: { "4": "I", "257": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "257": "rC" }, R: { "4": "sC" }, S: { "4": "tC" } }, B: 6, C: "ECMAScript 2015 (ES6)" };
  }
});

// node_modules/caniuse-lite/data/features/eventsource.js
var require_eventsource = __commonJS({
  "node_modules/caniuse-lite/data/features/eventsource.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "4": "F 9B AC BC CC" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "D A" }, K: { "1": "C Y hB sB iB", "4": "A B" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Server-sent events" };
  }
});

// node_modules/caniuse-lite/data/features/extended-system-fonts.js
var require_extended_system_fonts = __commonJS({
  "node_modules/caniuse-lite/data/features/extended-system-fonts.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "ui-serif, ui-sans-serif, ui-monospace and ui-rounded values for font-family" };
  }
});

// node_modules/caniuse-lite/data/features/feature-policy.js
var require_feature_policy = __commonJS({
  "node_modules/caniuse-lite/data/features/feature-policy.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W", "2": "C K L G M N O", "1025": "Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB wB xB", "260": "cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "cB dB eB fB gB P Q R S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB", "132": "QB lB RB SB Y TB UB VB WB XB YB ZB aB bB", "1025": "Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB", "772": "C K L G hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB 9B AC BC CC hB sB DC iB", "132": "EB FB GB HB IB JB KB LB MB NB OB PB QB", "1025": "dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC", "772": "OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1025": "H" }, M: { "260": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "lC mC nC oC pC qC", "2": "I gC hC iC", "132": "jC kC pB" }, Q: { "132": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Feature Policy" };
  }
});

// node_modules/caniuse-lite/data/features/fetch.js
var require_fetch = __commonJS({
  "node_modules/caniuse-lite/data/features/fetch.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "1025": "6", "1218": "1 2 3 4 5" }, D: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "260": "7", "772": "8" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t 9B AC BC CC hB sB DC iB", "260": "u", "772": "v" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Fetch" };
  }
});

// node_modules/caniuse-lite/data/features/fieldset-disabled.js
var require_fieldset_disabled = __commonJS({
  "node_modules/caniuse-lite/data/features/fieldset-disabled.js"(exports2, module2) {
    module2.exports = { A: { A: { "16": "uB", "132": "E F", "388": "J D A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G", "16": "M N O m" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W AC BC CC hB sB DC iB", "16": "F 9B" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC" }, H: { "388": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A", "260": "B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "disabled attribute of the fieldset element" };
  }
});

// node_modules/caniuse-lite/data/features/fileapi.js
var require_fileapi = __commonJS({
  "node_modules/caniuse-lite/data/features/fileapi.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "260": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB", "260": "I l J D E F A B C K L G M N O m n o p q r s t u xB" }, D: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l", "260": "0 1 2 3 4 K L G M N O m n o p q r s t u v w x y z", "388": "J D E F A B C" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB", "260": "J D E F 2B 3B 4B", "388": "1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B 9B AC BC CC", "260": "C G M N O m n o p q r hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC", "260": "E GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H eC", "2": "ZC aC bC", "260": "dC", "388": "jB I cC tB" }, J: { "260": "A", "388": "D" }, K: { "1": "Y", "2": "A B", "260": "C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A", "260": "B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "File API" };
  }
});

// node_modules/caniuse-lite/data/features/filereader.js
var require_filereader = __commonJS({
  "node_modules/caniuse-lite/data/features/filereader.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "132": "A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "2": "vB jB wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "2": "F B 9B AC BC CC" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "A", "2": "D" }, K: { "1": "C Y hB sB iB", "2": "A B" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "FileReader API" };
  }
});

// node_modules/caniuse-lite/data/features/filereadersync.js
var require_filereadersync = __commonJS({
  "node_modules/caniuse-lite/data/features/filereadersync.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F 9B AC", "16": "B BC CC hB sB" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "C Y sB iB", "2": "A", "16": "B hB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "FileReaderSync" };
  }
});

// node_modules/caniuse-lite/data/features/filesystem.js
var require_filesystem = __commonJS({
  "node_modules/caniuse-lite/data/features/filesystem.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "33": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "I l J D", "33": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "36": "E F A B C" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D", "33": "A" }, K: { "2": "A B C Y hB sB iB" }, L: { "33": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I", "33": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Filesystem & FileWriter API" };
  }
});

// node_modules/caniuse-lite/data/features/flac.js
var require_flac = __commonJS({
  "node_modules/caniuse-lite/data/features/flac.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G" }, C: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB wB xB" }, D: { "1": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB", "16": "BB CB DB", "388": "EB FB GB HB IB JB KB LB MB" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "516": "B C hB iB" }, F: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "ZC aC bC", "16": "jB I cC tB dC eC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y iB", "16": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "129": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 6, C: "FLAC audio format" };
  }
});

// node_modules/caniuse-lite/data/features/flexbox-gap.js
var require_flexbox_gap = __commonJS({
  "node_modules/caniuse-lite/data/features/flexbox-gap.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O P Q R S" }, C: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB wB xB" }, D: { "1": "T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S" }, E: { "1": "G 6B 7B qB rB 8B", "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B" }, F: { "1": "bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB 9B AC BC CC hB sB DC iB" }, G: { "1": "WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "oC pC qC", "2": "I gC hC iC jC kC pB lC mC nC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "gap property for Flexbox" };
  }
});

// node_modules/caniuse-lite/data/features/flexbox.js
var require_flexbox = __commonJS({
  "node_modules/caniuse-lite/data/features/flexbox.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "1028": "B", "1316": "A" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "164": "vB jB I l J D E F A B C K L G M N O m n o wB xB", "516": "p q r s t u" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "o p q r s t u v", "164": "I l J D E F A B C K L G M N O m n" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "33": "D E 2B 3B", "164": "I l J 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B C 9B AC BC CC hB sB DC", "33": "G M" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "33": "E HC IC", "164": "oB EC tB FC GC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "164": "jB I ZC aC bC cC tB" }, J: { "1": "A", "164": "D" }, K: { "1": "Y iB", "2": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "292": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS Flexible Box Layout Module" };
  }
});

// node_modules/caniuse-lite/data/features/flow-root.js
var require_flow_root = __commonJS({
  "node_modules/caniuse-lite/data/features/flow-root.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB wB xB" }, D: { "1": "PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB iB" }, F: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB 9B AC BC CC hB sB DC iB" }, G: { "1": "RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I gC hC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "display: flow-root" };
  }
});

// node_modules/caniuse-lite/data/features/focusin-focusout-events.js
var require_focusin_focusout_events = __commonJS({
  "node_modules/caniuse-lite/data/features/focusin-focusout-events.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "2": "uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F 9B AC BC CC", "16": "B hB sB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "I H cC tB dC eC", "2": "ZC aC bC", "16": "jB" }, J: { "1": "D A" }, K: { "1": "C Y iB", "2": "A", "16": "B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "focusin & focusout events" };
  }
});

// node_modules/caniuse-lite/data/features/focusoptions-preventscroll.js
var require_focusoptions_preventscroll = __commonJS({
  "node_modules/caniuse-lite/data/features/focusoptions-preventscroll.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M", "132": "N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "preventScroll support in focus" };
  }
});

// node_modules/caniuse-lite/data/features/font-family-system-ui.js
var require_font_family_system_ui = __commonJS({
  "node_modules/caniuse-lite/data/features/font-family-system-ui.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "132": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c" }, D: { "1": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB", "260": "KB LB MB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B", "16": "F", "132": "A 4B pB" }, F: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC", "132": "JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I gC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "132": "tC" } }, B: 5, C: "system-ui value for font-family" };
  }
});

// node_modules/caniuse-lite/data/features/font-feature.js
var require_font_feature = __commonJS({
  "node_modules/caniuse-lite/data/features/font-feature.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "33": "0 G M N O m n o p q r s t u v w x y z", "164": "I l J D E F A B C K L" }, D: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G", "33": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB", "292": "M N O m n" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "D E F 0B oB 2B 3B", "4": "I l J 1B" }, F: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 G M N O m n o p q r s t u v w x y z" }, G: { "1": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E HC IC JC", "4": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB", "33": "dC eC" }, J: { "2": "D", "33": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "33": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS font-feature-settings" };
  }
});

// node_modules/caniuse-lite/data/features/font-kerning.js
var require_font_kerning = __commonJS({
  "node_modules/caniuse-lite/data/features/font-kerning.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q wB xB", "194": "0 r s t u v w x y z" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v", "33": "w x y z" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B", "33": "D E F 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G 9B AC BC CC hB sB DC iB", "33": "M N O m" }, G: { "1": "PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC", "33": "E IC JC KC LC MC NC OC" }, H: { "2": "YC" }, I: { "1": "H eC", "2": "jB I ZC aC bC cC tB", "33": "dC" }, J: { "2": "D", "33": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS3 font-kerning" };
  }
});

// node_modules/caniuse-lite/data/features/font-loading.js
var require_font_loading = __commonJS({
  "node_modules/caniuse-lite/data/features/font-loading.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "194": "2 3 4 5 6 7" }, D: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS Font Loading" };
  }
});

// node_modules/caniuse-lite/data/features/font-metrics-overrides.js
var require_font_metrics_overrides = __commonJS({
  "node_modules/caniuse-lite/data/features/font-metrics-overrides.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U", "194": "V" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "@font-face metrics overrides" };
  }
});

// node_modules/caniuse-lite/data/features/font-size-adjust.js
var require_font_size_adjust = __commonJS({
  "node_modules/caniuse-lite/data/features/font-size-adjust.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "194": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "194": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C G M N O m n o p q r s t u v w 9B AC BC CC hB sB DC iB", "194": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "258": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "194": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "CSS font-size-adjust" };
  }
});

// node_modules/caniuse-lite/data/features/font-smooth.js
var require_font_smooth = __commonJS({
  "node_modules/caniuse-lite/data/features/font-smooth.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "676": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p q r wB xB", "804": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "I", "676": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "0B oB", "676": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "676": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "804": "tC" } }, B: 7, C: "CSS font-smooth" };
  }
});

// node_modules/caniuse-lite/data/features/font-unicode-range.js
var require_font_unicode_range = __commonJS({
  "node_modules/caniuse-lite/data/features/font-unicode-range.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "4": "F A B" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "4": "C K L G M" }, C: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "194": "3 4 5 6 7 8 9 AB" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "4": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "4": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "4": "G M N O m n o p" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "4": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "4": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D", "4": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "4": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "4": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 4, C: "Font unicode-range subsetting" };
  }
});

// node_modules/caniuse-lite/data/features/font-variant-alternates.js
var require_font_variant_alternates = __commonJS({
  "node_modules/caniuse-lite/data/features/font-variant-alternates.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "130": "A B" }, B: { "130": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "130": "I l J D E F A B C K L G M N O m n o p q", "322": "0 r s t u v w x y z" }, D: { "2": "I l J D E F A B C K L G", "130": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "D E F 0B oB 2B 3B", "130": "I l J 1B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "130": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB HC IC JC", "130": "EC tB FC GC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "130": "H dC eC" }, J: { "2": "D", "130": "A" }, K: { "2": "A B C hB sB iB", "130": "Y" }, L: { "130": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "130": "fC" }, P: { "130": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "130": "rC" }, R: { "130": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS font-variant-alternates" };
  }
});

// node_modules/caniuse-lite/data/features/font-variant-east-asian.js
var require_font_variant_east_asian = __commonJS({
  "node_modules/caniuse-lite/data/features/font-variant-east-asian.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q wB xB", "132": "0 r s t u v w x y z" }, D: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB 9B AC BC CC hB sB DC iB" }, G: { "2": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "132": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS font-variant-east-asian " };
  }
});

// node_modules/caniuse-lite/data/features/font-variant-numeric.js
var require_font_variant_numeric = __commonJS({
  "node_modules/caniuse-lite/data/features/font-variant-numeric.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B" }, F: { "1": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D", "16": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I gC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS font-variant-numeric" };
  }
});

// node_modules/caniuse-lite/data/features/fontface.js
var require_fontface = __commonJS({
  "node_modules/caniuse-lite/data/features/fontface.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "132": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W AC BC CC hB sB DC iB", "2": "F 9B" }, G: { "1": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "260": "oB EC" }, H: { "2": "YC" }, I: { "1": "I H cC tB dC eC", "2": "ZC", "4": "jB aC bC" }, J: { "1": "A", "4": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "@font-face Web fonts" };
  }
});

// node_modules/caniuse-lite/data/features/form-attribute.js
var require_form_attribute = __commonJS({
  "node_modules/caniuse-lite/data/features/form-attribute.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "16": "l" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Form attribute" };
  }
});

// node_modules/caniuse-lite/data/features/form-submit-attributes.js
var require_form_submit_attributes = __commonJS({
  "node_modules/caniuse-lite/data/features/form-submit-attributes.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "2": "F 9B", "16": "AC BC" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "I H cC tB dC eC", "2": "ZC aC bC", "16": "jB" }, J: { "1": "A", "2": "D" }, K: { "1": "B C Y hB sB iB", "16": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Attributes for form submission" };
  }
});

// node_modules/caniuse-lite/data/features/form-validation.js
var require_form_validation = __commonJS({
  "node_modules/caniuse-lite/data/features/form-validation.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "132": "l J D E F A 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W AC BC CC hB sB DC iB", "2": "F 9B" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB", "132": "E EC tB FC GC HC IC JC KC LC" }, H: { "516": "YC" }, I: { "1": "H eC", "2": "jB ZC aC bC", "132": "I cC tB dC" }, J: { "1": "A", "132": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "260": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "132": "tC" } }, B: 1, C: "Form validation" };
  }
});

// node_modules/caniuse-lite/data/features/forms.js
var require_forms = __commonJS({
  "node_modules/caniuse-lite/data/features/forms.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "4": "A B", "8": "J D E F" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "4": "C K L G" }, C: { "4": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "8": "vB jB wB xB" }, D: { "1": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "4": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB" }, E: { "4": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "0B oB" }, F: { "1": "F B C JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "4": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB" }, G: { "2": "oB", "4": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB", "4": "dC eC" }, J: { "2": "D", "4": "A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "4": "X" }, N: { "4": "A B" }, O: { "1": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "4": "I gC hC iC" }, Q: { "1": "rC" }, R: { "4": "sC" }, S: { "4": "tC" } }, B: 1, C: "HTML5 form features" };
  }
});

// node_modules/caniuse-lite/data/features/fullscreen.js
var require_fullscreen = __commonJS({
  "node_modules/caniuse-lite/data/features/fullscreen.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "548": "B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "516": "C K L G M N O" }, C: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F wB xB", "676": "0 1 2 3 4 5 6 7 8 9 A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB", "1700": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB" }, D: { "1": "ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L", "676": "G M N O m", "804": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB" }, E: { "2": "I l 0B oB", "548": "rB 8B", "676": "1B", "804": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B C 9B AC BC CC hB sB DC", "804": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC", "2052": "PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D", "292": "A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A", "548": "B" }, O: { "804": "fC" }, P: { "1": "pB lC mC nC oC pC qC", "804": "I gC hC iC jC kC" }, Q: { "804": "rC" }, R: { "804": "sC" }, S: { "1": "tC" } }, B: 1, C: "Full Screen API" };
  }
});

// node_modules/caniuse-lite/data/features/gamepad.js
var require_gamepad = __commonJS({
  "node_modules/caniuse-lite/data/features/gamepad.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n", "33": "o p q r" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "Gamepad API" };
  }
});

// node_modules/caniuse-lite/data/features/geolocation.js
var require_geolocation = __commonJS({
  "node_modules/caniuse-lite/data/features/geolocation.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "uB", "8": "J D E" }, B: { "1": "C K L G M N O", "129": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB wB xB", "8": "vB jB", "129": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB", "4": "I", "129": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J D E F B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "I 0B oB", "129": "A" }, F: { "1": "0 1 2 3 4 5 B C M N O m n o p q r s t u v w x y z CC hB sB DC iB", "2": "F G 9B", "8": "AC BC", "129": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "E oB EC tB FC GC HC IC JC KC", "129": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I ZC aC bC cC tB dC eC", "129": "H" }, J: { "1": "D A" }, K: { "1": "B C hB sB iB", "8": "A", "129": "Y" }, L: { "129": "H" }, M: { "129": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I", "129": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "129": "rC" }, R: { "129": "sC" }, S: { "1": "tC" } }, B: 2, C: "Geolocation" };
  }
});

// node_modules/caniuse-lite/data/features/getboundingclientrect.js
var require_getboundingclientrect = __commonJS({
  "node_modules/caniuse-lite/data/features/getboundingclientrect.js"(exports2, module2) {
    module2.exports = { A: { A: { "644": "J D uB", "2049": "F A B", "2692": "E" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2049": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB", "260": "I l J D E F A B", "1156": "jB", "1284": "wB", "1796": "xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "16": "F 9B", "132": "AC BC" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "132": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2049": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Element.getBoundingClientRect()" };
  }
});

// node_modules/caniuse-lite/data/features/getcomputedstyle.js
var require_getcomputedstyle = __commonJS({
  "node_modules/caniuse-lite/data/features/getcomputedstyle.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB", "132": "jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "260": "I l J D E F A" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "260": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "260": "F 9B AC BC" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "260": "oB EC tB" }, H: { "260": "YC" }, I: { "1": "I H cC tB dC eC", "260": "jB ZC aC bC" }, J: { "1": "A", "260": "D" }, K: { "1": "B C Y hB sB iB", "260": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "getComputedStyle" };
  }
});

// node_modules/caniuse-lite/data/features/getelementsbyclassname.js
var require_getelementsbyclassname = __commonJS({
  "node_modules/caniuse-lite/data/features/getelementsbyclassname.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "uB", "8": "J D E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "8": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "getElementsByClassName" };
  }
});

// node_modules/caniuse-lite/data/features/getrandomvalues.js
var require_getrandomvalues = __commonJS({
  "node_modules/caniuse-lite/data/features/getrandomvalues.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "33": "B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A", "33": "B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "crypto.getRandomValues()" };
  }
});

// node_modules/caniuse-lite/data/features/gyroscope.js
var require_gyroscope = __commonJS({
  "node_modules/caniuse-lite/data/features/gyroscope.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB", "194": "PB kB QB lB RB SB Y TB UB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "Gyroscope" };
  }
});

// node_modules/caniuse-lite/data/features/hardwareconcurrency.js
var require_hardwareconcurrency = __commonJS({
  "node_modules/caniuse-lite/data/features/hardwareconcurrency.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L" }, C: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB wB xB" }, D: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "2": "I l J D 0B oB 1B 2B 3B", "129": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "194": "E F A 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q 9B AC BC CC hB sB DC iB" }, G: { "2": "oB EC tB FC GC HC", "129": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "194": "E IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "navigator.hardwareConcurrency" };
  }
});

// node_modules/caniuse-lite/data/features/hashchange.js
var require_hashchange = __commonJS({
  "node_modules/caniuse-lite/data/features/hashchange.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "E F A B", "8": "J D uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "8": "vB jB wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "8": "I" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "8": "F 9B AC BC" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB" }, H: { "2": "YC" }, I: { "1": "jB I H aC bC cC tB dC eC", "2": "ZC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "8": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Hashchange event" };
  }
});

// node_modules/caniuse-lite/data/features/heif.js
var require_heif = __commonJS({
  "node_modules/caniuse-lite/data/features/heif.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "130": "B C K L G hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC", "130": "NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "HEIF/ISO Base Media File Format" };
  }
});

// node_modules/caniuse-lite/data/features/hevc.js
var require_hevc = __commonJS({
  "node_modules/caniuse-lite/data/features/hevc.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "132": "B" }, B: { "2": "P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "516": "B C hB iB" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "258": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "258": "Y" }, L: { "258": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I", "258": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "HEVC/H.265 video format" };
  }
});

// node_modules/caniuse-lite/data/features/hidden.js
var require_hidden = __commonJS({
  "node_modules/caniuse-lite/data/features/hidden.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "2": "F B 9B AC BC CC" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "I H cC tB dC eC", "2": "jB ZC aC bC" }, J: { "1": "A", "2": "D" }, K: { "1": "C Y hB sB iB", "2": "A B" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "hidden attribute" };
  }
});

// node_modules/caniuse-lite/data/features/high-resolution-time.js
var require_high_resolution_time = __commonJS({
  "node_modules/caniuse-lite/data/features/high-resolution-time.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m", "33": "n o p q" }, E: { "1": "E F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "High Resolution Time API" };
  }
});

// node_modules/caniuse-lite/data/features/history.js
var require_history = __commonJS({
  "node_modules/caniuse-lite/data/features/history.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "4": "l 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W sB DC iB", "2": "F B 9B AC BC CC hB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC", "4": "tB" }, H: { "2": "YC" }, I: { "1": "H aC bC tB dC eC", "2": "jB I ZC cC" }, J: { "1": "D A" }, K: { "1": "C Y hB sB iB", "2": "A B" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Session history management" };
  }
});

// node_modules/caniuse-lite/data/features/html-media-capture.js
var require_html_media_capture = __commonJS({
  "node_modules/caniuse-lite/data/features/html-media-capture.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "oB EC tB FC", "129": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC", "257": "aC bC" }, J: { "1": "A", "16": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "516": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "16": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 4, C: "HTML Media Capture" };
  }
});

// node_modules/caniuse-lite/data/features/html5semantic.js
var require_html5semantic = __commonJS({
  "node_modules/caniuse-lite/data/features/html5semantic.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "8": "J D E", "260": "F A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB", "132": "jB wB xB", "260": "I l J D E F A B C K L G M N O m n" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l", "260": "J D E F A B C K L G M N O m n o p q r s" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "132": "I 0B oB", "260": "l J 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "132": "F B 9B AC BC CC", "260": "C hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "132": "oB", "260": "EC tB FC GC" }, H: { "132": "YC" }, I: { "1": "H dC eC", "132": "ZC", "260": "jB I aC bC cC tB" }, J: { "260": "D A" }, K: { "1": "Y", "132": "A", "260": "B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "260": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "HTML5 semantic elements" };
  }
});

// node_modules/caniuse-lite/data/features/http-live-streaming.js
var require_http_live_streaming = __commonJS({
  "node_modules/caniuse-lite/data/features/http-live-streaming.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O", "2": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 7, C: "HTTP Live Streaming (HLS)" };
  }
});

// node_modules/caniuse-lite/data/features/http2.js
var require_http2 = __commonJS({
  "node_modules/caniuse-lite/data/features/http2.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "132": "B" }, B: { "1": "C K L G M N O", "513": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB", "2": "0 1 2 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "513": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "8 9 AB BB CB DB EB FB GB HB", "2": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "513": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B", "260": "F A 4B pB" }, F: { "1": "0 1 2 3 4 v w x y z", "2": "F B C G M N O m n o p q r s t u 9B AC BC CC hB sB DC iB", "513": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "513": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "513": "Y" }, L: { "513": "H" }, M: { "513": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I", "513": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "513": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "HTTP/2 protocol" };
  }
});

// node_modules/caniuse-lite/data/features/http3.js
var require_http3 = __commonJS({
  "node_modules/caniuse-lite/data/features/http3.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "W Z a b c d e f g h i j k X H", "2": "C K L G M N O", "322": "P Q R S T", "578": "U V" }, C: { "1": "Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB wB xB", "194": "aB bB cB dB eB fB gB P Q R mB S T U V W" }, D: { "1": "W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB", "322": "P Q R S T", "578": "U V" }, E: { "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB 5B", "1090": "L G 6B 7B qB rB 8B" }, F: { "1": "cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB 9B AC BC CC hB sB DC iB", "578": "bB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC", "66": "VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "194": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "oC pC qC", "2": "I gC hC iC jC kC pB lC mC nC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "HTTP/3 protocol" };
  }
});

// node_modules/caniuse-lite/data/features/iframe-sandbox.js
var require_iframe_sandbox = __commonJS({
  "node_modules/caniuse-lite/data/features/iframe-sandbox.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M wB xB", "4": "N O m n o p q r s t u" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC" }, H: { "2": "YC" }, I: { "1": "jB I H aC bC cC tB dC eC", "2": "ZC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "sandbox attribute for iframes" };
  }
});

// node_modules/caniuse-lite/data/features/iframe-seamless.js
var require_iframe_seamless = __commonJS({
  "node_modules/caniuse-lite/data/features/iframe-seamless.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "66": "n o p q r s t" }, E: { "2": "I l J E F A B C K L G 0B oB 1B 2B 4B pB hB iB 5B 6B 7B qB rB 8B", "130": "D 3B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "130": "HC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "seamless attribute for iframes" };
  }
});

// node_modules/caniuse-lite/data/features/iframe-srcdoc.js
var require_iframe_srcdoc = __commonJS({
  "node_modules/caniuse-lite/data/features/iframe-srcdoc.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "8": "J D E F A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "8": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB", "8": "jB I l J D E F A B C K L G M N O m n o p q r wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K", "8": "L G M N O m" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB", "8": "I l 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B 9B AC BC CC", "8": "C hB sB DC iB" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB", "8": "EC tB FC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "8": "jB I ZC aC bC cC tB" }, J: { "1": "A", "8": "D" }, K: { "1": "Y", "2": "A B", "8": "C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "8": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "srcdoc attribute for iframes" };
  }
});

// node_modules/caniuse-lite/data/features/imagecapture.js
var require_imagecapture = __commonJS({
  "node_modules/caniuse-lite/data/features/imagecapture.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "322": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "194": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB", "322": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "322": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "322": "rC" }, R: { "1": "sC" }, S: { "194": "tC" } }, B: 5, C: "ImageCapture API" };
  }
});

// node_modules/caniuse-lite/data/features/ime.js
var require_ime = __commonJS({
  "node_modules/caniuse-lite/data/features/ime.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "161": "B" }, B: { "2": "P Q R S T U V W Z a b c d e f g h i j k X H", "161": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A", "161": "B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Input Method Editor API" };
  }
});

// node_modules/caniuse-lite/data/features/img-naturalwidth-naturalheight.js
var require_img_naturalwidth_naturalheight = __commonJS({
  "node_modules/caniuse-lite/data/features/img-naturalwidth-naturalheight.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "naturalWidth & naturalHeight image properties" };
  }
});

// node_modules/caniuse-lite/data/features/import-maps.js
var require_import_maps = __commonJS({
  "node_modules/caniuse-lite/data/features/import-maps.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "a b c d e f g h i j k X H", "2": "C K L G M N O", "194": "P Q R S T U V W Z" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H wB xB", "322": "nB" }, D: { "1": "a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB", "194": "cB dB eB fB gB P Q R S T U V W Z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB 9B AC BC CC hB sB DC iB", "194": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pC qC", "2": "I gC hC iC jC kC pB lC mC nC oC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Import maps" };
  }
});

// node_modules/caniuse-lite/data/features/imports.js
var require_imports = __commonJS({
  "node_modules/caniuse-lite/data/features/imports.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "8": "A B" }, B: { "1": "P", "2": "Q R S T U V W Z a b c d e f g h i j k X H", "8": "C K L G M N O" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w wB xB", "8": "x y NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "72": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "66": "0 1 x y z", "72": "2" }, E: { "2": "I l 0B oB 1B", "8": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB", "2": "F B C G M VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "66": "N O m n o", "72": "p" }, G: { "2": "oB EC tB FC GC", "8": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "8": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC", "2": "nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "HTML Imports" };
  }
});

// node_modules/caniuse-lite/data/features/indeterminate-checkbox.js
var require_indeterminate_checkbox = __commonJS({
  "node_modules/caniuse-lite/data/features/indeterminate-checkbox.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "16": "uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "2": "vB jB", "16": "wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F B 9B AC BC CC hB sB" }, G: { "1": "QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "2": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "indeterminate checkbox" };
  }
});

// node_modules/caniuse-lite/data/features/indexeddb.js
var require_indexeddb = __commonJS({
  "node_modules/caniuse-lite/data/features/indexeddb.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "132": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "33": "A B C K L G", "36": "I l J D E F" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "A", "8": "I l J D E F", "33": "q", "36": "B C K L G M N O m n o p" }, E: { "1": "A B C K L G pB hB iB 5B 7B qB rB 8B", "8": "I l J D 0B oB 1B 2B", "260": "E F 3B 4B", "516": "6B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F 9B AC", "8": "B C BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC XC qB rB", "8": "oB EC tB FC GC HC", "260": "E IC JC KC", "516": "WC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "8": "jB I ZC aC bC cC tB" }, J: { "1": "A", "8": "D" }, K: { "1": "Y", "2": "A", "8": "B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "IndexedDB" };
  }
});

// node_modules/caniuse-lite/data/features/indexeddb2.js
var require_indexeddb2 = __commonJS({
  "node_modules/caniuse-lite/data/features/indexeddb2.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB wB xB", "132": "BB CB DB", "260": "EB FB GB HB" }, D: { "1": "PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB", "132": "FB GB HB IB", "260": "JB KB LB MB NB OB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "132": "2 3 4 5", "260": "6 7 8 9 AB BB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC", "16": "LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I", "260": "gC hC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "260": "tC" } }, B: 4, C: "IndexedDB 2.0" };
  }
});

// node_modules/caniuse-lite/data/features/inline-block.js
var require_inline_block = __commonJS({
  "node_modules/caniuse-lite/data/features/inline-block.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "E F A B", "4": "uB", "132": "J D" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "36": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS inline-block" };
  }
});

// node_modules/caniuse-lite/data/features/innertext.js
var require_innertext = __commonJS({
  "node_modules/caniuse-lite/data/features/innertext.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "16": "uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "16": "F" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "HTMLElement.innerText" };
  }
});

// node_modules/caniuse-lite/data/features/input-autocomplete-onoff.js
var require_input_autocomplete_onoff = __commonJS({
  "node_modules/caniuse-lite/data/features/input-autocomplete-onoff.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A uB", "132": "B" }, B: { "132": "C K L G M N O", "260": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w wB xB", "516": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "N O m n o p q r s t", "2": "I l J D E F A B C K L G M", "132": "0 1 2 3 4 5 6 7 u v w x y z", "260": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "J 1B 2B", "2": "I l 0B oB", "2052": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "oB EC tB", "1025": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1025": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2052": "A B" }, O: { "1025": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "260": "rC" }, R: { "1": "sC" }, S: { "516": "tC" } }, B: 1, C: "autocomplete attribute: on & off values" };
  }
});

// node_modules/caniuse-lite/data/features/input-color.js
var require_input_color = __commonJS({
  "node_modules/caniuse-lite/data/features/input-color.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m" }, E: { "1": "K L G iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "2": "F G M 9B AC BC CC" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC", "129": "QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 1, C: "Color input type" };
  }
});

// node_modules/caniuse-lite/data/features/input-datetime.js
var require_input_datetime = __commonJS({
  "node_modules/caniuse-lite/data/features/input-datetime.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB wB xB", "1090": "KB LB MB NB", "2052": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d", "4100": "e f g h i j k X H nB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m", "2052": "n o p q r" }, E: { "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B", "4100": "G 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "oB EC tB", "260": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB ZC aC bC", "514": "I cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2052": "tC" } }, B: 1, C: "Date and time input types" };
  }
});

// node_modules/caniuse-lite/data/features/input-email-tel-url.js
var require_input_email_tel_url = __commonJS({
  "node_modules/caniuse-lite/data/features/input-email-tel-url.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "132": "ZC aC bC" }, J: { "1": "A", "132": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Email, telephone & URL input types" };
  }
});

// node_modules/caniuse-lite/data/features/input-event.js
var require_input_event = __commonJS({
  "node_modules/caniuse-lite/data/features/input-event.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "2561": "A B", "2692": "F" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2561": "C K L G M N O" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "16": "vB", "1537": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB xB", "1796": "jB wB" }, D: { "1": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L", "1025": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB", "1537": "0 1 G M N O m n o p q r s t u v w x y z" }, E: { "1": "L G 5B 6B 7B qB rB 8B", "16": "I l J 0B oB", "1025": "D E F A B C 2B 3B 4B pB hB", "1537": "1B", "4097": "K iB" }, F: { "1": "JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "16": "F B C 9B AC BC CC hB sB", "260": "DC", "1025": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB", "1537": "G M N O m n o" }, G: { "16": "oB EC tB", "1025": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "1537": "FC GC HC" }, H: { "2": "YC" }, I: { "16": "ZC aC", "1025": "H eC", "1537": "jB I bC cC tB dC" }, J: { "1025": "A", "1537": "D" }, K: { "1": "A B C hB sB iB", "1025": "Y" }, L: { "1": "H" }, M: { "1537": "X" }, N: { "2561": "A B" }, O: { "1537": "fC" }, P: { "1025": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1025": "rC" }, R: { "1025": "sC" }, S: { "1537": "tC" } }, B: 1, C: "input event" };
  }
});

// node_modules/caniuse-lite/data/features/input-file-accept.js
var require_input_file_accept = __commonJS({
  "node_modules/caniuse-lite/data/features/input-file-accept.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "132": "0 1 2 3 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I", "16": "l J D E o p q r s", "132": "F A B C K L G M N O m n" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "132": "J D E F A B 2B 3B 4B pB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "2": "GC HC", "132": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "514": "oB EC tB FC" }, H: { "2": "YC" }, I: { "2": "ZC aC bC", "260": "jB I cC tB", "514": "H dC eC" }, J: { "132": "A", "260": "D" }, K: { "2": "A B C hB sB iB", "514": "Y" }, L: { "260": "H" }, M: { "2": "X" }, N: { "514": "A", "1028": "B" }, O: { "2": "fC" }, P: { "260": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "260": "rC" }, R: { "260": "sC" }, S: { "1": "tC" } }, B: 1, C: "accept attribute for file input" };
  }
});

// node_modules/caniuse-lite/data/features/input-file-directory.js
var require_input_file_directory = __commonJS({
  "node_modules/caniuse-lite/data/features/input-file-directory.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Directory selection from file input" };
  }
});

// node_modules/caniuse-lite/data/features/input-file-multiple.js
var require_input_file_multiple = __commonJS({
  "node_modules/caniuse-lite/data/features/input-file-multiple.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "2": "vB jB wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "2": "F 9B AC BC" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC" }, H: { "130": "YC" }, I: { "130": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "130": "A B C Y hB sB iB" }, L: { "132": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "130": "fC" }, P: { "130": "I", "132": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "132": "rC" }, R: { "132": "sC" }, S: { "2": "tC" } }, B: 1, C: "Multiple file selection" };
  }
});

// node_modules/caniuse-lite/data/features/input-inputmode.js
var require_input_inputmode = __commonJS({
  "node_modules/caniuse-lite/data/features/input-inputmode.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M wB xB", "4": "N O m n", "194": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f" }, D: { "1": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB", "66": "NB OB PB kB QB lB RB SB Y TB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "66": "AB BB CB DB EB FB GB HB IB JB" }, G: { "1": "QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "kC pB lC mC nC oC pC qC", "2": "I gC hC iC jC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "194": "tC" } }, B: 1, C: "inputmode attribute" };
  }
});

// node_modules/caniuse-lite/data/features/input-minlength.js
var require_input_minlength = __commonJS({
  "node_modules/caniuse-lite/data/features/input-minlength.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M" }, C: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB wB xB" }, D: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 1, C: "Minimum length attribute for input fields" };
  }
});

// node_modules/caniuse-lite/data/features/input-number.js
var require_input_number = __commonJS({
  "node_modules/caniuse-lite/data/features/input-number.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "129": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "129": "C K", "1025": "L G M N O" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB", "513": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "388": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB ZC aC bC", "388": "I H cC tB dC eC" }, J: { "2": "D", "388": "A" }, K: { "1": "A B C hB sB iB", "388": "Y" }, L: { "388": "H" }, M: { "641": "X" }, N: { "388": "A B" }, O: { "388": "fC" }, P: { "388": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "388": "rC" }, R: { "388": "sC" }, S: { "513": "tC" } }, B: 1, C: "Number input type" };
  }
});

// node_modules/caniuse-lite/data/features/input-pattern.js
var require_input_pattern = __commonJS({
  "node_modules/caniuse-lite/data/features/input-pattern.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "16": "l", "388": "J D E F A 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB", "388": "E FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H eC", "2": "jB I ZC aC bC cC tB dC" }, J: { "1": "A", "2": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Pattern attribute for input fields" };
  }
});

// node_modules/caniuse-lite/data/features/input-placeholder.js
var require_input_placeholder = __commonJS({
  "node_modules/caniuse-lite/data/features/input-placeholder.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "132": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W sB DC iB", "2": "F 9B AC BC CC", "132": "B hB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB H ZC aC bC tB dC eC", "4": "I cC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "input placeholder attribute" };
  }
});

// node_modules/caniuse-lite/data/features/input-range.js
var require_input_range = __commonJS({
  "node_modules/caniuse-lite/data/features/input-range.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "H tB dC eC", "4": "jB I ZC aC bC cC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Range input type" };
  }
});

// node_modules/caniuse-lite/data/features/input-search.js
var require_input_search = __commonJS({
  "node_modules/caniuse-lite/data/features/input-search.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "129": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "129": "C K L G M N O" }, C: { "2": "vB jB wB xB", "129": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L o p q r s", "129": "G M N O m n" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F 9B AC BC CC", "16": "B hB sB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB" }, H: { "129": "YC" }, I: { "1": "H dC eC", "16": "ZC aC", "129": "jB I bC cC tB" }, J: { "1": "D", "129": "A" }, K: { "1": "C Y", "2": "A", "16": "B hB sB", "129": "iB" }, L: { "1": "H" }, M: { "129": "X" }, N: { "129": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "129": "tC" } }, B: 1, C: "Search input type" };
  }
});

// node_modules/caniuse-lite/data/features/input-selection.js
var require_input_selection = __commonJS({
  "node_modules/caniuse-lite/data/features/input-selection.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "16": "F 9B AC BC" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Selection controls for input & textarea" };
  }
});

// node_modules/caniuse-lite/data/features/insert-adjacent.js
var require_insert_adjacent = __commonJS({
  "node_modules/caniuse-lite/data/features/insert-adjacent.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "16": "uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "16": "F" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Element.insertAdjacentElement() & Element.insertAdjacentText()" };
  }
});

// node_modules/caniuse-lite/data/features/insertadjacenthtml.js
var require_insertadjacenthtml = __commonJS({
  "node_modules/caniuse-lite/data/features/insertadjacenthtml.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "16": "uB", "132": "J D E F" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W AC BC CC hB sB DC iB", "16": "F 9B" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Element.insertAdjacentHTML()" };
  }
});

// node_modules/caniuse-lite/data/features/internationalization.js
var require_internationalization = __commonJS({
  "node_modules/caniuse-lite/data/features/internationalization.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 6, C: "Internationalization API" };
  }
});

// node_modules/caniuse-lite/data/features/intersectionobserver-v2.js
var require_intersectionobserver_v2 = __commonJS({
  "node_modules/caniuse-lite/data/features/intersectionobserver-v2.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "lC mC nC oC pC qC", "2": "I gC hC iC jC kC pB" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "IntersectionObserver V2" };
  }
});

// node_modules/caniuse-lite/data/features/intersectionobserver.js
var require_intersectionobserver = __commonJS({
  "node_modules/caniuse-lite/data/features/intersectionobserver.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O", "2": "C K L", "516": "G", "1025": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB wB xB", "194": "JB KB LB" }, D: { "1": "PB kB QB lB RB SB Y", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "516": "IB JB KB LB MB NB OB", "1025": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "K L G iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB" }, F: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB", "2": "0 1 2 3 4 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "516": "5 6 7 8 9 AB BB", "1025": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "1025": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "1025": "Y" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "516": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I", "516": "gC hC" }, Q: { "1025": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "IntersectionObserver" };
  }
});

// node_modules/caniuse-lite/data/features/intl-pluralrules.js
var require_intl_pluralrules = __commonJS({
  "node_modules/caniuse-lite/data/features/intl-pluralrules.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N", "130": "O" }, C: { "1": "PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB wB xB" }, D: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB iB" }, F: { "1": "HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB 9B AC BC CC hB sB DC iB" }, G: { "1": "RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Intl.PluralRules API" };
  }
});

// node_modules/caniuse-lite/data/features/intrinsic-width.js
var require_intrinsic_width = __commonJS({
  "node_modules/caniuse-lite/data/features/intrinsic-width.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "1537": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB", "932": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB wB xB", "2308": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "I l J D E F A B C K L G M N O m n o", "545": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB", "1537": "DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J 0B oB 1B", "516": "B C K L G hB iB 5B 6B 7B qB rB 8B", "548": "F A 4B pB", "676": "D E 2B 3B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "513": "1", "545": "G M N O m n o p q r s t u v w x y z", "1537": "0 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "oB EC tB FC GC", "516": "VC WC XC qB rB", "548": "JC KC LC MC NC OC PC QC RC SC TC UC", "676": "E HC IC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "545": "dC eC", "1537": "H" }, J: { "2": "D", "545": "A" }, K: { "2": "A B C hB sB iB", "1537": "Y" }, L: { "1537": "H" }, M: { "2308": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "545": "I", "1537": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "545": "rC" }, R: { "1537": "sC" }, S: { "932": "tC" } }, B: 5, C: "Intrinsic & Extrinsic Sizing" };
  }
});

// node_modules/caniuse-lite/data/features/jpeg2000.js
var require_jpeg2000 = __commonJS({
  "node_modules/caniuse-lite/data/features/jpeg2000.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "129": "l 1B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "JPEG 2000 image format" };
  }
});

// node_modules/caniuse-lite/data/features/jpegxl.js
var require_jpegxl = __commonJS({
  "node_modules/caniuse-lite/data/features/jpegxl.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b", "578": "c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a wB xB", "322": "b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b", "194": "c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB 9B AC BC CC hB sB DC iB", "194": "fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "JPEG XL image format" };
  }
});

// node_modules/caniuse-lite/data/features/jpegxr.js
var require_jpegxr = __commonJS({
  "node_modules/caniuse-lite/data/features/jpegxr.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O", "2": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "1": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "JPEG XR image format" };
  }
});

// node_modules/caniuse-lite/data/features/js-regexp-lookbehind.js
var require_js_regexp_lookbehind = __commonJS({
  "node_modules/caniuse-lite/data/features/js-regexp-lookbehind.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB wB xB" }, D: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Lookbehind in JS regular expressions" };
  }
});

// node_modules/caniuse-lite/data/features/json.js
var require_json = __commonJS({
  "node_modules/caniuse-lite/data/features/json.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D uB", "129": "E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "JSON parsing" };
  }
});

// node_modules/caniuse-lite/data/features/justify-content-space-evenly.js
var require_justify_content_space_evenly = __commonJS({
  "node_modules/caniuse-lite/data/features/justify-content-space-evenly.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G", "132": "M N O" }, C: { "1": "JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB wB xB" }, D: { "1": "QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB", "132": "OB PB kB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B", "132": "pB" }, F: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB 9B AC BC CC hB sB DC iB", "132": "BB CB DB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC", "132": "MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "132": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC", "132": "iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "132": "tC" } }, B: 5, C: "CSS justify-content: space-evenly" };
  }
});

// node_modules/caniuse-lite/data/features/kerning-pairs-ligatures.js
var require_kerning_pairs_ligatures = __commonJS({
  "node_modules/caniuse-lite/data/features/kerning-pairs-ligatures.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "ZC aC bC", "132": "jB I cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 7, C: "High-quality kerning pairs & ligatures" };
  }
});

// node_modules/caniuse-lite/data/features/keyboardevent-charcode.js
var require_keyboardevent_charcode = __commonJS({
  "node_modules/caniuse-lite/data/features/keyboardevent-charcode.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "16": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC hB sB DC", "16": "C" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "Y iB", "2": "A B hB sB", "16": "C" }, L: { "1": "H" }, M: { "130": "X" }, N: { "130": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 7, C: "KeyboardEvent.charCode" };
  }
});

// node_modules/caniuse-lite/data/features/keyboardevent-code.js
var require_keyboardevent_code = __commonJS({
  "node_modules/caniuse-lite/data/features/keyboardevent-code.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "194": "9 AB BB CB DB EB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v 9B AC BC CC hB sB DC iB", "194": "0 1 w x y z" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "194": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I", "194": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "194": "sC" }, S: { "1": "tC" } }, B: 5, C: "KeyboardEvent.code" };
  }
});

// node_modules/caniuse-lite/data/features/keyboardevent-getmodifierstate.js
var require_keyboardevent_getmodifierstate = __commonJS({
  "node_modules/caniuse-lite/data/features/keyboardevent-getmodifierstate.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B G M 9B AC BC CC hB sB DC", "16": "C" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y iB", "2": "A B hB sB", "16": "C" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "KeyboardEvent.getModifierState()" };
  }
});

// node_modules/caniuse-lite/data/features/keyboardevent-key.js
var require_keyboardevent_key = __commonJS({
  "node_modules/caniuse-lite/data/features/keyboardevent-key.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "260": "F A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p wB xB", "132": "q r s t u v" }, D: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "0 1 2 3 4 F B G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC", "16": "C" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "1": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y iB", "2": "A B hB sB", "16": "C" }, L: { "1": "H" }, M: { "1": "X" }, N: { "260": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 5, C: "KeyboardEvent.key" };
  }
});

// node_modules/caniuse-lite/data/features/keyboardevent-location.js
var require_keyboardevent_location = __commonJS({
  "node_modules/caniuse-lite/data/features/keyboardevent-location.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l J D E F A B C K L G M N O m n o p q r s t u v w" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "J 0B oB", "132": "I l 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC hB sB DC", "16": "C", "132": "G M" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB", "132": "FC GC HC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "16": "ZC aC", "132": "jB I bC cC tB" }, J: { "132": "D A" }, K: { "1": "Y iB", "2": "A B hB sB", "16": "C" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "KeyboardEvent.location" };
  }
});

// node_modules/caniuse-lite/data/features/keyboardevent-which.js
var require_keyboardevent_which = __commonJS({
  "node_modules/caniuse-lite/data/features/keyboardevent-which.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "16": "l" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W AC BC CC hB sB DC iB", "16": "F 9B" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB", "16": "ZC aC", "132": "dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "132": "H" }, M: { "132": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "2": "I", "132": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "132": "sC" }, S: { "1": "tC" } }, B: 7, C: "KeyboardEvent.which" };
  }
});

// node_modules/caniuse-lite/data/features/lazyload.js
var require_lazyload = __commonJS({
  "node_modules/caniuse-lite/data/features/lazyload.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "C K L G M N O", "2": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "1": "B", "2": "A" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Resource Hints: Lazyload" };
  }
});

// node_modules/caniuse-lite/data/features/let.js
var require_let = __commonJS({
  "node_modules/caniuse-lite/data/features/let.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "2052": "B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "194": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB wB xB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O", "322": "0 1 2 3 4 5 6 7 m n o p q r s t u v w x y z", "516": "8 9 AB BB CB DB EB FB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B", "1028": "A pB" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "322": "G M N O m n o p q r s t u", "516": "0 1 2 v w x y z" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC", "1028": "LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "516": "I" }, Q: { "1": "rC" }, R: { "516": "sC" }, S: { "1": "tC" } }, B: 6, C: "let" };
  }
});

// node_modules/caniuse-lite/data/features/link-icon-png.js
var require_link_icon_png = __commonJS({
  "node_modules/caniuse-lite/data/features/link-icon-png.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "PC QC RC SC TC UC VC WC XC qB rB", "130": "E oB EC tB FC GC HC IC JC KC LC MC NC OC" }, H: { "130": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D", "130": "A" }, K: { "1": "Y", "130": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "130": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "PNG favicons" };
  }
});

// node_modules/caniuse-lite/data/features/link-icon-svg.js
var require_link_icon_svg = __commonJS({
  "node_modules/caniuse-lite/data/features/link-icon-svg.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P", "1537": "Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB wB xB", "260": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "513": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P", "1537": "Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "BB CB DB EB FB GB HB IB JB KB", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB LB MB NB OB PB QB RB SB Y TB UB 9B AC BC CC hB sB DC iB", "1537": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "PC QC RC SC TC UC VC WC XC qB rB", "130": "E oB EC tB FC GC HC IC JC KC LC MC NC OC" }, H: { "130": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D", "130": "A" }, K: { "2": "Y", "130": "A B C hB sB iB" }, L: { "1537": "H" }, M: { "2": "X" }, N: { "130": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC", "1537": "nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "513": "tC" } }, B: 1, C: "SVG favicons" };
  }
});

// node_modules/caniuse-lite/data/features/link-rel-dns-prefetch.js
var require_link_rel_dns_prefetch = __commonJS({
  "node_modules/caniuse-lite/data/features/link-rel-dns-prefetch.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E uB", "132": "F" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB", "260": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "16": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "16": "jB I H ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "16": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "16": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "16": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Resource Hints: dns-prefetch" };
  }
});

// node_modules/caniuse-lite/data/features/link-rel-modulepreload.js
var require_link_rel_modulepreload = __commonJS({
  "node_modules/caniuse-lite/data/features/link-rel-modulepreload.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "kC pB lC mC nC oC pC qC", "2": "I gC hC iC jC" }, Q: { "16": "rC" }, R: { "16": "sC" }, S: { "2": "tC" } }, B: 1, C: "Resource Hints: modulepreload" };
  }
});

// node_modules/caniuse-lite/data/features/link-rel-preconnect.js
var require_link_rel_preconnect = __commonJS({
  "node_modules/caniuse-lite/data/features/link-rel-preconnect.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L", "260": "G M N O" }, C: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB", "2": "0 1 2 3 4 5 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "129": "6" }, D: { "1": "DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "16": "X" }, N: { "2": "A B" }, O: { "16": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Resource Hints: preconnect" };
  }
});

// node_modules/caniuse-lite/data/features/link-rel-prefetch.js
var require_link_rel_prefetch = __commonJS({
  "node_modules/caniuse-lite/data/features/link-rel-prefetch.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D" }, E: { "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB", "194": "L G 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC", "194": "UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "I H dC eC", "2": "jB ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Resource Hints: prefetch" };
  }
});

// node_modules/caniuse-lite/data/features/link-rel-preload.js
var require_link_rel_preload = __commonJS({
  "node_modules/caniuse-lite/data/features/link-rel-preload.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M", "1028": "N O" }, C: { "1": "U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB wB xB", "132": "NB", "578": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T" }, D: { "1": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "322": "B" }, F: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC", "322": "NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "Resource Hints: preload" };
  }
});

// node_modules/caniuse-lite/data/features/link-rel-prerender.js
var require_link_rel_prerender = __commonJS({
  "node_modules/caniuse-lite/data/features/link-rel-prerender.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "1": "B", "2": "A" }, O: { "2": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "Resource Hints: prerender" };
  }
});

// node_modules/caniuse-lite/data/features/loading-lazy-attr.js
var require_loading_lazy_attr = __commonJS({
  "node_modules/caniuse-lite/data/features/loading-lazy-attr.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB wB xB", "132": "dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB", "66": "dB eB" }, E: { "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB", "322": "L G 5B 6B 7B qB", "580": "rB 8B" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB 9B AC BC CC hB sB DC iB", "66": "RB SB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC", "322": "UC VC WC XC qB", "580": "rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "132": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "mC nC oC pC qC", "2": "I gC hC iC jC kC pB lC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "Lazy loading via attribute for images & iframes" };
  }
});

// node_modules/caniuse-lite/data/features/localecompare.js
var require_localecompare = __commonJS({
  "node_modules/caniuse-lite/data/features/localecompare.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "16": "uB", "132": "J D E F A" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "132": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l J D E F A B C K L G M N O m n o p q" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "132": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F B C 9B AC BC CC hB sB DC", "132": "iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "132": "E oB EC tB FC GC HC IC JC KC" }, H: { "132": "YC" }, I: { "1": "H dC eC", "132": "jB I ZC aC bC cC tB" }, J: { "132": "D A" }, K: { "1": "Y", "16": "A B C hB sB", "132": "iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "132": "A" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "132": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "4": "tC" } }, B: 6, C: "localeCompare()" };
  }
});

// node_modules/caniuse-lite/data/features/magnetometer.js
var require_magnetometer = __commonJS({
  "node_modules/caniuse-lite/data/features/magnetometer.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB", "194": "PB kB QB lB RB SB Y TB UB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "194": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "Magnetometer" };
  }
});

// node_modules/caniuse-lite/data/features/matchesselector.js
var require_matchesselector = __commonJS({
  "node_modules/caniuse-lite/data/features/matchesselector.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "36": "F A B" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "36": "C K L" }, C: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB", "36": "0 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z xB" }, D: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "36": "0 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "36": "l J D 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B 9B AC BC CC hB", "36": "C G M N O m n sB DC iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB", "36": "EC tB FC GC HC" }, H: { "2": "YC" }, I: { "1": "H", "2": "ZC", "36": "jB I aC bC cC tB dC eC" }, J: { "36": "D A" }, K: { "1": "Y", "2": "A B", "36": "C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "36": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "36": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "matches() DOM method" };
  }
});

// node_modules/caniuse-lite/data/features/matchmedia.js
var require_matchmedia = __commonJS({
  "node_modules/caniuse-lite/data/features/matchmedia.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B C 9B AC BC CC hB sB DC" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y iB", "2": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "matchMedia" };
  }
});

// node_modules/caniuse-lite/data/features/mathml.js
var require_mathml = __commonJS({
  "node_modules/caniuse-lite/data/features/mathml.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "F A B uB", "8": "J D E" }, B: { "2": "C K L G M N O", "8": "P Q R S T U V W Z a b c d e f g h", "584": "i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "129": "vB jB wB xB" }, D: { "1": "r", "8": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h", "584": "i j k X H nB yB zB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "260": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "2": "F", "4": "B C 9B AC BC CC hB sB DC iB", "8": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB", "584": "S T U V W" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "8": "oB EC tB" }, H: { "8": "YC" }, I: { "8": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "A", "8": "D" }, K: { "8": "A B C Y hB sB iB" }, L: { "8": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "4": "fC" }, P: { "8": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "8": "rC" }, R: { "8": "sC" }, S: { "1": "tC" } }, B: 2, C: "MathML" };
  }
});

// node_modules/caniuse-lite/data/features/maxlength.js
var require_maxlength = __commonJS({
  "node_modules/caniuse-lite/data/features/maxlength.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "16": "uB", "900": "J D E F" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "1025": "C K L G M N O" }, C: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "900": "vB jB wB xB", "1025": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "l 0B", "900": "I oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F", "132": "B C 9B AC BC CC hB sB DC iB" }, G: { "1": "EC tB FC GC HC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB", "2052": "E IC" }, H: { "132": "YC" }, I: { "1": "jB I bC cC tB dC eC", "16": "ZC aC", "4097": "H" }, J: { "1": "D A" }, K: { "132": "A B C hB sB iB", "4097": "Y" }, L: { "4097": "H" }, M: { "4097": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "4097": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1025": "tC" } }, B: 1, C: "maxlength attribute for input and textarea elements" };
  }
});

// node_modules/caniuse-lite/data/features/media-attribute.js
var require_media_attribute = __commonJS({
  "node_modules/caniuse-lite/data/features/media-attribute.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O", "16": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "1": "0 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "2": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H", "16": "nB yB zB" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB" }, F: { "1": "B C G M N O m n o p q r AC BC CC hB sB DC iB", "2": "0 1 2 3 4 5 6 7 8 9 F s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB" }, H: { "16": "YC" }, I: { "1": "I H cC tB dC eC", "16": "jB ZC aC bC" }, J: { "16": "D A" }, K: { "1": "C Y iB", "16": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "16": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Media attribute" };
  }
});

// node_modules/caniuse-lite/data/features/media-fragments.js
var require_media_fragments = __commonJS({
  "node_modules/caniuse-lite/data/features/media-fragments.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "132": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "132": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "I l J D E F A B C K L G M N", "132": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l 0B oB 1B", "132": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "132": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "oB EC tB FC GC HC", "132": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "132": "H dC eC" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "132": "Y" }, L: { "132": "H" }, M: { "132": "X" }, N: { "132": "A B" }, O: { "2": "fC" }, P: { "2": "I gC", "132": "hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "132": "tC" } }, B: 2, C: "Media Fragments" };
  }
});

// node_modules/caniuse-lite/data/features/media-session-api.js
var require_media_session_api = __commonJS({
  "node_modules/caniuse-lite/data/features/media-session-api.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB" }, E: { "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB", "16": "L G 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Media Session API" };
  }
});

// node_modules/caniuse-lite/data/features/mediacapture-fromelement.js
var require_mediacapture_fromelement = __commonJS({
  "node_modules/caniuse-lite/data/features/mediacapture-fromelement.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "260": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "324": "IB JB KB LB MB NB OB PB kB QB lB" }, E: { "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "132": "B C K L G hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "324": "3 4 5 6 7 8 9 AB BB CB DB EB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "260": "X" }, N: { "2": "A B" }, O: { "132": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I", "132": "gC hC iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "260": "tC" } }, B: 5, C: "Media Capture from DOM Elements API" };
  }
});

// node_modules/caniuse-lite/data/features/mediarecorder.js
var require_mediarecorder = __commonJS({
  "node_modules/caniuse-lite/data/features/mediarecorder.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB", "194": "EB FB" }, E: { "1": "G 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB", "322": "K L iB 5B" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "194": "1 2" }, G: { "1": "WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC", "578": "PC QC RC SC TC UC VC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 5, C: "MediaRecorder API" };
  }
});

// node_modules/caniuse-lite/data/features/mediasource.js
var require_mediasource = __commonJS({
  "node_modules/caniuse-lite/data/features/mediasource.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "132": "B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r wB xB", "66": "0 1 2 3 4 5 6 7 8 s t u v w x y z" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M", "33": "q r s t u v w x", "66": "N O m n o p" }, E: { "1": "E F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC", "260": "RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H eC", "2": "jB I ZC aC bC cC tB dC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "kC pB lC mC nC oC pC qC", "2": "I gC hC iC jC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "Media Source Extensions" };
  }
});

// node_modules/caniuse-lite/data/features/menu.js
var require_menu = __commonJS({
  "node_modules/caniuse-lite/data/features/menu.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D wB xB", "132": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T", "450": "U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "66": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 F B C G M N O m n o p q r s t u v w x y z EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "66": "2 3 4 5 6 7 8 9 AB BB CB DB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "450": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Context menu item (menuitem element)" };
  }
});

// node_modules/caniuse-lite/data/features/meta-theme-color.js
var require_meta_theme_color = __commonJS({
  "node_modules/caniuse-lite/data/features/meta-theme-color.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "132": "bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "258": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB" }, E: { "1": "G 7B qB rB 8B", "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B 6B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "513": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I", "16": "gC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "theme-color Meta Tag" };
  }
});

// node_modules/caniuse-lite/data/features/meter.js
var require_meter = __commonJS({
  "node_modules/caniuse-lite/data/features/meter.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "2": "F 9B AC BC CC" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "meter element" };
  }
});

// node_modules/caniuse-lite/data/features/midi.js
var require_midi = __commonJS({
  "node_modules/caniuse-lite/data/features/midi.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "Web MIDI API" };
  }
});

// node_modules/caniuse-lite/data/features/minmaxwh.js
var require_minmaxwh = __commonJS({
  "node_modules/caniuse-lite/data/features/minmaxwh.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "8": "J uB", "129": "D", "257": "E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "CSS min/max-width/height" };
  }
});

// node_modules/caniuse-lite/data/features/mp3.js
var require_mp3 = __commonJS({
  "node_modules/caniuse-lite/data/features/mp3.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "132": "I l J D E F A B C K L G M N O m n o wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "2": "ZC aC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "MP3 audio format" };
  }
});

// node_modules/caniuse-lite/data/features/mpeg-dash.js
var require_mpeg_dash = __commonJS({
  "node_modules/caniuse-lite/data/features/mpeg-dash.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O", "2": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "386": "o p" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Dynamic Adaptive Streaming over HTTP (MPEG-DASH)" };
  }
});

// node_modules/caniuse-lite/data/features/mpeg4.js
var require_mpeg4 = __commonJS({
  "node_modules/caniuse-lite/data/features/mpeg4.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n wB xB", "4": "0 1 o p q r s t u v w x y z" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "4": "jB I ZC aC cC tB", "132": "bC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "260": "X" }, N: { "1": "A B" }, O: { "4": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "MPEG-4/H.264 video format" };
  }
});

// node_modules/caniuse-lite/data/features/multibackgrounds.js
var require_multibackgrounds = __commonJS({
  "node_modules/caniuse-lite/data/features/multibackgrounds.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "2": "vB jB wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS3 Multiple backgrounds" };
  }
});

// node_modules/caniuse-lite/data/features/multicolumn.js
var require_multicolumn = __commonJS({
  "node_modules/caniuse-lite/data/features/multicolumn.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O", "516": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "132": "JB KB LB MB NB OB PB kB QB lB RB SB Y", "164": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB wB xB", "516": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c", "1028": "d e f g h i j k X H nB" }, D: { "420": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB", "516": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "132": "F 4B", "164": "D E 3B", "420": "I l J 0B oB 1B 2B" }, F: { "1": "C hB sB DC iB", "2": "F B 9B AC BC CC", "420": "0 1 2 3 G M N O m n o p q r s t u v w x y z", "516": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "132": "JC KC", "164": "E HC IC", "420": "oB EC tB FC GC" }, H: { "1": "YC" }, I: { "420": "jB I ZC aC bC cC tB dC eC", "516": "H" }, J: { "420": "D A" }, K: { "1": "C hB sB iB", "2": "A B", "516": "Y" }, L: { "516": "H" }, M: { "516": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "420": "I" }, Q: { "132": "rC" }, R: { "132": "sC" }, S: { "164": "tC" } }, B: 4, C: "CSS3 Multiple column layout" };
  }
});

// node_modules/caniuse-lite/data/features/mutation-events.js
var require_mutation_events = __commonJS({
  "node_modules/caniuse-lite/data/features/mutation-events.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "260": "F A B" }, B: { "132": "P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L G M N O" }, C: { "2": "vB jB I l wB xB", "260": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "16": "I l J D E F A B C K L", "132": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "16": "0B oB", "132": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "C DC iB", "2": "F 9B AC BC CC", "16": "B hB sB", "132": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "16": "oB EC", "132": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "16": "ZC aC", "132": "jB I H bC cC tB dC eC" }, J: { "132": "D A" }, K: { "1": "C iB", "2": "A", "16": "B hB sB", "132": "Y" }, L: { "132": "H" }, M: { "260": "X" }, N: { "260": "A B" }, O: { "132": "fC" }, P: { "132": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "132": "rC" }, R: { "132": "sC" }, S: { "260": "tC" } }, B: 5, C: "Mutation events" };
  }
});

// node_modules/caniuse-lite/data/features/mutationobserver.js
var require_mutationobserver = __commonJS({
  "node_modules/caniuse-lite/data/features/mutationobserver.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E uB", "8": "F A" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N", "33": "O m n o p q r s t" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "33": "J" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC", "33": "GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB ZC aC bC", "8": "I cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "8": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Mutation Observer" };
  }
});

// node_modules/caniuse-lite/data/features/namevalue-storage.js
var require_namevalue_storage = __commonJS({
  "node_modules/caniuse-lite/data/features/namevalue-storage.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "E F A B", "2": "uB", "8": "J D" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "4": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Web Storage - name/value pairs" };
  }
});

// node_modules/caniuse-lite/data/features/native-filesystem-api.js
var require_native_filesystem_api = __commonJS({
  "node_modules/caniuse-lite/data/features/native-filesystem-api.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "194": "P Q R S T U", "260": "V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB", "194": "cB dB eB fB gB P Q R S T U", "260": "V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B", "516": "qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB 9B AC BC CC hB sB DC iB", "194": "RB SB Y TB UB VB WB XB YB ZB", "260": "aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC", "516": "qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "File System Access API" };
  }
});

// node_modules/caniuse-lite/data/features/nav-timing.js
var require_nav_timing = __commonJS({
  "node_modules/caniuse-lite/data/features/nav-timing.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l", "33": "J D E F A B C" }, E: { "1": "E F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "I H cC tB dC eC", "2": "jB ZC aC bC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "Navigation Timing API" };
  }
});

// node_modules/caniuse-lite/data/features/navigator-language.js
var require_navigator_language = __commonJS({
  "node_modules/caniuse-lite/data/features/navigator-language.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y wB xB" }, D: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "16": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "16": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "16": "rC" }, R: { "16": "sC" }, S: { "1": "tC" } }, B: 2, C: "Navigator Language API" };
  }
});

// node_modules/caniuse-lite/data/features/netinfo.js
var require_netinfo = __commonJS({
  "node_modules/caniuse-lite/data/features/netinfo.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "1028": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB", "1028": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB 9B AC BC CC hB sB DC iB", "1028": "FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "ZC dC eC", "132": "jB I aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "132": "I", "516": "gC hC iC" }, Q: { "1": "rC" }, R: { "516": "sC" }, S: { "260": "tC" } }, B: 7, C: "Network Information API" };
  }
});

// node_modules/caniuse-lite/data/features/notifications.js
var require_notifications = __commonJS({
  "node_modules/caniuse-lite/data/features/notifications.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I", "36": "l J D E F A B C K L G M N O m n o" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "36": "H dC eC" }, J: { "1": "A", "2": "D" }, K: { "2": "A B C hB sB iB", "36": "Y" }, L: { "513": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "36": "I", "258": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "258": "sC" }, S: { "1": "tC" } }, B: 1, C: "Web Notifications" };
  }
});

// node_modules/caniuse-lite/data/features/object-entries.js
var require_object_entries = __commonJS({
  "node_modules/caniuse-lite/data/features/object-entries.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB wB xB" }, D: { "1": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D", "16": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I gC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 6, C: "Object.entries" };
  }
});

// node_modules/caniuse-lite/data/features/object-fit.js
var require_object_fit = __commonJS({
  "node_modules/caniuse-lite/data/features/object-fit.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G", "260": "M N O" }, C: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w x y" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B", "132": "E F 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F G M N O 9B AC BC", "33": "B C CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC", "132": "E IC JC KC" }, H: { "33": "YC" }, I: { "1": "H eC", "2": "jB I ZC aC bC cC tB dC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A", "33": "B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS3 object-fit/object-position" };
  }
});

// node_modules/caniuse-lite/data/features/object-observe.js
var require_object_observe = __commonJS({
  "node_modules/caniuse-lite/data/features/object-observe.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB", "2": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 q r s t u v w x y z", "2": "4 5 6 7 8 9 F B C G M N O m n o p AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "I", "2": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 7, C: "Object.observe data binding" };
  }
});

// node_modules/caniuse-lite/data/features/object-values.js
var require_object_values = __commonJS({
  "node_modules/caniuse-lite/data/features/object-values.js"(exports2, module2) {
    module2.exports = { A: { A: { "8": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "8": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB wB xB" }, D: { "1": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "8": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "8": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "8": "0 1 2 3 4 5 6 7 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "8": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "8": "YC" }, I: { "1": "H", "8": "jB I ZC aC bC cC tB dC eC" }, J: { "8": "D A" }, K: { "1": "Y", "8": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "8": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "8": "I gC" }, Q: { "1": "rC" }, R: { "8": "sC" }, S: { "1": "tC" } }, B: 6, C: "Object.values method" };
  }
});

// node_modules/caniuse-lite/data/features/objectrtc.js
var require_objectrtc = __commonJS({
  "node_modules/caniuse-lite/data/features/objectrtc.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O", "2": "C P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D", "130": "A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Object RTC (ORTC) API for WebRTC" };
  }
});

// node_modules/caniuse-lite/data/features/offline-apps.js
var require_offline_apps = __commonJS({
  "node_modules/caniuse-lite/data/features/offline-apps.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "F uB", "8": "J D E" }, B: { "1": "C K L G M N O P Q R S T", "2": "U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S wB xB", "2": "T U V W Z a b c d e f g h i j k X H nB", "4": "jB", "8": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T", "2": "U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB CC hB sB DC iB", "2": "F bB cB dB eB fB gB P Q R mB S T U V W 9B", "8": "AC BC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I ZC aC bC cC tB dC eC", "2": "H" }, J: { "1": "D A" }, K: { "1": "B C hB sB iB", "2": "A Y" }, L: { "2": "H" }, M: { "2": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 7, C: "Offline web applications" };
  }
});

// node_modules/caniuse-lite/data/features/offscreencanvas.js
var require_offscreencanvas = __commonJS({
  "node_modules/caniuse-lite/data/features/offscreencanvas.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB wB xB", "194": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB", "322": "PB kB QB lB RB SB Y TB UB VB WB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB 9B AC BC CC hB sB DC iB", "322": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "194": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pB lC mC nC oC pC qC", "2": "I gC hC iC jC kC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "194": "tC" } }, B: 1, C: "OffscreenCanvas" };
  }
});

// node_modules/caniuse-lite/data/features/ogg-vorbis.js
var require_ogg_vorbis = __commonJS({
  "node_modules/caniuse-lite/data/features/ogg-vorbis.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B", "132": "G 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "A", "2": "D" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Ogg Vorbis audio format" };
  }
});

// node_modules/caniuse-lite/data/features/ogv.js
var require_ogv = __commonJS({
  "node_modules/caniuse-lite/data/features/ogv.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "8": "F A B" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "8": "C K L G M" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "1": "X" }, N: { "8": "A B" }, O: { "1": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 6, C: "Ogg/Theora video format" };
  }
});

// node_modules/caniuse-lite/data/features/ol-reversed.js
var require_ol_reversed = __commonJS({
  "node_modules/caniuse-lite/data/features/ol-reversed.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G", "16": "M N O m" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "16": "J" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC hB sB DC", "16": "C" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Reversed attribute of ordered lists" };
  }
});

// node_modules/caniuse-lite/data/features/once-event-listener.js
var require_once_event_listener = __commonJS({
  "node_modules/caniuse-lite/data/features/once-event-listener.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G" }, C: { "1": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB wB xB" }, D: { "1": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I gC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: '"once" event listener option' };
  }
});

// node_modules/caniuse-lite/data/features/online-status.js
var require_online_status = __commonJS({
  "node_modules/caniuse-lite/data/features/online-status.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D uB", "260": "E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB", "516": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC", "4": "iB" }, G: { "1": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "A", "132": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Online/offline status" };
  }
});

// node_modules/caniuse-lite/data/features/opus.js
var require_opus = __commonJS({
  "node_modules/caniuse-lite/data/features/opus.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "132": "B C K L G hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC", "132": "NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Opus" };
  }
});

// node_modules/caniuse-lite/data/features/orientation-sensor.js
var require_orientation_sensor = __commonJS({
  "node_modules/caniuse-lite/data/features/orientation-sensor.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB", "194": "PB kB QB lB RB SB Y TB UB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "Orientation Sensor" };
  }
});

// node_modules/caniuse-lite/data/features/outline.js
var require_outline = __commonJS({
  "node_modules/caniuse-lite/data/features/outline.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D uB", "260": "E", "388": "F A B" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "388": "C K L" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC", "129": "iB", "260": "F B 9B AC BC CC hB sB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "C Y iB", "260": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "388": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS outline properties" };
  }
});

// node_modules/caniuse-lite/data/features/pad-start-end.js
var require_pad_start_end = __commonJS({
  "node_modules/caniuse-lite/data/features/pad-start-end.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L" }, C: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB wB xB" }, D: { "1": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I gC hC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 6, C: "String.prototype.padStart(), String.prototype.padEnd()" };
  }
});

// node_modules/caniuse-lite/data/features/page-transition-events.js
var require_page_transition_events = __commonJS({
  "node_modules/caniuse-lite/data/features/page-transition-events.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "PageTransitionEvent" };
  }
});

// node_modules/caniuse-lite/data/features/pagevisibility.js
var require_pagevisibility = __commonJS({
  "node_modules/caniuse-lite/data/features/pagevisibility.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F wB xB", "33": "A B C K L G M N" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K", "33": "L G M N O m n o p q r s t u v w x y z" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B C 9B AC BC CC hB sB DC", "33": "G M N O m" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB", "33": "dC eC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y iB", "2": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "33": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "Page Visibility" };
  }
});

// node_modules/caniuse-lite/data/features/passive-event-listener.js
var require_passive_event_listener = __commonJS({
  "node_modules/caniuse-lite/data/features/passive-event-listener.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB wB xB" }, D: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "Passive event listeners" };
  }
});

// node_modules/caniuse-lite/data/features/passwordrules.js
var require_passwordrules = __commonJS({
  "node_modules/caniuse-lite/data/features/passwordrules.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "16": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X wB xB", "16": "H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H", "16": "nB yB zB" }, E: { "1": "C K iB", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB hB", "16": "L G 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB 9B AC BC CC hB sB DC iB", "16": "KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "16": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "16": "H" }, J: { "2": "D", "16": "A" }, K: { "2": "A B C hB sB iB", "16": "Y" }, L: { "16": "H" }, M: { "16": "X" }, N: { "2": "A", "16": "B" }, O: { "16": "fC" }, P: { "2": "I gC hC", "16": "iC jC kC pB lC mC nC oC pC qC" }, Q: { "16": "rC" }, R: { "16": "sC" }, S: { "2": "tC" } }, B: 1, C: "Password Rules" };
  }
});

// node_modules/caniuse-lite/data/features/path2d.js
var require_path2d = __commonJS({
  "node_modules/caniuse-lite/data/features/path2d.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K", "132": "L G M N O" }, C: { "1": "FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x wB xB", "132": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB" }, D: { "1": "WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "132": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B", "132": "E F 3B" }, F: { "1": "MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p 9B AC BC CC hB sB DC iB", "132": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC", "16": "E", "132": "IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "132": "fC" }, P: { "1": "pB lC mC nC oC pC qC", "132": "I gC hC iC jC kC" }, Q: { "132": "rC" }, R: { "132": "sC" }, S: { "1": "tC" } }, B: 1, C: "Path2D" };
  }
});

// node_modules/caniuse-lite/data/features/payment-request.js
var require_payment_request = __commonJS({
  "node_modules/caniuse-lite/data/features/payment-request.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K", "322": "L", "8196": "G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB wB xB", "4162": "MB NB OB PB kB QB lB RB SB Y TB", "16452": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB", "194": "KB LB MB NB OB PB", "1090": "kB QB", "8196": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB" }, E: { "1": "K L G iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B", "514": "A B pB", "8196": "C hB" }, F: { "1": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "194": "7 8 9 AB BB CB DB EB", "8196": "FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB" }, G: { "1": "QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC", "514": "LC MC NC", "8196": "OC PC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "2049": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "mC nC oC pC qC", "2": "I", "8196": "gC hC iC jC kC pB lC" }, Q: { "8196": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "Payment Request API" };
  }
});

// node_modules/caniuse-lite/data/features/pdf-viewer.js
var require_pdf_viewer = __commonJS({
  "node_modules/caniuse-lite/data/features/pdf-viewer.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "132": "B" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "16": "C K L" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC hB sB DC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "16": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Built-in PDF viewer" };
  }
});

// node_modules/caniuse-lite/data/features/permissions-api.js
var require_permissions_api = __commonJS({
  "node_modules/caniuse-lite/data/features/permissions-api.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB wB xB" }, D: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 7, C: "Permissions API" };
  }
});

// node_modules/caniuse-lite/data/features/permissions-policy.js
var require_permissions_policy = __commonJS({
  "node_modules/caniuse-lite/data/features/permissions-policy.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "258": "P Q R S T U", "322": "V W", "388": "Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB wB xB", "258": "cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB", "258": "QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U", "322": "V W", "388": "Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB", "258": "C K L G hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB 9B AC BC CC hB sB DC iB", "258": "EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB", "322": "aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC", "258": "OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "258": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "258": "Y" }, L: { "388": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC", "258": "jC kC pB lC mC nC oC pC qC" }, Q: { "258": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Permissions Policy" };
  }
});

// node_modules/caniuse-lite/data/features/picture-in-picture.js
var require_picture_in_picture = __commonJS({
  "node_modules/caniuse-lite/data/features/picture-in-picture.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB wB xB", "132": "aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "1090": "VB", "1412": "ZB", "1668": "WB XB YB" }, D: { "1": "YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB", "2114": "XB" }, E: { "1": "L G 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B", "4100": "A B C K pB hB iB" }, F: { "1": "bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "8196": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB" }, G: { "1": "VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC", "4100": "JC KC LC MC NC OC PC QC RC SC TC UC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "16388": "H" }, M: { "16388": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Picture-in-Picture" };
  }
});

// node_modules/caniuse-lite/data/features/picture.js
var require_picture = __commonJS({
  "node_modules/caniuse-lite/data/features/picture.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C" }, C: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "578": "1 2 3 4" }, D: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "194": "4" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q 9B AC BC CC hB sB DC iB", "322": "r" }, G: { "1": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Picture element" };
  }
});

// node_modules/caniuse-lite/data/features/ping.js
var require_ping = __commonJS({
  "node_modules/caniuse-lite/data/features/ping.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M" }, C: { "2": "vB", "194": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "194": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "194": "tC" } }, B: 1, C: "Ping attribute" };
  }
});

// node_modules/caniuse-lite/data/features/png-alpha.js
var require_png_alpha = __commonJS({
  "node_modules/caniuse-lite/data/features/png-alpha.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "D E F A B", "2": "uB", "8": "J" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "PNG alpha transparency" };
  }
});

// node_modules/caniuse-lite/data/features/pointer-events.js
var require_pointer_events = __commonJS({
  "node_modules/caniuse-lite/data/features/pointer-events.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "2": "vB jB wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 7, C: "CSS pointer-events (for HTML)" };
  }
});

// node_modules/caniuse-lite/data/features/pointer.js
var require_pointer = __commonJS({
  "node_modules/caniuse-lite/data/features/pointer.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F uB", "164": "A" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l wB xB", "8": "0 1 2 3 4 5 6 7 J D E F A B C K L G M N O m n o p q r s t u v w x y z", "328": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB" }, D: { "1": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o", "8": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB", "584": "JB KB LB" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B", "8": "D E F A B C 2B 3B 4B pB hB", "1096": "iB" }, F: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "8": "0 1 2 3 4 5 G M N O m n o p q r s t u v w x y z", "584": "6 7 8" }, G: { "1": "SC TC UC VC WC XC qB rB", "8": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC", "6148": "RC" }, H: { "2": "YC" }, I: { "1": "H", "8": "jB I ZC aC bC cC tB dC eC" }, J: { "8": "D A" }, K: { "1": "Y", "2": "A", "8": "B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "36": "A" }, O: { "8": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "gC", "8": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "328": "tC" } }, B: 2, C: "Pointer events" };
  }
});

// node_modules/caniuse-lite/data/features/pointerlock.js
var require_pointerlock = __commonJS({
  "node_modules/caniuse-lite/data/features/pointerlock.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C" }, C: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K wB xB", "33": "0 1 2 3 4 5 6 7 L G M N O m n o p q r s t u v w x y z" }, D: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G", "33": "0 1 2 3 p q r s t u v w x y z", "66": "M N O m n o" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "G M N O m n o p q" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 2, C: "Pointer Lock API" };
  }
});

// node_modules/caniuse-lite/data/features/portals.js
var require_portals = __commonJS({
  "node_modules/caniuse-lite/data/features/portals.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T", "322": "b c d e f g h i j k X H", "450": "U V W Z a" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB", "194": "dB eB fB gB P Q R S T", "322": "V W Z a b c d e f g h i j k X H nB yB zB", "450": "U" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB 9B AC BC CC hB sB DC iB", "194": "RB SB Y TB UB VB WB XB YB ZB aB", "322": "bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "450": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Portals" };
  }
});

// node_modules/caniuse-lite/data/features/prefers-color-scheme.js
var require_prefers_color_scheme = __commonJS({
  "node_modules/caniuse-lite/data/features/prefers-color-scheme.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB wB xB" }, D: { "1": "eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB" }, E: { "1": "K L G iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB" }, F: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB 9B AC BC CC hB sB DC iB" }, G: { "1": "RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "mC nC oC pC qC", "2": "I gC hC iC jC kC pB lC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "prefers-color-scheme media query" };
  }
});

// node_modules/caniuse-lite/data/features/prefers-reduced-motion.js
var require_prefers_reduced_motion = __commonJS({
  "node_modules/caniuse-lite/data/features/prefers-reduced-motion.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB wB xB" }, D: { "1": "cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "lC mC nC oC pC qC", "2": "I gC hC iC jC kC pB" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "prefers-reduced-motion media query" };
  }
});

// node_modules/caniuse-lite/data/features/private-class-fields.js
var require_private_class_fields = __commonJS({
  "node_modules/caniuse-lite/data/features/private-class-fields.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB" }, E: { "1": "G 6B 7B qB rB 8B", "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B" }, F: { "1": "RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB 9B AC BC CC hB sB DC iB" }, G: { "1": "WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "lC mC nC oC pC qC", "2": "I gC hC iC jC kC pB" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Private class fields" };
  }
});

// node_modules/caniuse-lite/data/features/private-methods-and-accessors.js
var require_private_methods_and_accessors = __commonJS({
  "node_modules/caniuse-lite/data/features/private-methods-and-accessors.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O P Q R S" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S" }, E: { "1": "G 6B 7B qB rB 8B", "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B" }, F: { "1": "YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB 9B AC BC CC hB sB DC iB" }, G: { "1": "WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Public class fields" };
  }
});

// node_modules/caniuse-lite/data/features/progress.js
var require_progress = __commonJS({
  "node_modules/caniuse-lite/data/features/progress.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "2": "F 9B AC BC CC" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC", "132": "HC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "progress element" };
  }
});

// node_modules/caniuse-lite/data/features/promise-finally.js
var require_promise_finally = __commonJS({
  "node_modules/caniuse-lite/data/features/promise-finally.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N" }, C: { "1": "PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB wB xB" }, D: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB" }, F: { "1": "HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Promise.prototype.finally" };
  }
});

// node_modules/caniuse-lite/data/features/promises.js
var require_promises = __commonJS({
  "node_modules/caniuse-lite/data/features/promises.js"(exports2, module2) {
    module2.exports = { A: { A: { "8": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "4": "u v", "8": "vB jB I l J D E F A B C K L G M N O m n o p q r s t wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "4": "z", "8": "I l J D E F A B C K L G M N O m n o p q r s t u v w x y" }, E: { "1": "E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "I l J D 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "4": "m", "8": "F B C G M N O 9B AC BC CC hB sB DC iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "8": "oB EC tB FC GC HC" }, H: { "8": "YC" }, I: { "1": "H eC", "8": "jB I ZC aC bC cC tB dC" }, J: { "8": "D A" }, K: { "1": "Y", "8": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "8": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Promises" };
  }
});

// node_modules/caniuse-lite/data/features/proximity.js
var require_proximity = __commonJS({
  "node_modules/caniuse-lite/data/features/proximity.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 4, C: "Proximity API" };
  }
});

// node_modules/caniuse-lite/data/features/proxy.js
var require_proxy = __commonJS({
  "node_modules/caniuse-lite/data/features/proxy.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N wB xB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "5 6 7 8 9 I l J D E F A B C K L G M N O AB BB CB DB EB FB", "66": "0 1 2 3 4 m n o p q r s t u v w x y z" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 F B C s t u v w x y z 9B AC BC CC hB sB DC iB", "66": "G M N O m n o p q r" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 6, C: "Proxy object" };
  }
});

// node_modules/caniuse-lite/data/features/public-class-fields.js
var require_public_class_fields = __commonJS({
  "node_modules/caniuse-lite/data/features/public-class-fields.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB wB xB", "4": "YB ZB aB bB cB", "132": "XB" }, D: { "1": "aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB" }, E: { "1": "G 6B 7B qB rB 8B", "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB 5B", "260": "L" }, F: { "1": "QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB 9B AC BC CC hB sB DC iB" }, G: { "1": "VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "lC mC nC oC pC qC", "2": "I gC hC iC jC kC pB" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Public class fields" };
  }
});

// node_modules/caniuse-lite/data/features/publickeypinning.js
var require_publickeypinning = __commonJS({
  "node_modules/caniuse-lite/data/features/publickeypinning.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB", "2": "0 1 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB", "2": "0 1 2 3 4 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB", "2": "F B C G M N O m UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "4": "q", "16": "n o p r" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB", "2": "lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "HTTP Public Key Pinning" };
  }
});

// node_modules/caniuse-lite/data/features/push-api.js
var require_push_api = __commonJS({
  "node_modules/caniuse-lite/data/features/push-api.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O", "2": "C K L G M", "257": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB wB xB", "257": "BB DB EB FB GB HB IB KB LB MB NB OB PB kB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "1281": "CB JB QB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB", "257": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "388": "BB CB DB EB FB GB" }, E: { "2": "I l J D E F 0B oB 1B 2B 3B", "514": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB", "2114": "8B" }, F: { "2": "0 1 2 3 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "16": "4 5 6 7 8", "257": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "257": "tC" } }, B: 5, C: "Push API" };
  }
});

// node_modules/caniuse-lite/data/features/queryselector.js
var require_queryselector = __commonJS({
  "node_modules/caniuse-lite/data/features/queryselector.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "uB", "8": "J D", "132": "E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "8": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W AC BC CC hB sB DC iB", "8": "F 9B" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "querySelector/querySelectorAll" };
  }
});

// node_modules/caniuse-lite/data/features/readonly-attr.js
var require_readonly_attr = __commonJS({
  "node_modules/caniuse-lite/data/features/readonly-attr.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "16": "uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "16": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L G M N O m n o p q r s" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F 9B", "132": "B C AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB FC GC" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "Y", "132": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "257": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "readonly attribute of input and textarea elements" };
  }
});

// node_modules/caniuse-lite/data/features/referrer-policy.js
var require_referrer_policy = __commonJS({
  "node_modules/caniuse-lite/data/features/referrer-policy.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "132": "B" }, B: { "1": "P Q R S", "132": "C K L G M N O", "513": "T U V W Z a b c d e f g h i j k X H" }, C: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V", "2": "0 1 2 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "513": "W Z a b c d e f g h i j k X H nB" }, D: { "1": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T", "2": "I l J D E F A B C K L G M N O m n", "260": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB", "513": "U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "C hB iB", "2": "I l J D 0B oB 1B 2B", "132": "E F A B 3B 4B pB", "1025": "K L G 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB", "2": "F B C 9B AC BC CC hB sB DC iB", "513": "bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "PC QC RC SC", "2": "oB EC tB FC GC HC", "132": "E IC JC KC LC MC NC OC", "1025": "TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "513": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Referrer Policy" };
  }
});

// node_modules/caniuse-lite/data/features/registerprotocolhandler.js
var require_registerprotocolhandler = __commonJS({
  "node_modules/caniuse-lite/data/features/registerprotocolhandler.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "129": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB" }, D: { "2": "I l J D E F A B C", "129": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B 9B AC BC CC hB sB", "129": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D", "129": "A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "Custom protocol handling" };
  }
});

// node_modules/caniuse-lite/data/features/rel-noopener.js
var require_rel_noopener = __commonJS({
  "node_modules/caniuse-lite/data/features/rel-noopener.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB wB xB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 1, C: "rel=noopener" };
  }
});

// node_modules/caniuse-lite/data/features/rel-noreferrer.js
var require_rel_noreferrer = __commonJS({
  "node_modules/caniuse-lite/data/features/rel-noreferrer.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "132": "B" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "16": "C" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L G" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: 'Link type "noreferrer"' };
  }
});

// node_modules/caniuse-lite/data/features/rellist.js
var require_rellist = __commonJS({
  "node_modules/caniuse-lite/data/features/rellist.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M", "132": "N" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w wB xB" }, D: { "1": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB", "132": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "132": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "132": "fC" }, P: { "1": "kC pB lC mC nC oC pC qC", "2": "I", "132": "gC hC iC jC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 1, C: "relList (DOMTokenList)" };
  }
});

// node_modules/caniuse-lite/data/features/rem.js
var require_rem = __commonJS({
  "node_modules/caniuse-lite/data/features/rem.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E uB", "132": "F A" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "2": "vB jB wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F B 9B AC BC CC hB sB" }, G: { "1": "E EC tB GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB", "260": "FC" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "C Y iB", "2": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "rem (root em) units" };
  }
});

// node_modules/caniuse-lite/data/features/requestanimationframe.js
var require_requestanimationframe = __commonJS({
  "node_modules/caniuse-lite/data/features/requestanimationframe.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "33": "B C K L G M N O m n o p", "164": "I l J D E F A" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F", "33": "p q", "164": "O m n o", "420": "A B C K L G M N" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "33": "J" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC", "33": "GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "requestAnimationFrame" };
  }
});

// node_modules/caniuse-lite/data/features/requestidlecallback.js
var require_requestidlecallback = __commonJS({
  "node_modules/caniuse-lite/data/features/requestidlecallback.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB wB xB", "194": "KB LB" }, D: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB" }, E: { "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB", "322": "L G 5B 6B 7B qB rB 8B" }, F: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC", "322": "UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "requestIdleCallback" };
  }
});

// node_modules/caniuse-lite/data/features/resizeobserver.js
var require_resizeobserver = __commonJS({
  "node_modules/caniuse-lite/data/features/resizeobserver.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB wB xB" }, D: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB", "194": "LB MB NB OB PB kB QB lB RB SB" }, E: { "1": "L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB iB", "66": "K" }, F: { "1": "JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "194": "8 9 AB BB CB DB EB FB GB HB IB" }, G: { "1": "UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "kC pB lC mC nC oC pC qC", "2": "I gC hC iC jC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Resize Observer" };
  }
});

// node_modules/caniuse-lite/data/features/resource-timing.js
var require_resource_timing = __commonJS({
  "node_modules/caniuse-lite/data/features/resource-timing.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x wB xB", "194": "0 1 y z" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "260": "B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Resource Timing" };
  }
});

// node_modules/caniuse-lite/data/features/rest-parameters.js
var require_rest_parameters = __commonJS({
  "node_modules/caniuse-lite/data/features/rest-parameters.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "1": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB", "194": "BB CB DB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w x 9B AC BC CC hB sB DC iB", "194": "0 y z" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Rest parameters" };
  }
});

// node_modules/caniuse-lite/data/features/rtcpeerconnection.js
var require_rtcpeerconnection = __commonJS({
  "node_modules/caniuse-lite/data/features/rtcpeerconnection.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L", "516": "G M N O" }, C: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB", "33": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB" }, D: { "1": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p", "33": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB" }, F: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D", "130": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "33": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "33": "rC" }, R: { "33": "sC" }, S: { "1": "tC" } }, B: 5, C: "WebRTC Peer-to-peer connections" };
  }
});

// node_modules/caniuse-lite/data/features/ruby.js
var require_ruby = __commonJS({
  "node_modules/caniuse-lite/data/features/ruby.js"(exports2, module2) {
    module2.exports = { A: { A: { "4": "J D E F A B uB" }, B: { "4": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "8": "0 1 2 3 4 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "4": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "8": "I" }, E: { "4": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "I 0B oB" }, F: { "4": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "8": "F B C 9B AC BC CC hB sB DC iB" }, G: { "4": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "8": "oB EC tB" }, H: { "8": "YC" }, I: { "4": "jB I H cC tB dC eC", "8": "ZC aC bC" }, J: { "4": "A", "8": "D" }, K: { "4": "Y", "8": "A B C hB sB iB" }, L: { "4": "H" }, M: { "1": "X" }, N: { "4": "A B" }, O: { "4": "fC" }, P: { "4": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "4": "rC" }, R: { "4": "sC" }, S: { "1": "tC" } }, B: 1, C: "Ruby annotation" };
  }
});

// node_modules/caniuse-lite/data/features/run-in.js
var require_run_in = __commonJS({
  "node_modules/caniuse-lite/data/features/run-in.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "E F A B", "2": "J D uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "I l J D E F A B C K L G M N O m n o p q r s t u v w x y", "2": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J 1B", "2": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "2B", "129": "I 0B oB" }, F: { "1": "F B C G M N O 9B AC BC CC hB sB DC iB", "2": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "EC tB FC GC HC", "2": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "129": "oB" }, H: { "1": "YC" }, I: { "1": "jB I ZC aC bC cC tB dC", "2": "H eC" }, J: { "1": "D A" }, K: { "1": "A B C hB sB iB", "2": "Y" }, L: { "2": "H" }, M: { "2": "X" }, N: { "1": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "display: run-in" };
  }
});

// node_modules/caniuse-lite/data/features/same-site-cookie-attribute.js
var require_same_site_cookie_attribute = __commonJS({
  "node_modules/caniuse-lite/data/features/same-site-cookie-attribute.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "388": "B" }, B: { "1": "O P Q R S T U", "2": "C K L G", "129": "M N", "513": "V W Z a b c d e f g h i j k X H" }, C: { "1": "QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB wB xB" }, D: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "513": "Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "G 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB hB", "2052": "L", "3076": "C K iB 5B" }, F: { "1": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB", "2": "0 1 2 3 4 5 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "513": "ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC", "2052": "PC QC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "513": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "16": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 6, C: "'SameSite' cookie attribute" };
  }
});

// node_modules/caniuse-lite/data/features/screen-orientation.js
var require_screen_orientation = __commonJS({
  "node_modules/caniuse-lite/data/features/screen-orientation.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "164": "B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "36": "C K L G M N O" }, C: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N wB xB", "36": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB" }, D: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A", "36": "B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "16": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "Screen Orientation" };
  }
});

// node_modules/caniuse-lite/data/features/script-async.js
var require_script_async = __commonJS({
  "node_modules/caniuse-lite/data/features/script-async.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "2": "vB jB wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "132": "l" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "async attribute for external scripts" };
  }
});

// node_modules/caniuse-lite/data/features/script-defer.js
var require_script_defer = __commonJS({
  "node_modules/caniuse-lite/data/features/script-defer.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "132": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "257": "I l J D E F A B C K L G M N O m n o p q r s t u v w x wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "defer attribute for external scripts" };
  }
});

// node_modules/caniuse-lite/data/features/scrollintoview.js
var require_scrollintoview = __commonJS({
  "node_modules/caniuse-lite/data/features/scrollintoview.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D uB", "132": "E F A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "132": "C K L G M N O" }, C: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "132": "0 1 2 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB" }, E: { "1": "8B", "2": "I l 0B oB", "132": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB" }, F: { "1": "FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F 9B AC BC CC", "16": "B hB sB", "132": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB DC iB" }, G: { "16": "oB EC tB", "132": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "16": "ZC aC", "132": "jB I bC cC tB dC eC" }, J: { "132": "D A" }, K: { "1": "Y", "132": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "132": "fC" }, P: { "132": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "132": "sC" }, S: { "1": "tC" } }, B: 5, C: "scrollIntoView" };
  }
});

// node_modules/caniuse-lite/data/features/scrollintoviewifneeded.js
var require_scrollintoviewifneeded = __commonJS({
  "node_modules/caniuse-lite/data/features/scrollintoviewifneeded.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 7, C: "Element.scrollIntoViewIfNeeded()" };
  }
});

// node_modules/caniuse-lite/data/features/sdch.js
var require_sdch = __commonJS({
  "node_modules/caniuse-lite/data/features/sdch.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB", "2": "kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB", "2": "F B C bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "SDCH Accept-Encoding/Content-Encoding" };
  }
});

// node_modules/caniuse-lite/data/features/selection-api.js
var require_selection_api = __commonJS({
  "node_modules/caniuse-lite/data/features/selection-api.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "16": "uB", "260": "J D E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "132": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "2180": "AB BB CB DB EB FB GB HB IB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "132": "F B C 9B AC BC CC hB sB DC iB" }, G: { "16": "tB", "132": "oB EC", "516": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "16": "jB I ZC aC bC cC", "1025": "tB" }, J: { "1": "A", "16": "D" }, K: { "1": "Y", "16": "A B C hB sB", "132": "iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "16": "A" }, O: { "1025": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2180": "tC" } }, B: 5, C: "Selection API" };
  }
});

// node_modules/caniuse-lite/data/features/server-timing.js
var require_server_timing = __commonJS({
  "node_modules/caniuse-lite/data/features/server-timing.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB wB xB" }, D: { "1": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB", "196": "QB lB RB SB", "324": "Y" }, E: { "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB", "516": "K L G iB 5B 6B 7B qB rB 8B" }, F: { "1": "JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Server Timing" };
  }
});

// node_modules/caniuse-lite/data/features/serviceworkers.js
var require_serviceworkers = __commonJS({
  "node_modules/caniuse-lite/data/features/serviceworkers.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L", "322": "G M" }, C: { "1": "BB DB EB FB GB HB IB KB LB MB NB OB PB kB lB RB SB Y TB UB VB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "194": "0 1 2 3 4 5 6 7 8 9 AB", "513": "CB JB QB WB" }, D: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "4": "7 8 9 AB BB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t 9B AC BC CC hB sB DC iB", "4": "u v w x y" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "4": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "4": "Y" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "4": "sC" }, S: { "2": "tC" } }, B: 4, C: "Service Workers" };
  }
});

// node_modules/caniuse-lite/data/features/setimmediate.js
var require_setimmediate = __commonJS({
  "node_modules/caniuse-lite/data/features/setimmediate.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O", "2": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "1": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Efficient Script Yielding: setImmediate()" };
  }
});

// node_modules/caniuse-lite/data/features/sha-2.js
var require_sha_2 = __commonJS({
  "node_modules/caniuse-lite/data/features/sha-2.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "2": "uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "0 1 2 3 4 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "16": "YC" }, I: { "1": "jB I H aC bC cC tB dC eC", "260": "ZC" }, J: { "1": "D A" }, K: { "1": "Y", "16": "A B C hB sB iB" }, L: { "1": "H" }, M: { "16": "X" }, N: { "16": "A B" }, O: { "16": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "16": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "SHA-2 SSL certificates" };
  }
});

// node_modules/caniuse-lite/data/features/shadowdom.js
var require_shadowdom = __commonJS({
  "node_modules/caniuse-lite/data/features/shadowdom.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P", "2": "C K L G M N O Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "66": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB" }, D: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P", "2": "I l J D E F A B C K L G M N O m n o p q r Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "0 1 s t u v w x y z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB", "2": "F B C VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "33": "G M N O m n o" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB", "33": "dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC", "2": "nC oC pC qC", "33": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 7, C: "Shadow DOM (deprecated V0 spec)" };
  }
});

// node_modules/caniuse-lite/data/features/shadowdomv1.js
var require_shadowdomv1 = __commonJS({
  "node_modules/caniuse-lite/data/features/shadowdomv1.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB wB xB", "322": "PB", "578": "kB QB lB RB" }, D: { "1": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB" }, E: { "1": "A B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B" }, F: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC", "132": "LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I", "4": "gC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Shadow DOM (V1)" };
  }
});

// node_modules/caniuse-lite/data/features/sharedarraybuffer.js
var require_sharedarraybuffer = __commonJS({
  "node_modules/caniuse-lite/data/features/sharedarraybuffer.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b", "2": "C K L G", "194": "M N O", "513": "c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB wB xB", "194": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB", "450": "cB dB eB fB gB", "513": "P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB", "194": "QB lB RB SB Y TB UB VB", "513": "c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A 0B oB 1B 2B 3B 4B", "194": "B C K L G pB hB iB 5B 6B 7B", "513": "qB rB 8B" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB 9B AC BC CC hB sB DC iB", "194": "EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC", "194": "MC NC OC PC QC RC SC TC UC VC WC XC", "513": "qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "513": "H" }, M: { "513": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Shared Array Buffer" };
  }
});

// node_modules/caniuse-lite/data/features/sharedworkers.js
var require_sharedworkers = __commonJS({
  "node_modules/caniuse-lite/data/features/sharedworkers.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "l J 1B", "2": "I D E F A B C K L G 0B oB 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "2": "F 9B AC BC" }, G: { "1": "FC GC", "2": "E oB EC tB HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "B C hB sB iB", "2": "Y", "16": "A" }, L: { "2": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "I", "2": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 1, C: "Shared Web Workers" };
  }
});

// node_modules/caniuse-lite/data/features/sni.js
var require_sni = __commonJS({
  "node_modules/caniuse-lite/data/features/sni.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J uB", "132": "D E" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "A", "2": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Server Name Indication" };
  }
});

// node_modules/caniuse-lite/data/features/spdy.js
var require_spdy = __commonJS({
  "node_modules/caniuse-lite/data/features/spdy.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F A uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "2": "vB jB I l J D E F A B C IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "2": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "E F A B C 4B pB hB", "2": "I l J D 0B oB 1B 2B 3B", "129": "K L G iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 9 G M N O m n o p q r s t u v w x y z BB iB", "2": "7 8 F B C AB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC" }, G: { "1": "E IC JC KC LC MC NC OC PC", "2": "oB EC tB FC GC HC", "257": "QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I cC tB dC eC", "2": "H ZC aC bC" }, J: { "2": "D A" }, K: { "1": "iB", "2": "A B C Y hB sB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "1": "B", "2": "A" }, O: { "2": "fC" }, P: { "1": "I", "2": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "16": "sC" }, S: { "1": "tC" } }, B: 7, C: "SPDY protocol" };
  }
});

// node_modules/caniuse-lite/data/features/speech-recognition.js
var require_speech_recognition = __commonJS({
  "node_modules/caniuse-lite/data/features/speech-recognition.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "1026": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB", "322": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "I l J D E F A B C K L G M N O m n o p q r", "164": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L 0B oB 1B 2B 3B 4B pB hB iB 5B", "2084": "G 6B 7B qB rB 8B" }, F: { "2": "F B C G M N O m n o p q r s t 9B AC BC CC hB sB DC iB", "1026": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC", "2084": "WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "164": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "164": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "164": "rC" }, R: { "164": "sC" }, S: { "322": "tC" } }, B: 7, C: "Speech Recognition API" };
  }
});

// node_modules/caniuse-lite/data/features/speech-synthesis.js
var require_speech_synthesis = __commonJS({
  "node_modules/caniuse-lite/data/features/speech-synthesis.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O", "2": "C K", "257": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x wB xB", "194": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "257": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB", "2": "F B C G M N O m n o p q r s t 9B AC BC CC hB sB DC iB", "257": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 7, C: "Speech Synthesis API" };
  }
});

// node_modules/caniuse-lite/data/features/spellcheck-attribute.js
var require_spellcheck_attribute = __commonJS({
  "node_modules/caniuse-lite/data/features/spellcheck-attribute.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "4": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "4": "YC" }, I: { "4": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "A", "4": "D" }, K: { "4": "A B C Y hB sB iB" }, L: { "4": "H" }, M: { "4": "X" }, N: { "4": "A B" }, O: { "4": "fC" }, P: { "4": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "4": "sC" }, S: { "2": "tC" } }, B: 1, C: "Spellcheck attribute" };
  }
});

// node_modules/caniuse-lite/data/features/sql-storage.js
var require_sql_storage = __commonJS({
  "node_modules/caniuse-lite/data/features/sql-storage.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB iB", "2": "K L G 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC", "2": "RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 7, C: "Web SQL Database" };
  }
});

// node_modules/caniuse-lite/data/features/srcset.js
var require_srcset = __commonJS({
  "node_modules/caniuse-lite/data/features/srcset.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C", "514": "K L G" }, C: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y wB xB", "194": "0 1 2 3 4 z" }, D: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "260": "1 2 3 4" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B 2B", "260": "E 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n 9B AC BC CC hB sB DC iB", "260": "o p q r" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC", "260": "E IC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Srcset and sizes attributes" };
  }
});

// node_modules/caniuse-lite/data/features/stream.js
var require_stream = __commonJS({
  "node_modules/caniuse-lite/data/features/stream.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M wB xB", "129": "3 4 5 6 7 8", "420": "0 1 2 N O m n o p q r s t u v w x y z" }, D: { "1": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n", "420": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB" }, F: { "1": "7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B G M N 9B AC BC CC hB sB DC", "420": "0 1 2 3 4 5 6 C O m n o p q r s t u v w x y z iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC", "513": "UC VC WC XC qB rB", "1537": "NC OC PC QC RC SC TC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D", "420": "A" }, K: { "1": "Y", "2": "A B hB sB", "420": "C iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "420": "I gC" }, Q: { "1": "rC" }, R: { "420": "sC" }, S: { "2": "tC" } }, B: 4, C: "getUserMedia/Stream API" };
  }
});

// node_modules/caniuse-lite/data/features/streams.js
var require_streams = __commonJS({
  "node_modules/caniuse-lite/data/features/streams.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "130": "B" }, B: { "1": "a b c d e f g h i j k X H", "16": "C K", "260": "L G", "1028": "P Q R S T U V W Z", "5124": "M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB wB xB", "5124": "X H nB", "7172": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k", "7746": "OB PB kB QB lB RB SB Y" }, D: { "1": "a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB", "260": "JB KB LB MB NB OB PB", "1028": "kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z" }, E: { "2": "I l J D E F 0B oB 1B 2B 3B 4B", "1028": "G 6B 7B qB rB 8B", "3076": "A B C K L pB hB iB 5B" }, F: { "1": "eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "260": "6 7 8 9 AB BB CB", "1028": "DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC", "16": "LC", "1028": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "5124": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pC qC", "2": "I gC hC", "1028": "iC jC kC pB lC mC nC oC" }, Q: { "1028": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "Streams" };
  }
});

// node_modules/caniuse-lite/data/features/stricttransportsecurity.js
var require_stricttransportsecurity = __commonJS({
  "node_modules/caniuse-lite/data/features/stricttransportsecurity.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A uB", "129": "B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC hB sB DC" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Strict Transport Security" };
  }
});

// node_modules/caniuse-lite/data/features/style-scoped.js
var require_style_scoped = __commonJS({
  "node_modules/caniuse-lite/data/features/style-scoped.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB", "2": "vB jB I l J D E F A B C K L G M N O m n lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "322": "MB NB OB PB kB QB" }, D: { "2": "4 5 6 7 8 9 I l J D E F A B C K L G M N O m AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "194": "0 1 2 3 n o p q r s t u v w x y z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 7, C: "Scoped CSS" };
  }
});

// node_modules/caniuse-lite/data/features/subresource-integrity.js
var require_subresource_integrity = __commonJS({
  "node_modules/caniuse-lite/data/features/subresource-integrity.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M" }, C: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w x y 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC", "194": "NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "Subresource Integrity" };
  }
});

// node_modules/caniuse-lite/data/features/svg-css.js
var require_svg_css = __commonJS({
  "node_modules/caniuse-lite/data/features/svg-css.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "516": "C K L G" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "260": "I l J D E F A B C K L G M N O m n o p q" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "4": "I" }, E: { "1": "l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B", "132": "I oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "132": "oB EC" }, H: { "260": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "D A" }, K: { "1": "Y", "260": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "SVG in CSS backgrounds" };
  }
});

// node_modules/caniuse-lite/data/features/svg-filters.js
var require_svg_filters = __commonJS({
  "node_modules/caniuse-lite/data/features/svg-filters.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I", "4": "l J D" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "SVG filters" };
  }
});

// node_modules/caniuse-lite/data/features/svg-fonts.js
var require_svg_fonts = __commonJS({
  "node_modules/caniuse-lite/data/features/svg-fonts.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "F A B uB", "8": "J D E" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "2": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "130": "5 6 7 8 9 AB BB CB DB EB FB GB HB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B" }, F: { "1": "F B C G M N O m n o p q r 9B AC BC CC hB sB DC iB", "2": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "130": "0 1 2 3 s t u v w x y z" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "258": "YC" }, I: { "1": "jB I cC tB dC eC", "2": "H ZC aC bC" }, J: { "1": "D A" }, K: { "1": "A B C hB sB iB", "2": "Y" }, L: { "130": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "I", "130": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "130": "sC" }, S: { "2": "tC" } }, B: 2, C: "SVG fonts" };
  }
});

// node_modules/caniuse-lite/data/features/svg-fragment.js
var require_svg_fragment = __commonJS({
  "node_modules/caniuse-lite/data/features/svg-fragment.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "260": "F A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "1": "HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "132": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB" }, E: { "1": "C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D F A B 0B oB 1B 2B 4B pB", "132": "E 3B" }, F: { "1": "4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "G M N O m n o p", "4": "B C AC BC CC hB sB DC", "16": "F 9B", "132": "0 1 2 3 q r s t u v w x y z" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC JC KC LC MC NC", "132": "E IC" }, H: { "1": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D", "132": "A" }, K: { "1": "Y iB", "4": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "132": "I" }, Q: { "1": "rC" }, R: { "132": "sC" }, S: { "1": "tC" } }, B: 4, C: "SVG fragment identifiers" };
  }
});

// node_modules/caniuse-lite/data/features/svg-html.js
var require_svg_html = __commonJS({
  "node_modules/caniuse-lite/data/features/svg-html.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "388": "F A B" }, B: { "4": "P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB", "4": "jB" }, D: { "4": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "0B oB", "4": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "4": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "4": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "4": "H dC eC" }, J: { "1": "A", "2": "D" }, K: { "4": "A B C Y hB sB iB" }, L: { "4": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "4": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "4": "rC" }, R: { "4": "sC" }, S: { "1": "tC" } }, B: 2, C: "SVG effects for HTML" };
  }
});

// node_modules/caniuse-lite/data/features/svg-html5.js
var require_svg_html5 = __commonJS({
  "node_modules/caniuse-lite/data/features/svg-html5.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "8": "J D E", "129": "F A B" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "129": "C K L G M" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "8": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "8": "I l J" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "I l 0B oB", "129": "J D E 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "B CC hB sB", "8": "F 9B AC BC" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "8": "oB EC tB", "129": "E FC GC HC IC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "ZC aC bC", "129": "jB I cC tB" }, J: { "1": "A", "129": "D" }, K: { "1": "C Y iB", "8": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "129": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Inline SVG in HTML5" };
  }
});

// node_modules/caniuse-lite/data/features/svg-img.js
var require_svg_img = __commonJS({
  "node_modules/caniuse-lite/data/features/svg-img.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l J D E F A B C K L G M N O m n o p q r s t u" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B", "4": "oB", "132": "I l J D E 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "132": "E oB EC tB FC GC HC IC" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "ZC aC bC", "132": "jB I cC tB" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "SVG in HTML img element" };
  }
});

// node_modules/caniuse-lite/data/features/svg-smil.js
var require_svg_smil = __commonJS({
  "node_modules/caniuse-lite/data/features/svg-smil.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "8": "J D E F A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "8": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "8": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "4": "I" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "0B oB", "132": "I l 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "132": "oB EC tB FC" }, H: { "2": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "8": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "SVG SMIL animation" };
  }
});

// node_modules/caniuse-lite/data/features/svg.js
var require_svg = __commonJS({
  "node_modules/caniuse-lite/data/features/svg.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "8": "J D E", "772": "F A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "513": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "4": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "4": "0B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "H dC eC", "2": "ZC aC bC", "132": "jB I cC tB" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "257": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "SVG (basic support)" };
  }
});

// node_modules/caniuse-lite/data/features/sxg.js
var require_sxg = __commonJS({
  "node_modules/caniuse-lite/data/features/sxg.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB", "132": "ZB aB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "16": "fC" }, P: { "1": "lC mC nC oC pC qC", "2": "I gC hC iC jC kC pB" }, Q: { "16": "rC" }, R: { "16": "sC" }, S: { "2": "tC" } }, B: 6, C: "Signed HTTP Exchanges (SXG)" };
  }
});

// node_modules/caniuse-lite/data/features/tabindex-attr.js
var require_tabindex_attr = __commonJS({
  "node_modules/caniuse-lite/data/features/tabindex-attr.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "D E F A B", "16": "J uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "16": "vB jB wB xB", "129": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "16": "I l 0B oB", "257": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "16": "F" }, G: { "769": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "16": "YC" }, I: { "16": "jB I H ZC aC bC cC tB dC eC" }, J: { "16": "D A" }, K: { "16": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "16": "A B" }, O: { "16": "fC" }, P: { "16": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "16": "sC" }, S: { "129": "tC" } }, B: 1, C: "tabindex global attribute" };
  }
});

// node_modules/caniuse-lite/data/features/template-literals.js
var require_template_literals = __commonJS({
  "node_modules/caniuse-lite/data/features/template-literals.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "16": "C" }, C: { "1": "1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "A B K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B", "129": "C" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v 9B AC BC CC hB sB DC iB" }, G: { "1": "JC KC LC MC NC OC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC", "129": "PC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "ES6 Template Literals (Template Strings)" };
  }
});

// node_modules/caniuse-lite/data/features/template.js
var require_template = __commonJS({
  "node_modules/caniuse-lite/data/features/template.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C", "388": "K L" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o wB xB" }, D: { "1": "2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s", "132": "0 1 t u v w x y z" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D 0B oB 1B", "388": "E 3B", "514": "2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "132": "G M N O m n o" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC", "388": "E IC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "HTML templates" };
  }
});

// node_modules/caniuse-lite/data/features/temporal.js
var require_temporal = __commonJS({
  "node_modules/caniuse-lite/data/features/temporal.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "Temporal" };
  }
});

// node_modules/caniuse-lite/data/features/testfeat.js
var require_testfeat = __commonJS({
  "node_modules/caniuse-lite/data/features/testfeat.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E A B uB", "16": "F" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "16": "I l" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "B C" }, E: { "2": "I J 0B oB 1B", "16": "l D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC sB DC iB", "16": "hB" }, G: { "2": "oB EC tB FC GC", "16": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC cC tB dC eC", "16": "bC" }, J: { "2": "A", "16": "D" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Test feature - updated" };
  }
});

// node_modules/caniuse-lite/data/features/text-decoration.js
var require_text_decoration = __commonJS({
  "node_modules/caniuse-lite/data/features/text-decoration.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "2052": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l wB xB", "1028": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "1060": "0 1 2 J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, D: { "2": "I l J D E F A B C K L G M N O m n o p q r s", "226": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB", "2052": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D 0B oB 1B 2B", "772": "K L G iB 5B 6B 7B qB rB 8B", "804": "E F A B C 4B pB hB", "1316": "3B" }, F: { "2": "0 1 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "226": "2 3 4 5 6 7 8 9 AB", "2052": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "oB EC tB FC GC HC", "292": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "2052": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2052": "fC" }, P: { "2": "I gC hC", "2052": "iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "1": "sC" }, S: { "1028": "tC" } }, B: 4, C: "text-decoration styling" };
  }
});

// node_modules/caniuse-lite/data/features/text-emphasis.js
var require_text_emphasis = __commonJS({
  "node_modules/caniuse-lite/data/features/text-emphasis.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "k X H", "2": "C K L G M N O", "164": "P Q R S T U V W Z a b c d e f g h i j" }, C: { "1": "DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB wB xB", "322": "CB" }, D: { "1": "k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r", "164": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j" }, E: { "1": "E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B", "164": "D 2B" }, F: { "1": "V W", "2": "F B C 9B AC BC CC hB sB DC iB", "164": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB", "164": "dC eC" }, J: { "2": "D", "164": "A" }, K: { "2": "A B C hB sB iB", "164": "Y" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "164": "fC" }, P: { "164": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "164": "rC" }, R: { "164": "sC" }, S: { "1": "tC" } }, B: 4, C: "text-emphasis styling" };
  }
});

// node_modules/caniuse-lite/data/features/text-overflow.js
var require_text_overflow = __commonJS({
  "node_modules/caniuse-lite/data/features/text-overflow.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B", "2": "uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "8": "vB jB I l J wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "33": "F 9B AC BC CC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "Y iB", "33": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS3 Text-overflow" };
  }
});

// node_modules/caniuse-lite/data/features/text-size-adjust.js
var require_text_size_adjust = __commonJS({
  "node_modules/caniuse-lite/data/features/text-size-adjust.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "33": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s u v w x y z AB BB CB DB EB FB GB HB IB JB KB", "258": "t" }, E: { "2": "I l J D E F A B C K L G 0B oB 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "258": "1B" }, F: { "1": "AB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z BB 9B AC BC CC hB sB DC iB" }, G: { "2": "oB EC tB", "33": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "33": "X" }, N: { "161": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS text-size-adjust" };
  }
});

// node_modules/caniuse-lite/data/features/text-stroke.js
var require_text_stroke = __commonJS({
  "node_modules/caniuse-lite/data/features/text-stroke.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L", "33": "P Q R S T U V W Z a b c d e f g h i j k X H", "161": "G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB wB xB", "161": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "450": "FB" }, D: { "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "33": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "33": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "36": "oB" }, H: { "2": "YC" }, I: { "2": "jB", "33": "I H ZC aC bC cC tB dC eC" }, J: { "33": "D A" }, K: { "2": "A B C hB sB iB", "33": "Y" }, L: { "33": "H" }, M: { "161": "X" }, N: { "2": "A B" }, O: { "33": "fC" }, P: { "33": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "33": "rC" }, R: { "33": "sC" }, S: { "161": "tC" } }, B: 7, C: "CSS text-stroke and text-fill" };
  }
});

// node_modules/caniuse-lite/data/features/text-underline-offset.js
var require_text_underline_offset = __commonJS({
  "node_modules/caniuse-lite/data/features/text-underline-offset.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB wB xB", "130": "XB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "K L G iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "text-underline-offset" };
  }
});

// node_modules/caniuse-lite/data/features/textcontent.js
var require_textcontent = __commonJS({
  "node_modules/caniuse-lite/data/features/textcontent.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "16": "F" }, G: { "1": "E EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Node.textContent" };
  }
});

// node_modules/caniuse-lite/data/features/textencoder.js
var require_textencoder = __commonJS({
  "node_modules/caniuse-lite/data/features/textencoder.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O wB xB", "132": "m" }, D: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "TextEncoder & TextDecoder" };
  }
});

// node_modules/caniuse-lite/data/features/tls1-1.js
var require_tls1_1 = __commonJS({
  "node_modules/caniuse-lite/data/features/tls1-1.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D uB", "66": "E F A" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB", "2": "vB jB I l J D E F A B C K L G M N O m n o p wB xB", "66": "q", "129": "WB XB YB ZB aB bB cB dB eB fB", "388": "gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T", "2": "I l J D E F A B C K L G M N O m n o", "1540": "U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "D E F A B C K 3B 4B pB hB iB", "2": "I l J 0B oB 1B 2B", "513": "L G 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB iB", "2": "F B C 9B AC BC CC hB sB DC", "1540": "bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y iB", "2": "A B C hB sB" }, L: { "1": "H" }, M: { "129": "X" }, N: { "1": "B", "66": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "TLS 1.1" };
  }
});

// node_modules/caniuse-lite/data/features/tls1-2.js
var require_tls1_2 = __commonJS({
  "node_modules/caniuse-lite/data/features/tls1-2.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D uB", "66": "E F A" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q wB xB", "66": "r s t" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F G 9B", "66": "B C AC BC CC hB sB DC iB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "1": "A", "2": "D" }, K: { "1": "Y iB", "2": "A B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "66": "A" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "TLS 1.2" };
  }
});

// node_modules/caniuse-lite/data/features/tls1-3.js
var require_tls1_3 = __commonJS({
  "node_modules/caniuse-lite/data/features/tls1-3.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB wB xB", "132": "QB lB RB", "450": "IB JB KB LB MB NB OB PB kB" }, D: { "1": "YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB", "706": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB" }, E: { "1": "L G 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB", "1028": "K iB 5B" }, F: { "1": "OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB 9B AC BC CC hB sB DC iB", "706": "LB MB NB" }, G: { "1": "QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "pB lC mC nC oC pC qC", "2": "I gC hC iC jC kC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 6, C: "TLS 1.3" };
  }
});

// node_modules/caniuse-lite/data/features/token-binding.js
var require_token_binding = __commonJS({
  "node_modules/caniuse-lite/data/features/token-binding.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L", "194": "P Q R S T U V W Z a b c d e f g h i j k X H", "257": "G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X wB xB", "16": "H nB" }, D: { "2": "0 1 2 3 4 5 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "16": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB", "194": "PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E 0B oB 1B 2B 3B", "16": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C G M N O m n o p q r s t u v w 9B AC BC CC hB sB DC iB", "16": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC", "16": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "16": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "16": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "16": "Y" }, L: { "16": "H" }, M: { "16": "X" }, N: { "2": "A", "16": "B" }, O: { "16": "fC" }, P: { "16": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "16": "rC" }, R: { "16": "sC" }, S: { "2": "tC" } }, B: 6, C: "Token Binding" };
  }
});

// node_modules/caniuse-lite/data/features/touch.js
var require_touch = __commonJS({
  "node_modules/caniuse-lite/data/features/touch.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "8": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "578": "C K L G M N O" }, C: { "1": "O m n o p q r JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "4": "I l J D E F A B C K L G M N", "194": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "8": "A", "260": "B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 2, C: "Touch events" };
  }
});

// node_modules/caniuse-lite/data/features/transforms2d.js
var require_transforms2d = __commonJS({
  "node_modules/caniuse-lite/data/features/transforms2d.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "8": "J D E", "129": "A B", "161": "F" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "129": "C K L G M" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "33": "I l J D E F A B C K L G wB xB" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "33": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F 9B AC", "33": "B C G M N O m n o p BC CC hB sB DC" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "33": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "33": "jB I ZC aC bC cC tB dC eC" }, J: { "33": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "CSS3 2D Transforms" };
  }
});

// node_modules/caniuse-lite/data/features/transforms3d.js
var require_transforms3d = __commonJS({
  "node_modules/caniuse-lite/data/features/transforms3d.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "132": "A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F wB xB", "33": "A B C K L G" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B", "33": "0 1 2 C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "rB 8B", "2": "0B oB", "33": "I l J D E 1B 2B 3B", "257": "F A B C K L G 4B pB hB iB 5B 6B 7B qB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "G M N O m n o p" }, G: { "1": "rB", "33": "E oB EC tB FC GC HC IC", "257": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "1": "H", "2": "ZC aC bC", "33": "jB I cC tB dC eC" }, J: { "33": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS3 3D Transforms" };
  }
});

// node_modules/caniuse-lite/data/features/trusted-types.js
var require_trusted_types = __commonJS({
  "node_modules/caniuse-lite/data/features/trusted-types.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O P Q R" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "nC oC pC qC", "2": "I gC hC iC jC kC pB lC mC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Trusted Types for DOM manipulation" };
  }
});

// node_modules/caniuse-lite/data/features/ttf.js
var require_ttf = __commonJS({
  "node_modules/caniuse-lite/data/features/ttf.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "132": "F A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W AC BC CC hB sB DC iB", "2": "F 9B" }, G: { "1": "E tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC" }, H: { "2": "YC" }, I: { "1": "jB I H aC bC cC tB dC eC", "2": "ZC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "TTF/OTF - TrueType and OpenType font support" };
  }
});

// node_modules/caniuse-lite/data/features/typedarrays.js
var require_typedarrays = __commonJS({
  "node_modules/caniuse-lite/data/features/typedarrays.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "B", "2": "J D E F uB", "132": "A" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB", "260": "1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F B 9B AC BC CC hB sB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC", "260": "tB" }, H: { "1": "YC" }, I: { "1": "I H cC tB dC eC", "2": "jB ZC aC bC" }, J: { "1": "A", "2": "D" }, K: { "1": "C Y iB", "2": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Typed Arrays" };
  }
});

// node_modules/caniuse-lite/data/features/u2f.js
var require_u2f = __commonJS({
  "node_modules/caniuse-lite/data/features/u2f.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "513": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB wB xB", "322": "EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB" }, D: { "2": "0 1 2 3 4 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "130": "5 6 7", "513": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB iB" }, F: { "2": "0 1 2 3 4 5 6 8 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "513": "7 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "322": "tC" } }, B: 6, C: "FIDO U2F API" };
  }
});

// node_modules/caniuse-lite/data/features/unhandledrejection.js
var require_unhandledrejection = __commonJS({
  "node_modules/caniuse-lite/data/features/unhandledrejection.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB wB xB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC", "16": "NC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 1, C: "unhandledrejection/rejectionhandled events" };
  }
});

// node_modules/caniuse-lite/data/features/upgradeinsecurerequests.js
var require_upgradeinsecurerequests = __commonJS({
  "node_modules/caniuse-lite/data/features/upgradeinsecurerequests.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M" }, C: { "1": "9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q r s t u v w 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Upgrade Insecure Requests" };
  }
});

// node_modules/caniuse-lite/data/features/url-scroll-to-text-fragment.js
var require_url_scroll_to_text_fragment = __commonJS({
  "node_modules/caniuse-lite/data/features/url-scroll-to-text-fragment.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O", "66": "P Q R" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB", "66": "cB dB eB fB gB P Q" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB 9B AC BC CC hB sB DC iB", "66": "UB VB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "nC oC pC qC", "2": "I gC hC iC jC kC pB lC mC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "URL Scroll-To-Text Fragment" };
  }
});

// node_modules/caniuse-lite/data/features/url.js
var require_url = __commonJS({
  "node_modules/caniuse-lite/data/features/url.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p", "130": "q r s t u v w x y" }, E: { "1": "E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B 2B", "130": "D" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "130": "G M N O" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC", "130": "HC" }, H: { "2": "YC" }, I: { "1": "H eC", "2": "jB I ZC aC bC cC tB", "130": "dC" }, J: { "2": "D", "130": "A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "URL API" };
  }
});

// node_modules/caniuse-lite/data/features/urlsearchparams.js
var require_urlsearchparams = __commonJS({
  "node_modules/caniuse-lite/data/features/urlsearchparams.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M" }, C: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB", "132": "0 1 2 3 4 5 6 7 8 9 w x y z AB" }, D: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB" }, E: { "1": "B C K L G pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B" }, F: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "2": "I" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 1, C: "URLSearchParams" };
  }
});

// node_modules/caniuse-lite/data/features/use-strict.js
var require_use_strict = __commonJS({
  "node_modules/caniuse-lite/data/features/use-strict.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "132": "l 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F B 9B AC BC CC hB sB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "jB I H cC tB dC eC", "2": "ZC aC bC" }, J: { "1": "D A" }, K: { "1": "C Y sB iB", "2": "A B hB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "ECMAScript 5 Strict Mode" };
  }
});

// node_modules/caniuse-lite/data/features/user-select-none.js
var require_user_select_none = __commonJS({
  "node_modules/caniuse-lite/data/features/user-select-none.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "33": "A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "33": "C K L G M N O" }, C: { "1": "XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "33": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB wB xB" }, D: { "1": "LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "33": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB" }, E: { "33": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "33": "0 1 2 3 4 5 6 7 G M N O m n o p q r s t u v w x y z" }, G: { "33": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "33": "jB I ZC aC bC cC tB dC eC" }, J: { "33": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "33": "A B" }, O: { "2": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "33": "I gC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "33": "tC" } }, B: 5, C: "CSS user-select: none" };
  }
});

// node_modules/caniuse-lite/data/features/user-timing.js
var require_user_timing = __commonJS({
  "node_modules/caniuse-lite/data/features/user-timing.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "User Timing API" };
  }
});

// node_modules/caniuse-lite/data/features/variable-fonts.js
var require_variable_fonts = __commonJS({
  "node_modules/caniuse-lite/data/features/variable-fonts.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB wB xB", "4609": "RB SB Y TB UB VB WB XB YB", "4674": "lB", "5698": "QB", "7490": "KB LB MB NB OB", "7746": "PB kB", "8705": "ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB", "4097": "UB", "4290": "kB QB lB", "6148": "RB SB Y TB" }, E: { "1": "G 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "4609": "B C hB iB", "8193": "K L 5B 6B" }, F: { "1": "LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB 9B AC BC CC hB sB DC iB", "4097": "KB", "6148": "GB HB IB JB" }, G: { "1": "RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC", "4097": "NC OC PC QC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "4097": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC", "4097": "jC kC pB lC mC nC oC pC qC" }, Q: { "4097": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Variable fonts" };
  }
});

// node_modules/caniuse-lite/data/features/vector-effect.js
var require_vector_effect = __commonJS({
  "node_modules/caniuse-lite/data/features/vector-effect.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "2": "F B 9B AC BC CC hB sB" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "H dC eC", "16": "jB I ZC aC bC cC tB" }, J: { "16": "D A" }, K: { "1": "C Y iB", "2": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "SVG vector-effect: non-scaling-stroke" };
  }
});

// node_modules/caniuse-lite/data/features/vibration.js
var require_vibration = __commonJS({
  "node_modules/caniuse-lite/data/features/vibration.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A wB xB", "33": "B C K L G" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m n o p q r s t u v w" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "Vibration API" };
  }
});

// node_modules/caniuse-lite/data/features/video.js
var require_video = __commonJS({
  "node_modules/caniuse-lite/data/features/video.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "260": "I l J D E F A B C K L G M N O m wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A 1B 2B 3B 4B pB", "2": "0B oB", "513": "B C K L G hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC", "513": "NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "132": "ZC aC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Video element" };
  }
});

// node_modules/caniuse-lite/data/features/videotracks.js
var require_videotracks = __commonJS({
  "node_modules/caniuse-lite/data/features/videotracks.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O", "322": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "194": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB", "322": "CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J 0B oB 1B" }, F: { "2": "F B C G M N O m n o p q r s t u v w x y 9B AC BC CC hB sB DC iB", "322": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "322": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "194": "tC" } }, B: 1, C: "Video Tracks" };
  }
});

// node_modules/caniuse-lite/data/features/viewport-unit-variants.js
var require_viewport_unit_variants = __commonJS({
  "node_modules/caniuse-lite/data/features/viewport-unit-variants.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k", "194": "X H nB yB zB" }, E: { "1": "rB 8B", "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "Large, Small, and Dynamic viewport units" };
  }
});

// node_modules/caniuse-lite/data/features/viewport-units.js
var require_viewport_units = __commonJS({
  "node_modules/caniuse-lite/data/features/viewport-units.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "132": "F", "260": "A B" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "260": "C K L G" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N O m", "260": "n o p q r s" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B", "260": "J" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC", "516": "HC", "772": "GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "260": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "Viewport units: vw, vh, vmin, vmax" };
  }
});

// node_modules/caniuse-lite/data/features/wai-aria.js
var require_wai_aria = __commonJS({
  "node_modules/caniuse-lite/data/features/wai-aria.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D uB", "4": "E F A B" }, B: { "4": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "4": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "4": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "0B oB", "4": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F", "4": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "4": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "4": "YC" }, I: { "2": "jB I ZC aC bC cC tB", "4": "H dC eC" }, J: { "2": "D A" }, K: { "4": "A B C Y hB sB iB" }, L: { "4": "H" }, M: { "4": "X" }, N: { "4": "A B" }, O: { "2": "fC" }, P: { "4": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "4": "rC" }, R: { "4": "sC" }, S: { "4": "tC" } }, B: 2, C: "WAI-ARIA Accessibility features" };
  }
});

// node_modules/caniuse-lite/data/features/wake-lock.js
var require_wake_lock = __commonJS({
  "node_modules/caniuse-lite/data/features/wake-lock.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "b c d e f g h i j k X H", "2": "C K L G M N O", "194": "P Q R S T U V W Z a" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB", "194": "ZB aB bB cB dB eB fB gB P Q R S T" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB 9B AC BC CC hB sB DC iB", "194": "PB QB RB SB Y TB UB VB WB XB YB ZB aB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "oC pC qC", "2": "I gC hC iC jC kC pB lC mC nC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "Screen Wake Lock API" };
  }
});

// node_modules/caniuse-lite/data/features/wasm.js
var require_wasm = __commonJS({
  "node_modules/caniuse-lite/data/features/wasm.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L", "578": "G" }, C: { "1": "KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB wB xB", "194": "EB FB GB HB IB", "1025": "JB" }, D: { "1": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB", "322": "IB JB KB LB MB NB" }, E: { "1": "B C K L G hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB" }, F: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "322": "5 6 7 8 9 AB" }, G: { "1": "NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I gC hC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "194": "tC" } }, B: 6, C: "WebAssembly" };
  }
});

// node_modules/caniuse-lite/data/features/wav.js
var require_wav = __commonJS({
  "node_modules/caniuse-lite/data/features/wav.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W BC CC hB sB DC iB", "2": "F 9B AC" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "16": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "Wav audio format" };
  }
});

// node_modules/caniuse-lite/data/features/wbr-element.js
var require_wbr_element = __commonJS({
  "node_modules/caniuse-lite/data/features/wbr-element.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D uB", "2": "E F A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "0B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "16": "F" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB" }, H: { "1": "YC" }, I: { "1": "jB I H bC cC tB dC eC", "16": "ZC aC" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "wbr (word break opportunity) element" };
  }
});

// node_modules/caniuse-lite/data/features/web-animation.js
var require_web_animation = __commonJS({
  "node_modules/caniuse-lite/data/features/web-animation.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O", "260": "P Q R S" }, C: { "1": "R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB", "260": "kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB", "516": "EB FB GB HB IB JB KB LB MB NB OB PB", "580": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB", "2049": "dB eB fB gB P Q" }, D: { "1": "T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "132": "3 4 5", "260": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S" }, E: { "1": "G 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B pB", "1090": "B C K hB iB", "2049": "L 5B 6B" }, F: { "1": "ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p 9B AC BC CC hB sB DC iB", "132": "q r s", "260": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC", "1090": "NC OC PC QC RC SC TC", "2049": "UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "260": "fC" }, P: { "260": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "260": "rC" }, R: { "260": "sC" }, S: { "516": "tC" } }, B: 5, C: "Web Animations API" };
  }
});

// node_modules/caniuse-lite/data/features/web-app-manifest.js
var require_web_app_manifest = __commonJS({
  "node_modules/caniuse-lite/data/features/web-app-manifest.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M", "130": "N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB V W Z a b c d e f g h i j k X H nB wB xB", "578": "eB fB gB P Q R mB S T U" }, D: { "1": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC", "260": "OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "2": "tC" } }, B: 5, C: "Add to home screen (A2HS)" };
  }
});

// node_modules/caniuse-lite/data/features/web-bluetooth.js
var require_web_bluetooth = __commonJS({
  "node_modules/caniuse-lite/data/features/web-bluetooth.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "1025": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB", "194": "CB DB EB FB GB HB IB JB", "706": "KB LB MB", "1025": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "450": "3 4 5 6", "706": "7 8 9", "1025": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC eC", "1025": "H" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "1025": "Y" }, L: { "1025": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "hC iC jC kC pB lC mC nC oC pC qC", "2": "I gC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Web Bluetooth" };
  }
});

// node_modules/caniuse-lite/data/features/web-serial.js
var require_web_serial = __commonJS({
  "node_modules/caniuse-lite/data/features/web-serial.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "a b c d e f g h i j k X H", "2": "C K L G M N O", "66": "P Q R S T U V W Z" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB", "66": "gB P Q R S T U V W Z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y 9B AC BC CC hB sB DC iB", "66": "TB UB VB WB XB YB ZB aB bB cB dB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Web Serial API" };
  }
});

// node_modules/caniuse-lite/data/features/web-share.js
var require_web_share = __commonJS({
  "node_modules/caniuse-lite/data/features/web-share.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P Q", "516": "R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z", "130": "O m n o p q r", "1028": "a b c d e f g h i j k X H nB yB zB" }, E: { "1": "L G 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB", "2049": "K iB 5B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC", "2049": "QC RC SC TC UC" }, H: { "2": "YC" }, I: { "2": "jB I ZC aC bC cC tB dC", "258": "H eC" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "258": "Y" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I", "258": "gC hC iC" }, Q: { "2": "rC" }, R: { "16": "sC" }, S: { "2": "tC" } }, B: 5, C: "Web Share API" };
  }
});

// node_modules/caniuse-lite/data/features/webauthn.js
var require_webauthn = __commonJS({
  "node_modules/caniuse-lite/data/features/webauthn.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C", "226": "K L G M N" }, C: { "1": "QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB wB xB" }, D: { "1": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB" }, E: { "1": "K L G 5B 6B 7B qB rB 8B", "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB", "322": "iB" }, F: { "1": "LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB 9B AC BC CC hB sB DC iB" }, G: { "1": "WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC", "578": "SC", "2052": "VC", "3076": "TC UC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 2, C: "Web Authentication API" };
  }
});

// node_modules/caniuse-lite/data/features/webgl.js
var require_webgl = __commonJS({
  "node_modules/caniuse-lite/data/features/webgl.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "uB", "8": "J D E F A", "129": "B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "129": "C K L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "129": "I l J D E F A B C K L G M N O m n o p q" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D", "129": "E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "E F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB", "129": "J D 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B 9B AC BC CC hB sB DC", "129": "C G M N O iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC HC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "1": "A", "2": "D" }, K: { "1": "C Y iB", "2": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "8": "A", "129": "B" }, O: { "129": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "129": "tC" } }, B: 6, C: "WebGL - 3D Canvas graphics" };
  }
});

// node_modules/caniuse-lite/data/features/webgl2.js
var require_webgl2 = __commonJS({
  "node_modules/caniuse-lite/data/features/webgl2.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r wB xB", "194": "9 AB BB", "450": "0 1 2 3 4 5 6 7 8 s t u v w x y z", "2242": "CB DB EB FB GB HB" }, D: { "1": "NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z", "578": "AB BB CB DB EB FB GB HB IB JB KB LB MB" }, E: { "1": "G 7B qB rB 8B", "2": "I l J D E F A 0B oB 1B 2B 3B 4B", "1090": "B C K L pB hB iB 5B 6B" }, F: { "1": "AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB" }, G: { "1": "XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC", "1090": "PC QC RC SC TC UC VC WC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "iC jC kC pB lC mC nC oC pC qC", "2": "I gC hC" }, Q: { "578": "rC" }, R: { "2": "sC" }, S: { "2242": "tC" } }, B: 6, C: "WebGL 2.0" };
  }
});

// node_modules/caniuse-lite/data/features/webgpu.js
var require_webgpu = __commonJS({
  "node_modules/caniuse-lite/data/features/webgpu.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P", "578": "Q R S T U V W Z a b c d e", "1602": "f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB wB xB", "194": "SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P", "578": "Q R S T U V W Z a b c d e", "1602": "f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B 0B oB 1B 2B 3B 4B pB", "322": "C K L G hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB 9B AC BC CC hB sB DC iB", "578": "bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "194": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 5, C: "WebGPU" };
  }
});

// node_modules/caniuse-lite/data/features/webhid.js
var require_webhid = __commonJS({
  "node_modules/caniuse-lite/data/features/webhid.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "a b c d e f g h i j k X H", "2": "C K L G M N O", "66": "P Q R S T U V W Z" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB", "66": "gB P Q R S T U V W Z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB 9B AC BC CC hB sB DC iB", "66": "UB VB WB XB YB ZB aB bB cB dB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "WebHID API" };
  }
});

// node_modules/caniuse-lite/data/features/webkit-user-drag.js
var require_webkit_user_drag = __commonJS({
  "node_modules/caniuse-lite/data/features/webkit-user-drag.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "132": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "16": "I l J D E F A B C K L G", "132": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "F B C 9B AC BC CC hB sB DC iB", "132": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "CSS -webkit-user-drag property" };
  }
});

// node_modules/caniuse-lite/data/features/webm.js
var require_webm = __commonJS({
  "node_modules/caniuse-lite/data/features/webm.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E uB", "520": "F A B" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "8": "C K", "388": "L G M N O" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "132": "I l J D E F A B C K L G M N O m n o p q r s t u" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l", "132": "J D E F A B C K L G M N O m n o p q r" }, E: { "2": "0B", "8": "I l oB 1B", "520": "J D E F A B C 2B 3B 4B pB hB", "1028": "K iB 5B", "7172": "L", "8196": "G 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F 9B AC BC", "132": "B C G CC hB sB DC iB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC", "1028": "QC RC SC TC UC", "3076": "VC WC XC qB rB" }, H: { "2": "YC" }, I: { "1": "H", "2": "ZC aC", "132": "jB I bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "8": "A B" }, O: { "1": "fC" }, P: { "1": "gC hC iC jC kC pB lC mC nC oC pC qC", "132": "I" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 6, C: "WebM video format" };
  }
});

// node_modules/caniuse-lite/data/features/webnfc.js
var require_webnfc = __commonJS({
  "node_modules/caniuse-lite/data/features/webnfc.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O P a b c d e f g h i j k X H", "450": "Q R S T U V W Z" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P a b c d e f g h i j k X H nB yB zB", "450": "Q R S T U V W Z" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB 9B AC BC CC hB sB DC iB", "450": "VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "257": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "Web NFC" };
  }
});

// node_modules/caniuse-lite/data/features/webp.js
var require_webp = __commonJS({
  "node_modules/caniuse-lite/data/features/webp.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N" }, C: { "1": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "8": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l", "8": "J D E", "132": "F A B C K L G M N O m n o p", "260": "q r s t u v w x y" }, E: { "2": "I l J D E F A B C K 0B oB 1B 2B 3B 4B pB hB iB 5B", "516": "L G 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F 9B AC BC", "8": "B CC", "132": "hB sB DC", "260": "C G M N O iB" }, G: { "1": "VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC" }, H: { "1": "YC" }, I: { "1": "H tB dC eC", "2": "jB ZC aC bC", "132": "I cC" }, J: { "2": "D A" }, K: { "1": "C Y hB sB iB", "2": "A", "132": "B" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "8": "tC" } }, B: 7, C: "WebP image format" };
  }
});

// node_modules/caniuse-lite/data/features/websockets.js
var require_websockets = __commonJS({
  "node_modules/caniuse-lite/data/features/websockets.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB wB xB", "132": "I l", "292": "J D E F A" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l J D E F A B C K L", "260": "G" }, E: { "1": "D E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "132": "l 1B", "260": "J 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F 9B AC BC CC", "132": "B C hB sB DC" }, G: { "1": "E GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC", "132": "tB FC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "129": "D" }, K: { "1": "Y iB", "2": "A", "132": "B C hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Web Sockets" };
  }
});

// node_modules/caniuse-lite/data/features/webusb.js
var require_webusb = __commonJS({
  "node_modules/caniuse-lite/data/features/webusb.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB", "66": "LB MB NB OB PB kB QB" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "0 1 2 3 4 5 6 7 F B C G M N O m n o p q r s t u v w x y z 9B AC BC CC hB sB DC iB", "66": "8 9 AB BB CB DB EB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "1": "jC kC pB lC mC nC oC pC qC", "2": "I gC hC iC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 7, C: "WebUSB" };
  }
});

// node_modules/caniuse-lite/data/features/webvr.js
var require_webvr = __commonJS({
  "node_modules/caniuse-lite/data/features/webvr.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L Q R S T U V W Z a b c d e f g h i j k X H", "66": "P", "257": "G M N O" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB wB xB", "129": "MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "194": "LB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "66": "OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P" }, E: { "2": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "66": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C Y hB sB iB" }, L: { "2": "H" }, M: { "2": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "513": "I", "516": "gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "66": "sC" }, S: { "2": "tC" } }, B: 7, C: "WebVR API" };
  }
});

// node_modules/caniuse-lite/data/features/webvtt.js
var require_webvtt = __commonJS({
  "node_modules/caniuse-lite/data/features/webvtt.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "vB jB I l J D E F A B C K L G M N O m n o p q wB xB", "66": "r s t u v w x", "129": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I l J D E F A B C K L G M N" }, E: { "1": "J D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB I ZC aC bC cC tB" }, J: { "1": "A", "2": "D" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "B", "2": "A" }, O: { "2": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "129": "tC" } }, B: 5, C: "WebVTT - Web Video Text Tracks" };
  }
});

// node_modules/caniuse-lite/data/features/webworkers.js
var require_webworkers = __commonJS({
  "node_modules/caniuse-lite/data/features/webworkers.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "2": "uB", "8": "J D E F" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "8": "vB jB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "8": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W CC hB sB DC iB", "2": "F 9B", "8": "AC BC" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "H ZC dC eC", "2": "jB I aC bC cC tB" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "8": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Web Workers" };
  }
});

// node_modules/caniuse-lite/data/features/webxr.js
var require_webxr = __commonJS({
  "node_modules/caniuse-lite/data/features/webxr.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "2": "C K L G M N O", "132": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "2": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB wB xB", "322": "fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB" }, D: { "2": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y", "66": "TB UB VB WB XB YB ZB aB bB cB dB eB fB gB", "132": "P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "2": "I l J D E F A B C 0B oB 1B 2B 3B 4B pB hB iB", "578": "K L G 5B 6B 7B qB rB 8B" }, F: { "2": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB 9B AC BC CC hB sB DC iB", "66": "JB KB LB MB NB OB PB QB RB SB Y TB", "132": "UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W" }, G: { "2": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "2": "YC" }, I: { "2": "jB I H ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "2": "A B C hB sB iB", "132": "Y" }, L: { "132": "H" }, M: { "322": "X" }, N: { "2": "A B" }, O: { "2": "fC" }, P: { "2": "I gC hC iC jC kC pB lC", "132": "mC nC oC pC qC" }, Q: { "2": "rC" }, R: { "2": "sC" }, S: { "2": "tC" } }, B: 4, C: "WebXR Device API" };
  }
});

// node_modules/caniuse-lite/data/features/will-change.js
var require_will_change = __commonJS({
  "node_modules/caniuse-lite/data/features/will-change.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K L G M N O" }, C: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L G M N O m n o p q r s t u v wB xB", "194": "0 1 2 w x y z" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p q 9B AC BC CC hB sB DC iB" }, G: { "1": "KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS will-change property" };
  }
});

// node_modules/caniuse-lite/data/features/woff.js
var require_woff = __commonJS({
  "node_modules/caniuse-lite/data/features/woff.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB xB", "2": "vB jB wB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "I" }, E: { "1": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I l 0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W hB sB DC iB", "2": "F B 9B AC BC CC" }, G: { "1": "E FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB" }, H: { "2": "YC" }, I: { "1": "H dC eC", "2": "jB ZC aC bC cC tB", "130": "I" }, J: { "1": "D A" }, K: { "1": "B C Y hB sB iB", "2": "A" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 2, C: "WOFF - Web Open Font Format" };
  }
});

// node_modules/caniuse-lite/data/features/woff2.js
var require_woff2 = __commonJS({
  "node_modules/caniuse-lite/data/features/woff2.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F A B uB" }, B: { "1": "L G M N O P Q R S T U V W Z a b c d e f g h i j k X H", "2": "C K" }, C: { "1": "6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "0 1 2 3 4 5 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z wB xB" }, D: { "1": "3 4 5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "2": "0 1 2 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z" }, E: { "1": "C K L G iB 5B 6B 7B qB rB 8B", "2": "I l J D E F 0B oB 1B 2B 3B 4B", "132": "A B pB hB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C G M N O m n o p 9B AC BC CC hB sB DC iB" }, G: { "1": "LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "E oB EC tB FC GC HC IC JC KC" }, H: { "2": "YC" }, I: { "1": "H", "2": "jB I ZC aC bC cC tB dC eC" }, J: { "2": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "2": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "WOFF 2.0 - Web Open Font Format" };
  }
});

// node_modules/caniuse-lite/data/features/word-break.js
var require_word_break = __commonJS({
  "node_modules/caniuse-lite/data/features/word-break.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "J D E F A B uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB I l J D E F A B C K L wB xB" }, D: { "1": "BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "4": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB" }, E: { "1": "F A B C K L G 4B pB hB iB 5B 6B 7B qB rB 8B", "4": "I l J D E 0B oB 1B 2B 3B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "2": "F B C 9B AC BC CC hB sB DC iB", "4": "G M N O m n o p q r s t u v w x" }, G: { "1": "JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "4": "E oB EC tB FC GC HC IC" }, H: { "2": "YC" }, I: { "1": "H", "4": "jB I ZC aC bC cC tB dC eC" }, J: { "4": "D A" }, K: { "1": "Y", "2": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "4": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "4": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 5, C: "CSS3 word-break" };
  }
});

// node_modules/caniuse-lite/data/features/wordwrap.js
var require_wordwrap = __commonJS({
  "node_modules/caniuse-lite/data/features/wordwrap.js"(exports2, module2) {
    module2.exports = { A: { A: { "4": "J D E F A B uB" }, B: { "1": "O P Q R S T U V W Z a b c d e f g h i j k X H", "4": "C K L G M N" }, C: { "1": "GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "4": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "4": "I l J D E F A B C K L G M N O m n o p" }, E: { "1": "D E F A B C K L G 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "4": "I l J 0B oB 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F 9B AC", "4": "B C BC CC hB sB DC" }, G: { "1": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "4": "oB EC tB FC GC" }, H: { "4": "YC" }, I: { "1": "H dC eC", "4": "jB I ZC aC bC cC tB" }, J: { "1": "A", "4": "D" }, K: { "1": "Y", "4": "A B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "4": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "4": "tC" } }, B: 5, C: "CSS3 Overflow-wrap" };
  }
});

// node_modules/caniuse-lite/data/features/x-doc-messaging.js
var require_x_doc_messaging = __commonJS({
  "node_modules/caniuse-lite/data/features/x-doc-messaging.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D uB", "132": "E F", "260": "A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB", "2": "vB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "0B oB" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB", "2": "F" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "4": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "Cross-document messaging" };
  }
});

// node_modules/caniuse-lite/data/features/x-frame-options.js
var require_x_frame_options = __commonJS({
  "node_modules/caniuse-lite/data/features/x-frame-options.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "E F A B", "2": "J D uB" }, B: { "1": "C K L G M N O", "4": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB", "4": "I l J D E F A B C K L G M N YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "16": "vB jB wB xB" }, D: { "4": "0 1 2 3 4 5 6 7 8 9 t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J D E F A B C K L G M N O m n o p q r s" }, E: { "4": "J D E F A B C K L G 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "16": "I l 0B oB" }, F: { "4": "0 1 2 3 4 5 6 7 8 9 C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W DC iB", "16": "F B 9B AC BC CC hB sB" }, G: { "4": "E HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "16": "oB EC tB FC GC" }, H: { "2": "YC" }, I: { "4": "I H cC tB dC eC", "16": "jB ZC aC bC" }, J: { "4": "D A" }, K: { "4": "Y iB", "16": "A B C hB sB" }, L: { "4": "H" }, M: { "4": "X" }, N: { "1": "A B" }, O: { "4": "fC" }, P: { "4": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "4": "rC" }, R: { "4": "sC" }, S: { "1": "tC" } }, B: 6, C: "X-Frame-Options HTTP header" };
  }
});

// node_modules/caniuse-lite/data/features/xhr2.js
var require_xhr2 = __commonJS({
  "node_modules/caniuse-lite/data/features/xhr2.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "J D E F uB", "132": "A B" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "2": "vB jB", "260": "A B", "388": "J D E F", "900": "I l wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "16": "I l J", "132": "w x", "388": "D E F A B C K L G M N O m n o p q r s t u v" }, E: { "1": "E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "2": "I 0B oB", "132": "D 2B", "388": "l J 1B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 C O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W iB", "2": "F B 9B AC BC CC hB sB DC", "132": "G M N" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "2": "oB EC tB", "132": "HC", "388": "FC GC" }, H: { "2": "YC" }, I: { "1": "H eC", "2": "ZC aC bC", "388": "dC", "900": "jB I cC tB" }, J: { "132": "A", "388": "D" }, K: { "1": "C Y iB", "2": "A B hB sB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "132": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 1, C: "XMLHttpRequest advanced features" };
  }
});

// node_modules/caniuse-lite/data/features/xhtml.js
var require_xhtml = __commonJS({
  "node_modules/caniuse-lite/data/features/xhtml.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "F A B", "2": "J D E uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "1": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "1": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "1": "YC" }, I: { "1": "jB I H ZC aC bC cC tB dC eC" }, J: { "1": "D A" }, K: { "1": "A B C Y hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "2": "sC" }, S: { "1": "tC" } }, B: 1, C: "XHTML served as application/xhtml+xml" };
  }
});

// node_modules/caniuse-lite/data/features/xhtmlsmil.js
var require_xhtmlsmil = __commonJS({
  "node_modules/caniuse-lite/data/features/xhtmlsmil.js"(exports2, module2) {
    module2.exports = { A: { A: { "2": "F A B uB", "4": "J D E" }, B: { "2": "C K L G M N O", "8": "P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "8": "0 1 2 3 4 5 6 7 8 9 vB jB I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB wB xB" }, D: { "8": "0 1 2 3 4 5 6 7 8 9 I l J D E F A B C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB" }, E: { "8": "I l J D E F A B C K L G 0B oB 1B 2B 3B 4B pB hB iB 5B 6B 7B qB rB 8B" }, F: { "8": "0 1 2 3 4 5 6 7 8 9 F B C G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W 9B AC BC CC hB sB DC iB" }, G: { "8": "E oB EC tB FC GC HC IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB" }, H: { "8": "YC" }, I: { "8": "jB I H ZC aC bC cC tB dC eC" }, J: { "8": "D A" }, K: { "8": "A B C Y hB sB iB" }, L: { "8": "H" }, M: { "8": "X" }, N: { "2": "A B" }, O: { "8": "fC" }, P: { "8": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "8": "rC" }, R: { "8": "sC" }, S: { "8": "tC" } }, B: 7, C: "XHTML+SMIL animation" };
  }
});

// node_modules/caniuse-lite/data/features/xml-serializer.js
var require_xml_serializer = __commonJS({
  "node_modules/caniuse-lite/data/features/xml-serializer.js"(exports2, module2) {
    module2.exports = { A: { A: { "1": "A B", "260": "J D E F uB" }, B: { "1": "C K L G M N O P Q R S T U V W Z a b c d e f g h i j k X H" }, C: { "1": "0 1 2 3 4 5 6 7 8 9 C K L G M N O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W Z a b c d e f g h i j k X H nB", "132": "B", "260": "vB jB I l J D wB xB", "516": "E F A" }, D: { "1": "0 1 2 3 4 5 6 7 8 9 y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB kB QB lB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R S T U V W Z a b c d e f g h i j k X H nB yB zB", "132": "I l J D E F A B C K L G M N O m n o p q r s t u v w x" }, E: { "1": "E F A B C K L G 3B 4B pB hB iB 5B 6B 7B qB rB 8B", "132": "I l J D 0B oB 1B 2B" }, F: { "1": "0 1 2 3 4 5 6 7 8 9 O m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB Y TB UB VB WB XB YB ZB aB bB cB dB eB fB gB P Q R mB S T U V W", "16": "F 9B", "132": "B C G M N AC BC CC hB sB DC iB" }, G: { "1": "E IC JC KC LC MC NC OC PC QC RC SC TC UC VC WC XC qB rB", "132": "oB EC tB FC GC HC" }, H: { "132": "YC" }, I: { "1": "H dC eC", "132": "jB I ZC aC bC cC tB" }, J: { "132": "D A" }, K: { "1": "Y", "16": "A", "132": "B C hB sB iB" }, L: { "1": "H" }, M: { "1": "X" }, N: { "1": "A B" }, O: { "1": "fC" }, P: { "1": "I gC hC iC jC kC pB lC mC nC oC pC qC" }, Q: { "1": "rC" }, R: { "1": "sC" }, S: { "1": "tC" } }, B: 4, C: "DOM Parsing and Serialization" };
  }
});

// node_modules/caniuse-lite/data/features.js
var require_features = __commonJS({
  "node_modules/caniuse-lite/data/features.js"(exports2, module2) {
    module2.exports = { "aac": require_aac(), "abortcontroller": require_abortcontroller(), "ac3-ec3": require_ac3_ec3(), "accelerometer": require_accelerometer(), "addeventlistener": require_addeventlistener(), "alternate-stylesheet": require_alternate_stylesheet(), "ambient-light": require_ambient_light(), "apng": require_apng(), "array-find-index": require_array_find_index(), "array-find": require_array_find(), "array-flat": require_array_flat(), "array-includes": require_array_includes(), "arrow-functions": require_arrow_functions(), "asmjs": require_asmjs(), "async-clipboard": require_async_clipboard(), "async-functions": require_async_functions(), "atob-btoa": require_atob_btoa(), "audio-api": require_audio_api(), "audio": require_audio(), "audiotracks": require_audiotracks(), "autofocus": require_autofocus(), "auxclick": require_auxclick(), "av1": require_av1(), "avif": require_avif(), "background-attachment": require_background_attachment(), "background-clip-text": require_background_clip_text(), "background-img-opts": require_background_img_opts(), "background-position-x-y": require_background_position_x_y(), "background-repeat-round-space": require_background_repeat_round_space(), "background-sync": require_background_sync(), "battery-status": require_battery_status(), "beacon": require_beacon(), "beforeafterprint": require_beforeafterprint(), "bigint": require_bigint(), "blobbuilder": require_blobbuilder(), "bloburls": require_bloburls(), "border-image": require_border_image(), "border-radius": require_border_radius(), "broadcastchannel": require_broadcastchannel(), "brotli": require_brotli(), "calc": require_calc(), "canvas-blending": require_canvas_blending(), "canvas-text": require_canvas_text(), "canvas": require_canvas(), "ch-unit": require_ch_unit(), "chacha20-poly1305": require_chacha20_poly1305(), "channel-messaging": require_channel_messaging(), "childnode-remove": require_childnode_remove(), "classlist": require_classlist(), "client-hints-dpr-width-viewport": require_client_hints_dpr_width_viewport(), "clipboard": require_clipboard(), "colr-v1": require_colr_v1(), "colr": require_colr(), "comparedocumentposition": require_comparedocumentposition(), "console-basic": require_console_basic(), "console-time": require_console_time(), "const": require_const(), "constraint-validation": require_constraint_validation(), "contenteditable": require_contenteditable(), "contentsecuritypolicy": require_contentsecuritypolicy(), "contentsecuritypolicy2": require_contentsecuritypolicy2(), "cookie-store-api": require_cookie_store_api(), "cors": require_cors(), "createimagebitmap": require_createimagebitmap(), "credential-management": require_credential_management(), "cryptography": require_cryptography(), "css-all": require_css_all(), "css-animation": require_css_animation(), "css-any-link": require_css_any_link(), "css-appearance": require_css_appearance(), "css-at-counter-style": require_css_at_counter_style(), "css-autofill": require_css_autofill(), "css-backdrop-filter": require_css_backdrop_filter(), "css-background-offsets": require_css_background_offsets(), "css-backgroundblendmode": require_css_backgroundblendmode(), "css-boxdecorationbreak": require_css_boxdecorationbreak(), "css-boxshadow": require_css_boxshadow(), "css-canvas": require_css_canvas(), "css-caret-color": require_css_caret_color(), "css-cascade-layers": require_css_cascade_layers(), "css-case-insensitive": require_css_case_insensitive(), "css-clip-path": require_css_clip_path(), "css-color-adjust": require_css_color_adjust(), "css-color-function": require_css_color_function(), "css-conic-gradients": require_css_conic_gradients(), "css-container-queries": require_css_container_queries(), "css-containment": require_css_containment(), "css-content-visibility": require_css_content_visibility(), "css-counters": require_css_counters(), "css-crisp-edges": require_css_crisp_edges(), "css-cross-fade": require_css_cross_fade(), "css-default-pseudo": require_css_default_pseudo(), "css-descendant-gtgt": require_css_descendant_gtgt(), "css-deviceadaptation": require_css_deviceadaptation(), "css-dir-pseudo": require_css_dir_pseudo(), "css-display-contents": require_css_display_contents(), "css-element-function": require_css_element_function(), "css-env-function": require_css_env_function(), "css-exclusions": require_css_exclusions(), "css-featurequeries": require_css_featurequeries(), "css-file-selector-button": require_css_file_selector_button(), "css-filter-function": require_css_filter_function(), "css-filters": require_css_filters(), "css-first-letter": require_css_first_letter(), "css-first-line": require_css_first_line(), "css-fixed": require_css_fixed(), "css-focus-visible": require_css_focus_visible(), "css-focus-within": require_css_focus_within(), "css-font-palette": require_css_font_palette(), "css-font-rendering-controls": require_css_font_rendering_controls(), "css-font-stretch": require_css_font_stretch(), "css-gencontent": require_css_gencontent(), "css-gradients": require_css_gradients(), "css-grid": require_css_grid(), "css-hanging-punctuation": require_css_hanging_punctuation(), "css-has": require_css_has(), "css-hyphenate": require_css_hyphenate(), "css-hyphens": require_css_hyphens(), "css-image-orientation": require_css_image_orientation(), "css-image-set": require_css_image_set(), "css-in-out-of-range": require_css_in_out_of_range(), "css-indeterminate-pseudo": require_css_indeterminate_pseudo(), "css-initial-letter": require_css_initial_letter(), "css-initial-value": require_css_initial_value(), "css-lch-lab": require_css_lch_lab(), "css-letter-spacing": require_css_letter_spacing(), "css-line-clamp": require_css_line_clamp(), "css-logical-props": require_css_logical_props(), "css-marker-pseudo": require_css_marker_pseudo(), "css-masks": require_css_masks(), "css-matches-pseudo": require_css_matches_pseudo(), "css-math-functions": require_css_math_functions(), "css-media-interaction": require_css_media_interaction(), "css-media-resolution": require_css_media_resolution(), "css-media-scripting": require_css_media_scripting(), "css-mediaqueries": require_css_mediaqueries(), "css-mixblendmode": require_css_mixblendmode(), "css-motion-paths": require_css_motion_paths(), "css-namespaces": require_css_namespaces(), "css-nesting": require_css_nesting(), "css-not-sel-list": require_css_not_sel_list(), "css-nth-child-of": require_css_nth_child_of(), "css-opacity": require_css_opacity(), "css-optional-pseudo": require_css_optional_pseudo(), "css-overflow-anchor": require_css_overflow_anchor(), "css-overflow-overlay": require_css_overflow_overlay(), "css-overflow": require_css_overflow(), "css-overscroll-behavior": require_css_overscroll_behavior(), "css-page-break": require_css_page_break(), "css-paged-media": require_css_paged_media(), "css-paint-api": require_css_paint_api(), "css-placeholder-shown": require_css_placeholder_shown(), "css-placeholder": require_css_placeholder(), "css-print-color-adjust": require_css_print_color_adjust(), "css-read-only-write": require_css_read_only_write(), "css-rebeccapurple": require_css_rebeccapurple(), "css-reflections": require_css_reflections(), "css-regions": require_css_regions(), "css-repeating-gradients": require_css_repeating_gradients(), "css-resize": require_css_resize(), "css-revert-value": require_css_revert_value(), "css-rrggbbaa": require_css_rrggbbaa(), "css-scroll-behavior": require_css_scroll_behavior(), "css-scroll-timeline": require_css_scroll_timeline(), "css-scrollbar": require_css_scrollbar(), "css-sel2": require_css_sel2(), "css-sel3": require_css_sel3(), "css-selection": require_css_selection(), "css-shapes": require_css_shapes(), "css-snappoints": require_css_snappoints(), "css-sticky": require_css_sticky(), "css-subgrid": require_css_subgrid(), "css-supports-api": require_css_supports_api(), "css-table": require_css_table(), "css-text-align-last": require_css_text_align_last(), "css-text-indent": require_css_text_indent(), "css-text-justify": require_css_text_justify(), "css-text-orientation": require_css_text_orientation(), "css-text-spacing": require_css_text_spacing(), "css-textshadow": require_css_textshadow(), "css-touch-action-2": require_css_touch_action_2(), "css-touch-action": require_css_touch_action(), "css-transitions": require_css_transitions(), "css-unicode-bidi": require_css_unicode_bidi(), "css-unset-value": require_css_unset_value(), "css-variables": require_css_variables(), "css-when-else": require_css_when_else(), "css-widows-orphans": require_css_widows_orphans(), "css-width-stretch": require_css_width_stretch(), "css-writing-mode": require_css_writing_mode(), "css-zoom": require_css_zoom(), "css3-attr": require_css3_attr(), "css3-boxsizing": require_css3_boxsizing(), "css3-colors": require_css3_colors(), "css3-cursors-grab": require_css3_cursors_grab(), "css3-cursors-newer": require_css3_cursors_newer(), "css3-cursors": require_css3_cursors(), "css3-tabsize": require_css3_tabsize(), "currentcolor": require_currentcolor(), "custom-elements": require_custom_elements(), "custom-elementsv1": require_custom_elementsv1(), "customevent": require_customevent(), "datalist": require_datalist(), "dataset": require_dataset(), "datauri": require_datauri(), "date-tolocaledatestring": require_date_tolocaledatestring(), "decorators": require_decorators(), "details": require_details(), "deviceorientation": require_deviceorientation(), "devicepixelratio": require_devicepixelratio(), "dialog": require_dialog(), "dispatchevent": require_dispatchevent(), "dnssec": require_dnssec(), "do-not-track": require_do_not_track(), "document-currentscript": require_document_currentscript(), "document-evaluate-xpath": require_document_evaluate_xpath(), "document-execcommand": require_document_execcommand(), "document-policy": require_document_policy(), "document-scrollingelement": require_document_scrollingelement(), "documenthead": require_documenthead(), "dom-manip-convenience": require_dom_manip_convenience(), "dom-range": require_dom_range(), "domcontentloaded": require_domcontentloaded(), "domfocusin-domfocusout-events": require_domfocusin_domfocusout_events(), "dommatrix": require_dommatrix(), "download": require_download(), "dragndrop": require_dragndrop(), "element-closest": require_element_closest(), "element-from-point": require_element_from_point(), "element-scroll-methods": require_element_scroll_methods(), "eme": require_eme(), "eot": require_eot(), "es5": require_es5(), "es6-class": require_es6_class(), "es6-generators": require_es6_generators(), "es6-module-dynamic-import": require_es6_module_dynamic_import(), "es6-module": require_es6_module(), "es6-number": require_es6_number(), "es6-string-includes": require_es6_string_includes(), "es6": require_es6(), "eventsource": require_eventsource(), "extended-system-fonts": require_extended_system_fonts(), "feature-policy": require_feature_policy(), "fetch": require_fetch(), "fieldset-disabled": require_fieldset_disabled(), "fileapi": require_fileapi(), "filereader": require_filereader(), "filereadersync": require_filereadersync(), "filesystem": require_filesystem(), "flac": require_flac(), "flexbox-gap": require_flexbox_gap(), "flexbox": require_flexbox(), "flow-root": require_flow_root(), "focusin-focusout-events": require_focusin_focusout_events(), "focusoptions-preventscroll": require_focusoptions_preventscroll(), "font-family-system-ui": require_font_family_system_ui(), "font-feature": require_font_feature(), "font-kerning": require_font_kerning(), "font-loading": require_font_loading(), "font-metrics-overrides": require_font_metrics_overrides(), "font-size-adjust": require_font_size_adjust(), "font-smooth": require_font_smooth(), "font-unicode-range": require_font_unicode_range(), "font-variant-alternates": require_font_variant_alternates(), "font-variant-east-asian": require_font_variant_east_asian(), "font-variant-numeric": require_font_variant_numeric(), "fontface": require_fontface(), "form-attribute": require_form_attribute(), "form-submit-attributes": require_form_submit_attributes(), "form-validation": require_form_validation(), "forms": require_forms(), "fullscreen": require_fullscreen(), "gamepad": require_gamepad(), "geolocation": require_geolocation(), "getboundingclientrect": require_getboundingclientrect(), "getcomputedstyle": require_getcomputedstyle(), "getelementsbyclassname": require_getelementsbyclassname(), "getrandomvalues": require_getrandomvalues(), "gyroscope": require_gyroscope(), "hardwareconcurrency": require_hardwareconcurrency(), "hashchange": require_hashchange(), "heif": require_heif(), "hevc": require_hevc(), "hidden": require_hidden(), "high-resolution-time": require_high_resolution_time(), "history": require_history(), "html-media-capture": require_html_media_capture(), "html5semantic": require_html5semantic(), "http-live-streaming": require_http_live_streaming(), "http2": require_http2(), "http3": require_http3(), "iframe-sandbox": require_iframe_sandbox(), "iframe-seamless": require_iframe_seamless(), "iframe-srcdoc": require_iframe_srcdoc(), "imagecapture": require_imagecapture(), "ime": require_ime(), "img-naturalwidth-naturalheight": require_img_naturalwidth_naturalheight(), "import-maps": require_import_maps(), "imports": require_imports(), "indeterminate-checkbox": require_indeterminate_checkbox(), "indexeddb": require_indexeddb(), "indexeddb2": require_indexeddb2(), "inline-block": require_inline_block(), "innertext": require_innertext(), "input-autocomplete-onoff": require_input_autocomplete_onoff(), "input-color": require_input_color(), "input-datetime": require_input_datetime(), "input-email-tel-url": require_input_email_tel_url(), "input-event": require_input_event(), "input-file-accept": require_input_file_accept(), "input-file-directory": require_input_file_directory(), "input-file-multiple": require_input_file_multiple(), "input-inputmode": require_input_inputmode(), "input-minlength": require_input_minlength(), "input-number": require_input_number(), "input-pattern": require_input_pattern(), "input-placeholder": require_input_placeholder(), "input-range": require_input_range(), "input-search": require_input_search(), "input-selection": require_input_selection(), "insert-adjacent": require_insert_adjacent(), "insertadjacenthtml": require_insertadjacenthtml(), "internationalization": require_internationalization(), "intersectionobserver-v2": require_intersectionobserver_v2(), "intersectionobserver": require_intersectionobserver(), "intl-pluralrules": require_intl_pluralrules(), "intrinsic-width": require_intrinsic_width(), "jpeg2000": require_jpeg2000(), "jpegxl": require_jpegxl(), "jpegxr": require_jpegxr(), "js-regexp-lookbehind": require_js_regexp_lookbehind(), "json": require_json(), "justify-content-space-evenly": require_justify_content_space_evenly(), "kerning-pairs-ligatures": require_kerning_pairs_ligatures(), "keyboardevent-charcode": require_keyboardevent_charcode(), "keyboardevent-code": require_keyboardevent_code(), "keyboardevent-getmodifierstate": require_keyboardevent_getmodifierstate(), "keyboardevent-key": require_keyboardevent_key(), "keyboardevent-location": require_keyboardevent_location(), "keyboardevent-which": require_keyboardevent_which(), "lazyload": require_lazyload(), "let": require_let(), "link-icon-png": require_link_icon_png(), "link-icon-svg": require_link_icon_svg(), "link-rel-dns-prefetch": require_link_rel_dns_prefetch(), "link-rel-modulepreload": require_link_rel_modulepreload(), "link-rel-preconnect": require_link_rel_preconnect(), "link-rel-prefetch": require_link_rel_prefetch(), "link-rel-preload": require_link_rel_preload(), "link-rel-prerender": require_link_rel_prerender(), "loading-lazy-attr": require_loading_lazy_attr(), "localecompare": require_localecompare(), "magnetometer": require_magnetometer(), "matchesselector": require_matchesselector(), "matchmedia": require_matchmedia(), "mathml": require_mathml(), "maxlength": require_maxlength(), "media-attribute": require_media_attribute(), "media-fragments": require_media_fragments(), "media-session-api": require_media_session_api(), "mediacapture-fromelement": require_mediacapture_fromelement(), "mediarecorder": require_mediarecorder(), "mediasource": require_mediasource(), "menu": require_menu(), "meta-theme-color": require_meta_theme_color(), "meter": require_meter(), "midi": require_midi(), "minmaxwh": require_minmaxwh(), "mp3": require_mp3(), "mpeg-dash": require_mpeg_dash(), "mpeg4": require_mpeg4(), "multibackgrounds": require_multibackgrounds(), "multicolumn": require_multicolumn(), "mutation-events": require_mutation_events(), "mutationobserver": require_mutationobserver(), "namevalue-storage": require_namevalue_storage(), "native-filesystem-api": require_native_filesystem_api(), "nav-timing": require_nav_timing(), "navigator-language": require_navigator_language(), "netinfo": require_netinfo(), "notifications": require_notifications(), "object-entries": require_object_entries(), "object-fit": require_object_fit(), "object-observe": require_object_observe(), "object-values": require_object_values(), "objectrtc": require_objectrtc(), "offline-apps": require_offline_apps(), "offscreencanvas": require_offscreencanvas(), "ogg-vorbis": require_ogg_vorbis(), "ogv": require_ogv(), "ol-reversed": require_ol_reversed(), "once-event-listener": require_once_event_listener(), "online-status": require_online_status(), "opus": require_opus(), "orientation-sensor": require_orientation_sensor(), "outline": require_outline(), "pad-start-end": require_pad_start_end(), "page-transition-events": require_page_transition_events(), "pagevisibility": require_pagevisibility(), "passive-event-listener": require_passive_event_listener(), "passwordrules": require_passwordrules(), "path2d": require_path2d(), "payment-request": require_payment_request(), "pdf-viewer": require_pdf_viewer(), "permissions-api": require_permissions_api(), "permissions-policy": require_permissions_policy(), "picture-in-picture": require_picture_in_picture(), "picture": require_picture(), "ping": require_ping(), "png-alpha": require_png_alpha(), "pointer-events": require_pointer_events(), "pointer": require_pointer(), "pointerlock": require_pointerlock(), "portals": require_portals(), "prefers-color-scheme": require_prefers_color_scheme(), "prefers-reduced-motion": require_prefers_reduced_motion(), "private-class-fields": require_private_class_fields(), "private-methods-and-accessors": require_private_methods_and_accessors(), "progress": require_progress(), "promise-finally": require_promise_finally(), "promises": require_promises(), "proximity": require_proximity(), "proxy": require_proxy(), "public-class-fields": require_public_class_fields(), "publickeypinning": require_publickeypinning(), "push-api": require_push_api(), "queryselector": require_queryselector(), "readonly-attr": require_readonly_attr(), "referrer-policy": require_referrer_policy(), "registerprotocolhandler": require_registerprotocolhandler(), "rel-noopener": require_rel_noopener(), "rel-noreferrer": require_rel_noreferrer(), "rellist": require_rellist(), "rem": require_rem(), "requestanimationframe": require_requestanimationframe(), "requestidlecallback": require_requestidlecallback(), "resizeobserver": require_resizeobserver(), "resource-timing": require_resource_timing(), "rest-parameters": require_rest_parameters(), "rtcpeerconnection": require_rtcpeerconnection(), "ruby": require_ruby(), "run-in": require_run_in(), "same-site-cookie-attribute": require_same_site_cookie_attribute(), "screen-orientation": require_screen_orientation(), "script-async": require_script_async(), "script-defer": require_script_defer(), "scrollintoview": require_scrollintoview(), "scrollintoviewifneeded": require_scrollintoviewifneeded(), "sdch": require_sdch(), "selection-api": require_selection_api(), "server-timing": require_server_timing(), "serviceworkers": require_serviceworkers(), "setimmediate": require_setimmediate(), "sha-2": require_sha_2(), "shadowdom": require_shadowdom(), "shadowdomv1": require_shadowdomv1(), "sharedarraybuffer": require_sharedarraybuffer(), "sharedworkers": require_sharedworkers(), "sni": require_sni(), "spdy": require_spdy(), "speech-recognition": require_speech_recognition(), "speech-synthesis": require_speech_synthesis(), "spellcheck-attribute": require_spellcheck_attribute(), "sql-storage": require_sql_storage(), "srcset": require_srcset(), "stream": require_stream(), "streams": require_streams(), "stricttransportsecurity": require_stricttransportsecurity(), "style-scoped": require_style_scoped(), "subresource-integrity": require_subresource_integrity(), "svg-css": require_svg_css(), "svg-filters": require_svg_filters(), "svg-fonts": require_svg_fonts(), "svg-fragment": require_svg_fragment(), "svg-html": require_svg_html(), "svg-html5": require_svg_html5(), "svg-img": require_svg_img(), "svg-smil": require_svg_smil(), "svg": require_svg(), "sxg": require_sxg(), "tabindex-attr": require_tabindex_attr(), "template-literals": require_template_literals(), "template": require_template(), "temporal": require_temporal(), "testfeat": require_testfeat(), "text-decoration": require_text_decoration(), "text-emphasis": require_text_emphasis(), "text-overflow": require_text_overflow(), "text-size-adjust": require_text_size_adjust(), "text-stroke": require_text_stroke(), "text-underline-offset": require_text_underline_offset(), "textcontent": require_textcontent(), "textencoder": require_textencoder(), "tls1-1": require_tls1_1(), "tls1-2": require_tls1_2(), "tls1-3": require_tls1_3(), "token-binding": require_token_binding(), "touch": require_touch(), "transforms2d": require_transforms2d(), "transforms3d": require_transforms3d(), "trusted-types": require_trusted_types(), "ttf": require_ttf(), "typedarrays": require_typedarrays(), "u2f": require_u2f(), "unhandledrejection": require_unhandledrejection(), "upgradeinsecurerequests": require_upgradeinsecurerequests(), "url-scroll-to-text-fragment": require_url_scroll_to_text_fragment(), "url": require_url(), "urlsearchparams": require_urlsearchparams(), "use-strict": require_use_strict(), "user-select-none": require_user_select_none(), "user-timing": require_user_timing(), "variable-fonts": require_variable_fonts(), "vector-effect": require_vector_effect(), "vibration": require_vibration(), "video": require_video(), "videotracks": require_videotracks(), "viewport-unit-variants": require_viewport_unit_variants(), "viewport-units": require_viewport_units(), "wai-aria": require_wai_aria(), "wake-lock": require_wake_lock(), "wasm": require_wasm(), "wav": require_wav(), "wbr-element": require_wbr_element(), "web-animation": require_web_animation(), "web-app-manifest": require_web_app_manifest(), "web-bluetooth": require_web_bluetooth(), "web-serial": require_web_serial(), "web-share": require_web_share(), "webauthn": require_webauthn(), "webgl": require_webgl(), "webgl2": require_webgl2(), "webgpu": require_webgpu(), "webhid": require_webhid(), "webkit-user-drag": require_webkit_user_drag(), "webm": require_webm(), "webnfc": require_webnfc(), "webp": require_webp(), "websockets": require_websockets(), "webusb": require_webusb(), "webvr": require_webvr(), "webvtt": require_webvtt(), "webworkers": require_webworkers(), "webxr": require_webxr(), "will-change": require_will_change(), "woff": require_woff(), "woff2": require_woff2(), "word-break": require_word_break(), "wordwrap": require_wordwrap(), "x-doc-messaging": require_x_doc_messaging(), "x-frame-options": require_x_frame_options(), "xhr2": require_xhr2(), "xhtml": require_xhtml(), "xhtmlsmil": require_xhtmlsmil(), "xml-serializer": require_xml_serializer() };
  }
});

// node_modules/caniuse-lite/dist/unpacker/features.js
var require_features2 = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/features.js"(exports2, module2) {
    module2.exports.features = require_features();
  }
});

// node_modules/caniuse-lite/dist/unpacker/index.js
var require_unpacker = __commonJS({
  "node_modules/caniuse-lite/dist/unpacker/index.js"(exports2, module2) {
    module2.exports.agents = require_agents2().agents;
    module2.exports.feature = require_feature();
    module2.exports.features = require_features2().features;
    module2.exports.region = require_region();
  }
});

// node_modules/autoprefixer/lib/utils.js
var require_utils = __commonJS({
  "node_modules/autoprefixer/lib/utils.js"(exports2, module2) {
    var { list } = require_postcss();
    module2.exports.error = function(text) {
      let err = new Error(text);
      err.autoprefixer = true;
      throw err;
    };
    module2.exports.uniq = function(array) {
      return [...new Set(array)];
    };
    module2.exports.removeNote = function(string) {
      if (!string.includes(" ")) {
        return string;
      }
      return string.split(" ")[0];
    };
    module2.exports.escapeRegexp = function(string) {
      return string.replace(/[$()*+-.?[\\\]^{|}]/g, "\\$&");
    };
    module2.exports.regexp = function(word, escape = true) {
      if (escape) {
        word = this.escapeRegexp(word);
      }
      return new RegExp(`(^|[\\s,(])(${word}($|[\\s(,]))`, "gi");
    };
    module2.exports.editList = function(value, callback) {
      let origin = list.comma(value);
      let changed = callback(origin, []);
      if (origin === changed) {
        return value;
      }
      let join = value.match(/,\s*/);
      join = join ? join[0] : ", ";
      return changed.join(join);
    };
    module2.exports.splitSelector = function(selector) {
      return list.comma(selector).map((i) => {
        return list.space(i).map((k) => {
          return k.split(/(?=\.|#)/g);
        });
      });
    };
    module2.exports.isPureNumber = function(value) {
      if (typeof value === "number") {
        return true;
      }
      if (typeof value === "string") {
        return /^[0-9]+$/.test(value);
      }
      return false;
    };
  }
});

// node_modules/autoprefixer/lib/browsers.js
var require_browsers3 = __commonJS({
  "node_modules/autoprefixer/lib/browsers.js"(exports2, module2) {
    var browserslist = require_browserslist();
    var agents = require_unpacker().agents;
    var utils = require_utils();
    var Browsers = class {
      static prefixes() {
        if (this.prefixesCache) {
          return this.prefixesCache;
        }
        this.prefixesCache = [];
        for (let name in agents) {
          this.prefixesCache.push(`-${agents[name].prefix}-`);
        }
        this.prefixesCache = utils.uniq(this.prefixesCache).sort((a, b) => b.length - a.length);
        return this.prefixesCache;
      }
      static withPrefix(value) {
        if (!this.prefixesRegexp) {
          this.prefixesRegexp = new RegExp(this.prefixes().join("|"));
        }
        return this.prefixesRegexp.test(value);
      }
      constructor(data, requirements, options, browserslistOpts) {
        this.data = data;
        this.options = options || {};
        this.browserslistOpts = browserslistOpts || {};
        this.selected = this.parse(requirements);
      }
      parse(requirements) {
        let opts = {};
        for (let i in this.browserslistOpts) {
          opts[i] = this.browserslistOpts[i];
        }
        opts.path = this.options.from;
        return browserslist(requirements, opts);
      }
      prefix(browser) {
        let [name, version] = browser.split(" ");
        let data = this.data[name];
        let prefix = data.prefix_exceptions && data.prefix_exceptions[version];
        if (!prefix) {
          prefix = data.prefix;
        }
        return `-${prefix}-`;
      }
      isSelected(browser) {
        return this.selected.includes(browser);
      }
    };
    module2.exports = Browsers;
  }
});

// node_modules/autoprefixer/lib/vendor.js
var require_vendor = __commonJS({
  "node_modules/autoprefixer/lib/vendor.js"(exports2, module2) {
    module2.exports = {
      prefix(prop) {
        let match = prop.match(/^(-\w+-)/);
        if (match) {
          return match[0];
        }
        return "";
      },
      unprefixed(prop) {
        return prop.replace(/^-\w+-/, "");
      }
    };
  }
});

// node_modules/autoprefixer/lib/prefixer.js
var require_prefixer = __commonJS({
  "node_modules/autoprefixer/lib/prefixer.js"(exports2, module2) {
    var Browsers = require_browsers3();
    var vendor = require_vendor();
    var utils = require_utils();
    function clone(obj, parent) {
      let cloned = new obj.constructor();
      for (let i of Object.keys(obj || {})) {
        let value = obj[i];
        if (i === "parent" && typeof value === "object") {
          if (parent) {
            cloned[i] = parent;
          }
        } else if (i === "source" || i === null) {
          cloned[i] = value;
        } else if (Array.isArray(value)) {
          cloned[i] = value.map((x) => clone(x, cloned));
        } else if (i !== "_autoprefixerPrefix" && i !== "_autoprefixerValues" && i !== "proxyCache") {
          if (typeof value === "object" && value !== null) {
            value = clone(value, cloned);
          }
          cloned[i] = value;
        }
      }
      return cloned;
    }
    var Prefixer = class {
      static hack(klass) {
        if (!this.hacks) {
          this.hacks = {};
        }
        return klass.names.map((name) => {
          this.hacks[name] = klass;
          return this.hacks[name];
        });
      }
      static load(name, prefixes, all) {
        let Klass = this.hacks && this.hacks[name];
        if (Klass) {
          return new Klass(name, prefixes, all);
        } else {
          return new this(name, prefixes, all);
        }
      }
      static clone(node, overrides) {
        let cloned = clone(node);
        for (let name in overrides) {
          cloned[name] = overrides[name];
        }
        return cloned;
      }
      constructor(name, prefixes, all) {
        this.prefixes = prefixes;
        this.name = name;
        this.all = all;
      }
      parentPrefix(node) {
        let prefix;
        if (typeof node._autoprefixerPrefix !== "undefined") {
          prefix = node._autoprefixerPrefix;
        } else if (node.type === "decl" && node.prop[0] === "-") {
          prefix = vendor.prefix(node.prop);
        } else if (node.type === "root") {
          prefix = false;
        } else if (node.type === "rule" && node.selector.includes(":-") && /:(-\w+-)/.test(node.selector)) {
          prefix = node.selector.match(/:(-\w+-)/)[1];
        } else if (node.type === "atrule" && node.name[0] === "-") {
          prefix = vendor.prefix(node.name);
        } else {
          prefix = this.parentPrefix(node.parent);
        }
        if (!Browsers.prefixes().includes(prefix)) {
          prefix = false;
        }
        node._autoprefixerPrefix = prefix;
        return node._autoprefixerPrefix;
      }
      process(node, result) {
        if (!this.check(node)) {
          return void 0;
        }
        let parent = this.parentPrefix(node);
        let prefixes = this.prefixes.filter((prefix) => !parent || parent === utils.removeNote(prefix));
        let added = [];
        for (let prefix of prefixes) {
          if (this.add(node, prefix, added.concat([prefix]), result)) {
            added.push(prefix);
          }
        }
        return added;
      }
      clone(node, overrides) {
        return Prefixer.clone(node, overrides);
      }
    };
    module2.exports = Prefixer;
  }
});

// node_modules/autoprefixer/lib/declaration.js
var require_declaration2 = __commonJS({
  "node_modules/autoprefixer/lib/declaration.js"(exports2, module2) {
    var Prefixer = require_prefixer();
    var Browsers = require_browsers3();
    var utils = require_utils();
    var Declaration = class extends Prefixer {
      check() {
        return true;
      }
      prefixed(prop, prefix) {
        return prefix + prop;
      }
      normalize(prop) {
        return prop;
      }
      otherPrefixes(value, prefix) {
        for (let other of Browsers.prefixes()) {
          if (other === prefix) {
            continue;
          }
          if (value.includes(other)) {
            return true;
          }
        }
        return false;
      }
      set(decl, prefix) {
        decl.prop = this.prefixed(decl.prop, prefix);
        return decl;
      }
      needCascade(decl) {
        if (!decl._autoprefixerCascade) {
          decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw("before").includes("\n");
        }
        return decl._autoprefixerCascade;
      }
      maxPrefixed(prefixes, decl) {
        if (decl._autoprefixerMax) {
          return decl._autoprefixerMax;
        }
        let max = 0;
        for (let prefix of prefixes) {
          prefix = utils.removeNote(prefix);
          if (prefix.length > max) {
            max = prefix.length;
          }
        }
        decl._autoprefixerMax = max;
        return decl._autoprefixerMax;
      }
      calcBefore(prefixes, decl, prefix = "") {
        let max = this.maxPrefixed(prefixes, decl);
        let diff = max - utils.removeNote(prefix).length;
        let before = decl.raw("before");
        if (diff > 0) {
          before += Array(diff).fill(" ").join("");
        }
        return before;
      }
      restoreBefore(decl) {
        let lines = decl.raw("before").split("\n");
        let min = lines[lines.length - 1];
        this.all.group(decl).up((prefixed) => {
          let array = prefixed.raw("before").split("\n");
          let last = array[array.length - 1];
          if (last.length < min.length) {
            min = last;
          }
        });
        lines[lines.length - 1] = min;
        decl.raws.before = lines.join("\n");
      }
      insert(decl, prefix, prefixes) {
        let cloned = this.set(this.clone(decl), prefix);
        if (!cloned)
          return void 0;
        let already = decl.parent.some((i) => i.prop === cloned.prop && i.value === cloned.value);
        if (already) {
          return void 0;
        }
        if (this.needCascade(decl)) {
          cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
        }
        return decl.parent.insertBefore(decl, cloned);
      }
      isAlready(decl, prefixed) {
        let already = this.all.group(decl).up((i) => i.prop === prefixed);
        if (!already) {
          already = this.all.group(decl).down((i) => i.prop === prefixed);
        }
        return already;
      }
      add(decl, prefix, prefixes, result) {
        let prefixed = this.prefixed(decl.prop, prefix);
        if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) {
          return void 0;
        }
        return this.insert(decl, prefix, prefixes, result);
      }
      process(decl, result) {
        if (!this.needCascade(decl)) {
          super.process(decl, result);
          return;
        }
        let prefixes = super.process(decl, result);
        if (!prefixes || !prefixes.length) {
          return;
        }
        this.restoreBefore(decl);
        decl.raws.before = this.calcBefore(prefixes, decl);
      }
      old(prop, prefix) {
        return [this.prefixed(prop, prefix)];
      }
    };
    module2.exports = Declaration;
  }
});

// node_modules/fraction.js/fraction.js
var require_fraction = __commonJS({
  "node_modules/fraction.js/fraction.js"(exports2, module2) {
    (function(root) {
      "use strict";
      var MAX_CYCLE_LEN = 2e3;
      var P = {
        "s": 1,
        "n": 0,
        "d": 1
      };
      function assign(n, s) {
        if (isNaN(n = parseInt(n, 10))) {
          throw Fraction["InvalidParameter"];
        }
        return n * s;
      }
      function newFraction(n, d) {
        if (d === 0) {
          throw Fraction["DivisionByZero"];
        }
        var f = Object.create(Fraction.prototype);
        f["s"] = n < 0 ? -1 : 1;
        n = n < 0 ? -n : n;
        var a = gcd(n, d);
        f["n"] = n / a;
        f["d"] = d / a;
        return f;
      }
      function factorize(num) {
        var factors = {};
        var n = num;
        var i = 2;
        var s = 4;
        while (s <= n) {
          while (n % i === 0) {
            n /= i;
            factors[i] = (factors[i] || 0) + 1;
          }
          s += 1 + 2 * i++;
        }
        if (n !== num) {
          if (n > 1)
            factors[n] = (factors[n] || 0) + 1;
        } else {
          factors[num] = (factors[num] || 0) + 1;
        }
        return factors;
      }
      var parse = function(p1, p2) {
        var n = 0, d = 1, s = 1;
        var v = 0, w = 0, x = 0, y = 1, z = 1;
        var A = 0, B = 1;
        var C = 1, D = 1;
        var N = 1e7;
        var M;
        if (p1 === void 0 || p1 === null) {
        } else if (p2 !== void 0) {
          n = p1;
          d = p2;
          s = n * d;
          if (n % 1 !== 0 || d % 1 !== 0) {
            throw Fraction["NonIntegerParameter"];
          }
        } else
          switch (typeof p1) {
            case "object": {
              if ("d" in p1 && "n" in p1) {
                n = p1["n"];
                d = p1["d"];
                if ("s" in p1)
                  n *= p1["s"];
              } else if (0 in p1) {
                n = p1[0];
                if (1 in p1)
                  d = p1[1];
              } else {
                throw Fraction["InvalidParameter"];
              }
              s = n * d;
              break;
            }
            case "number": {
              if (p1 < 0) {
                s = p1;
                p1 = -p1;
              }
              if (p1 % 1 === 0) {
                n = p1;
              } else if (p1 > 0) {
                if (p1 >= 1) {
                  z = Math.pow(10, Math.floor(1 + Math.log(p1) / Math.LN10));
                  p1 /= z;
                }
                while (B <= N && D <= N) {
                  M = (A + C) / (B + D);
                  if (p1 === M) {
                    if (B + D <= N) {
                      n = A + C;
                      d = B + D;
                    } else if (D > B) {
                      n = C;
                      d = D;
                    } else {
                      n = A;
                      d = B;
                    }
                    break;
                  } else {
                    if (p1 > M) {
                      A += C;
                      B += D;
                    } else {
                      C += A;
                      D += B;
                    }
                    if (B > N) {
                      n = C;
                      d = D;
                    } else {
                      n = A;
                      d = B;
                    }
                  }
                }
                n *= z;
              } else if (isNaN(p1) || isNaN(p2)) {
                d = n = NaN;
              }
              break;
            }
            case "string": {
              B = p1.match(/\d+|./g);
              if (B === null)
                throw Fraction["InvalidParameter"];
              if (B[A] === "-") {
                s = -1;
                A++;
              } else if (B[A] === "+") {
                A++;
              }
              if (B.length === A + 1) {
                w = assign(B[A++], s);
              } else if (B[A + 1] === "." || B[A] === ".") {
                if (B[A] !== ".") {
                  v = assign(B[A++], s);
                }
                A++;
                if (A + 1 === B.length || B[A + 1] === "(" && B[A + 3] === ")" || B[A + 1] === "'" && B[A + 3] === "'") {
                  w = assign(B[A], s);
                  y = Math.pow(10, B[A].length);
                  A++;
                }
                if (B[A] === "(" && B[A + 2] === ")" || B[A] === "'" && B[A + 2] === "'") {
                  x = assign(B[A + 1], s);
                  z = Math.pow(10, B[A + 1].length) - 1;
                  A += 3;
                }
              } else if (B[A + 1] === "/" || B[A + 1] === ":") {
                w = assign(B[A], s);
                y = assign(B[A + 2], 1);
                A += 3;
              } else if (B[A + 3] === "/" && B[A + 1] === " ") {
                v = assign(B[A], s);
                w = assign(B[A + 2], s);
                y = assign(B[A + 4], 1);
                A += 5;
              }
              if (B.length <= A) {
                d = y * z;
                s = n = x + d * v + z * w;
                break;
              }
            }
            default:
              throw Fraction["InvalidParameter"];
          }
        if (d === 0) {
          throw Fraction["DivisionByZero"];
        }
        P["s"] = s < 0 ? -1 : 1;
        P["n"] = Math.abs(n);
        P["d"] = Math.abs(d);
      };
      function modpow(b, e, m) {
        var r = 1;
        for (; e > 0; b = b * b % m, e >>= 1) {
          if (e & 1) {
            r = r * b % m;
          }
        }
        return r;
      }
      function cycleLen(n, d) {
        for (; d % 2 === 0; d /= 2) {
        }
        for (; d % 5 === 0; d /= 5) {
        }
        if (d === 1)
          return 0;
        var rem = 10 % d;
        var t = 1;
        for (; rem !== 1; t++) {
          rem = rem * 10 % d;
          if (t > MAX_CYCLE_LEN)
            return 0;
        }
        return t;
      }
      function cycleStart(n, d, len) {
        var rem1 = 1;
        var rem2 = modpow(10, len, d);
        for (var t = 0; t < 300; t++) {
          if (rem1 === rem2)
            return t;
          rem1 = rem1 * 10 % d;
          rem2 = rem2 * 10 % d;
        }
        return 0;
      }
      function gcd(a, b) {
        if (!a)
          return b;
        if (!b)
          return a;
        while (1) {
          a %= b;
          if (!a)
            return b;
          b %= a;
          if (!b)
            return a;
        }
      }
      ;
      function Fraction(a, b) {
        parse(a, b);
        if (this instanceof Fraction) {
          a = gcd(P["d"], P["n"]);
          this["s"] = P["s"];
          this["n"] = P["n"] / a;
          this["d"] = P["d"] / a;
        } else {
          return newFraction(P["s"] * P["n"], P["d"]);
        }
      }
      Fraction["DivisionByZero"] = new Error("Division by Zero");
      Fraction["InvalidParameter"] = new Error("Invalid argument");
      Fraction["NonIntegerParameter"] = new Error("Parameters must be integer");
      Fraction.prototype = {
        "s": 1,
        "n": 0,
        "d": 1,
        "abs": function() {
          return newFraction(this["n"], this["d"]);
        },
        "neg": function() {
          return newFraction(-this["s"] * this["n"], this["d"]);
        },
        "add": function(a, b) {
          parse(a, b);
          return newFraction(this["s"] * this["n"] * P["d"] + P["s"] * this["d"] * P["n"], this["d"] * P["d"]);
        },
        "sub": function(a, b) {
          parse(a, b);
          return newFraction(this["s"] * this["n"] * P["d"] - P["s"] * this["d"] * P["n"], this["d"] * P["d"]);
        },
        "mul": function(a, b) {
          parse(a, b);
          return newFraction(this["s"] * P["s"] * this["n"] * P["n"], this["d"] * P["d"]);
        },
        "div": function(a, b) {
          parse(a, b);
          return newFraction(this["s"] * P["s"] * this["n"] * P["d"], this["d"] * P["n"]);
        },
        "clone": function() {
          return newFraction(this["s"] * this["n"], this["d"]);
        },
        "mod": function(a, b) {
          if (isNaN(this["n"]) || isNaN(this["d"])) {
            return new Fraction(NaN);
          }
          if (a === void 0) {
            return newFraction(this["s"] * this["n"] % this["d"], 1);
          }
          parse(a, b);
          if (P["n"] === 0 && this["d"] === 0) {
            throw Fraction["DivisionByZero"];
          }
          return newFraction(this["s"] * (P["d"] * this["n"]) % (P["n"] * this["d"]), P["d"] * this["d"]);
        },
        "gcd": function(a, b) {
          parse(a, b);
          return newFraction(gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]), P["d"] * this["d"]);
        },
        "lcm": function(a, b) {
          parse(a, b);
          if (P["n"] === 0 && this["n"] === 0) {
            return newFraction(0, 1);
          }
          return newFraction(P["n"] * this["n"], gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]));
        },
        "ceil": function(places) {
          places = Math.pow(10, places || 0);
          if (isNaN(this["n"]) || isNaN(this["d"])) {
            return new Fraction(NaN);
          }
          return newFraction(Math.ceil(places * this["s"] * this["n"] / this["d"]), places);
        },
        "floor": function(places) {
          places = Math.pow(10, places || 0);
          if (isNaN(this["n"]) || isNaN(this["d"])) {
            return new Fraction(NaN);
          }
          return newFraction(Math.floor(places * this["s"] * this["n"] / this["d"]), places);
        },
        "round": function(places) {
          places = Math.pow(10, places || 0);
          if (isNaN(this["n"]) || isNaN(this["d"])) {
            return new Fraction(NaN);
          }
          return newFraction(Math.round(places * this["s"] * this["n"] / this["d"]), places);
        },
        "inverse": function() {
          return newFraction(this["s"] * this["d"], this["n"]);
        },
        "pow": function(a, b) {
          parse(a, b);
          if (P["d"] === 1) {
            if (P["s"] < 0) {
              return newFraction(Math.pow(this["s"] * this["d"], P["n"]), Math.pow(this["n"], P["n"]));
            } else {
              return newFraction(Math.pow(this["s"] * this["n"], P["n"]), Math.pow(this["d"], P["n"]));
            }
          }
          if (this["s"] < 0)
            return null;
          var N = factorize(this["n"]);
          var D = factorize(this["d"]);
          var n = 1;
          var d = 1;
          for (var k in N) {
            if (k === "1")
              continue;
            if (k === "0") {
              n = 0;
              break;
            }
            N[k] *= P["n"];
            if (N[k] % P["d"] === 0) {
              N[k] /= P["d"];
            } else
              return null;
            n *= Math.pow(k, N[k]);
          }
          for (var k in D) {
            if (k === "1")
              continue;
            D[k] *= P["n"];
            if (D[k] % P["d"] === 0) {
              D[k] /= P["d"];
            } else
              return null;
            d *= Math.pow(k, D[k]);
          }
          if (P["s"] < 0) {
            return newFraction(d, n);
          }
          return newFraction(n, d);
        },
        "equals": function(a, b) {
          parse(a, b);
          return this["s"] * this["n"] * P["d"] === P["s"] * P["n"] * this["d"];
        },
        "compare": function(a, b) {
          parse(a, b);
          var t = this["s"] * this["n"] * P["d"] - P["s"] * P["n"] * this["d"];
          return (0 < t) - (t < 0);
        },
        "simplify": function(eps) {
          if (isNaN(this["n"]) || isNaN(this["d"])) {
            return this;
          }
          eps = eps || 1e-3;
          var thisABS = this["abs"]();
          var cont = thisABS["toContinued"]();
          for (var i = 1; i < cont.length; i++) {
            var s = newFraction(cont[i - 1], 1);
            for (var k = i - 2; k >= 0; k--) {
              s = s["inverse"]()["add"](cont[k]);
            }
            if (s["sub"](thisABS)["abs"]().valueOf() < eps) {
              return s["mul"](this["s"]);
            }
          }
          return this;
        },
        "divisible": function(a, b) {
          parse(a, b);
          return !(!(P["n"] * this["d"]) || this["n"] * P["d"] % (P["n"] * this["d"]));
        },
        "valueOf": function() {
          return this["s"] * this["n"] / this["d"];
        },
        "toFraction": function(excludeWhole) {
          var whole, str = "";
          var n = this["n"];
          var d = this["d"];
          if (this["s"] < 0) {
            str += "-";
          }
          if (d === 1) {
            str += n;
          } else {
            if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
              str += whole;
              str += " ";
              n %= d;
            }
            str += n;
            str += "/";
            str += d;
          }
          return str;
        },
        "toLatex": function(excludeWhole) {
          var whole, str = "";
          var n = this["n"];
          var d = this["d"];
          if (this["s"] < 0) {
            str += "-";
          }
          if (d === 1) {
            str += n;
          } else {
            if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
              str += whole;
              n %= d;
            }
            str += "\\frac{";
            str += n;
            str += "}{";
            str += d;
            str += "}";
          }
          return str;
        },
        "toContinued": function() {
          var t;
          var a = this["n"];
          var b = this["d"];
          var res = [];
          if (isNaN(a) || isNaN(b)) {
            return res;
          }
          do {
            res.push(Math.floor(a / b));
            t = a % b;
            a = b;
            b = t;
          } while (a !== 1);
          return res;
        },
        "toString": function(dec) {
          var N = this["n"];
          var D = this["d"];
          if (isNaN(N) || isNaN(D)) {
            return "NaN";
          }
          dec = dec || 15;
          var cycLen = cycleLen(N, D);
          var cycOff = cycleStart(N, D, cycLen);
          var str = this["s"] < 0 ? "-" : "";
          str += N / D | 0;
          N %= D;
          N *= 10;
          if (N)
            str += ".";
          if (cycLen) {
            for (var i = cycOff; i--; ) {
              str += N / D | 0;
              N %= D;
              N *= 10;
            }
            str += "(";
            for (var i = cycLen; i--; ) {
              str += N / D | 0;
              N %= D;
              N *= 10;
            }
            str += ")";
          } else {
            for (var i = dec; N && i--; ) {
              str += N / D | 0;
              N %= D;
              N *= 10;
            }
          }
          return str;
        }
      };
      if (typeof define === "function" && define["amd"]) {
        define([], function() {
          return Fraction;
        });
      } else if (typeof exports2 === "object") {
        Object.defineProperty(Fraction, "__esModule", { "value": true });
        Fraction["default"] = Fraction;
        Fraction["Fraction"] = Fraction;
        module2["exports"] = Fraction;
      } else {
        root["Fraction"] = Fraction;
      }
    })(exports2);
  }
});

// node_modules/autoprefixer/lib/resolution.js
var require_resolution = __commonJS({
  "node_modules/autoprefixer/lib/resolution.js"(exports2, module2) {
    var FractionJs = require_fraction();
    var Prefixer = require_prefixer();
    var utils = require_utils();
    var REGEXP = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpcm|dpi|x)/gi;
    var SPLIT = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpcm|dpi|x)/i;
    var Resolution = class extends Prefixer {
      prefixName(prefix, name) {
        if (prefix === "-moz-") {
          return name + "--moz-device-pixel-ratio";
        } else {
          return prefix + name + "-device-pixel-ratio";
        }
      }
      prefixQuery(prefix, name, colon, value, units) {
        value = new FractionJs(value);
        if (units === "dpi") {
          value = value.div(96);
        } else if (units === "dpcm") {
          value = value.mul(2.54).div(96);
        }
        value = value.simplify();
        if (prefix === "-o-") {
          value = value.n + "/" + value.d;
        }
        return this.prefixName(prefix, name) + colon + value;
      }
      clean(rule) {
        if (!this.bad) {
          this.bad = [];
          for (let prefix of this.prefixes) {
            this.bad.push(this.prefixName(prefix, "min"));
            this.bad.push(this.prefixName(prefix, "max"));
          }
        }
        rule.params = utils.editList(rule.params, (queries) => {
          return queries.filter((query) => this.bad.every((i) => !query.includes(i)));
        });
      }
      process(rule) {
        let parent = this.parentPrefix(rule);
        let prefixes = parent ? [parent] : this.prefixes;
        rule.params = utils.editList(rule.params, (origin, prefixed) => {
          for (let query of origin) {
            if (!query.includes("min-resolution") && !query.includes("max-resolution")) {
              prefixed.push(query);
              continue;
            }
            for (let prefix of prefixes) {
              let processed = query.replace(REGEXP, (str) => {
                let parts = str.match(SPLIT);
                return this.prefixQuery(prefix, parts[1], parts[2], parts[3], parts[4]);
              });
              prefixed.push(processed);
            }
            prefixed.push(query);
          }
          return utils.uniq(prefixed);
        });
      }
    };
    module2.exports = Resolution;
  }
});

// node_modules/autoprefixer/lib/transition.js
var require_transition = __commonJS({
  "node_modules/autoprefixer/lib/transition.js"(exports2, module2) {
    var { list } = require_postcss();
    var parser = require_lib();
    var Browsers = require_browsers3();
    var vendor = require_vendor();
    var Transition = class {
      constructor(prefixes) {
        this.props = ["transition", "transition-property"];
        this.prefixes = prefixes;
      }
      add(decl, result) {
        let prefix, prop;
        let add = this.prefixes.add[decl.prop];
        let vendorPrefixes = this.ruleVendorPrefixes(decl);
        let declPrefixes = vendorPrefixes || add && add.prefixes || [];
        let params = this.parse(decl.value);
        let names = params.map((i) => this.findProp(i));
        let added = [];
        if (names.some((i) => i[0] === "-")) {
          return;
        }
        for (let param of params) {
          prop = this.findProp(param);
          if (prop[0] === "-")
            continue;
          let prefixer = this.prefixes.add[prop];
          if (!prefixer || !prefixer.prefixes)
            continue;
          for (prefix of prefixer.prefixes) {
            if (vendorPrefixes && !vendorPrefixes.some((p) => prefix.includes(p))) {
              continue;
            }
            let prefixed = this.prefixes.prefixed(prop, prefix);
            if (prefixed !== "-ms-transform" && !names.includes(prefixed)) {
              if (!this.disabled(prop, prefix)) {
                added.push(this.clone(prop, prefixed, param));
              }
            }
          }
        }
        params = params.concat(added);
        let value = this.stringify(params);
        let webkitClean = this.stringify(this.cleanFromUnprefixed(params, "-webkit-"));
        if (declPrefixes.includes("-webkit-")) {
          this.cloneBefore(decl, `-webkit-${decl.prop}`, webkitClean);
        }
        this.cloneBefore(decl, decl.prop, webkitClean);
        if (declPrefixes.includes("-o-")) {
          let operaClean = this.stringify(this.cleanFromUnprefixed(params, "-o-"));
          this.cloneBefore(decl, `-o-${decl.prop}`, operaClean);
        }
        for (prefix of declPrefixes) {
          if (prefix !== "-webkit-" && prefix !== "-o-") {
            let prefixValue = this.stringify(this.cleanOtherPrefixes(params, prefix));
            this.cloneBefore(decl, prefix + decl.prop, prefixValue);
          }
        }
        if (value !== decl.value && !this.already(decl, decl.prop, value)) {
          this.checkForWarning(result, decl);
          decl.cloneBefore();
          decl.value = value;
        }
      }
      findProp(param) {
        let prop = param[0].value;
        if (/^\d/.test(prop)) {
          for (let [i, token] of param.entries()) {
            if (i !== 0 && token.type === "word") {
              return token.value;
            }
          }
        }
        return prop;
      }
      already(decl, prop, value) {
        return decl.parent.some((i) => i.prop === prop && i.value === value);
      }
      cloneBefore(decl, prop, value) {
        if (!this.already(decl, prop, value)) {
          decl.cloneBefore({ prop, value });
        }
      }
      checkForWarning(result, decl) {
        if (decl.prop !== "transition-property") {
          return;
        }
        let isPrefixed = false;
        let hasAssociatedProp = false;
        decl.parent.each((i) => {
          if (i.type !== "decl") {
            return void 0;
          }
          if (i.prop.indexOf("transition-") !== 0) {
            return void 0;
          }
          let values = list.comma(i.value);
          if (i.prop === "transition-property") {
            values.forEach((value) => {
              let lookup = this.prefixes.add[value];
              if (lookup && lookup.prefixes && lookup.prefixes.length > 0) {
                isPrefixed = true;
              }
            });
            return void 0;
          }
          hasAssociatedProp = hasAssociatedProp || values.length > 1;
          return false;
        });
        if (isPrefixed && hasAssociatedProp) {
          decl.warn(result, "Replace transition-property to transition, because Autoprefixer could not support any cases of transition-property and other transition-*");
        }
      }
      remove(decl) {
        let params = this.parse(decl.value);
        params = params.filter((i) => {
          let prop = this.prefixes.remove[this.findProp(i)];
          return !prop || !prop.remove;
        });
        let value = this.stringify(params);
        if (decl.value === value) {
          return;
        }
        if (params.length === 0) {
          decl.remove();
          return;
        }
        let double = decl.parent.some((i) => {
          return i.prop === decl.prop && i.value === value;
        });
        let smaller = decl.parent.some((i) => {
          return i !== decl && i.prop === decl.prop && i.value.length > value.length;
        });
        if (double || smaller) {
          decl.remove();
          return;
        }
        decl.value = value;
      }
      parse(value) {
        let ast = parser(value);
        let result = [];
        let param = [];
        for (let node of ast.nodes) {
          param.push(node);
          if (node.type === "div" && node.value === ",") {
            result.push(param);
            param = [];
          }
        }
        result.push(param);
        return result.filter((i) => i.length > 0);
      }
      stringify(params) {
        if (params.length === 0) {
          return "";
        }
        let nodes = [];
        for (let param of params) {
          if (param[param.length - 1].type !== "div") {
            param.push(this.div(params));
          }
          nodes = nodes.concat(param);
        }
        if (nodes[0].type === "div") {
          nodes = nodes.slice(1);
        }
        if (nodes[nodes.length - 1].type === "div") {
          nodes = nodes.slice(0, -2 + 1 || void 0);
        }
        return parser.stringify({ nodes });
      }
      clone(origin, name, param) {
        let result = [];
        let changed = false;
        for (let i of param) {
          if (!changed && i.type === "word" && i.value === origin) {
            result.push({ type: "word", value: name });
            changed = true;
          } else {
            result.push(i);
          }
        }
        return result;
      }
      div(params) {
        for (let param of params) {
          for (let node of param) {
            if (node.type === "div" && node.value === ",") {
              return node;
            }
          }
        }
        return { type: "div", value: ",", after: " " };
      }
      cleanOtherPrefixes(params, prefix) {
        return params.filter((param) => {
          let current = vendor.prefix(this.findProp(param));
          return current === "" || current === prefix;
        });
      }
      cleanFromUnprefixed(params, prefix) {
        let remove = params.map((i) => this.findProp(i)).filter((i) => i.slice(0, prefix.length) === prefix).map((i) => this.prefixes.unprefixed(i));
        let result = [];
        for (let param of params) {
          let prop = this.findProp(param);
          let p = vendor.prefix(prop);
          if (!remove.includes(prop) && (p === prefix || p === "")) {
            result.push(param);
          }
        }
        return result;
      }
      disabled(prop, prefix) {
        let other = ["order", "justify-content", "align-self", "align-content"];
        if (prop.includes("flex") || other.includes(prop)) {
          if (this.prefixes.options.flexbox === false) {
            return true;
          }
          if (this.prefixes.options.flexbox === "no-2009") {
            return prefix.includes("2009");
          }
        }
        return void 0;
      }
      ruleVendorPrefixes(decl) {
        let { parent } = decl;
        if (parent.type !== "rule") {
          return false;
        } else if (!parent.selector.includes(":-")) {
          return false;
        }
        let selectors = Browsers.prefixes().filter((s) => parent.selector.includes(":" + s));
        return selectors.length > 0 ? selectors : false;
      }
    };
    module2.exports = Transition;
  }
});

// node_modules/autoprefixer/lib/old-value.js
var require_old_value = __commonJS({
  "node_modules/autoprefixer/lib/old-value.js"(exports2, module2) {
    var utils = require_utils();
    var OldValue = class {
      constructor(unprefixed, prefixed, string, regexp) {
        this.unprefixed = unprefixed;
        this.prefixed = prefixed;
        this.string = string || prefixed;
        this.regexp = regexp || utils.regexp(prefixed);
      }
      check(value) {
        if (value.includes(this.string)) {
          return !!value.match(this.regexp);
        }
        return false;
      }
    };
    module2.exports = OldValue;
  }
});

// node_modules/autoprefixer/lib/value.js
var require_value = __commonJS({
  "node_modules/autoprefixer/lib/value.js"(exports2, module2) {
    var Prefixer = require_prefixer();
    var OldValue = require_old_value();
    var vendor = require_vendor();
    var utils = require_utils();
    var Value = class extends Prefixer {
      static save(prefixes, decl) {
        let prop = decl.prop;
        let result = [];
        for (let prefix in decl._autoprefixerValues) {
          let value = decl._autoprefixerValues[prefix];
          if (value === decl.value) {
            continue;
          }
          let item;
          let propPrefix = vendor.prefix(prop);
          if (propPrefix === "-pie-") {
            continue;
          }
          if (propPrefix === prefix) {
            item = decl.value = value;
            result.push(item);
            continue;
          }
          let prefixed = prefixes.prefixed(prop, prefix);
          let rule = decl.parent;
          if (!rule.every((i) => i.prop !== prefixed)) {
            result.push(item);
            continue;
          }
          let trimmed = value.replace(/\s+/, " ");
          let already = rule.some((i) => i.prop === decl.prop && i.value.replace(/\s+/, " ") === trimmed);
          if (already) {
            result.push(item);
            continue;
          }
          let cloned = this.clone(decl, { value });
          item = decl.parent.insertBefore(decl, cloned);
          result.push(item);
        }
        return result;
      }
      check(decl) {
        let value = decl.value;
        if (!value.includes(this.name)) {
          return false;
        }
        return !!value.match(this.regexp());
      }
      regexp() {
        return this.regexpCache || (this.regexpCache = utils.regexp(this.name));
      }
      replace(string, prefix) {
        return string.replace(this.regexp(), `$1${prefix}$2`);
      }
      value(decl) {
        if (decl.raws.value && decl.raws.value.value === decl.value) {
          return decl.raws.value.raw;
        } else {
          return decl.value;
        }
      }
      add(decl, prefix) {
        if (!decl._autoprefixerValues) {
          decl._autoprefixerValues = {};
        }
        let value = decl._autoprefixerValues[prefix] || this.value(decl);
        let before;
        do {
          before = value;
          value = this.replace(value, prefix);
          if (value === false)
            return;
        } while (value !== before);
        decl._autoprefixerValues[prefix] = value;
      }
      old(prefix) {
        return new OldValue(this.name, prefix + this.name);
      }
    };
    module2.exports = Value;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-utils.js
var require_grid_utils = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-utils.js"(exports2) {
    var parser = require_lib();
    var list = require_postcss().list;
    var uniq = require_utils().uniq;
    var escapeRegexp = require_utils().escapeRegexp;
    var splitSelector = require_utils().splitSelector;
    function convert(value) {
      if (value && value.length === 2 && value[0] === "span" && parseInt(value[1], 10) > 0) {
        return [false, parseInt(value[1], 10)];
      }
      if (value && value.length === 1 && parseInt(value[0], 10) > 0) {
        return [parseInt(value[0], 10), false];
      }
      return [false, false];
    }
    exports2.translate = translate;
    function translate(values, startIndex, endIndex) {
      let startValue = values[startIndex];
      let endValue = values[endIndex];
      if (!startValue) {
        return [false, false];
      }
      let [start, spanStart] = convert(startValue);
      let [end, spanEnd] = convert(endValue);
      if (start && !endValue) {
        return [start, false];
      }
      if (spanStart && end) {
        return [end - spanStart, spanStart];
      }
      if (start && spanEnd) {
        return [start, spanEnd];
      }
      if (start && end) {
        return [start, end - start];
      }
      return [false, false];
    }
    exports2.parse = parse;
    function parse(decl) {
      let node = parser(decl.value);
      let values = [];
      let current = 0;
      values[current] = [];
      for (let i of node.nodes) {
        if (i.type === "div") {
          current += 1;
          values[current] = [];
        } else if (i.type === "word") {
          values[current].push(i.value);
        }
      }
      return values;
    }
    exports2.insertDecl = insertDecl;
    function insertDecl(decl, prop, value) {
      if (value && !decl.parent.some((i) => i.prop === `-ms-${prop}`)) {
        decl.cloneBefore({
          prop: `-ms-${prop}`,
          value: value.toString()
        });
      }
    }
    exports2.prefixTrackProp = prefixTrackProp;
    function prefixTrackProp({ prop, prefix }) {
      return prefix + prop.replace("template-", "");
    }
    function transformRepeat({ nodes }, { gap }) {
      let { count, size } = nodes.reduce((result, node) => {
        if (node.type === "div" && node.value === ",") {
          result.key = "size";
        } else {
          result[result.key].push(parser.stringify(node));
        }
        return result;
      }, {
        key: "count",
        size: [],
        count: []
      });
      if (gap) {
        size = size.filter((i) => i.trim());
        let val = [];
        for (let i = 1; i <= count; i++) {
          size.forEach((item, index) => {
            if (index > 0 || i > 1) {
              val.push(gap);
            }
            val.push(item);
          });
        }
        return val.join(" ");
      }
      return `(${size.join("")})[${count.join("")}]`;
    }
    exports2.prefixTrackValue = prefixTrackValue;
    function prefixTrackValue({ value, gap }) {
      let result = parser(value).nodes.reduce((nodes, node) => {
        if (node.type === "function" && node.value === "repeat") {
          return nodes.concat({
            type: "word",
            value: transformRepeat(node, { gap })
          });
        }
        if (gap && node.type === "space") {
          return nodes.concat({
            type: "space",
            value: " "
          }, {
            type: "word",
            value: gap
          }, node);
        }
        return nodes.concat(node);
      }, []);
      return parser.stringify(result);
    }
    var DOTS = /^\.+$/;
    function track(start, end) {
      return { start, end, span: end - start };
    }
    function getColumns(line) {
      return line.trim().split(/\s+/g);
    }
    exports2.parseGridAreas = parseGridAreas;
    function parseGridAreas({ rows, gap }) {
      return rows.reduce((areas, line, rowIndex) => {
        if (gap.row)
          rowIndex *= 2;
        if (line.trim() === "")
          return areas;
        getColumns(line).forEach((area, columnIndex) => {
          if (DOTS.test(area))
            return;
          if (gap.column)
            columnIndex *= 2;
          if (typeof areas[area] === "undefined") {
            areas[area] = {
              column: track(columnIndex + 1, columnIndex + 2),
              row: track(rowIndex + 1, rowIndex + 2)
            };
          } else {
            let { column, row } = areas[area];
            column.start = Math.min(column.start, columnIndex + 1);
            column.end = Math.max(column.end, columnIndex + 2);
            column.span = column.end - column.start;
            row.start = Math.min(row.start, rowIndex + 1);
            row.end = Math.max(row.end, rowIndex + 2);
            row.span = row.end - row.start;
          }
        });
        return areas;
      }, {});
    }
    function testTrack(node) {
      return node.type === "word" && /^\[.+]$/.test(node.value);
    }
    function verifyRowSize(result) {
      if (result.areas.length > result.rows.length) {
        result.rows.push("auto");
      }
      return result;
    }
    exports2.parseTemplate = parseTemplate;
    function parseTemplate({ decl, gap }) {
      let gridTemplate = parser(decl.value).nodes.reduce((result, node) => {
        let { type, value } = node;
        if (testTrack(node) || type === "space")
          return result;
        if (type === "string") {
          result = verifyRowSize(result);
          result.areas.push(value);
        }
        if (type === "word" || type === "function") {
          result[result.key].push(parser.stringify(node));
        }
        if (type === "div" && value === "/") {
          result.key = "columns";
          result = verifyRowSize(result);
        }
        return result;
      }, {
        key: "rows",
        columns: [],
        rows: [],
        areas: []
      });
      return {
        areas: parseGridAreas({
          rows: gridTemplate.areas,
          gap
        }),
        columns: prefixTrackValue({
          value: gridTemplate.columns.join(" "),
          gap: gap.column
        }),
        rows: prefixTrackValue({
          value: gridTemplate.rows.join(" "),
          gap: gap.row
        })
      };
    }
    function getMSDecls(area, addRowSpan = false, addColumnSpan = false) {
      let result = [
        {
          prop: "-ms-grid-row",
          value: String(area.row.start)
        }
      ];
      if (area.row.span > 1 || addRowSpan) {
        result.push({
          prop: "-ms-grid-row-span",
          value: String(area.row.span)
        });
      }
      result.push({
        prop: "-ms-grid-column",
        value: String(area.column.start)
      });
      if (area.column.span > 1 || addColumnSpan) {
        result.push({
          prop: "-ms-grid-column-span",
          value: String(area.column.span)
        });
      }
      return result;
    }
    function getParentMedia(parent) {
      if (parent.type === "atrule" && parent.name === "media") {
        return parent;
      }
      if (!parent.parent) {
        return false;
      }
      return getParentMedia(parent.parent);
    }
    function changeDuplicateAreaSelectors(ruleSelectors, templateSelectors) {
      ruleSelectors = ruleSelectors.map((selector) => {
        let selectorBySpace = list.space(selector);
        let selectorByComma = list.comma(selector);
        if (selectorBySpace.length > selectorByComma.length) {
          selector = selectorBySpace.slice(-1).join("");
        }
        return selector;
      });
      return ruleSelectors.map((ruleSelector) => {
        let newSelector = templateSelectors.map((tplSelector, index) => {
          let space = index === 0 ? "" : " ";
          return `${space}${tplSelector} > ${ruleSelector}`;
        });
        return newSelector;
      });
    }
    function selectorsEqual(ruleA, ruleB) {
      return ruleA.selectors.some((sel) => {
        return ruleB.selectors.includes(sel);
      });
    }
    function parseGridTemplatesData(css) {
      let parsed = [];
      css.walkDecls(/grid-template(-areas)?$/, (d) => {
        let rule = d.parent;
        let media = getParentMedia(rule);
        let gap = getGridGap(d);
        let inheritedGap = inheritGridGap(d, gap);
        let { areas } = parseTemplate({ decl: d, gap: inheritedGap || gap });
        let areaNames = Object.keys(areas);
        if (areaNames.length === 0) {
          return true;
        }
        let index = parsed.reduce((acc, { allAreas }, idx) => {
          let hasAreas = allAreas && areaNames.some((area) => allAreas.includes(area));
          return hasAreas ? idx : acc;
        }, null);
        if (index !== null) {
          let { allAreas, rules } = parsed[index];
          let hasNoDuplicates = rules.some((r) => {
            return r.hasDuplicates === false && selectorsEqual(r, rule);
          });
          let duplicatesFound = false;
          let duplicateAreaNames = rules.reduce((acc, r) => {
            if (!r.params && selectorsEqual(r, rule)) {
              duplicatesFound = true;
              return r.duplicateAreaNames;
            }
            if (!duplicatesFound) {
              areaNames.forEach((name) => {
                if (r.areas[name]) {
                  acc.push(name);
                }
              });
            }
            return uniq(acc);
          }, []);
          rules.forEach((r) => {
            areaNames.forEach((name) => {
              let area = r.areas[name];
              if (area && area.row.span !== areas[name].row.span) {
                areas[name].row.updateSpan = true;
              }
              if (area && area.column.span !== areas[name].column.span) {
                areas[name].column.updateSpan = true;
              }
            });
          });
          parsed[index].allAreas = uniq([...allAreas, ...areaNames]);
          parsed[index].rules.push({
            hasDuplicates: !hasNoDuplicates,
            params: media.params,
            selectors: rule.selectors,
            node: rule,
            duplicateAreaNames,
            areas
          });
        } else {
          parsed.push({
            allAreas: areaNames,
            areasCount: 0,
            rules: [
              {
                hasDuplicates: false,
                duplicateRules: [],
                params: media.params,
                selectors: rule.selectors,
                node: rule,
                duplicateAreaNames: [],
                areas
              }
            ]
          });
        }
        return void 0;
      });
      return parsed;
    }
    exports2.insertAreas = insertAreas;
    function insertAreas(css, isDisabled) {
      let gridTemplatesData = parseGridTemplatesData(css);
      if (gridTemplatesData.length === 0) {
        return void 0;
      }
      let rulesToInsert = {};
      css.walkDecls("grid-area", (gridArea) => {
        let gridAreaRule = gridArea.parent;
        let hasPrefixedRow = gridAreaRule.first.prop === "-ms-grid-row";
        let gridAreaMedia = getParentMedia(gridAreaRule);
        if (isDisabled(gridArea)) {
          return void 0;
        }
        let gridAreaRuleIndex = css.index(gridAreaMedia || gridAreaRule);
        let value = gridArea.value;
        let data = gridTemplatesData.filter((d) => d.allAreas.includes(value))[0];
        if (!data) {
          return true;
        }
        let lastArea = data.allAreas[data.allAreas.length - 1];
        let selectorBySpace = list.space(gridAreaRule.selector);
        let selectorByComma = list.comma(gridAreaRule.selector);
        let selectorIsComplex = selectorBySpace.length > 1 && selectorBySpace.length > selectorByComma.length;
        if (hasPrefixedRow) {
          return false;
        }
        if (!rulesToInsert[lastArea]) {
          rulesToInsert[lastArea] = {};
        }
        let lastRuleIsSet = false;
        for (let rule of data.rules) {
          let area = rule.areas[value];
          let hasDuplicateName = rule.duplicateAreaNames.includes(value);
          if (!area) {
            let lastRule = rulesToInsert[lastArea].lastRule;
            let lastRuleIndex;
            if (lastRule) {
              lastRuleIndex = css.index(lastRule);
            } else {
              lastRuleIndex = -1;
            }
            if (gridAreaRuleIndex > lastRuleIndex) {
              rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule;
            }
            continue;
          }
          if (rule.params && !rulesToInsert[lastArea][rule.params]) {
            rulesToInsert[lastArea][rule.params] = [];
          }
          if ((!rule.hasDuplicates || !hasDuplicateName) && !rule.params) {
            getMSDecls(area, false, false).reverse().forEach((i) => gridAreaRule.prepend(Object.assign(i, {
              raws: {
                between: gridArea.raws.between
              }
            })));
            rulesToInsert[lastArea].lastRule = gridAreaRule;
            lastRuleIsSet = true;
          } else if (rule.hasDuplicates && !rule.params && !selectorIsComplex) {
            let cloned = gridAreaRule.clone();
            cloned.removeAll();
            getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach((i) => cloned.prepend(Object.assign(i, {
              raws: {
                between: gridArea.raws.between
              }
            })));
            cloned.selectors = changeDuplicateAreaSelectors(cloned.selectors, rule.selectors);
            if (rulesToInsert[lastArea].lastRule) {
              rulesToInsert[lastArea].lastRule.after(cloned);
            }
            rulesToInsert[lastArea].lastRule = cloned;
            lastRuleIsSet = true;
          } else if (rule.hasDuplicates && !rule.params && selectorIsComplex && gridAreaRule.selector.includes(rule.selectors[0])) {
            gridAreaRule.walkDecls(/-ms-grid-(row|column)/, (d) => d.remove());
            getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach((i) => gridAreaRule.prepend(Object.assign(i, {
              raws: {
                between: gridArea.raws.between
              }
            })));
          } else if (rule.params) {
            let cloned = gridAreaRule.clone();
            cloned.removeAll();
            getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach((i) => cloned.prepend(Object.assign(i, {
              raws: {
                between: gridArea.raws.between
              }
            })));
            if (rule.hasDuplicates && hasDuplicateName) {
              cloned.selectors = changeDuplicateAreaSelectors(cloned.selectors, rule.selectors);
            }
            cloned.raws = rule.node.raws;
            if (css.index(rule.node.parent) > gridAreaRuleIndex) {
              rule.node.parent.append(cloned);
            } else {
              rulesToInsert[lastArea][rule.params].push(cloned);
            }
            if (!lastRuleIsSet) {
              rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule;
            }
          }
        }
        return void 0;
      });
      Object.keys(rulesToInsert).forEach((area) => {
        let data = rulesToInsert[area];
        let lastRule = data.lastRule;
        Object.keys(data).reverse().filter((p) => p !== "lastRule").forEach((params) => {
          if (data[params].length > 0 && lastRule) {
            lastRule.after({ name: "media", params });
            lastRule.next().append(data[params]);
          }
        });
      });
      return void 0;
    }
    exports2.warnMissedAreas = warnMissedAreas;
    function warnMissedAreas(areas, decl, result) {
      let missed = Object.keys(areas);
      decl.root().walkDecls("grid-area", (gridArea) => {
        missed = missed.filter((e) => e !== gridArea.value);
      });
      if (missed.length > 0) {
        decl.warn(result, "Can not find grid areas: " + missed.join(", "));
      }
      return void 0;
    }
    exports2.warnTemplateSelectorNotFound = warnTemplateSelectorNotFound;
    function warnTemplateSelectorNotFound(decl, result) {
      let rule = decl.parent;
      let root = decl.root();
      let duplicatesFound = false;
      let slicedSelectorArr = list.space(rule.selector).filter((str) => str !== ">").slice(0, -1);
      if (slicedSelectorArr.length > 0) {
        let gridTemplateFound = false;
        let foundAreaSelector = null;
        root.walkDecls(/grid-template(-areas)?$/, (d) => {
          let parent = d.parent;
          let templateSelectors = parent.selectors;
          let { areas } = parseTemplate({ decl: d, gap: getGridGap(d) });
          let hasArea = areas[decl.value];
          for (let tplSelector of templateSelectors) {
            if (gridTemplateFound) {
              break;
            }
            let tplSelectorArr = list.space(tplSelector).filter((str) => str !== ">");
            gridTemplateFound = tplSelectorArr.every((item, idx) => item === slicedSelectorArr[idx]);
          }
          if (gridTemplateFound || !hasArea) {
            return true;
          }
          if (!foundAreaSelector) {
            foundAreaSelector = parent.selector;
          }
          if (foundAreaSelector && foundAreaSelector !== parent.selector) {
            duplicatesFound = true;
          }
          return void 0;
        });
        if (!gridTemplateFound && duplicatesFound) {
          decl.warn(result, `Autoprefixer cannot find a grid-template containing the duplicate grid-area "${decl.value}" with full selector matching: ${slicedSelectorArr.join(" ")}`);
        }
      }
    }
    exports2.warnIfGridRowColumnExists = warnIfGridRowColumnExists;
    function warnIfGridRowColumnExists(decl, result) {
      let rule = decl.parent;
      let decls = [];
      rule.walkDecls(/^grid-(row|column)/, (d) => {
        if (!d.prop.endsWith("-end") && !d.value.startsWith("span") && !d.prop.endsWith("-gap")) {
          decls.push(d);
        }
      });
      if (decls.length > 0) {
        decls.forEach((d) => {
          d.warn(result, `You already have a grid-area declaration present in the rule. You should use either grid-area or ${d.prop}, not both`);
        });
      }
      return void 0;
    }
    exports2.getGridGap = getGridGap;
    function getGridGap(decl) {
      let gap = {};
      let testGap = /^(grid-)?((row|column)-)?gap$/;
      decl.parent.walkDecls(testGap, ({ prop, value }) => {
        if (/^(grid-)?gap$/.test(prop)) {
          let [row, , column] = parser(value).nodes;
          gap.row = row && parser.stringify(row);
          gap.column = column ? parser.stringify(column) : gap.row;
        }
        if (/^(grid-)?row-gap$/.test(prop))
          gap.row = value;
        if (/^(grid-)?column-gap$/.test(prop))
          gap.column = value;
      });
      return gap;
    }
    function parseMediaParams(params) {
      if (!params) {
        return [];
      }
      let parsed = parser(params);
      let prop;
      let value;
      parsed.walk((node) => {
        if (node.type === "word" && /min|max/g.test(node.value)) {
          prop = node.value;
        } else if (node.value.includes("px")) {
          value = parseInt(node.value.replace(/\D/g, ""));
        }
      });
      return [prop, value];
    }
    function shouldInheritGap(selA, selB) {
      let result;
      let splitSelectorArrA = splitSelector(selA);
      let splitSelectorArrB = splitSelector(selB);
      if (splitSelectorArrA[0].length < splitSelectorArrB[0].length) {
        return false;
      } else if (splitSelectorArrA[0].length > splitSelectorArrB[0].length) {
        let idx = splitSelectorArrA[0].reduce((res, [item], index) => {
          let firstSelectorPart = splitSelectorArrB[0][0][0];
          if (item === firstSelectorPart) {
            return index;
          }
          return false;
        }, false);
        if (idx) {
          result = splitSelectorArrB[0].every((arr, index) => {
            return arr.every((part, innerIndex) => splitSelectorArrA[0].slice(idx)[index][innerIndex] === part);
          });
        }
      } else {
        result = splitSelectorArrB.some((byCommaArr) => {
          return byCommaArr.every((bySpaceArr, index) => {
            return bySpaceArr.every((part, innerIndex) => splitSelectorArrA[0][index][innerIndex] === part);
          });
        });
      }
      return result;
    }
    exports2.inheritGridGap = inheritGridGap;
    function inheritGridGap(decl, gap) {
      let rule = decl.parent;
      let mediaRule = getParentMedia(rule);
      let root = rule.root();
      let splitSelectorArr = splitSelector(rule.selector);
      if (Object.keys(gap).length > 0) {
        return false;
      }
      let [prop] = parseMediaParams(mediaRule.params);
      let lastBySpace = splitSelectorArr[0];
      let escaped = escapeRegexp(lastBySpace[lastBySpace.length - 1][0]);
      let regexp = new RegExp(`(${escaped}$)|(${escaped}[,.])`);
      let closestRuleGap;
      root.walkRules(regexp, (r) => {
        let gridGap;
        if (rule.toString() === r.toString()) {
          return false;
        }
        r.walkDecls("grid-gap", (d) => gridGap = getGridGap(d));
        if (!gridGap || Object.keys(gridGap).length === 0) {
          return true;
        }
        if (!shouldInheritGap(rule.selector, r.selector)) {
          return true;
        }
        let media = getParentMedia(r);
        if (media) {
          let propToCompare = parseMediaParams(media.params)[0];
          if (propToCompare === prop) {
            closestRuleGap = gridGap;
            return true;
          }
        } else {
          closestRuleGap = gridGap;
          return true;
        }
        return void 0;
      });
      if (closestRuleGap && Object.keys(closestRuleGap).length > 0) {
        return closestRuleGap;
      }
      return false;
    }
    exports2.warnGridGap = warnGridGap;
    function warnGridGap({ gap, hasColumns, decl, result }) {
      let hasBothGaps = gap.row && gap.column;
      if (!hasColumns && (hasBothGaps || gap.column && !gap.row)) {
        delete gap.column;
        decl.warn(result, "Can not implement grid-gap without grid-template-columns");
      }
    }
    function normalizeRowColumn(str) {
      let normalized = parser(str).nodes.reduce((result, node) => {
        if (node.type === "function" && node.value === "repeat") {
          let key = "count";
          let [count, value] = node.nodes.reduce((acc, n) => {
            if (n.type === "word" && key === "count") {
              acc[0] = Math.abs(parseInt(n.value));
              return acc;
            }
            if (n.type === "div" && n.value === ",") {
              key = "value";
              return acc;
            }
            if (key === "value") {
              acc[1] += parser.stringify(n);
            }
            return acc;
          }, [0, ""]);
          if (count) {
            for (let i = 0; i < count; i++) {
              result.push(value);
            }
          }
          return result;
        }
        if (node.type === "space") {
          return result;
        }
        return result.concat(parser.stringify(node));
      }, []);
      return normalized;
    }
    exports2.autoplaceGridItems = autoplaceGridItems;
    function autoplaceGridItems(decl, result, gap, autoflowValue = "row") {
      let { parent } = decl;
      let rowDecl = parent.nodes.find((i) => i.prop === "grid-template-rows");
      let rows = normalizeRowColumn(rowDecl.value);
      let columns = normalizeRowColumn(decl.value);
      let filledRows = rows.map((_, rowIndex) => {
        return Array.from({ length: columns.length }, (v, k) => k + rowIndex * columns.length + 1).join(" ");
      });
      let areas = parseGridAreas({ rows: filledRows, gap });
      let keys = Object.keys(areas);
      let items = keys.map((i) => areas[i]);
      if (autoflowValue.includes("column")) {
        items = items.sort((a, b) => a.column.start - b.column.start);
      }
      items.reverse().forEach((item, index) => {
        let { column, row } = item;
        let nodeSelector = parent.selectors.map((sel) => sel + ` > *:nth-child(${keys.length - index})`).join(", ");
        let node = parent.clone().removeAll();
        node.selector = nodeSelector;
        node.append({ prop: "-ms-grid-row", value: row.start });
        node.append({ prop: "-ms-grid-column", value: column.start });
        parent.after(node);
      });
      return void 0;
    }
  }
});

// node_modules/autoprefixer/lib/processor.js
var require_processor2 = __commonJS({
  "node_modules/autoprefixer/lib/processor.js"(exports2, module2) {
    var parser = require_lib();
    var Value = require_value();
    var insertAreas = require_grid_utils().insertAreas;
    var OLD_LINEAR = /(^|[^-])linear-gradient\(\s*(top|left|right|bottom)/i;
    var OLD_RADIAL = /(^|[^-])radial-gradient\(\s*\d+(\w*|%)\s+\d+(\w*|%)\s*,/i;
    var IGNORE_NEXT = /(!\s*)?autoprefixer:\s*ignore\s+next/i;
    var GRID_REGEX = /(!\s*)?autoprefixer\s*grid:\s*(on|off|(no-)?autoplace)/i;
    var SIZES = [
      "width",
      "height",
      "min-width",
      "max-width",
      "min-height",
      "max-height",
      "inline-size",
      "min-inline-size",
      "max-inline-size",
      "block-size",
      "min-block-size",
      "max-block-size"
    ];
    function hasGridTemplate(decl) {
      return decl.parent.some((i) => i.prop === "grid-template" || i.prop === "grid-template-areas");
    }
    function hasRowsAndColumns(decl) {
      let hasRows = decl.parent.some((i) => i.prop === "grid-template-rows");
      let hasColumns = decl.parent.some((i) => i.prop === "grid-template-columns");
      return hasRows && hasColumns;
    }
    var Processor = class {
      constructor(prefixes) {
        this.prefixes = prefixes;
      }
      add(css, result) {
        let resolution = this.prefixes.add["@resolution"];
        let keyframes = this.prefixes.add["@keyframes"];
        let viewport = this.prefixes.add["@viewport"];
        let supports = this.prefixes.add["@supports"];
        css.walkAtRules((rule) => {
          if (rule.name === "keyframes") {
            if (!this.disabled(rule, result)) {
              return keyframes && keyframes.process(rule);
            }
          } else if (rule.name === "viewport") {
            if (!this.disabled(rule, result)) {
              return viewport && viewport.process(rule);
            }
          } else if (rule.name === "supports") {
            if (this.prefixes.options.supports !== false && !this.disabled(rule, result)) {
              return supports.process(rule);
            }
          } else if (rule.name === "media" && rule.params.includes("-resolution")) {
            if (!this.disabled(rule, result)) {
              return resolution && resolution.process(rule);
            }
          }
          return void 0;
        });
        css.walkRules((rule) => {
          if (this.disabled(rule, result))
            return void 0;
          return this.prefixes.add.selectors.map((selector) => {
            return selector.process(rule, result);
          });
        });
        function insideGrid(decl) {
          return decl.parent.nodes.some((node) => {
            if (node.type !== "decl")
              return false;
            let displayGrid = node.prop === "display" && /(inline-)?grid/.test(node.value);
            let gridTemplate = node.prop.startsWith("grid-template");
            let gridGap = /^grid-([A-z]+-)?gap/.test(node.prop);
            return displayGrid || gridTemplate || gridGap;
          });
        }
        function insideFlex(decl) {
          return decl.parent.some((node) => {
            return node.prop === "display" && /(inline-)?flex/.test(node.value);
          });
        }
        let gridPrefixes = this.gridStatus(css, result) && this.prefixes.add["grid-area"] && this.prefixes.add["grid-area"].prefixes;
        css.walkDecls((decl) => {
          if (this.disabledDecl(decl, result))
            return void 0;
          let parent = decl.parent;
          let prop = decl.prop;
          let value = decl.value;
          if (prop === "color-adjust") {
            result.warn("Replace color-adjust to print-color-adjust. The color-adjust shorthand is currently deprecated.", { node: decl });
          } else if (prop === "grid-row-span") {
            result.warn("grid-row-span is not part of final Grid Layout. Use grid-row.", { node: decl });
            return void 0;
          } else if (prop === "grid-column-span") {
            result.warn("grid-column-span is not part of final Grid Layout. Use grid-column.", { node: decl });
            return void 0;
          } else if (prop === "display" && value === "box") {
            result.warn("You should write display: flex by final spec instead of display: box", { node: decl });
            return void 0;
          } else if (prop === "text-emphasis-position") {
            if (value === "under" || value === "over") {
              result.warn("You should use 2 values for text-emphasis-position For example, `under left` instead of just `under`.", { node: decl });
            }
          } else if (/^(align|justify|place)-(items|content)$/.test(prop) && insideFlex(decl)) {
            if (value === "start" || value === "end") {
              result.warn(`${value} value has mixed support, consider using flex-${value} instead`, { node: decl });
            }
          } else if (prop === "text-decoration-skip" && value === "ink") {
            result.warn("Replace text-decoration-skip: ink to text-decoration-skip-ink: auto, because spec had been changed", { node: decl });
          } else {
            if (gridPrefixes && this.gridStatus(decl, result)) {
              if (decl.value === "subgrid") {
                result.warn("IE does not support subgrid", { node: decl });
              }
              if (/^(align|justify|place)-items$/.test(prop) && insideGrid(decl)) {
                let fixed = prop.replace("-items", "-self");
                result.warn(`IE does not support ${prop} on grid containers. Try using ${fixed} on child elements instead: ${decl.parent.selector} > * { ${fixed}: ${decl.value} }`, { node: decl });
              } else if (/^(align|justify|place)-content$/.test(prop) && insideGrid(decl)) {
                result.warn(`IE does not support ${decl.prop} on grid containers`, {
                  node: decl
                });
              } else if (prop === "display" && decl.value === "contents") {
                result.warn("Please do not use display: contents; if you have grid setting enabled", { node: decl });
                return void 0;
              } else if (decl.prop === "grid-gap") {
                let status = this.gridStatus(decl, result);
                if (status === "autoplace" && !hasRowsAndColumns(decl) && !hasGridTemplate(decl)) {
                  result.warn("grid-gap only works if grid-template(-areas) is being used or both rows and columns have been declared and cells have not been manually placed inside the explicit grid", { node: decl });
                } else if ((status === true || status === "no-autoplace") && !hasGridTemplate(decl)) {
                  result.warn("grid-gap only works if grid-template(-areas) is being used", { node: decl });
                }
              } else if (prop === "grid-auto-columns") {
                result.warn("grid-auto-columns is not supported by IE", {
                  node: decl
                });
                return void 0;
              } else if (prop === "grid-auto-rows") {
                result.warn("grid-auto-rows is not supported by IE", { node: decl });
                return void 0;
              } else if (prop === "grid-auto-flow") {
                let hasRows = parent.some((i) => i.prop === "grid-template-rows");
                let hasCols = parent.some((i) => i.prop === "grid-template-columns");
                if (hasGridTemplate(decl)) {
                  result.warn("grid-auto-flow is not supported by IE", {
                    node: decl
                  });
                } else if (value.includes("dense")) {
                  result.warn("grid-auto-flow: dense is not supported by IE", {
                    node: decl
                  });
                } else if (!hasRows && !hasCols) {
                  result.warn("grid-auto-flow works only if grid-template-rows and grid-template-columns are present in the same rule", { node: decl });
                }
                return void 0;
              } else if (value.includes("auto-fit")) {
                result.warn("auto-fit value is not supported by IE", {
                  node: decl,
                  word: "auto-fit"
                });
                return void 0;
              } else if (value.includes("auto-fill")) {
                result.warn("auto-fill value is not supported by IE", {
                  node: decl,
                  word: "auto-fill"
                });
                return void 0;
              } else if (prop.startsWith("grid-template") && value.includes("[")) {
                result.warn("Autoprefixer currently does not support line names. Try using grid-template-areas instead.", { node: decl, word: "[" });
              }
            }
            if (value.includes("radial-gradient")) {
              if (OLD_RADIAL.test(decl.value)) {
                result.warn("Gradient has outdated direction syntax. New syntax is like `closest-side at 0 0` instead of `0 0, closest-side`.", { node: decl });
              } else {
                let ast = parser(value);
                for (let i of ast.nodes) {
                  if (i.type === "function" && i.value === "radial-gradient") {
                    for (let word of i.nodes) {
                      if (word.type === "word") {
                        if (word.value === "cover") {
                          result.warn("Gradient has outdated direction syntax. Replace `cover` to `farthest-corner`.", { node: decl });
                        } else if (word.value === "contain") {
                          result.warn("Gradient has outdated direction syntax. Replace `contain` to `closest-side`.", { node: decl });
                        }
                      }
                    }
                  }
                }
              }
            }
            if (value.includes("linear-gradient")) {
              if (OLD_LINEAR.test(value)) {
                result.warn("Gradient has outdated direction syntax. New syntax is like `to left` instead of `right`.", { node: decl });
              }
            }
          }
          if (SIZES.includes(decl.prop)) {
            if (!decl.value.includes("-fill-available")) {
              if (decl.value.includes("fill-available")) {
                result.warn("Replace fill-available to stretch, because spec had been changed", { node: decl });
              } else if (decl.value.includes("fill")) {
                let ast = parser(value);
                if (ast.nodes.some((i) => i.type === "word" && i.value === "fill")) {
                  result.warn("Replace fill to stretch, because spec had been changed", { node: decl });
                }
              }
            }
          }
          let prefixer;
          if (decl.prop === "transition" || decl.prop === "transition-property") {
            return this.prefixes.transition.add(decl, result);
          } else if (decl.prop === "align-self") {
            let display = this.displayType(decl);
            if (display !== "grid" && this.prefixes.options.flexbox !== false) {
              prefixer = this.prefixes.add["align-self"];
              if (prefixer && prefixer.prefixes) {
                prefixer.process(decl);
              }
            }
            if (this.gridStatus(decl, result) !== false) {
              prefixer = this.prefixes.add["grid-row-align"];
              if (prefixer && prefixer.prefixes) {
                return prefixer.process(decl, result);
              }
            }
          } else if (decl.prop === "justify-self") {
            if (this.gridStatus(decl, result) !== false) {
              prefixer = this.prefixes.add["grid-column-align"];
              if (prefixer && prefixer.prefixes) {
                return prefixer.process(decl, result);
              }
            }
          } else if (decl.prop === "place-self") {
            prefixer = this.prefixes.add["place-self"];
            if (prefixer && prefixer.prefixes && this.gridStatus(decl, result) !== false) {
              return prefixer.process(decl, result);
            }
          } else {
            prefixer = this.prefixes.add[decl.prop];
            if (prefixer && prefixer.prefixes) {
              return prefixer.process(decl, result);
            }
          }
          return void 0;
        });
        if (this.gridStatus(css, result)) {
          insertAreas(css, this.disabled);
        }
        return css.walkDecls((decl) => {
          if (this.disabledValue(decl, result))
            return;
          let unprefixed = this.prefixes.unprefixed(decl.prop);
          let list = this.prefixes.values("add", unprefixed);
          if (Array.isArray(list)) {
            for (let value of list) {
              if (value.process)
                value.process(decl, result);
            }
          }
          Value.save(this.prefixes, decl);
        });
      }
      remove(css, result) {
        let resolution = this.prefixes.remove["@resolution"];
        css.walkAtRules((rule, i) => {
          if (this.prefixes.remove[`@${rule.name}`]) {
            if (!this.disabled(rule, result)) {
              rule.parent.removeChild(i);
            }
          } else if (rule.name === "media" && rule.params.includes("-resolution") && resolution) {
            resolution.clean(rule);
          }
        });
        for (let checker of this.prefixes.remove.selectors) {
          css.walkRules((rule, i) => {
            if (checker.check(rule)) {
              if (!this.disabled(rule, result)) {
                rule.parent.removeChild(i);
              }
            }
          });
        }
        return css.walkDecls((decl, i) => {
          if (this.disabled(decl, result))
            return;
          let rule = decl.parent;
          let unprefixed = this.prefixes.unprefixed(decl.prop);
          if (decl.prop === "transition" || decl.prop === "transition-property") {
            this.prefixes.transition.remove(decl);
          }
          if (this.prefixes.remove[decl.prop] && this.prefixes.remove[decl.prop].remove) {
            let notHack = this.prefixes.group(decl).down((other) => {
              return this.prefixes.normalize(other.prop) === unprefixed;
            });
            if (unprefixed === "flex-flow") {
              notHack = true;
            }
            if (decl.prop === "-webkit-box-orient") {
              let hacks = { "flex-direction": true, "flex-flow": true };
              if (!decl.parent.some((j) => hacks[j.prop]))
                return;
            }
            if (notHack && !this.withHackValue(decl)) {
              if (decl.raw("before").includes("\n")) {
                this.reduceSpaces(decl);
              }
              rule.removeChild(i);
              return;
            }
          }
          for (let checker of this.prefixes.values("remove", unprefixed)) {
            if (!checker.check)
              continue;
            if (!checker.check(decl.value))
              continue;
            unprefixed = checker.unprefixed;
            let notHack = this.prefixes.group(decl).down((other) => {
              return other.value.includes(unprefixed);
            });
            if (notHack) {
              rule.removeChild(i);
              return;
            }
          }
        });
      }
      withHackValue(decl) {
        return decl.prop === "-webkit-background-clip" && decl.value === "text";
      }
      disabledValue(node, result) {
        if (this.gridStatus(node, result) === false && node.type === "decl") {
          if (node.prop === "display" && node.value.includes("grid")) {
            return true;
          }
        }
        if (this.prefixes.options.flexbox === false && node.type === "decl") {
          if (node.prop === "display" && node.value.includes("flex")) {
            return true;
          }
        }
        if (node.type === "decl" && node.prop === "content") {
          return true;
        }
        return this.disabled(node, result);
      }
      disabledDecl(node, result) {
        if (this.gridStatus(node, result) === false && node.type === "decl") {
          if (node.prop.includes("grid") || node.prop === "justify-items") {
            return true;
          }
        }
        if (this.prefixes.options.flexbox === false && node.type === "decl") {
          let other = ["order", "justify-content", "align-items", "align-content"];
          if (node.prop.includes("flex") || other.includes(node.prop)) {
            return true;
          }
        }
        return this.disabled(node, result);
      }
      disabled(node, result) {
        if (!node)
          return false;
        if (node._autoprefixerDisabled !== void 0) {
          return node._autoprefixerDisabled;
        }
        if (node.parent) {
          let p = node.prev();
          if (p && p.type === "comment" && IGNORE_NEXT.test(p.text)) {
            node._autoprefixerDisabled = true;
            node._autoprefixerSelfDisabled = true;
            return true;
          }
        }
        let value = null;
        if (node.nodes) {
          let status;
          node.each((i) => {
            if (i.type !== "comment")
              return;
            if (/(!\s*)?autoprefixer:\s*(off|on)/i.test(i.text)) {
              if (typeof status !== "undefined") {
                result.warn("Second Autoprefixer control comment was ignored. Autoprefixer applies control comment to whole block, not to next rules.", { node: i });
              } else {
                status = /on/i.test(i.text);
              }
            }
          });
          if (status !== void 0) {
            value = !status;
          }
        }
        if (!node.nodes || value === null) {
          if (node.parent) {
            let isParentDisabled = this.disabled(node.parent, result);
            if (node.parent._autoprefixerSelfDisabled === true) {
              value = false;
            } else {
              value = isParentDisabled;
            }
          } else {
            value = false;
          }
        }
        node._autoprefixerDisabled = value;
        return value;
      }
      reduceSpaces(decl) {
        let stop = false;
        this.prefixes.group(decl).up(() => {
          stop = true;
          return true;
        });
        if (stop) {
          return;
        }
        let parts = decl.raw("before").split("\n");
        let prevMin = parts[parts.length - 1].length;
        let diff = false;
        this.prefixes.group(decl).down((other) => {
          parts = other.raw("before").split("\n");
          let last = parts.length - 1;
          if (parts[last].length > prevMin) {
            if (diff === false) {
              diff = parts[last].length - prevMin;
            }
            parts[last] = parts[last].slice(0, -diff);
            other.raws.before = parts.join("\n");
          }
        });
      }
      displayType(decl) {
        for (let i of decl.parent.nodes) {
          if (i.prop !== "display") {
            continue;
          }
          if (i.value.includes("flex")) {
            return "flex";
          }
          if (i.value.includes("grid")) {
            return "grid";
          }
        }
        return false;
      }
      gridStatus(node, result) {
        if (!node)
          return false;
        if (node._autoprefixerGridStatus !== void 0) {
          return node._autoprefixerGridStatus;
        }
        let value = null;
        if (node.nodes) {
          let status;
          node.each((i) => {
            if (i.type !== "comment")
              return;
            if (GRID_REGEX.test(i.text)) {
              let hasAutoplace = /:\s*autoplace/i.test(i.text);
              let noAutoplace = /no-autoplace/i.test(i.text);
              if (typeof status !== "undefined") {
                result.warn("Second Autoprefixer grid control comment was ignored. Autoprefixer applies control comments to the whole block, not to the next rules.", { node: i });
              } else if (hasAutoplace) {
                status = "autoplace";
              } else if (noAutoplace) {
                status = true;
              } else {
                status = /on/i.test(i.text);
              }
            }
          });
          if (status !== void 0) {
            value = status;
          }
        }
        if (node.type === "atrule" && node.name === "supports") {
          let params = node.params;
          if (params.includes("grid") && params.includes("auto")) {
            value = false;
          }
        }
        if (!node.nodes || value === null) {
          if (node.parent) {
            let isParentGrid = this.gridStatus(node.parent, result);
            if (node.parent._autoprefixerSelfDisabled === true) {
              value = false;
            } else {
              value = isParentGrid;
            }
          } else if (typeof this.prefixes.options.grid !== "undefined") {
            value = this.prefixes.options.grid;
          } else if (typeof process.env.AUTOPREFIXER_GRID !== "undefined") {
            if (process.env.AUTOPREFIXER_GRID === "autoplace") {
              value = "autoplace";
            } else {
              value = true;
            }
          } else {
            value = false;
          }
        }
        node._autoprefixerGridStatus = value;
        return value;
      }
    };
    module2.exports = Processor;
  }
});

// node_modules/autoprefixer/lib/brackets.js
var require_brackets = __commonJS({
  "node_modules/autoprefixer/lib/brackets.js"(exports2, module2) {
    function last(array) {
      return array[array.length - 1];
    }
    var brackets = {
      parse(str) {
        let current = [""];
        let stack = [current];
        for (let sym of str) {
          if (sym === "(") {
            current = [""];
            last(stack).push(current);
            stack.push(current);
            continue;
          }
          if (sym === ")") {
            stack.pop();
            current = last(stack);
            current.push("");
            continue;
          }
          current[current.length - 1] += sym;
        }
        return stack[0];
      },
      stringify(ast) {
        let result = "";
        for (let i of ast) {
          if (typeof i === "object") {
            result += `(${brackets.stringify(i)})`;
            continue;
          }
          result += i;
        }
        return result;
      }
    };
    module2.exports = brackets;
  }
});

// node_modules/autoprefixer/lib/supports.js
var require_supports = __commonJS({
  "node_modules/autoprefixer/lib/supports.js"(exports2, module2) {
    var featureQueries = require_css_featurequeries();
    var { feature } = require_unpacker();
    var { parse } = require_postcss();
    var Browsers = require_browsers3();
    var brackets = require_brackets();
    var Value = require_value();
    var utils = require_utils();
    var data = feature(featureQueries);
    var supported = [];
    for (let browser in data.stats) {
      let versions = data.stats[browser];
      for (let version in versions) {
        let support = versions[version];
        if (/y/.test(support)) {
          supported.push(browser + " " + version);
        }
      }
    }
    var Supports = class {
      constructor(Prefixes, all) {
        this.Prefixes = Prefixes;
        this.all = all;
      }
      prefixer() {
        if (this.prefixerCache) {
          return this.prefixerCache;
        }
        let filtered = this.all.browsers.selected.filter((i) => {
          return supported.includes(i);
        });
        let browsers = new Browsers(this.all.browsers.data, filtered, this.all.options);
        this.prefixerCache = new this.Prefixes(this.all.data, browsers, this.all.options);
        return this.prefixerCache;
      }
      parse(str) {
        let parts = str.split(":");
        let prop = parts[0];
        let value = parts[1];
        if (!value)
          value = "";
        return [prop.trim(), value.trim()];
      }
      virtual(str) {
        let [prop, value] = this.parse(str);
        let rule = parse("a{}").first;
        rule.append({ prop, value, raws: { before: "" } });
        return rule;
      }
      prefixed(str) {
        let rule = this.virtual(str);
        if (this.disabled(rule.first)) {
          return rule.nodes;
        }
        let result = { warn: () => null };
        let prefixer = this.prefixer().add[rule.first.prop];
        prefixer && prefixer.process && prefixer.process(rule.first, result);
        for (let decl of rule.nodes) {
          for (let value of this.prefixer().values("add", rule.first.prop)) {
            value.process(decl);
          }
          Value.save(this.all, decl);
        }
        return rule.nodes;
      }
      isNot(node) {
        return typeof node === "string" && /not\s*/i.test(node);
      }
      isOr(node) {
        return typeof node === "string" && /\s*or\s*/i.test(node);
      }
      isProp(node) {
        return typeof node === "object" && node.length === 1 && typeof node[0] === "string";
      }
      isHack(all, unprefixed) {
        let check = new RegExp(`(\\(|\\s)${utils.escapeRegexp(unprefixed)}:`);
        return !check.test(all);
      }
      toRemove(str, all) {
        let [prop, value] = this.parse(str);
        let unprefixed = this.all.unprefixed(prop);
        let cleaner = this.all.cleaner();
        if (cleaner.remove[prop] && cleaner.remove[prop].remove && !this.isHack(all, unprefixed)) {
          return true;
        }
        for (let checker of cleaner.values("remove", unprefixed)) {
          if (checker.check(value)) {
            return true;
          }
        }
        return false;
      }
      remove(nodes, all) {
        let i = 0;
        while (i < nodes.length) {
          if (!this.isNot(nodes[i - 1]) && this.isProp(nodes[i]) && this.isOr(nodes[i + 1])) {
            if (this.toRemove(nodes[i][0], all)) {
              nodes.splice(i, 2);
              continue;
            }
            i += 2;
            continue;
          }
          if (typeof nodes[i] === "object") {
            nodes[i] = this.remove(nodes[i], all);
          }
          i += 1;
        }
        return nodes;
      }
      cleanBrackets(nodes) {
        return nodes.map((i) => {
          if (typeof i !== "object") {
            return i;
          }
          if (i.length === 1 && typeof i[0] === "object") {
            return this.cleanBrackets(i[0]);
          }
          return this.cleanBrackets(i);
        });
      }
      convert(progress) {
        let result = [""];
        for (let i of progress) {
          result.push([`${i.prop}: ${i.value}`]);
          result.push(" or ");
        }
        result[result.length - 1] = "";
        return result;
      }
      normalize(nodes) {
        if (typeof nodes !== "object") {
          return nodes;
        }
        nodes = nodes.filter((i) => i !== "");
        if (typeof nodes[0] === "string") {
          let firstNode = nodes[0].trim();
          if (firstNode.includes(":") || firstNode === "selector" || firstNode === "not selector") {
            return [brackets.stringify(nodes)];
          }
        }
        return nodes.map((i) => this.normalize(i));
      }
      add(nodes, all) {
        return nodes.map((i) => {
          if (this.isProp(i)) {
            let prefixed = this.prefixed(i[0]);
            if (prefixed.length > 1) {
              return this.convert(prefixed);
            }
            return i;
          }
          if (typeof i === "object") {
            return this.add(i, all);
          }
          return i;
        });
      }
      process(rule) {
        let ast = brackets.parse(rule.params);
        ast = this.normalize(ast);
        ast = this.remove(ast, rule.params);
        ast = this.add(ast, rule.params);
        ast = this.cleanBrackets(ast);
        rule.params = brackets.stringify(ast);
      }
      disabled(node) {
        if (!this.all.options.grid) {
          if (node.prop === "display" && node.value.includes("grid")) {
            return true;
          }
          if (node.prop.includes("grid") || node.prop === "justify-items") {
            return true;
          }
        }
        if (this.all.options.flexbox === false) {
          if (node.prop === "display" && node.value.includes("flex")) {
            return true;
          }
          let other = ["order", "justify-content", "align-items", "align-content"];
          if (node.prop.includes("flex") || other.includes(node.prop)) {
            return true;
          }
        }
        return false;
      }
    };
    module2.exports = Supports;
  }
});

// node_modules/autoprefixer/lib/old-selector.js
var require_old_selector = __commonJS({
  "node_modules/autoprefixer/lib/old-selector.js"(exports2, module2) {
    var OldSelector = class {
      constructor(selector, prefix) {
        this.prefix = prefix;
        this.prefixed = selector.prefixed(this.prefix);
        this.regexp = selector.regexp(this.prefix);
        this.prefixeds = selector.possible().map((x) => [selector.prefixed(x), selector.regexp(x)]);
        this.unprefixed = selector.name;
        this.nameRegexp = selector.regexp();
      }
      isHack(rule) {
        let index = rule.parent.index(rule) + 1;
        let rules = rule.parent.nodes;
        while (index < rules.length) {
          let before = rules[index].selector;
          if (!before) {
            return true;
          }
          if (before.includes(this.unprefixed) && before.match(this.nameRegexp)) {
            return false;
          }
          let some = false;
          for (let [string, regexp] of this.prefixeds) {
            if (before.includes(string) && before.match(regexp)) {
              some = true;
              break;
            }
          }
          if (!some) {
            return true;
          }
          index += 1;
        }
        return true;
      }
      check(rule) {
        if (!rule.selector.includes(this.prefixed)) {
          return false;
        }
        if (!rule.selector.match(this.regexp)) {
          return false;
        }
        if (this.isHack(rule)) {
          return false;
        }
        return true;
      }
    };
    module2.exports = OldSelector;
  }
});

// node_modules/autoprefixer/lib/selector.js
var require_selector = __commonJS({
  "node_modules/autoprefixer/lib/selector.js"(exports2, module2) {
    var { list } = require_postcss();
    var OldSelector = require_old_selector();
    var Prefixer = require_prefixer();
    var Browsers = require_browsers3();
    var utils = require_utils();
    var Selector = class extends Prefixer {
      constructor(name, prefixes, all) {
        super(name, prefixes, all);
        this.regexpCache = /* @__PURE__ */ new Map();
      }
      check(rule) {
        if (rule.selector.includes(this.name)) {
          return !!rule.selector.match(this.regexp());
        }
        return false;
      }
      prefixed(prefix) {
        return this.name.replace(/^(\W*)/, `$1${prefix}`);
      }
      regexp(prefix) {
        if (!this.regexpCache.has(prefix)) {
          let name = prefix ? this.prefixed(prefix) : this.name;
          this.regexpCache.set(prefix, new RegExp(`(^|[^:"'=])${utils.escapeRegexp(name)}`, "gi"));
        }
        return this.regexpCache.get(prefix);
      }
      possible() {
        return Browsers.prefixes();
      }
      prefixeds(rule) {
        if (rule._autoprefixerPrefixeds) {
          if (rule._autoprefixerPrefixeds[this.name]) {
            return rule._autoprefixerPrefixeds;
          }
        } else {
          rule._autoprefixerPrefixeds = {};
        }
        let prefixeds = {};
        if (rule.selector.includes(",")) {
          let ruleParts = list.comma(rule.selector);
          let toProcess = ruleParts.filter((el) => el.includes(this.name));
          for (let prefix of this.possible()) {
            prefixeds[prefix] = toProcess.map((el) => this.replace(el, prefix)).join(", ");
          }
        } else {
          for (let prefix of this.possible()) {
            prefixeds[prefix] = this.replace(rule.selector, prefix);
          }
        }
        rule._autoprefixerPrefixeds[this.name] = prefixeds;
        return rule._autoprefixerPrefixeds;
      }
      already(rule, prefixeds, prefix) {
        let index = rule.parent.index(rule) - 1;
        while (index >= 0) {
          let before = rule.parent.nodes[index];
          if (before.type !== "rule") {
            return false;
          }
          let some = false;
          for (let key in prefixeds[this.name]) {
            let prefixed = prefixeds[this.name][key];
            if (before.selector === prefixed) {
              if (prefix === key) {
                return true;
              } else {
                some = true;
                break;
              }
            }
          }
          if (!some) {
            return false;
          }
          index -= 1;
        }
        return false;
      }
      replace(selector, prefix) {
        return selector.replace(this.regexp(), `$1${this.prefixed(prefix)}`);
      }
      add(rule, prefix) {
        let prefixeds = this.prefixeds(rule);
        if (this.already(rule, prefixeds, prefix)) {
          return;
        }
        let cloned = this.clone(rule, { selector: prefixeds[this.name][prefix] });
        rule.parent.insertBefore(rule, cloned);
      }
      old(prefix) {
        return new OldSelector(this, prefix);
      }
    };
    module2.exports = Selector;
  }
});

// node_modules/autoprefixer/lib/at-rule.js
var require_at_rule2 = __commonJS({
  "node_modules/autoprefixer/lib/at-rule.js"(exports2, module2) {
    var Prefixer = require_prefixer();
    var AtRule = class extends Prefixer {
      add(rule, prefix) {
        let prefixed = prefix + rule.name;
        let already = rule.parent.some((i) => i.name === prefixed && i.params === rule.params);
        if (already) {
          return void 0;
        }
        let cloned = this.clone(rule, { name: prefixed });
        return rule.parent.insertBefore(rule, cloned);
      }
      process(node) {
        let parent = this.parentPrefix(node);
        for (let prefix of this.prefixes) {
          if (!parent || parent === prefix) {
            this.add(node, prefix);
          }
        }
      }
    };
    module2.exports = AtRule;
  }
});

// node_modules/autoprefixer/lib/hacks/fullscreen.js
var require_fullscreen2 = __commonJS({
  "node_modules/autoprefixer/lib/hacks/fullscreen.js"(exports2, module2) {
    var Selector = require_selector();
    var Fullscreen = class extends Selector {
      prefixed(prefix) {
        if (prefix === "-webkit-") {
          return ":-webkit-full-screen";
        }
        if (prefix === "-moz-") {
          return ":-moz-full-screen";
        }
        return `:${prefix}fullscreen`;
      }
    };
    Fullscreen.names = [":fullscreen"];
    module2.exports = Fullscreen;
  }
});

// node_modules/autoprefixer/lib/hacks/placeholder.js
var require_placeholder = __commonJS({
  "node_modules/autoprefixer/lib/hacks/placeholder.js"(exports2, module2) {
    var Selector = require_selector();
    var Placeholder = class extends Selector {
      possible() {
        return super.possible().concat(["-moz- old", "-ms- old"]);
      }
      prefixed(prefix) {
        if (prefix === "-webkit-") {
          return "::-webkit-input-placeholder";
        }
        if (prefix === "-ms-") {
          return "::-ms-input-placeholder";
        }
        if (prefix === "-ms- old") {
          return ":-ms-input-placeholder";
        }
        if (prefix === "-moz- old") {
          return ":-moz-placeholder";
        }
        return `::${prefix}placeholder`;
      }
    };
    Placeholder.names = ["::placeholder"];
    module2.exports = Placeholder;
  }
});

// node_modules/autoprefixer/lib/hacks/placeholder-shown.js
var require_placeholder_shown = __commonJS({
  "node_modules/autoprefixer/lib/hacks/placeholder-shown.js"(exports2, module2) {
    var Selector = require_selector();
    var PlaceholderShown = class extends Selector {
      prefixed(prefix) {
        if (prefix === "-ms-") {
          return ":-ms-input-placeholder";
        }
        return `:${prefix}placeholder-shown`;
      }
    };
    PlaceholderShown.names = [":placeholder-shown"];
    module2.exports = PlaceholderShown;
  }
});

// node_modules/autoprefixer/lib/hacks/file-selector-button.js
var require_file_selector_button = __commonJS({
  "node_modules/autoprefixer/lib/hacks/file-selector-button.js"(exports2, module2) {
    var Selector = require_selector();
    var utils = require_utils();
    var FileSelectorButton = class extends Selector {
      constructor(name, prefixes, all) {
        super(name, prefixes, all);
        if (this.prefixes) {
          this.prefixes = utils.uniq(this.prefixes.map(() => "-webkit-"));
        }
      }
      prefixed(prefix) {
        if (prefix === "-webkit-") {
          return "::-webkit-file-upload-button";
        }
        return `::${prefix}file-selector-button`;
      }
    };
    FileSelectorButton.names = ["::file-selector-button"];
    module2.exports = FileSelectorButton;
  }
});

// node_modules/autoprefixer/lib/hacks/flex-spec.js
var require_flex_spec = __commonJS({
  "node_modules/autoprefixer/lib/hacks/flex-spec.js"(exports2, module2) {
    module2.exports = function(prefix) {
      let spec;
      if (prefix === "-webkit- 2009" || prefix === "-moz-") {
        spec = 2009;
      } else if (prefix === "-ms-") {
        spec = 2012;
      } else if (prefix === "-webkit-") {
        spec = "final";
      }
      if (prefix === "-webkit- 2009") {
        prefix = "-webkit-";
      }
      return [spec, prefix];
    };
  }
});

// node_modules/autoprefixer/lib/hacks/flex.js
var require_flex = __commonJS({
  "node_modules/autoprefixer/lib/hacks/flex.js"(exports2, module2) {
    var list = require_postcss().list;
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var Flex = class extends Declaration {
      prefixed(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2009) {
          return prefix + "box-flex";
        }
        return super.prefixed(prop, prefix);
      }
      normalize() {
        return "flex";
      }
      set(decl, prefix) {
        let spec = flexSpec(prefix)[0];
        if (spec === 2009) {
          decl.value = list.space(decl.value)[0];
          decl.value = Flex.oldValues[decl.value] || decl.value;
          return super.set(decl, prefix);
        }
        if (spec === 2012) {
          let components = list.space(decl.value);
          if (components.length === 3 && components[2] === "0") {
            decl.value = components.slice(0, 2).concat("0px").join(" ");
          }
        }
        return super.set(decl, prefix);
      }
    };
    Flex.names = ["flex", "box-flex"];
    Flex.oldValues = {
      auto: "1",
      none: "0"
    };
    module2.exports = Flex;
  }
});

// node_modules/autoprefixer/lib/hacks/order.js
var require_order = __commonJS({
  "node_modules/autoprefixer/lib/hacks/order.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var Order = class extends Declaration {
      prefixed(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2009) {
          return prefix + "box-ordinal-group";
        }
        if (spec === 2012) {
          return prefix + "flex-order";
        }
        return super.prefixed(prop, prefix);
      }
      normalize() {
        return "order";
      }
      set(decl, prefix) {
        let spec = flexSpec(prefix)[0];
        if (spec === 2009 && /\d/.test(decl.value)) {
          decl.value = (parseInt(decl.value) + 1).toString();
          return super.set(decl, prefix);
        }
        return super.set(decl, prefix);
      }
    };
    Order.names = ["order", "flex-order", "box-ordinal-group"];
    module2.exports = Order;
  }
});

// node_modules/autoprefixer/lib/hacks/filter.js
var require_filter = __commonJS({
  "node_modules/autoprefixer/lib/hacks/filter.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var Filter = class extends Declaration {
      check(decl) {
        let v = decl.value;
        return !v.toLowerCase().includes("alpha(") && !v.includes("DXImageTransform.Microsoft") && !v.includes("data:image/svg+xml");
      }
    };
    Filter.names = ["filter"];
    module2.exports = Filter;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-end.js
var require_grid_end = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-end.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var { isPureNumber } = require_utils();
    var GridEnd = class extends Declaration {
      insert(decl, prefix, prefixes, result) {
        if (prefix !== "-ms-")
          return super.insert(decl, prefix, prefixes);
        let clonedDecl = this.clone(decl);
        let startProp = decl.prop.replace(/end$/, "start");
        let spanProp = prefix + decl.prop.replace(/end$/, "span");
        if (decl.parent.some((i) => i.prop === spanProp)) {
          return void 0;
        }
        clonedDecl.prop = spanProp;
        if (decl.value.includes("span")) {
          clonedDecl.value = decl.value.replace(/span\s/i, "");
        } else {
          let startDecl;
          decl.parent.walkDecls(startProp, (d) => {
            startDecl = d;
          });
          if (startDecl) {
            if (isPureNumber(startDecl.value)) {
              let value = Number(decl.value) - Number(startDecl.value) + "";
              clonedDecl.value = value;
            } else {
              return void 0;
            }
          } else {
            decl.warn(result, `Can not prefix ${decl.prop} (${startProp} is not found)`);
          }
        }
        decl.cloneBefore(clonedDecl);
        return void 0;
      }
    };
    GridEnd.names = ["grid-row-end", "grid-column-end"];
    module2.exports = GridEnd;
  }
});

// node_modules/autoprefixer/lib/hacks/animation.js
var require_animation = __commonJS({
  "node_modules/autoprefixer/lib/hacks/animation.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var Animation = class extends Declaration {
      check(decl) {
        return !decl.value.split(/\s+/).some((i) => {
          let lower = i.toLowerCase();
          return lower === "reverse" || lower === "alternate-reverse";
        });
      }
    };
    Animation.names = ["animation", "animation-direction"];
    module2.exports = Animation;
  }
});

// node_modules/autoprefixer/lib/hacks/flex-flow.js
var require_flex_flow = __commonJS({
  "node_modules/autoprefixer/lib/hacks/flex-flow.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var FlexFlow = class extends Declaration {
      insert(decl, prefix, prefixes) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec !== 2009) {
          return super.insert(decl, prefix, prefixes);
        }
        let values = decl.value.split(/\s+/).filter((i) => i !== "wrap" && i !== "nowrap" && "wrap-reverse");
        if (values.length === 0) {
          return void 0;
        }
        let already = decl.parent.some((i) => i.prop === prefix + "box-orient" || i.prop === prefix + "box-direction");
        if (already) {
          return void 0;
        }
        let value = values[0];
        let orient = value.includes("row") ? "horizontal" : "vertical";
        let dir = value.includes("reverse") ? "reverse" : "normal";
        let cloned = this.clone(decl);
        cloned.prop = prefix + "box-orient";
        cloned.value = orient;
        if (this.needCascade(decl)) {
          cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
        }
        decl.parent.insertBefore(decl, cloned);
        cloned = this.clone(decl);
        cloned.prop = prefix + "box-direction";
        cloned.value = dir;
        if (this.needCascade(decl)) {
          cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
        }
        return decl.parent.insertBefore(decl, cloned);
      }
    };
    FlexFlow.names = ["flex-flow", "box-direction", "box-orient"];
    module2.exports = FlexFlow;
  }
});

// node_modules/autoprefixer/lib/hacks/flex-grow.js
var require_flex_grow = __commonJS({
  "node_modules/autoprefixer/lib/hacks/flex-grow.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var Flex = class extends Declaration {
      normalize() {
        return "flex";
      }
      prefixed(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2009) {
          return prefix + "box-flex";
        }
        if (spec === 2012) {
          return prefix + "flex-positive";
        }
        return super.prefixed(prop, prefix);
      }
    };
    Flex.names = ["flex-grow", "flex-positive"];
    module2.exports = Flex;
  }
});

// node_modules/autoprefixer/lib/hacks/flex-wrap.js
var require_flex_wrap = __commonJS({
  "node_modules/autoprefixer/lib/hacks/flex-wrap.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var FlexWrap = class extends Declaration {
      set(decl, prefix) {
        let spec = flexSpec(prefix)[0];
        if (spec !== 2009) {
          return super.set(decl, prefix);
        }
        return void 0;
      }
    };
    FlexWrap.names = ["flex-wrap"];
    module2.exports = FlexWrap;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-area.js
var require_grid_area = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-area.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var utils = require_grid_utils();
    var GridArea = class extends Declaration {
      insert(decl, prefix, prefixes, result) {
        if (prefix !== "-ms-")
          return super.insert(decl, prefix, prefixes);
        let values = utils.parse(decl);
        let [rowStart, rowSpan] = utils.translate(values, 0, 2);
        let [columnStart, columnSpan] = utils.translate(values, 1, 3);
        [
          ["grid-row", rowStart],
          ["grid-row-span", rowSpan],
          ["grid-column", columnStart],
          ["grid-column-span", columnSpan]
        ].forEach(([prop, value]) => {
          utils.insertDecl(decl, prop, value);
        });
        utils.warnTemplateSelectorNotFound(decl, result);
        utils.warnIfGridRowColumnExists(decl, result);
        return void 0;
      }
    };
    GridArea.names = ["grid-area"];
    module2.exports = GridArea;
  }
});

// node_modules/autoprefixer/lib/hacks/place-self.js
var require_place_self = __commonJS({
  "node_modules/autoprefixer/lib/hacks/place-self.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var utils = require_grid_utils();
    var PlaceSelf = class extends Declaration {
      insert(decl, prefix, prefixes) {
        if (prefix !== "-ms-")
          return super.insert(decl, prefix, prefixes);
        if (decl.parent.some((i) => i.prop === "-ms-grid-row-align")) {
          return void 0;
        }
        let [[first, second]] = utils.parse(decl);
        if (second) {
          utils.insertDecl(decl, "grid-row-align", first);
          utils.insertDecl(decl, "grid-column-align", second);
        } else {
          utils.insertDecl(decl, "grid-row-align", first);
          utils.insertDecl(decl, "grid-column-align", first);
        }
        return void 0;
      }
    };
    PlaceSelf.names = ["place-self"];
    module2.exports = PlaceSelf;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-start.js
var require_grid_start = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-start.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var GridStart = class extends Declaration {
      check(decl) {
        let value = decl.value;
        return !value.includes("/") && !value.includes("span");
      }
      normalize(prop) {
        return prop.replace("-start", "");
      }
      prefixed(prop, prefix) {
        let result = super.prefixed(prop, prefix);
        if (prefix === "-ms-") {
          result = result.replace("-start", "");
        }
        return result;
      }
    };
    GridStart.names = ["grid-row-start", "grid-column-start"];
    module2.exports = GridStart;
  }
});

// node_modules/autoprefixer/lib/hacks/align-self.js
var require_align_self = __commonJS({
  "node_modules/autoprefixer/lib/hacks/align-self.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var AlignSelf = class extends Declaration {
      check(decl) {
        return decl.parent && !decl.parent.some((i) => {
          return i.prop && i.prop.startsWith("grid-");
        });
      }
      prefixed(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2012) {
          return prefix + "flex-item-align";
        }
        return super.prefixed(prop, prefix);
      }
      normalize() {
        return "align-self";
      }
      set(decl, prefix) {
        let spec = flexSpec(prefix)[0];
        if (spec === 2012) {
          decl.value = AlignSelf.oldValues[decl.value] || decl.value;
          return super.set(decl, prefix);
        }
        if (spec === "final") {
          return super.set(decl, prefix);
        }
        return void 0;
      }
    };
    AlignSelf.names = ["align-self", "flex-item-align"];
    AlignSelf.oldValues = {
      "flex-end": "end",
      "flex-start": "start"
    };
    module2.exports = AlignSelf;
  }
});

// node_modules/autoprefixer/lib/hacks/appearance.js
var require_appearance = __commonJS({
  "node_modules/autoprefixer/lib/hacks/appearance.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var utils = require_utils();
    var Appearance = class extends Declaration {
      constructor(name, prefixes, all) {
        super(name, prefixes, all);
        if (this.prefixes) {
          this.prefixes = utils.uniq(this.prefixes.map((i) => {
            if (i === "-ms-") {
              return "-webkit-";
            }
            return i;
          }));
        }
      }
    };
    Appearance.names = ["appearance"];
    module2.exports = Appearance;
  }
});

// node_modules/autoprefixer/lib/hacks/flex-basis.js
var require_flex_basis = __commonJS({
  "node_modules/autoprefixer/lib/hacks/flex-basis.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var FlexBasis = class extends Declaration {
      normalize() {
        return "flex-basis";
      }
      prefixed(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2012) {
          return prefix + "flex-preferred-size";
        }
        return super.prefixed(prop, prefix);
      }
      set(decl, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2012 || spec === "final") {
          return super.set(decl, prefix);
        }
        return void 0;
      }
    };
    FlexBasis.names = ["flex-basis", "flex-preferred-size"];
    module2.exports = FlexBasis;
  }
});

// node_modules/autoprefixer/lib/hacks/mask-border.js
var require_mask_border = __commonJS({
  "node_modules/autoprefixer/lib/hacks/mask-border.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var MaskBorder = class extends Declaration {
      normalize() {
        return this.name.replace("box-image", "border");
      }
      prefixed(prop, prefix) {
        let result = super.prefixed(prop, prefix);
        if (prefix === "-webkit-") {
          result = result.replace("border", "box-image");
        }
        return result;
      }
    };
    MaskBorder.names = [
      "mask-border",
      "mask-border-source",
      "mask-border-slice",
      "mask-border-width",
      "mask-border-outset",
      "mask-border-repeat",
      "mask-box-image",
      "mask-box-image-source",
      "mask-box-image-slice",
      "mask-box-image-width",
      "mask-box-image-outset",
      "mask-box-image-repeat"
    ];
    module2.exports = MaskBorder;
  }
});

// node_modules/autoprefixer/lib/hacks/mask-composite.js
var require_mask_composite = __commonJS({
  "node_modules/autoprefixer/lib/hacks/mask-composite.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var MaskComposite = class extends Declaration {
      insert(decl, prefix, prefixes) {
        let isCompositeProp = decl.prop === "mask-composite";
        let compositeValues;
        if (isCompositeProp) {
          compositeValues = decl.value.split(",");
        } else {
          compositeValues = decl.value.match(MaskComposite.regexp) || [];
        }
        compositeValues = compositeValues.map((el) => el.trim()).filter((el) => el);
        let hasCompositeValues = compositeValues.length;
        let compositeDecl;
        if (hasCompositeValues) {
          compositeDecl = this.clone(decl);
          compositeDecl.value = compositeValues.map((value) => MaskComposite.oldValues[value] || value).join(", ");
          if (compositeValues.includes("intersect")) {
            compositeDecl.value += ", xor";
          }
          compositeDecl.prop = prefix + "mask-composite";
        }
        if (isCompositeProp) {
          if (!hasCompositeValues) {
            return void 0;
          }
          if (this.needCascade(decl)) {
            compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix);
          }
          return decl.parent.insertBefore(decl, compositeDecl);
        }
        let cloned = this.clone(decl);
        cloned.prop = prefix + cloned.prop;
        if (hasCompositeValues) {
          cloned.value = cloned.value.replace(MaskComposite.regexp, "");
        }
        if (this.needCascade(decl)) {
          cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
        }
        decl.parent.insertBefore(decl, cloned);
        if (!hasCompositeValues) {
          return decl;
        }
        if (this.needCascade(decl)) {
          compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix);
        }
        return decl.parent.insertBefore(decl, compositeDecl);
      }
    };
    MaskComposite.names = ["mask", "mask-composite"];
    MaskComposite.oldValues = {
      add: "source-over",
      subtract: "source-out",
      intersect: "source-in",
      exclude: "xor"
    };
    MaskComposite.regexp = new RegExp(`\\s+(${Object.keys(MaskComposite.oldValues).join("|")})\\b(?!\\))\\s*(?=[,])`, "ig");
    module2.exports = MaskComposite;
  }
});

// node_modules/autoprefixer/lib/hacks/align-items.js
var require_align_items = __commonJS({
  "node_modules/autoprefixer/lib/hacks/align-items.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var AlignItems = class extends Declaration {
      prefixed(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2009) {
          return prefix + "box-align";
        }
        if (spec === 2012) {
          return prefix + "flex-align";
        }
        return super.prefixed(prop, prefix);
      }
      normalize() {
        return "align-items";
      }
      set(decl, prefix) {
        let spec = flexSpec(prefix)[0];
        if (spec === 2009 || spec === 2012) {
          decl.value = AlignItems.oldValues[decl.value] || decl.value;
        }
        return super.set(decl, prefix);
      }
    };
    AlignItems.names = ["align-items", "flex-align", "box-align"];
    AlignItems.oldValues = {
      "flex-end": "end",
      "flex-start": "start"
    };
    module2.exports = AlignItems;
  }
});

// node_modules/autoprefixer/lib/hacks/user-select.js
var require_user_select = __commonJS({
  "node_modules/autoprefixer/lib/hacks/user-select.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var UserSelect = class extends Declaration {
      set(decl, prefix) {
        if (prefix === "-ms-" && decl.value === "contain") {
          decl.value = "element";
        }
        return super.set(decl, prefix);
      }
      insert(decl, prefix, prefixes) {
        if (decl.value === "all" && prefix === "-ms-") {
          return void 0;
        } else {
          return super.insert(decl, prefix, prefixes);
        }
      }
    };
    UserSelect.names = ["user-select"];
    module2.exports = UserSelect;
  }
});

// node_modules/autoprefixer/lib/hacks/flex-shrink.js
var require_flex_shrink = __commonJS({
  "node_modules/autoprefixer/lib/hacks/flex-shrink.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var FlexShrink = class extends Declaration {
      normalize() {
        return "flex-shrink";
      }
      prefixed(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2012) {
          return prefix + "flex-negative";
        }
        return super.prefixed(prop, prefix);
      }
      set(decl, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2012 || spec === "final") {
          return super.set(decl, prefix);
        }
        return void 0;
      }
    };
    FlexShrink.names = ["flex-shrink", "flex-negative"];
    module2.exports = FlexShrink;
  }
});

// node_modules/autoprefixer/lib/hacks/break-props.js
var require_break_props = __commonJS({
  "node_modules/autoprefixer/lib/hacks/break-props.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var BreakProps = class extends Declaration {
      prefixed(prop, prefix) {
        return `${prefix}column-${prop}`;
      }
      normalize(prop) {
        if (prop.includes("inside")) {
          return "break-inside";
        }
        if (prop.includes("before")) {
          return "break-before";
        }
        return "break-after";
      }
      set(decl, prefix) {
        if (decl.prop === "break-inside" && decl.value === "avoid-column" || decl.value === "avoid-page") {
          decl.value = "avoid";
        }
        return super.set(decl, prefix);
      }
      insert(decl, prefix, prefixes) {
        if (decl.prop !== "break-inside") {
          return super.insert(decl, prefix, prefixes);
        }
        if (/region/i.test(decl.value) || /page/i.test(decl.value)) {
          return void 0;
        }
        return super.insert(decl, prefix, prefixes);
      }
    };
    BreakProps.names = [
      "break-inside",
      "page-break-inside",
      "column-break-inside",
      "break-before",
      "page-break-before",
      "column-break-before",
      "break-after",
      "page-break-after",
      "column-break-after"
    ];
    module2.exports = BreakProps;
  }
});

// node_modules/autoprefixer/lib/hacks/writing-mode.js
var require_writing_mode = __commonJS({
  "node_modules/autoprefixer/lib/hacks/writing-mode.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var WritingMode = class extends Declaration {
      insert(decl, prefix, prefixes) {
        if (prefix === "-ms-") {
          let cloned = this.set(this.clone(decl), prefix);
          if (this.needCascade(decl)) {
            cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
          }
          let direction = "ltr";
          decl.parent.nodes.forEach((i) => {
            if (i.prop === "direction") {
              if (i.value === "rtl" || i.value === "ltr")
                direction = i.value;
            }
          });
          cloned.value = WritingMode.msValues[direction][decl.value] || decl.value;
          return decl.parent.insertBefore(decl, cloned);
        }
        return super.insert(decl, prefix, prefixes);
      }
    };
    WritingMode.names = ["writing-mode"];
    WritingMode.msValues = {
      ltr: {
        "horizontal-tb": "lr-tb",
        "vertical-rl": "tb-rl",
        "vertical-lr": "tb-lr"
      },
      rtl: {
        "horizontal-tb": "rl-tb",
        "vertical-rl": "bt-rl",
        "vertical-lr": "bt-lr"
      }
    };
    module2.exports = WritingMode;
  }
});

// node_modules/autoprefixer/lib/hacks/border-image.js
var require_border_image2 = __commonJS({
  "node_modules/autoprefixer/lib/hacks/border-image.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var BorderImage = class extends Declaration {
      set(decl, prefix) {
        decl.value = decl.value.replace(/\s+fill(\s)/, "$1");
        return super.set(decl, prefix);
      }
    };
    BorderImage.names = ["border-image"];
    module2.exports = BorderImage;
  }
});

// node_modules/autoprefixer/lib/hacks/align-content.js
var require_align_content = __commonJS({
  "node_modules/autoprefixer/lib/hacks/align-content.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var AlignContent = class extends Declaration {
      prefixed(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2012) {
          return prefix + "flex-line-pack";
        }
        return super.prefixed(prop, prefix);
      }
      normalize() {
        return "align-content";
      }
      set(decl, prefix) {
        let spec = flexSpec(prefix)[0];
        if (spec === 2012) {
          decl.value = AlignContent.oldValues[decl.value] || decl.value;
          return super.set(decl, prefix);
        }
        if (spec === "final") {
          return super.set(decl, prefix);
        }
        return void 0;
      }
    };
    AlignContent.names = ["align-content", "flex-line-pack"];
    AlignContent.oldValues = {
      "flex-end": "end",
      "flex-start": "start",
      "space-between": "justify",
      "space-around": "distribute"
    };
    module2.exports = AlignContent;
  }
});

// node_modules/autoprefixer/lib/hacks/border-radius.js
var require_border_radius2 = __commonJS({
  "node_modules/autoprefixer/lib/hacks/border-radius.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var BorderRadius = class extends Declaration {
      prefixed(prop, prefix) {
        if (prefix === "-moz-") {
          return prefix + (BorderRadius.toMozilla[prop] || prop);
        }
        return super.prefixed(prop, prefix);
      }
      normalize(prop) {
        return BorderRadius.toNormal[prop] || prop;
      }
    };
    BorderRadius.names = ["border-radius"];
    BorderRadius.toMozilla = {};
    BorderRadius.toNormal = {};
    for (let ver of ["top", "bottom"]) {
      for (let hor of ["left", "right"]) {
        let normal = `border-${ver}-${hor}-radius`;
        let mozilla = `border-radius-${ver}${hor}`;
        BorderRadius.names.push(normal);
        BorderRadius.names.push(mozilla);
        BorderRadius.toMozilla[normal] = mozilla;
        BorderRadius.toNormal[mozilla] = normal;
      }
    }
    module2.exports = BorderRadius;
  }
});

// node_modules/autoprefixer/lib/hacks/block-logical.js
var require_block_logical = __commonJS({
  "node_modules/autoprefixer/lib/hacks/block-logical.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var BlockLogical = class extends Declaration {
      prefixed(prop, prefix) {
        if (prop.includes("-start")) {
          return prefix + prop.replace("-block-start", "-before");
        }
        return prefix + prop.replace("-block-end", "-after");
      }
      normalize(prop) {
        if (prop.includes("-before")) {
          return prop.replace("-before", "-block-start");
        }
        return prop.replace("-after", "-block-end");
      }
    };
    BlockLogical.names = [
      "border-block-start",
      "border-block-end",
      "margin-block-start",
      "margin-block-end",
      "padding-block-start",
      "padding-block-end",
      "border-before",
      "border-after",
      "margin-before",
      "margin-after",
      "padding-before",
      "padding-after"
    ];
    module2.exports = BlockLogical;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-template.js
var require_grid_template = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-template.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var {
      parseTemplate,
      warnMissedAreas,
      getGridGap,
      warnGridGap,
      inheritGridGap
    } = require_grid_utils();
    var GridTemplate = class extends Declaration {
      insert(decl, prefix, prefixes, result) {
        if (prefix !== "-ms-")
          return super.insert(decl, prefix, prefixes);
        if (decl.parent.some((i) => i.prop === "-ms-grid-rows")) {
          return void 0;
        }
        let gap = getGridGap(decl);
        let inheritedGap = inheritGridGap(decl, gap);
        let { rows, columns, areas } = parseTemplate({
          decl,
          gap: inheritedGap || gap
        });
        let hasAreas = Object.keys(areas).length > 0;
        let hasRows = Boolean(rows);
        let hasColumns = Boolean(columns);
        warnGridGap({
          gap,
          hasColumns,
          decl,
          result
        });
        warnMissedAreas(areas, decl, result);
        if (hasRows && hasColumns || hasAreas) {
          decl.cloneBefore({
            prop: "-ms-grid-rows",
            value: rows,
            raws: {}
          });
        }
        if (hasColumns) {
          decl.cloneBefore({
            prop: "-ms-grid-columns",
            value: columns,
            raws: {}
          });
        }
        return decl;
      }
    };
    GridTemplate.names = ["grid-template"];
    module2.exports = GridTemplate;
  }
});

// node_modules/autoprefixer/lib/hacks/inline-logical.js
var require_inline_logical = __commonJS({
  "node_modules/autoprefixer/lib/hacks/inline-logical.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var InlineLogical = class extends Declaration {
      prefixed(prop, prefix) {
        return prefix + prop.replace("-inline", "");
      }
      normalize(prop) {
        return prop.replace(/(margin|padding|border)-(start|end)/, "$1-inline-$2");
      }
    };
    InlineLogical.names = [
      "border-inline-start",
      "border-inline-end",
      "margin-inline-start",
      "margin-inline-end",
      "padding-inline-start",
      "padding-inline-end",
      "border-start",
      "border-end",
      "margin-start",
      "margin-end",
      "padding-start",
      "padding-end"
    ];
    module2.exports = InlineLogical;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-row-align.js
var require_grid_row_align = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-row-align.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var GridRowAlign = class extends Declaration {
      check(decl) {
        return !decl.value.includes("flex-") && decl.value !== "baseline";
      }
      prefixed(prop, prefix) {
        return prefix + "grid-row-align";
      }
      normalize() {
        return "align-self";
      }
    };
    GridRowAlign.names = ["grid-row-align"];
    module2.exports = GridRowAlign;
  }
});

// node_modules/autoprefixer/lib/hacks/transform-decl.js
var require_transform_decl = __commonJS({
  "node_modules/autoprefixer/lib/hacks/transform-decl.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var TransformDecl = class extends Declaration {
      keyframeParents(decl) {
        let { parent } = decl;
        while (parent) {
          if (parent.type === "atrule" && parent.name === "keyframes") {
            return true;
          }
          ;
          ({ parent } = parent);
        }
        return false;
      }
      contain3d(decl) {
        if (decl.prop === "transform-origin") {
          return false;
        }
        for (let func of TransformDecl.functions3d) {
          if (decl.value.includes(`${func}(`)) {
            return true;
          }
        }
        return false;
      }
      set(decl, prefix) {
        decl = super.set(decl, prefix);
        if (prefix === "-ms-") {
          decl.value = decl.value.replace(/rotatez/gi, "rotate");
        }
        return decl;
      }
      insert(decl, prefix, prefixes) {
        if (prefix === "-ms-") {
          if (!this.contain3d(decl) && !this.keyframeParents(decl)) {
            return super.insert(decl, prefix, prefixes);
          }
        } else if (prefix === "-o-") {
          if (!this.contain3d(decl)) {
            return super.insert(decl, prefix, prefixes);
          }
        } else {
          return super.insert(decl, prefix, prefixes);
        }
        return void 0;
      }
    };
    TransformDecl.names = ["transform", "transform-origin"];
    TransformDecl.functions3d = [
      "matrix3d",
      "translate3d",
      "translateZ",
      "scale3d",
      "scaleZ",
      "rotate3d",
      "rotateX",
      "rotateY",
      "perspective"
    ];
    module2.exports = TransformDecl;
  }
});

// node_modules/autoprefixer/lib/hacks/flex-direction.js
var require_flex_direction = __commonJS({
  "node_modules/autoprefixer/lib/hacks/flex-direction.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var FlexDirection = class extends Declaration {
      normalize() {
        return "flex-direction";
      }
      insert(decl, prefix, prefixes) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec !== 2009) {
          return super.insert(decl, prefix, prefixes);
        }
        let already = decl.parent.some((i) => i.prop === prefix + "box-orient" || i.prop === prefix + "box-direction");
        if (already) {
          return void 0;
        }
        let v = decl.value;
        let orient, dir;
        if (v === "inherit" || v === "initial" || v === "unset") {
          orient = v;
          dir = v;
        } else {
          orient = v.includes("row") ? "horizontal" : "vertical";
          dir = v.includes("reverse") ? "reverse" : "normal";
        }
        let cloned = this.clone(decl);
        cloned.prop = prefix + "box-orient";
        cloned.value = orient;
        if (this.needCascade(decl)) {
          cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
        }
        decl.parent.insertBefore(decl, cloned);
        cloned = this.clone(decl);
        cloned.prop = prefix + "box-direction";
        cloned.value = dir;
        if (this.needCascade(decl)) {
          cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
        }
        return decl.parent.insertBefore(decl, cloned);
      }
      old(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2009) {
          return [prefix + "box-orient", prefix + "box-direction"];
        } else {
          return super.old(prop, prefix);
        }
      }
    };
    FlexDirection.names = ["flex-direction", "box-direction", "box-orient"];
    module2.exports = FlexDirection;
  }
});

// node_modules/autoprefixer/lib/hacks/image-rendering.js
var require_image_rendering = __commonJS({
  "node_modules/autoprefixer/lib/hacks/image-rendering.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var ImageRendering = class extends Declaration {
      check(decl) {
        return decl.value === "pixelated";
      }
      prefixed(prop, prefix) {
        if (prefix === "-ms-") {
          return "-ms-interpolation-mode";
        }
        return super.prefixed(prop, prefix);
      }
      set(decl, prefix) {
        if (prefix !== "-ms-")
          return super.set(decl, prefix);
        decl.prop = "-ms-interpolation-mode";
        decl.value = "nearest-neighbor";
        return decl;
      }
      normalize() {
        return "image-rendering";
      }
      process(node, result) {
        return super.process(node, result);
      }
    };
    ImageRendering.names = ["image-rendering", "interpolation-mode"];
    module2.exports = ImageRendering;
  }
});

// node_modules/autoprefixer/lib/hacks/backdrop-filter.js
var require_backdrop_filter = __commonJS({
  "node_modules/autoprefixer/lib/hacks/backdrop-filter.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var utils = require_utils();
    var BackdropFilter = class extends Declaration {
      constructor(name, prefixes, all) {
        super(name, prefixes, all);
        if (this.prefixes) {
          this.prefixes = utils.uniq(this.prefixes.map((i) => {
            return i === "-ms-" ? "-webkit-" : i;
          }));
        }
      }
    };
    BackdropFilter.names = ["backdrop-filter"];
    module2.exports = BackdropFilter;
  }
});

// node_modules/autoprefixer/lib/hacks/background-clip.js
var require_background_clip = __commonJS({
  "node_modules/autoprefixer/lib/hacks/background-clip.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var utils = require_utils();
    var BackgroundClip = class extends Declaration {
      constructor(name, prefixes, all) {
        super(name, prefixes, all);
        if (this.prefixes) {
          this.prefixes = utils.uniq(this.prefixes.map((i) => {
            return i === "-ms-" ? "-webkit-" : i;
          }));
        }
      }
      check(decl) {
        return decl.value.toLowerCase() === "text";
      }
    };
    BackgroundClip.names = ["background-clip"];
    module2.exports = BackgroundClip;
  }
});

// node_modules/autoprefixer/lib/hacks/text-decoration.js
var require_text_decoration2 = __commonJS({
  "node_modules/autoprefixer/lib/hacks/text-decoration.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var BASIC = [
      "none",
      "underline",
      "overline",
      "line-through",
      "blink",
      "inherit",
      "initial",
      "unset"
    ];
    var TextDecoration = class extends Declaration {
      check(decl) {
        return decl.value.split(/\s+/).some((i) => !BASIC.includes(i));
      }
    };
    TextDecoration.names = ["text-decoration"];
    module2.exports = TextDecoration;
  }
});

// node_modules/autoprefixer/lib/hacks/justify-content.js
var require_justify_content = __commonJS({
  "node_modules/autoprefixer/lib/hacks/justify-content.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var Declaration = require_declaration2();
    var JustifyContent = class extends Declaration {
      prefixed(prop, prefix) {
        let spec;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2009) {
          return prefix + "box-pack";
        }
        if (spec === 2012) {
          return prefix + "flex-pack";
        }
        return super.prefixed(prop, prefix);
      }
      normalize() {
        return "justify-content";
      }
      set(decl, prefix) {
        let spec = flexSpec(prefix)[0];
        if (spec === 2009 || spec === 2012) {
          let value = JustifyContent.oldValues[decl.value] || decl.value;
          decl.value = value;
          if (spec !== 2009 || value !== "distribute") {
            return super.set(decl, prefix);
          }
        } else if (spec === "final") {
          return super.set(decl, prefix);
        }
        return void 0;
      }
    };
    JustifyContent.names = ["justify-content", "flex-pack", "box-pack"];
    JustifyContent.oldValues = {
      "flex-end": "end",
      "flex-start": "start",
      "space-between": "justify",
      "space-around": "distribute"
    };
    module2.exports = JustifyContent;
  }
});

// node_modules/autoprefixer/lib/hacks/background-size.js
var require_background_size = __commonJS({
  "node_modules/autoprefixer/lib/hacks/background-size.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var BackgroundSize = class extends Declaration {
      set(decl, prefix) {
        let value = decl.value.toLowerCase();
        if (prefix === "-webkit-" && !value.includes(" ") && value !== "contain" && value !== "cover") {
          decl.value = decl.value + " " + decl.value;
        }
        return super.set(decl, prefix);
      }
    };
    BackgroundSize.names = ["background-size"];
    module2.exports = BackgroundSize;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-row-column.js
var require_grid_row_column = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-row-column.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var utils = require_grid_utils();
    var GridRowColumn = class extends Declaration {
      insert(decl, prefix, prefixes) {
        if (prefix !== "-ms-")
          return super.insert(decl, prefix, prefixes);
        let values = utils.parse(decl);
        let [start, span] = utils.translate(values, 0, 1);
        let hasStartValueSpan = values[0] && values[0].includes("span");
        if (hasStartValueSpan) {
          span = values[0].join("").replace(/\D/g, "");
        }
        ;
        [
          [decl.prop, start],
          [`${decl.prop}-span`, span]
        ].forEach(([prop, value]) => {
          utils.insertDecl(decl, prop, value);
        });
        return void 0;
      }
    };
    GridRowColumn.names = ["grid-row", "grid-column"];
    module2.exports = GridRowColumn;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-rows-columns.js
var require_grid_rows_columns = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-rows-columns.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var {
      prefixTrackProp,
      prefixTrackValue,
      autoplaceGridItems,
      getGridGap,
      inheritGridGap
    } = require_grid_utils();
    var Processor = require_processor2();
    var GridRowsColumns = class extends Declaration {
      prefixed(prop, prefix) {
        if (prefix === "-ms-") {
          return prefixTrackProp({ prop, prefix });
        }
        return super.prefixed(prop, prefix);
      }
      normalize(prop) {
        return prop.replace(/^grid-(rows|columns)/, "grid-template-$1");
      }
      insert(decl, prefix, prefixes, result) {
        if (prefix !== "-ms-")
          return super.insert(decl, prefix, prefixes);
        let { parent, prop, value } = decl;
        let isRowProp = prop.includes("rows");
        let isColumnProp = prop.includes("columns");
        let hasGridTemplate = parent.some((i) => i.prop === "grid-template" || i.prop === "grid-template-areas");
        if (hasGridTemplate && isRowProp) {
          return false;
        }
        let processor = new Processor({ options: {} });
        let status = processor.gridStatus(parent, result);
        let gap = getGridGap(decl);
        gap = inheritGridGap(decl, gap) || gap;
        let gapValue = isRowProp ? gap.row : gap.column;
        if ((status === "no-autoplace" || status === true) && !hasGridTemplate) {
          gapValue = null;
        }
        let prefixValue = prefixTrackValue({
          value,
          gap: gapValue
        });
        decl.cloneBefore({
          prop: prefixTrackProp({ prop, prefix }),
          value: prefixValue
        });
        let autoflow = parent.nodes.find((i) => i.prop === "grid-auto-flow");
        let autoflowValue = "row";
        if (autoflow && !processor.disabled(autoflow, result)) {
          autoflowValue = autoflow.value.trim();
        }
        if (status === "autoplace") {
          let rowDecl = parent.nodes.find((i) => i.prop === "grid-template-rows");
          if (!rowDecl && hasGridTemplate) {
            return void 0;
          } else if (!rowDecl && !hasGridTemplate) {
            decl.warn(result, "Autoplacement does not work without grid-template-rows property");
            return void 0;
          }
          let columnDecl = parent.nodes.find((i) => {
            return i.prop === "grid-template-columns";
          });
          if (!columnDecl && !hasGridTemplate) {
            decl.warn(result, "Autoplacement does not work without grid-template-columns property");
          }
          if (isColumnProp && !hasGridTemplate) {
            autoplaceGridItems(decl, result, gap, autoflowValue);
          }
        }
        return void 0;
      }
    };
    GridRowsColumns.names = [
      "grid-template-rows",
      "grid-template-columns",
      "grid-rows",
      "grid-columns"
    ];
    module2.exports = GridRowsColumns;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-column-align.js
var require_grid_column_align = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-column-align.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var GridColumnAlign = class extends Declaration {
      check(decl) {
        return !decl.value.includes("flex-") && decl.value !== "baseline";
      }
      prefixed(prop, prefix) {
        return prefix + "grid-column-align";
      }
      normalize() {
        return "justify-self";
      }
    };
    GridColumnAlign.names = ["grid-column-align"];
    module2.exports = GridColumnAlign;
  }
});

// node_modules/autoprefixer/lib/hacks/print-color-adjust.js
var require_print_color_adjust = __commonJS({
  "node_modules/autoprefixer/lib/hacks/print-color-adjust.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var PrintColorAdjust = class extends Declaration {
      prefixed(prop, prefix) {
        if (prefix === "-moz-") {
          return "color-adjust";
        } else {
          return prefix + "print-color-adjust";
        }
      }
      normalize() {
        return "print-color-adjust";
      }
    };
    PrintColorAdjust.names = ["print-color-adjust", "color-adjust"];
    module2.exports = PrintColorAdjust;
  }
});

// node_modules/autoprefixer/lib/hacks/overscroll-behavior.js
var require_overscroll_behavior = __commonJS({
  "node_modules/autoprefixer/lib/hacks/overscroll-behavior.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var OverscrollBehavior = class extends Declaration {
      prefixed(prop, prefix) {
        return prefix + "scroll-chaining";
      }
      normalize() {
        return "overscroll-behavior";
      }
      set(decl, prefix) {
        if (decl.value === "auto") {
          decl.value = "chained";
        } else if (decl.value === "none" || decl.value === "contain") {
          decl.value = "none";
        }
        return super.set(decl, prefix);
      }
    };
    OverscrollBehavior.names = ["overscroll-behavior", "scroll-chaining"];
    module2.exports = OverscrollBehavior;
  }
});

// node_modules/autoprefixer/lib/hacks/grid-template-areas.js
var require_grid_template_areas = __commonJS({
  "node_modules/autoprefixer/lib/hacks/grid-template-areas.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var {
      parseGridAreas,
      warnMissedAreas,
      prefixTrackProp,
      prefixTrackValue,
      getGridGap,
      warnGridGap,
      inheritGridGap
    } = require_grid_utils();
    function getGridRows(tpl) {
      return tpl.trim().slice(1, -1).split(/["']\s*["']?/g);
    }
    var GridTemplateAreas = class extends Declaration {
      insert(decl, prefix, prefixes, result) {
        if (prefix !== "-ms-")
          return super.insert(decl, prefix, prefixes);
        let hasColumns = false;
        let hasRows = false;
        let parent = decl.parent;
        let gap = getGridGap(decl);
        gap = inheritGridGap(decl, gap) || gap;
        parent.walkDecls(/-ms-grid-rows/, (i) => i.remove());
        parent.walkDecls(/grid-template-(rows|columns)/, (trackDecl) => {
          if (trackDecl.prop === "grid-template-rows") {
            hasRows = true;
            let { prop, value } = trackDecl;
            trackDecl.cloneBefore({
              prop: prefixTrackProp({ prop, prefix }),
              value: prefixTrackValue({ value, gap: gap.row })
            });
          } else {
            hasColumns = true;
          }
        });
        let gridRows = getGridRows(decl.value);
        if (hasColumns && !hasRows && gap.row && gridRows.length > 1) {
          decl.cloneBefore({
            prop: "-ms-grid-rows",
            value: prefixTrackValue({
              value: `repeat(${gridRows.length}, auto)`,
              gap: gap.row
            }),
            raws: {}
          });
        }
        warnGridGap({
          gap,
          hasColumns,
          decl,
          result
        });
        let areas = parseGridAreas({
          rows: gridRows,
          gap
        });
        warnMissedAreas(areas, decl, result);
        return decl;
      }
    };
    GridTemplateAreas.names = ["grid-template-areas"];
    module2.exports = GridTemplateAreas;
  }
});

// node_modules/autoprefixer/lib/hacks/text-emphasis-position.js
var require_text_emphasis_position = __commonJS({
  "node_modules/autoprefixer/lib/hacks/text-emphasis-position.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var TextEmphasisPosition = class extends Declaration {
      set(decl, prefix) {
        if (prefix === "-webkit-") {
          decl.value = decl.value.replace(/\s*(right|left)\s*/i, "");
        }
        return super.set(decl, prefix);
      }
    };
    TextEmphasisPosition.names = ["text-emphasis-position"];
    module2.exports = TextEmphasisPosition;
  }
});

// node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js
var require_text_decoration_skip_ink = __commonJS({
  "node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js"(exports2, module2) {
    var Declaration = require_declaration2();
    var TextDecorationSkipInk = class extends Declaration {
      set(decl, prefix) {
        if (decl.prop === "text-decoration-skip-ink" && decl.value === "auto") {
          decl.prop = prefix + "text-decoration-skip";
          decl.value = "ink";
          return decl;
        } else {
          return super.set(decl, prefix);
        }
      }
    };
    TextDecorationSkipInk.names = [
      "text-decoration-skip-ink",
      "text-decoration-skip"
    ];
    module2.exports = TextDecorationSkipInk;
  }
});

// node_modules/normalize-range/index.js
var require_normalize_range = __commonJS({
  "node_modules/normalize-range/index.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      wrap: wrapRange,
      limit: limitRange,
      validate: validateRange,
      test: testRange,
      curry,
      name
    };
    function wrapRange(min, max, value) {
      var maxLessMin = max - min;
      return ((value - min) % maxLessMin + maxLessMin) % maxLessMin + min;
    }
    function limitRange(min, max, value) {
      return Math.max(min, Math.min(max, value));
    }
    function validateRange(min, max, value, minExclusive, maxExclusive) {
      if (!testRange(min, max, value, minExclusive, maxExclusive)) {
        throw new Error(value + " is outside of range [" + min + "," + max + ")");
      }
      return value;
    }
    function testRange(min, max, value, minExclusive, maxExclusive) {
      return !(value < min || value > max || maxExclusive && value === max || minExclusive && value === min);
    }
    function name(min, max, minExcl, maxExcl) {
      return (minExcl ? "(" : "[") + min + "," + max + (maxExcl ? ")" : "]");
    }
    function curry(min, max, minExclusive, maxExclusive) {
      var boundNameFn = name.bind(null, min, max, minExclusive, maxExclusive);
      return {
        wrap: wrapRange.bind(null, min, max),
        limit: limitRange.bind(null, min, max),
        validate: function(value) {
          return validateRange(min, max, value, minExclusive, maxExclusive);
        },
        test: function(value) {
          return testRange(min, max, value, minExclusive, maxExclusive);
        },
        toString: boundNameFn,
        name: boundNameFn
      };
    }
  }
});

// node_modules/autoprefixer/lib/hacks/gradient.js
var require_gradient = __commonJS({
  "node_modules/autoprefixer/lib/hacks/gradient.js"(exports2, module2) {
    var parser = require_lib();
    var range = require_normalize_range();
    var OldValue = require_old_value();
    var Value = require_value();
    var utils = require_utils();
    var IS_DIRECTION = /top|left|right|bottom/gi;
    var Gradient = class extends Value {
      replace(string, prefix) {
        let ast = parser(string);
        for (let node of ast.nodes) {
          if (node.type === "function" && node.value === this.name) {
            node.nodes = this.newDirection(node.nodes);
            node.nodes = this.normalize(node.nodes);
            if (prefix === "-webkit- old") {
              let changes = this.oldWebkit(node);
              if (!changes) {
                return false;
              }
            } else {
              node.nodes = this.convertDirection(node.nodes);
              node.value = prefix + node.value;
            }
          }
        }
        return ast.toString();
      }
      replaceFirst(params, ...words) {
        let prefix = words.map((i) => {
          if (i === " ") {
            return { type: "space", value: i };
          }
          return { type: "word", value: i };
        });
        return prefix.concat(params.slice(1));
      }
      normalizeUnit(str, full) {
        let num = parseFloat(str);
        let deg = num / full * 360;
        return `${deg}deg`;
      }
      normalize(nodes) {
        if (!nodes[0])
          return nodes;
        if (/-?\d+(.\d+)?grad/.test(nodes[0].value)) {
          nodes[0].value = this.normalizeUnit(nodes[0].value, 400);
        } else if (/-?\d+(.\d+)?rad/.test(nodes[0].value)) {
          nodes[0].value = this.normalizeUnit(nodes[0].value, 2 * Math.PI);
        } else if (/-?\d+(.\d+)?turn/.test(nodes[0].value)) {
          nodes[0].value = this.normalizeUnit(nodes[0].value, 1);
        } else if (nodes[0].value.includes("deg")) {
          let num = parseFloat(nodes[0].value);
          num = range.wrap(0, 360, num);
          nodes[0].value = `${num}deg`;
        }
        if (nodes[0].value === "0deg") {
          nodes = this.replaceFirst(nodes, "to", " ", "top");
        } else if (nodes[0].value === "90deg") {
          nodes = this.replaceFirst(nodes, "to", " ", "right");
        } else if (nodes[0].value === "180deg") {
          nodes = this.replaceFirst(nodes, "to", " ", "bottom");
        } else if (nodes[0].value === "270deg") {
          nodes = this.replaceFirst(nodes, "to", " ", "left");
        }
        return nodes;
      }
      newDirection(params) {
        if (params[0].value === "to") {
          return params;
        }
        IS_DIRECTION.lastIndex = 0;
        if (!IS_DIRECTION.test(params[0].value)) {
          return params;
        }
        params.unshift({
          type: "word",
          value: "to"
        }, {
          type: "space",
          value: " "
        });
        for (let i = 2; i < params.length; i++) {
          if (params[i].type === "div") {
            break;
          }
          if (params[i].type === "word") {
            params[i].value = this.revertDirection(params[i].value);
          }
        }
        return params;
      }
      isRadial(params) {
        let state = "before";
        for (let param of params) {
          if (state === "before" && param.type === "space") {
            state = "at";
          } else if (state === "at" && param.value === "at") {
            state = "after";
          } else if (state === "after" && param.type === "space") {
            return true;
          } else if (param.type === "div") {
            break;
          } else {
            state = "before";
          }
        }
        return false;
      }
      convertDirection(params) {
        if (params.length > 0) {
          if (params[0].value === "to") {
            this.fixDirection(params);
          } else if (params[0].value.includes("deg")) {
            this.fixAngle(params);
          } else if (this.isRadial(params)) {
            this.fixRadial(params);
          }
        }
        return params;
      }
      fixDirection(params) {
        params.splice(0, 2);
        for (let param of params) {
          if (param.type === "div") {
            break;
          }
          if (param.type === "word") {
            param.value = this.revertDirection(param.value);
          }
        }
      }
      fixAngle(params) {
        let first = params[0].value;
        first = parseFloat(first);
        first = Math.abs(450 - first) % 360;
        first = this.roundFloat(first, 3);
        params[0].value = `${first}deg`;
      }
      fixRadial(params) {
        let first = [];
        let second = [];
        let a, b, c, i, next;
        for (i = 0; i < params.length - 2; i++) {
          a = params[i];
          b = params[i + 1];
          c = params[i + 2];
          if (a.type === "space" && b.value === "at" && c.type === "space") {
            next = i + 3;
            break;
          } else {
            first.push(a);
          }
        }
        let div;
        for (i = next; i < params.length; i++) {
          if (params[i].type === "div") {
            div = params[i];
            break;
          } else {
            second.push(params[i]);
          }
        }
        params.splice(0, i, ...second, div, ...first);
      }
      revertDirection(word) {
        return Gradient.directions[word.toLowerCase()] || word;
      }
      roundFloat(float, digits) {
        return parseFloat(float.toFixed(digits));
      }
      oldWebkit(node) {
        let { nodes } = node;
        let string = parser.stringify(node.nodes);
        if (this.name !== "linear-gradient") {
          return false;
        }
        if (nodes[0] && nodes[0].value.includes("deg")) {
          return false;
        }
        if (string.includes("px") || string.includes("-corner") || string.includes("-side")) {
          return false;
        }
        let params = [[]];
        for (let i of nodes) {
          params[params.length - 1].push(i);
          if (i.type === "div" && i.value === ",") {
            params.push([]);
          }
        }
        this.oldDirection(params);
        this.colorStops(params);
        node.nodes = [];
        for (let param of params) {
          node.nodes = node.nodes.concat(param);
        }
        node.nodes.unshift({ type: "word", value: "linear" }, this.cloneDiv(node.nodes));
        node.value = "-webkit-gradient";
        return true;
      }
      oldDirection(params) {
        let div = this.cloneDiv(params[0]);
        if (params[0][0].value !== "to") {
          return params.unshift([
            { type: "word", value: Gradient.oldDirections.bottom },
            div
          ]);
        } else {
          let words = [];
          for (let node of params[0].slice(2)) {
            if (node.type === "word") {
              words.push(node.value.toLowerCase());
            }
          }
          words = words.join(" ");
          let old = Gradient.oldDirections[words] || words;
          params[0] = [{ type: "word", value: old }, div];
          return params[0];
        }
      }
      cloneDiv(params) {
        for (let i of params) {
          if (i.type === "div" && i.value === ",") {
            return i;
          }
        }
        return { type: "div", value: ",", after: " " };
      }
      colorStops(params) {
        let result = [];
        for (let i = 0; i < params.length; i++) {
          let pos;
          let param = params[i];
          let item;
          if (i === 0) {
            continue;
          }
          let color = parser.stringify(param[0]);
          if (param[1] && param[1].type === "word") {
            pos = param[1].value;
          } else if (param[2] && param[2].type === "word") {
            pos = param[2].value;
          }
          let stop;
          if (i === 1 && (!pos || pos === "0%")) {
            stop = `from(${color})`;
          } else if (i === params.length - 1 && (!pos || pos === "100%")) {
            stop = `to(${color})`;
          } else if (pos) {
            stop = `color-stop(${pos}, ${color})`;
          } else {
            stop = `color-stop(${color})`;
          }
          let div = param[param.length - 1];
          params[i] = [{ type: "word", value: stop }];
          if (div.type === "div" && div.value === ",") {
            item = params[i].push(div);
          }
          result.push(item);
        }
        return result;
      }
      old(prefix) {
        if (prefix === "-webkit-") {
          let type = this.name === "linear-gradient" ? "linear" : "radial";
          let string = "-gradient";
          let regexp = utils.regexp(`-webkit-(${type}-gradient|gradient\\(\\s*${type})`, false);
          return new OldValue(this.name, prefix + this.name, string, regexp);
        } else {
          return super.old(prefix);
        }
      }
      add(decl, prefix) {
        let p = decl.prop;
        if (p.includes("mask")) {
          if (prefix === "-webkit-" || prefix === "-webkit- old") {
            return super.add(decl, prefix);
          }
        } else if (p === "list-style" || p === "list-style-image" || p === "content") {
          if (prefix === "-webkit-" || prefix === "-webkit- old") {
            return super.add(decl, prefix);
          }
        } else {
          return super.add(decl, prefix);
        }
        return void 0;
      }
    };
    Gradient.names = [
      "linear-gradient",
      "repeating-linear-gradient",
      "radial-gradient",
      "repeating-radial-gradient"
    ];
    Gradient.directions = {
      top: "bottom",
      left: "right",
      bottom: "top",
      right: "left"
    };
    Gradient.oldDirections = {
      "top": "left bottom, left top",
      "left": "right top, left top",
      "bottom": "left top, left bottom",
      "right": "left top, right top",
      "top right": "left bottom, right top",
      "top left": "right bottom, left top",
      "right top": "left bottom, right top",
      "right bottom": "left top, right bottom",
      "bottom right": "left top, right bottom",
      "bottom left": "right top, left bottom",
      "left top": "right bottom, left top",
      "left bottom": "right top, left bottom"
    };
    module2.exports = Gradient;
  }
});

// node_modules/autoprefixer/lib/hacks/intrinsic.js
var require_intrinsic = __commonJS({
  "node_modules/autoprefixer/lib/hacks/intrinsic.js"(exports2, module2) {
    var OldValue = require_old_value();
    var Value = require_value();
    function regexp(name) {
      return new RegExp(`(^|[\\s,(])(${name}($|[\\s),]))`, "gi");
    }
    var Intrinsic = class extends Value {
      regexp() {
        if (!this.regexpCache)
          this.regexpCache = regexp(this.name);
        return this.regexpCache;
      }
      isStretch() {
        return this.name === "stretch" || this.name === "fill" || this.name === "fill-available";
      }
      replace(string, prefix) {
        if (prefix === "-moz-" && this.isStretch()) {
          return string.replace(this.regexp(), "$1-moz-available$3");
        }
        if (prefix === "-webkit-" && this.isStretch()) {
          return string.replace(this.regexp(), "$1-webkit-fill-available$3");
        }
        return super.replace(string, prefix);
      }
      old(prefix) {
        let prefixed = prefix + this.name;
        if (this.isStretch()) {
          if (prefix === "-moz-") {
            prefixed = "-moz-available";
          } else if (prefix === "-webkit-") {
            prefixed = "-webkit-fill-available";
          }
        }
        return new OldValue(this.name, prefixed, prefixed, regexp(prefixed));
      }
      add(decl, prefix) {
        if (decl.prop.includes("grid") && prefix !== "-webkit-") {
          return void 0;
        }
        return super.add(decl, prefix);
      }
    };
    Intrinsic.names = [
      "max-content",
      "min-content",
      "fit-content",
      "fill",
      "fill-available",
      "stretch"
    ];
    module2.exports = Intrinsic;
  }
});

// node_modules/autoprefixer/lib/hacks/pixelated.js
var require_pixelated = __commonJS({
  "node_modules/autoprefixer/lib/hacks/pixelated.js"(exports2, module2) {
    var OldValue = require_old_value();
    var Value = require_value();
    var Pixelated = class extends Value {
      replace(string, prefix) {
        if (prefix === "-webkit-") {
          return string.replace(this.regexp(), "$1-webkit-optimize-contrast");
        }
        if (prefix === "-moz-") {
          return string.replace(this.regexp(), "$1-moz-crisp-edges");
        }
        return super.replace(string, prefix);
      }
      old(prefix) {
        if (prefix === "-webkit-") {
          return new OldValue(this.name, "-webkit-optimize-contrast");
        }
        if (prefix === "-moz-") {
          return new OldValue(this.name, "-moz-crisp-edges");
        }
        return super.old(prefix);
      }
    };
    Pixelated.names = ["pixelated"];
    module2.exports = Pixelated;
  }
});

// node_modules/autoprefixer/lib/hacks/image-set.js
var require_image_set = __commonJS({
  "node_modules/autoprefixer/lib/hacks/image-set.js"(exports2, module2) {
    var Value = require_value();
    var ImageSet = class extends Value {
      replace(string, prefix) {
        let fixed = super.replace(string, prefix);
        if (prefix === "-webkit-") {
          fixed = fixed.replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, "url($1)$2");
        }
        return fixed;
      }
    };
    ImageSet.names = ["image-set"];
    module2.exports = ImageSet;
  }
});

// node_modules/autoprefixer/lib/hacks/cross-fade.js
var require_cross_fade = __commonJS({
  "node_modules/autoprefixer/lib/hacks/cross-fade.js"(exports2, module2) {
    var list = require_postcss().list;
    var Value = require_value();
    var CrossFade = class extends Value {
      replace(string, prefix) {
        return list.space(string).map((value) => {
          if (value.slice(0, +this.name.length + 1) !== this.name + "(") {
            return value;
          }
          let close = value.lastIndexOf(")");
          let after = value.slice(close + 1);
          let args = value.slice(this.name.length + 1, close);
          if (prefix === "-webkit-") {
            let match = args.match(/\d*.?\d+%?/);
            if (match) {
              args = args.slice(match[0].length).trim();
              args += `, ${match[0]}`;
            } else {
              args += ", 0.5";
            }
          }
          return prefix + this.name + "(" + args + ")" + after;
        }).join(" ");
      }
    };
    CrossFade.names = ["cross-fade"];
    module2.exports = CrossFade;
  }
});

// node_modules/autoprefixer/lib/hacks/display-flex.js
var require_display_flex = __commonJS({
  "node_modules/autoprefixer/lib/hacks/display-flex.js"(exports2, module2) {
    var flexSpec = require_flex_spec();
    var OldValue = require_old_value();
    var Value = require_value();
    var DisplayFlex = class extends Value {
      constructor(name, prefixes) {
        super(name, prefixes);
        if (name === "display-flex") {
          this.name = "flex";
        }
      }
      check(decl) {
        return decl.prop === "display" && decl.value === this.name;
      }
      prefixed(prefix) {
        let spec, value;
        [spec, prefix] = flexSpec(prefix);
        if (spec === 2009) {
          if (this.name === "flex") {
            value = "box";
          } else {
            value = "inline-box";
          }
        } else if (spec === 2012) {
          if (this.name === "flex") {
            value = "flexbox";
          } else {
            value = "inline-flexbox";
          }
        } else if (spec === "final") {
          value = this.name;
        }
        return prefix + value;
      }
      replace(string, prefix) {
        return this.prefixed(prefix);
      }
      old(prefix) {
        let prefixed = this.prefixed(prefix);
        if (!prefixed)
          return void 0;
        return new OldValue(this.name, prefixed);
      }
    };
    DisplayFlex.names = ["display-flex", "inline-flex"];
    module2.exports = DisplayFlex;
  }
});

// node_modules/autoprefixer/lib/hacks/display-grid.js
var require_display_grid = __commonJS({
  "node_modules/autoprefixer/lib/hacks/display-grid.js"(exports2, module2) {
    var Value = require_value();
    var DisplayGrid = class extends Value {
      constructor(name, prefixes) {
        super(name, prefixes);
        if (name === "display-grid") {
          this.name = "grid";
        }
      }
      check(decl) {
        return decl.prop === "display" && decl.value === this.name;
      }
    };
    DisplayGrid.names = ["display-grid", "inline-grid"];
    module2.exports = DisplayGrid;
  }
});

// node_modules/autoprefixer/lib/hacks/filter-value.js
var require_filter_value = __commonJS({
  "node_modules/autoprefixer/lib/hacks/filter-value.js"(exports2, module2) {
    var Value = require_value();
    var FilterValue = class extends Value {
      constructor(name, prefixes) {
        super(name, prefixes);
        if (name === "filter-function") {
          this.name = "filter";
        }
      }
    };
    FilterValue.names = ["filter", "filter-function"];
    module2.exports = FilterValue;
  }
});

// node_modules/autoprefixer/lib/hacks/autofill.js
var require_autofill = __commonJS({
  "node_modules/autoprefixer/lib/hacks/autofill.js"(exports2, module2) {
    var Selector = require_selector();
    var utils = require_utils();
    var Autofill = class extends Selector {
      constructor(name, prefixes, all) {
        super(name, prefixes, all);
        if (this.prefixes) {
          this.prefixes = utils.uniq(this.prefixes.map(() => "-webkit-"));
        }
      }
      prefixed(prefix) {
        if (prefix === "-webkit-") {
          return ":-webkit-autofill";
        }
        return `:${prefix}autofill`;
      }
    };
    Autofill.names = [":autofill"];
    module2.exports = Autofill;
  }
});

// node_modules/autoprefixer/lib/prefixes.js
var require_prefixes = __commonJS({
  "node_modules/autoprefixer/lib/prefixes.js"(exports2, module2) {
    var vendor = require_vendor();
    var Declaration = require_declaration2();
    var Resolution = require_resolution();
    var Transition = require_transition();
    var Processor = require_processor2();
    var Supports = require_supports();
    var Browsers = require_browsers3();
    var Selector = require_selector();
    var AtRule = require_at_rule2();
    var Value = require_value();
    var utils = require_utils();
    var hackFullscreen = require_fullscreen2();
    var hackPlaceholder = require_placeholder();
    var hackPlaceholderShown = require_placeholder_shown();
    var hackFileSelectorButton = require_file_selector_button();
    var hackFlex = require_flex();
    var hackOrder = require_order();
    var hackFilter = require_filter();
    var hackGridEnd = require_grid_end();
    var hackAnimation = require_animation();
    var hackFlexFlow = require_flex_flow();
    var hackFlexGrow = require_flex_grow();
    var hackFlexWrap = require_flex_wrap();
    var hackGridArea = require_grid_area();
    var hackPlaceSelf = require_place_self();
    var hackGridStart = require_grid_start();
    var hackAlignSelf = require_align_self();
    var hackAppearance = require_appearance();
    var hackFlexBasis = require_flex_basis();
    var hackMaskBorder = require_mask_border();
    var hackMaskComposite = require_mask_composite();
    var hackAlignItems = require_align_items();
    var hackUserSelect = require_user_select();
    var hackFlexShrink = require_flex_shrink();
    var hackBreakProps = require_break_props();
    var hackWritingMode = require_writing_mode();
    var hackBorderImage = require_border_image2();
    var hackAlignContent = require_align_content();
    var hackBorderRadius = require_border_radius2();
    var hackBlockLogical = require_block_logical();
    var hackGridTemplate = require_grid_template();
    var hackInlineLogical = require_inline_logical();
    var hackGridRowAlign = require_grid_row_align();
    var hackTransformDecl = require_transform_decl();
    var hackFlexDirection = require_flex_direction();
    var hackImageRendering = require_image_rendering();
    var hackBackdropFilter = require_backdrop_filter();
    var hackBackgroundClip = require_background_clip();
    var hackTextDecoration = require_text_decoration2();
    var hackJustifyContent = require_justify_content();
    var hackBackgroundSize = require_background_size();
    var hackGridRowColumn = require_grid_row_column();
    var hackGridRowsColumns = require_grid_rows_columns();
    var hackGridColumnAlign = require_grid_column_align();
    var hackPrintColorAdjust = require_print_color_adjust();
    var hackOverscrollBehavior = require_overscroll_behavior();
    var hackGridTemplateAreas = require_grid_template_areas();
    var hackTextEmphasisPosition = require_text_emphasis_position();
    var hackTextDecorationSkipInk = require_text_decoration_skip_ink();
    var hackGradient = require_gradient();
    var hackIntrinsic = require_intrinsic();
    var hackPixelated = require_pixelated();
    var hackImageSet = require_image_set();
    var hackCrossFade = require_cross_fade();
    var hackDisplayFlex = require_display_flex();
    var hackDisplayGrid = require_display_grid();
    var hackFilterValue = require_filter_value();
    var hackAutofill = require_autofill();
    Selector.hack(hackAutofill);
    Selector.hack(hackFullscreen);
    Selector.hack(hackPlaceholder);
    Selector.hack(hackPlaceholderShown);
    Selector.hack(hackFileSelectorButton);
    Declaration.hack(hackFlex);
    Declaration.hack(hackOrder);
    Declaration.hack(hackFilter);
    Declaration.hack(hackGridEnd);
    Declaration.hack(hackAnimation);
    Declaration.hack(hackFlexFlow);
    Declaration.hack(hackFlexGrow);
    Declaration.hack(hackFlexWrap);
    Declaration.hack(hackGridArea);
    Declaration.hack(hackPlaceSelf);
    Declaration.hack(hackGridStart);
    Declaration.hack(hackAlignSelf);
    Declaration.hack(hackAppearance);
    Declaration.hack(hackFlexBasis);
    Declaration.hack(hackMaskBorder);
    Declaration.hack(hackMaskComposite);
    Declaration.hack(hackAlignItems);
    Declaration.hack(hackUserSelect);
    Declaration.hack(hackFlexShrink);
    Declaration.hack(hackBreakProps);
    Declaration.hack(hackWritingMode);
    Declaration.hack(hackBorderImage);
    Declaration.hack(hackAlignContent);
    Declaration.hack(hackBorderRadius);
    Declaration.hack(hackBlockLogical);
    Declaration.hack(hackGridTemplate);
    Declaration.hack(hackInlineLogical);
    Declaration.hack(hackGridRowAlign);
    Declaration.hack(hackTransformDecl);
    Declaration.hack(hackFlexDirection);
    Declaration.hack(hackImageRendering);
    Declaration.hack(hackBackdropFilter);
    Declaration.hack(hackBackgroundClip);
    Declaration.hack(hackTextDecoration);
    Declaration.hack(hackJustifyContent);
    Declaration.hack(hackBackgroundSize);
    Declaration.hack(hackGridRowColumn);
    Declaration.hack(hackGridRowsColumns);
    Declaration.hack(hackGridColumnAlign);
    Declaration.hack(hackOverscrollBehavior);
    Declaration.hack(hackGridTemplateAreas);
    Declaration.hack(hackPrintColorAdjust);
    Declaration.hack(hackTextEmphasisPosition);
    Declaration.hack(hackTextDecorationSkipInk);
    Value.hack(hackGradient);
    Value.hack(hackIntrinsic);
    Value.hack(hackPixelated);
    Value.hack(hackImageSet);
    Value.hack(hackCrossFade);
    Value.hack(hackDisplayFlex);
    Value.hack(hackDisplayGrid);
    Value.hack(hackFilterValue);
    var declsCache = /* @__PURE__ */ new Map();
    var Prefixes = class {
      constructor(data, browsers, options = {}) {
        this.data = data;
        this.browsers = browsers;
        this.options = options;
        [this.add, this.remove] = this.preprocess(this.select(this.data));
        this.transition = new Transition(this);
        this.processor = new Processor(this);
      }
      cleaner() {
        if (this.cleanerCache) {
          return this.cleanerCache;
        }
        if (this.browsers.selected.length) {
          let empty = new Browsers(this.browsers.data, []);
          this.cleanerCache = new Prefixes(this.data, empty, this.options);
        } else {
          return this;
        }
        return this.cleanerCache;
      }
      select(list) {
        let selected = { add: {}, remove: {} };
        for (let name in list) {
          let data = list[name];
          let add = data.browsers.map((i) => {
            let params = i.split(" ");
            return {
              browser: `${params[0]} ${params[1]}`,
              note: params[2]
            };
          });
          let notes = add.filter((i) => i.note).map((i) => `${this.browsers.prefix(i.browser)} ${i.note}`);
          notes = utils.uniq(notes);
          add = add.filter((i) => this.browsers.isSelected(i.browser)).map((i) => {
            let prefix = this.browsers.prefix(i.browser);
            if (i.note) {
              return `${prefix} ${i.note}`;
            } else {
              return prefix;
            }
          });
          add = this.sort(utils.uniq(add));
          if (this.options.flexbox === "no-2009") {
            add = add.filter((i) => !i.includes("2009"));
          }
          let all = data.browsers.map((i) => this.browsers.prefix(i));
          if (data.mistakes) {
            all = all.concat(data.mistakes);
          }
          all = all.concat(notes);
          all = utils.uniq(all);
          if (add.length) {
            selected.add[name] = add;
            if (add.length < all.length) {
              selected.remove[name] = all.filter((i) => !add.includes(i));
            }
          } else {
            selected.remove[name] = all;
          }
        }
        return selected;
      }
      sort(prefixes) {
        return prefixes.sort((a, b) => {
          let aLength = utils.removeNote(a).length;
          let bLength = utils.removeNote(b).length;
          if (aLength === bLength) {
            return b.length - a.length;
          } else {
            return bLength - aLength;
          }
        });
      }
      preprocess(selected) {
        let add = {
          "selectors": [],
          "@supports": new Supports(Prefixes, this)
        };
        for (let name in selected.add) {
          let prefixes = selected.add[name];
          if (name === "@keyframes" || name === "@viewport") {
            add[name] = new AtRule(name, prefixes, this);
          } else if (name === "@resolution") {
            add[name] = new Resolution(name, prefixes, this);
          } else if (this.data[name].selector) {
            add.selectors.push(Selector.load(name, prefixes, this));
          } else {
            let props = this.data[name].props;
            if (props) {
              let value = Value.load(name, prefixes, this);
              for (let prop of props) {
                if (!add[prop]) {
                  add[prop] = { values: [] };
                }
                add[prop].values.push(value);
              }
            } else {
              let values = add[name] && add[name].values || [];
              add[name] = Declaration.load(name, prefixes, this);
              add[name].values = values;
            }
          }
        }
        let remove = { selectors: [] };
        for (let name in selected.remove) {
          let prefixes = selected.remove[name];
          if (this.data[name].selector) {
            let selector = Selector.load(name, prefixes);
            for (let prefix of prefixes) {
              remove.selectors.push(selector.old(prefix));
            }
          } else if (name === "@keyframes" || name === "@viewport") {
            for (let prefix of prefixes) {
              let prefixed = `@${prefix}${name.slice(1)}`;
              remove[prefixed] = { remove: true };
            }
          } else if (name === "@resolution") {
            remove[name] = new Resolution(name, prefixes, this);
          } else {
            let props = this.data[name].props;
            if (props) {
              let value = Value.load(name, [], this);
              for (let prefix of prefixes) {
                let old = value.old(prefix);
                if (old) {
                  for (let prop of props) {
                    if (!remove[prop]) {
                      remove[prop] = {};
                    }
                    if (!remove[prop].values) {
                      remove[prop].values = [];
                    }
                    remove[prop].values.push(old);
                  }
                }
              }
            } else {
              for (let p of prefixes) {
                let olds = this.decl(name).old(name, p);
                if (name === "align-self") {
                  let a = add[name] && add[name].prefixes;
                  if (a) {
                    if (p === "-webkit- 2009" && a.includes("-webkit-")) {
                      continue;
                    } else if (p === "-webkit-" && a.includes("-webkit- 2009")) {
                      continue;
                    }
                  }
                }
                for (let prefixed of olds) {
                  if (!remove[prefixed]) {
                    remove[prefixed] = {};
                  }
                  remove[prefixed].remove = true;
                }
              }
            }
          }
        }
        return [add, remove];
      }
      decl(prop) {
        if (!declsCache.has(prop)) {
          declsCache.set(prop, Declaration.load(prop));
        }
        return declsCache.get(prop);
      }
      unprefixed(prop) {
        let value = this.normalize(vendor.unprefixed(prop));
        if (value === "flex-direction") {
          value = "flex-flow";
        }
        return value;
      }
      normalize(prop) {
        return this.decl(prop).normalize(prop);
      }
      prefixed(prop, prefix) {
        prop = vendor.unprefixed(prop);
        return this.decl(prop).prefixed(prop, prefix);
      }
      values(type, prop) {
        let data = this[type];
        let global2 = data["*"] && data["*"].values;
        let values = data[prop] && data[prop].values;
        if (global2 && values) {
          return utils.uniq(global2.concat(values));
        } else {
          return global2 || values || [];
        }
      }
      group(decl) {
        let rule = decl.parent;
        let index = rule.index(decl);
        let { length } = rule.nodes;
        let unprefixed = this.unprefixed(decl.prop);
        let checker = (step, callback) => {
          index += step;
          while (index >= 0 && index < length) {
            let other = rule.nodes[index];
            if (other.type === "decl") {
              if (step === -1 && other.prop === unprefixed) {
                if (!Browsers.withPrefix(other.value)) {
                  break;
                }
              }
              if (this.unprefixed(other.prop) !== unprefixed) {
                break;
              } else if (callback(other) === true) {
                return true;
              }
              if (step === 1 && other.prop === unprefixed) {
                if (!Browsers.withPrefix(other.value)) {
                  break;
                }
              }
            }
            index += step;
          }
          return false;
        };
        return {
          up(callback) {
            return checker(-1, callback);
          },
          down(callback) {
            return checker(1, callback);
          }
        };
      }
    };
    module2.exports = Prefixes;
  }
});

// node_modules/autoprefixer/data/prefixes.js
var require_prefixes2 = __commonJS({
  "node_modules/autoprefixer/data/prefixes.js"(exports2, module2) {
    var unpack = require_unpacker().feature;
    function browsersSort(a, b) {
      a = a.split(" ");
      b = b.split(" ");
      if (a[0] > b[0]) {
        return 1;
      } else if (a[0] < b[0]) {
        return -1;
      } else {
        return Math.sign(parseFloat(a[1]) - parseFloat(b[1]));
      }
    }
    function f(data, opts, callback) {
      data = unpack(data);
      if (!callback) {
        ;
        [callback, opts] = [opts, {}];
      }
      let match = opts.match || /\sx($|\s)/;
      let need = [];
      for (let browser in data.stats) {
        let versions = data.stats[browser];
        for (let version in versions) {
          let support = versions[version];
          if (support.match(match)) {
            need.push(browser + " " + version);
          }
        }
      }
      callback(need.sort(browsersSort));
    }
    var result = {};
    function prefix(names, data) {
      for (let name of names) {
        result[name] = Object.assign({}, data);
      }
    }
    function add(names, data) {
      for (let name of names) {
        result[name].browsers = result[name].browsers.concat(data.browsers).sort(browsersSort);
      }
    }
    module2.exports = result;
    var prefixBorderRadius = require_border_radius();
    f(prefixBorderRadius, (browsers) => prefix([
      "border-radius",
      "border-top-left-radius",
      "border-top-right-radius",
      "border-bottom-right-radius",
      "border-bottom-left-radius"
    ], {
      mistakes: ["-khtml-", "-ms-", "-o-"],
      feature: "border-radius",
      browsers
    }));
    var prefixBoxshadow = require_css_boxshadow();
    f(prefixBoxshadow, (browsers) => prefix(["box-shadow"], {
      mistakes: ["-khtml-"],
      feature: "css-boxshadow",
      browsers
    }));
    var prefixAnimation = require_css_animation();
    f(prefixAnimation, (browsers) => prefix([
      "animation",
      "animation-name",
      "animation-duration",
      "animation-delay",
      "animation-direction",
      "animation-fill-mode",
      "animation-iteration-count",
      "animation-play-state",
      "animation-timing-function",
      "@keyframes"
    ], {
      mistakes: ["-khtml-", "-ms-"],
      feature: "css-animation",
      browsers
    }));
    var prefixTransition = require_css_transitions();
    f(prefixTransition, (browsers) => prefix([
      "transition",
      "transition-property",
      "transition-duration",
      "transition-delay",
      "transition-timing-function"
    ], {
      mistakes: ["-khtml-", "-ms-"],
      browsers,
      feature: "css-transitions"
    }));
    var prefixTransform2d = require_transforms2d();
    f(prefixTransform2d, (browsers) => prefix(["transform", "transform-origin"], {
      feature: "transforms2d",
      browsers
    }));
    var prefixTransforms3d = require_transforms3d();
    f(prefixTransforms3d, (browsers) => {
      prefix(["perspective", "perspective-origin"], {
        feature: "transforms3d",
        browsers
      });
      return prefix(["transform-style"], {
        mistakes: ["-ms-", "-o-"],
        browsers,
        feature: "transforms3d"
      });
    });
    f(prefixTransforms3d, { match: /y\sx|y\s#2/ }, (browsers) => prefix(["backface-visibility"], {
      mistakes: ["-ms-", "-o-"],
      feature: "transforms3d",
      browsers
    }));
    var prefixGradients = require_css_gradients();
    f(prefixGradients, { match: /y\sx/ }, (browsers) => prefix([
      "linear-gradient",
      "repeating-linear-gradient",
      "radial-gradient",
      "repeating-radial-gradient"
    ], {
      props: [
        "background",
        "background-image",
        "border-image",
        "mask",
        "list-style",
        "list-style-image",
        "content",
        "mask-image"
      ],
      mistakes: ["-ms-"],
      feature: "css-gradients",
      browsers
    }));
    f(prefixGradients, { match: /a\sx/ }, (browsers) => {
      browsers = browsers.map((i) => {
        if (/firefox|op/.test(i)) {
          return i;
        } else {
          return `${i} old`;
        }
      });
      return add([
        "linear-gradient",
        "repeating-linear-gradient",
        "radial-gradient",
        "repeating-radial-gradient"
      ], {
        feature: "css-gradients",
        browsers
      });
    });
    var prefixBoxsizing = require_css3_boxsizing();
    f(prefixBoxsizing, (browsers) => prefix(["box-sizing"], {
      feature: "css3-boxsizing",
      browsers
    }));
    var prefixFilters = require_css_filters();
    f(prefixFilters, (browsers) => prefix(["filter"], {
      feature: "css-filters",
      browsers
    }));
    var prefixFilterFunction = require_css_filter_function();
    f(prefixFilterFunction, (browsers) => prefix(["filter-function"], {
      props: [
        "background",
        "background-image",
        "border-image",
        "mask",
        "list-style",
        "list-style-image",
        "content",
        "mask-image"
      ],
      feature: "css-filter-function",
      browsers
    }));
    var prefixBackdrop = require_css_backdrop_filter();
    f(prefixBackdrop, { match: /y\sx|y\s#2/ }, (browsers) => prefix(["backdrop-filter"], {
      feature: "css-backdrop-filter",
      browsers
    }));
    var prefixElementFunction = require_css_element_function();
    f(prefixElementFunction, (browsers) => prefix(["element"], {
      props: [
        "background",
        "background-image",
        "border-image",
        "mask",
        "list-style",
        "list-style-image",
        "content",
        "mask-image"
      ],
      feature: "css-element-function",
      browsers
    }));
    var prefixMulticolumns = require_multicolumn();
    f(prefixMulticolumns, (browsers) => {
      prefix([
        "columns",
        "column-width",
        "column-gap",
        "column-rule",
        "column-rule-color",
        "column-rule-width",
        "column-count",
        "column-rule-style",
        "column-span",
        "column-fill"
      ], {
        feature: "multicolumn",
        browsers
      });
      let noff = browsers.filter((i) => !/firefox/.test(i));
      prefix(["break-before", "break-after", "break-inside"], {
        feature: "multicolumn",
        browsers: noff
      });
    });
    var prefixUserSelect = require_user_select_none();
    f(prefixUserSelect, (browsers) => prefix(["user-select"], {
      mistakes: ["-khtml-"],
      feature: "user-select-none",
      browsers
    }));
    var prefixFlexbox = require_flexbox();
    f(prefixFlexbox, { match: /a\sx/ }, (browsers) => {
      browsers = browsers.map((i) => {
        if (/ie|firefox/.test(i)) {
          return i;
        } else {
          return `${i} 2009`;
        }
      });
      prefix(["display-flex", "inline-flex"], {
        props: ["display"],
        feature: "flexbox",
        browsers
      });
      prefix(["flex", "flex-grow", "flex-shrink", "flex-basis"], {
        feature: "flexbox",
        browsers
      });
      prefix([
        "flex-direction",
        "flex-wrap",
        "flex-flow",
        "justify-content",
        "order",
        "align-items",
        "align-self",
        "align-content"
      ], {
        feature: "flexbox",
        browsers
      });
    });
    f(prefixFlexbox, { match: /y\sx/ }, (browsers) => {
      add(["display-flex", "inline-flex"], {
        feature: "flexbox",
        browsers
      });
      add(["flex", "flex-grow", "flex-shrink", "flex-basis"], {
        feature: "flexbox",
        browsers
      });
      add([
        "flex-direction",
        "flex-wrap",
        "flex-flow",
        "justify-content",
        "order",
        "align-items",
        "align-self",
        "align-content"
      ], {
        feature: "flexbox",
        browsers
      });
    });
    var prefixCalc = require_calc();
    f(prefixCalc, (browsers) => prefix(["calc"], {
      props: ["*"],
      feature: "calc",
      browsers
    }));
    var prefixBackgroundOptions = require_background_img_opts();
    f(prefixBackgroundOptions, (browsers) => prefix(["background-origin", "background-size"], {
      feature: "background-img-opts",
      browsers
    }));
    var prefixBackgroundClipText = require_background_clip_text();
    f(prefixBackgroundClipText, (browsers) => prefix(["background-clip"], {
      feature: "background-clip-text",
      browsers
    }));
    var prefixFontFeature = require_font_feature();
    f(prefixFontFeature, (browsers) => prefix([
      "font-feature-settings",
      "font-variant-ligatures",
      "font-language-override"
    ], {
      feature: "font-feature",
      browsers
    }));
    var prefixFontKerning = require_font_kerning();
    f(prefixFontKerning, (browsers) => prefix(["font-kerning"], {
      feature: "font-kerning",
      browsers
    }));
    var prefixBorderImage = require_border_image();
    f(prefixBorderImage, (browsers) => prefix(["border-image"], {
      feature: "border-image",
      browsers
    }));
    var prefixSelection = require_css_selection();
    f(prefixSelection, (browsers) => prefix(["::selection"], {
      selector: true,
      feature: "css-selection",
      browsers
    }));
    var prefixPlaceholder = require_css_placeholder();
    f(prefixPlaceholder, (browsers) => {
      prefix(["::placeholder"], {
        selector: true,
        feature: "css-placeholder",
        browsers: browsers.concat(["ie 10 old", "ie 11 old", "firefox 18 old"])
      });
    });
    var prefixPlaceholderShown = require_css_placeholder_shown();
    f(prefixPlaceholderShown, (browsers) => {
      prefix([":placeholder-shown"], {
        selector: true,
        feature: "css-placeholder-shown",
        browsers
      });
    });
    var prefixHyphens = require_css_hyphens();
    f(prefixHyphens, (browsers) => prefix(["hyphens"], {
      feature: "css-hyphens",
      browsers
    }));
    var prefixFullscreen = require_fullscreen();
    f(prefixFullscreen, (browsers) => prefix([":fullscreen"], {
      selector: true,
      feature: "fullscreen",
      browsers
    }));
    f(prefixFullscreen, { match: /x(\s#2|$)/ }, (browsers) => prefix(["::backdrop"], {
      selector: true,
      feature: "fullscreen",
      browsers
    }));
    var prefixFileSelectorButton = require_css_file_selector_button();
    f(prefixFileSelectorButton, (browsers) => prefix(["::file-selector-button"], {
      selector: true,
      feature: "file-selector-button",
      browsers
    }));
    var prefixAutofill = require_css_autofill();
    f(prefixAutofill, (browsers) => prefix([":autofill"], {
      selector: true,
      feature: "css-autofill",
      browsers
    }));
    var prefixTabsize = require_css3_tabsize();
    f(prefixTabsize, (browsers) => prefix(["tab-size"], {
      feature: "css3-tabsize",
      browsers
    }));
    var prefixIntrinsic = require_intrinsic_width();
    var sizeProps = [
      "width",
      "min-width",
      "max-width",
      "height",
      "min-height",
      "max-height",
      "inline-size",
      "min-inline-size",
      "max-inline-size",
      "block-size",
      "min-block-size",
      "max-block-size",
      "grid",
      "grid-template",
      "grid-template-rows",
      "grid-template-columns",
      "grid-auto-columns",
      "grid-auto-rows"
    ];
    f(prefixIntrinsic, (browsers) => prefix(["max-content", "min-content"], {
      props: sizeProps,
      feature: "intrinsic-width",
      browsers
    }));
    f(prefixIntrinsic, { match: /x|\s#4/ }, (browsers) => prefix(["fill", "fill-available"], {
      props: sizeProps,
      feature: "intrinsic-width",
      browsers
    }));
    f(prefixIntrinsic, { match: /x|\s#5/ }, (browsers) => prefix(["fit-content"], {
      props: sizeProps,
      feature: "intrinsic-width",
      browsers
    }));
    var prefixStretch = require_css_width_stretch();
    f(prefixStretch, (browsers) => prefix(["stretch"], {
      props: sizeProps,
      feature: "css-width-stretch",
      browsers
    }));
    var prefixCursorsNewer = require_css3_cursors_newer();
    f(prefixCursorsNewer, (browsers) => prefix(["zoom-in", "zoom-out"], {
      props: ["cursor"],
      feature: "css3-cursors-newer",
      browsers
    }));
    var prefixCursorsGrab = require_css3_cursors_grab();
    f(prefixCursorsGrab, (browsers) => prefix(["grab", "grabbing"], {
      props: ["cursor"],
      feature: "css3-cursors-grab",
      browsers
    }));
    var prefixSticky = require_css_sticky();
    f(prefixSticky, (browsers) => prefix(["sticky"], {
      props: ["position"],
      feature: "css-sticky",
      browsers
    }));
    var prefixPointer = require_pointer();
    f(prefixPointer, (browsers) => prefix(["touch-action"], {
      feature: "pointer",
      browsers
    }));
    var prefixDecoration = require_text_decoration();
    f(prefixDecoration, (browsers) => prefix([
      "text-decoration-style",
      "text-decoration-color",
      "text-decoration-line",
      "text-decoration"
    ], {
      feature: "text-decoration",
      browsers
    }));
    f(prefixDecoration, { match: /x.*#[235]/ }, (browsers) => prefix(["text-decoration-skip", "text-decoration-skip-ink"], {
      feature: "text-decoration",
      browsers
    }));
    var prefixTextSizeAdjust = require_text_size_adjust();
    f(prefixTextSizeAdjust, (browsers) => prefix(["text-size-adjust"], {
      feature: "text-size-adjust",
      browsers
    }));
    var prefixCssMasks = require_css_masks();
    f(prefixCssMasks, (browsers) => {
      prefix([
        "mask-clip",
        "mask-composite",
        "mask-image",
        "mask-origin",
        "mask-repeat",
        "mask-border-repeat",
        "mask-border-source"
      ], {
        feature: "css-masks",
        browsers
      });
      prefix([
        "mask",
        "mask-position",
        "mask-size",
        "mask-border",
        "mask-border-outset",
        "mask-border-width",
        "mask-border-slice"
      ], {
        feature: "css-masks",
        browsers
      });
    });
    var prefixClipPath = require_css_clip_path();
    f(prefixClipPath, (browsers) => prefix(["clip-path"], {
      feature: "css-clip-path",
      browsers
    }));
    var prefixBoxdecoration = require_css_boxdecorationbreak();
    f(prefixBoxdecoration, (browsers) => prefix(["box-decoration-break"], {
      feature: "css-boxdecorationbreak",
      browsers
    }));
    var prefixObjectFit = require_object_fit();
    f(prefixObjectFit, (browsers) => prefix(["object-fit", "object-position"], {
      feature: "object-fit",
      browsers
    }));
    var prefixShapes = require_css_shapes();
    f(prefixShapes, (browsers) => prefix(["shape-margin", "shape-outside", "shape-image-threshold"], {
      feature: "css-shapes",
      browsers
    }));
    var prefixTextOverflow = require_text_overflow();
    f(prefixTextOverflow, (browsers) => prefix(["text-overflow"], {
      feature: "text-overflow",
      browsers
    }));
    var prefixDeviceadaptation = require_css_deviceadaptation();
    f(prefixDeviceadaptation, (browsers) => prefix(["@viewport"], {
      feature: "css-deviceadaptation",
      browsers
    }));
    var prefixResolut = require_css_media_resolution();
    f(prefixResolut, { match: /( x($| )|a #2)/ }, (browsers) => prefix(["@resolution"], {
      feature: "css-media-resolution",
      browsers
    }));
    var prefixTextAlignLast = require_css_text_align_last();
    f(prefixTextAlignLast, (browsers) => prefix(["text-align-last"], {
      feature: "css-text-align-last",
      browsers
    }));
    var prefixCrispedges = require_css_crisp_edges();
    f(prefixCrispedges, { match: /y x|a x #1/ }, (browsers) => prefix(["pixelated"], {
      props: ["image-rendering"],
      feature: "css-crisp-edges",
      browsers
    }));
    f(prefixCrispedges, { match: /a x #2/ }, (browsers) => prefix(["image-rendering"], {
      feature: "css-crisp-edges",
      browsers
    }));
    var prefixLogicalProps = require_css_logical_props();
    f(prefixLogicalProps, (browsers) => prefix([
      "border-inline-start",
      "border-inline-end",
      "margin-inline-start",
      "margin-inline-end",
      "padding-inline-start",
      "padding-inline-end"
    ], {
      feature: "css-logical-props",
      browsers
    }));
    f(prefixLogicalProps, { match: /x\s#2/ }, (browsers) => prefix([
      "border-block-start",
      "border-block-end",
      "margin-block-start",
      "margin-block-end",
      "padding-block-start",
      "padding-block-end"
    ], {
      feature: "css-logical-props",
      browsers
    }));
    var prefixAppearance = require_css_appearance();
    f(prefixAppearance, { match: /#2|x/ }, (browsers) => prefix(["appearance"], {
      feature: "css-appearance",
      browsers
    }));
    var prefixSnappoints = require_css_snappoints();
    f(prefixSnappoints, (browsers) => prefix([
      "scroll-snap-type",
      "scroll-snap-coordinate",
      "scroll-snap-destination",
      "scroll-snap-points-x",
      "scroll-snap-points-y"
    ], {
      feature: "css-snappoints",
      browsers
    }));
    var prefixRegions = require_css_regions();
    f(prefixRegions, (browsers) => prefix(["flow-into", "flow-from", "region-fragment"], {
      feature: "css-regions",
      browsers
    }));
    var prefixImageSet = require_css_image_set();
    f(prefixImageSet, (browsers) => prefix(["image-set"], {
      props: [
        "background",
        "background-image",
        "border-image",
        "cursor",
        "mask",
        "mask-image",
        "list-style",
        "list-style-image",
        "content"
      ],
      feature: "css-image-set",
      browsers
    }));
    var prefixWritingMode = require_css_writing_mode();
    f(prefixWritingMode, { match: /a|x/ }, (browsers) => prefix(["writing-mode"], {
      feature: "css-writing-mode",
      browsers
    }));
    var prefixCrossFade = require_css_cross_fade();
    f(prefixCrossFade, (browsers) => prefix(["cross-fade"], {
      props: [
        "background",
        "background-image",
        "border-image",
        "mask",
        "list-style",
        "list-style-image",
        "content",
        "mask-image"
      ],
      feature: "css-cross-fade",
      browsers
    }));
    var prefixReadOnly = require_css_read_only_write();
    f(prefixReadOnly, (browsers) => prefix([":read-only", ":read-write"], {
      selector: true,
      feature: "css-read-only-write",
      browsers
    }));
    var prefixTextEmphasis = require_text_emphasis();
    f(prefixTextEmphasis, (browsers) => prefix([
      "text-emphasis",
      "text-emphasis-position",
      "text-emphasis-style",
      "text-emphasis-color"
    ], {
      feature: "text-emphasis",
      browsers
    }));
    var prefixGrid = require_css_grid();
    f(prefixGrid, (browsers) => {
      prefix(["display-grid", "inline-grid"], {
        props: ["display"],
        feature: "css-grid",
        browsers
      });
      prefix([
        "grid-template-columns",
        "grid-template-rows",
        "grid-row-start",
        "grid-column-start",
        "grid-row-end",
        "grid-column-end",
        "grid-row",
        "grid-column",
        "grid-area",
        "grid-template",
        "grid-template-areas",
        "place-self"
      ], {
        feature: "css-grid",
        browsers
      });
    });
    f(prefixGrid, { match: /a x/ }, (browsers) => prefix(["grid-column-align", "grid-row-align"], {
      feature: "css-grid",
      browsers
    }));
    var prefixTextSpacing = require_css_text_spacing();
    f(prefixTextSpacing, (browsers) => prefix(["text-spacing"], {
      feature: "css-text-spacing",
      browsers
    }));
    var prefixAnyLink = require_css_any_link();
    f(prefixAnyLink, (browsers) => prefix([":any-link"], {
      selector: true,
      feature: "css-any-link",
      browsers
    }));
    var prefixBidi = require_css_unicode_bidi();
    f(prefixBidi, (browsers) => prefix(["isolate"], {
      props: ["unicode-bidi"],
      feature: "css-unicode-bidi",
      browsers
    }));
    f(prefixBidi, { match: /y x|a x #2/ }, (browsers) => prefix(["plaintext"], {
      props: ["unicode-bidi"],
      feature: "css-unicode-bidi",
      browsers
    }));
    f(prefixBidi, { match: /y x/ }, (browsers) => prefix(["isolate-override"], {
      props: ["unicode-bidi"],
      feature: "css-unicode-bidi",
      browsers
    }));
    var prefixOverscroll = require_css_overscroll_behavior();
    f(prefixOverscroll, { match: /a #1/ }, (browsers) => prefix(["overscroll-behavior"], {
      feature: "css-overscroll-behavior",
      browsers
    }));
    var prefixTextOrientation = require_css_text_orientation();
    f(prefixTextOrientation, (browsers) => prefix(["text-orientation"], {
      feature: "css-text-orientation",
      browsers
    }));
    var prefixPrintAdjust = require_css_print_color_adjust();
    f(prefixPrintAdjust, (browsers) => prefix(["print-color-adjust", "color-adjust"], {
      feature: "css-print-color-adjust",
      browsers
    }));
  }
});

// node_modules/autoprefixer/lib/info.js
var require_info = __commonJS({
  "node_modules/autoprefixer/lib/info.js"(exports2, module2) {
    var browserslist = require_browserslist();
    function capitalize(str) {
      return str.slice(0, 1).toUpperCase() + str.slice(1);
    }
    var NAMES = {
      ie: "IE",
      ie_mob: "IE Mobile",
      ios_saf: "iOS Safari",
      op_mini: "Opera Mini",
      op_mob: "Opera Mobile",
      and_chr: "Chrome for Android",
      and_ff: "Firefox for Android",
      and_uc: "UC for Android",
      and_qq: "QQ Browser",
      kaios: "KaiOS Browser",
      baidu: "Baidu Browser",
      samsung: "Samsung Internet"
    };
    function prefix(name, prefixes, note) {
      let out = `  ${name}`;
      if (note)
        out += " *";
      out += ": ";
      out += prefixes.map((i) => i.replace(/^-(.*)-$/g, "$1")).join(", ");
      out += "\n";
      return out;
    }
    module2.exports = function(prefixes) {
      if (prefixes.browsers.selected.length === 0) {
        return "No browsers selected";
      }
      let versions = {};
      for (let browser of prefixes.browsers.selected) {
        let parts = browser.split(" ");
        let name = parts[0];
        let version = parts[1];
        name = NAMES[name] || capitalize(name);
        if (versions[name]) {
          versions[name].push(version);
        } else {
          versions[name] = [version];
        }
      }
      let out = "Browsers:\n";
      for (let browser in versions) {
        let list = versions[browser];
        list = list.sort((a, b) => parseFloat(b) - parseFloat(a));
        out += `  ${browser}: ${list.join(", ")}
`;
      }
      let coverage = browserslist.coverage(prefixes.browsers.selected);
      let round = Math.round(coverage * 100) / 100;
      out += `
These browsers account for ${round}% of all users globally
`;
      let atrules = [];
      for (let name in prefixes.add) {
        let data = prefixes.add[name];
        if (name[0] === "@" && data.prefixes) {
          atrules.push(prefix(name, data.prefixes));
        }
      }
      if (atrules.length > 0) {
        out += `
At-Rules:
${atrules.sort().join("")}`;
      }
      let selectors = [];
      for (let selector of prefixes.add.selectors) {
        if (selector.prefixes) {
          selectors.push(prefix(selector.name, selector.prefixes));
        }
      }
      if (selectors.length > 0) {
        out += `
Selectors:
${selectors.sort().join("")}`;
      }
      let values = [];
      let props = [];
      let hadGrid = false;
      for (let name in prefixes.add) {
        let data = prefixes.add[name];
        if (name[0] !== "@" && data.prefixes) {
          let grid = name.indexOf("grid-") === 0;
          if (grid)
            hadGrid = true;
          props.push(prefix(name, data.prefixes, grid));
        }
        if (!Array.isArray(data.values)) {
          continue;
        }
        for (let value of data.values) {
          let grid = value.name.includes("grid");
          if (grid)
            hadGrid = true;
          let string = prefix(value.name, value.prefixes, grid);
          if (!values.includes(string)) {
            values.push(string);
          }
        }
      }
      if (props.length > 0) {
        out += `
Properties:
${props.sort().join("")}`;
      }
      if (values.length > 0) {
        out += `
Values:
${values.sort().join("")}`;
      }
      if (hadGrid) {
        out += "\n* - Prefixes will be added only on grid: true option.\n";
      }
      if (!atrules.length && !selectors.length && !props.length && !values.length) {
        out += "\nAwesome! Your browsers don't require any vendor prefixes.\nNow you can remove Autoprefixer from build steps.";
      }
      return out;
    };
  }
});

// node_modules/autoprefixer/lib/autoprefixer.js
var require_autoprefixer = __commonJS({
  "node_modules/autoprefixer/lib/autoprefixer.js"(exports2, module2) {
    var browserslist = require_browserslist();
    var { agents } = require_unpacker();
    var pico = require_picocolors();
    var Browsers = require_browsers3();
    var Prefixes = require_prefixes();
    var dataPrefixes = require_prefixes2();
    var getInfo = require_info();
    var autoprefixerData = { browsers: agents, prefixes: dataPrefixes };
    var WARNING = "\n  Replace Autoprefixer `browsers` option to Browserslist config.\n  Use `browserslist` key in `package.json` or `.browserslistrc` file.\n\n  Using `browsers` option can cause errors. Browserslist config can\n  be used for Babel, Autoprefixer, postcss-normalize and other tools.\n\n  If you really need to use option, rename it to `overrideBrowserslist`.\n\n  Learn more at:\n  https://github.com/browserslist/browserslist#readme\n  https://twitter.com/browserslist\n\n";
    function isPlainObject(obj) {
      return Object.prototype.toString.apply(obj) === "[object Object]";
    }
    var cache = /* @__PURE__ */ new Map();
    function timeCapsule(result, prefixes) {
      if (prefixes.browsers.selected.length === 0) {
        return;
      }
      if (prefixes.add.selectors.length > 0) {
        return;
      }
      if (Object.keys(prefixes.add).length > 2) {
        return;
      }
      result.warn("Autoprefixer target browsers do not need any prefixes.You do not need Autoprefixer anymore.\nCheck your Browserslist config to be sure that your targets are set up correctly.\n\n  Learn more at:\n  https://github.com/postcss/autoprefixer#readme\n  https://github.com/browserslist/browserslist#readme\n\n");
    }
    module2.exports = plugin;
    function plugin(...reqs) {
      let options;
      if (reqs.length === 1 && isPlainObject(reqs[0])) {
        options = reqs[0];
        reqs = void 0;
      } else if (reqs.length === 0 || reqs.length === 1 && !reqs[0]) {
        reqs = void 0;
      } else if (reqs.length <= 2 && (Array.isArray(reqs[0]) || !reqs[0])) {
        options = reqs[1];
        reqs = reqs[0];
      } else if (typeof reqs[reqs.length - 1] === "object") {
        options = reqs.pop();
      }
      if (!options) {
        options = {};
      }
      if (options.browser) {
        throw new Error("Change `browser` option to `overrideBrowserslist` in Autoprefixer");
      } else if (options.browserslist) {
        throw new Error("Change `browserslist` option to `overrideBrowserslist` in Autoprefixer");
      }
      if (options.overrideBrowserslist) {
        reqs = options.overrideBrowserslist;
      } else if (options.browsers) {
        if (typeof console !== "undefined" && console.warn) {
          console.warn(pico.red(WARNING.replace(/`[^`]+`/g, (i) => pico.yellow(i.slice(1, -1)))));
        }
        reqs = options.browsers;
      }
      let brwlstOpts = {
        ignoreUnknownVersions: options.ignoreUnknownVersions,
        stats: options.stats,
        env: options.env
      };
      function loadPrefixes(opts) {
        let d = autoprefixerData;
        let browsers = new Browsers(d.browsers, reqs, opts, brwlstOpts);
        let key = browsers.selected.join(", ") + JSON.stringify(options);
        if (!cache.has(key)) {
          cache.set(key, new Prefixes(d.prefixes, browsers, options));
        }
        return cache.get(key);
      }
      return {
        postcssPlugin: "autoprefixer",
        prepare(result) {
          let prefixes = loadPrefixes({
            from: result.opts.from,
            env: options.env
          });
          return {
            OnceExit(root) {
              timeCapsule(result, prefixes);
              if (options.remove !== false) {
                prefixes.processor.remove(root, result);
              }
              if (options.add !== false) {
                prefixes.processor.add(root, result);
              }
            }
          };
        },
        info(opts) {
          opts = opts || {};
          opts.from = opts.from || process.cwd();
          return getInfo(loadPrefixes(opts));
        },
        options,
        browsers: reqs
      };
    }
    plugin.postcss = true;
    plugin.data = autoprefixerData;
    plugin.defaults = browserslist.defaults;
    plugin.info = () => plugin().info();
  }
});

// node_modules/yaml/dist/PlainValue-ec8e588e.js
var require_PlainValue_ec8e588e = __commonJS({
  "node_modules/yaml/dist/PlainValue-ec8e588e.js"(exports2) {
    "use strict";
    var Char = {
      ANCHOR: "&",
      COMMENT: "#",
      TAG: "!",
      DIRECTIVES_END: "-",
      DOCUMENT_END: "."
    };
    var Type = {
      ALIAS: "ALIAS",
      BLANK_LINE: "BLANK_LINE",
      BLOCK_FOLDED: "BLOCK_FOLDED",
      BLOCK_LITERAL: "BLOCK_LITERAL",
      COMMENT: "COMMENT",
      DIRECTIVE: "DIRECTIVE",
      DOCUMENT: "DOCUMENT",
      FLOW_MAP: "FLOW_MAP",
      FLOW_SEQ: "FLOW_SEQ",
      MAP: "MAP",
      MAP_KEY: "MAP_KEY",
      MAP_VALUE: "MAP_VALUE",
      PLAIN: "PLAIN",
      QUOTE_DOUBLE: "QUOTE_DOUBLE",
      QUOTE_SINGLE: "QUOTE_SINGLE",
      SEQ: "SEQ",
      SEQ_ITEM: "SEQ_ITEM"
    };
    var defaultTagPrefix = "tag:yaml.org,2002:";
    var defaultTags = {
      MAP: "tag:yaml.org,2002:map",
      SEQ: "tag:yaml.org,2002:seq",
      STR: "tag:yaml.org,2002:str"
    };
    function findLineStarts(src) {
      const ls = [0];
      let offset = src.indexOf("\n");
      while (offset !== -1) {
        offset += 1;
        ls.push(offset);
        offset = src.indexOf("\n", offset);
      }
      return ls;
    }
    function getSrcInfo(cst) {
      let lineStarts, src;
      if (typeof cst === "string") {
        lineStarts = findLineStarts(cst);
        src = cst;
      } else {
        if (Array.isArray(cst))
          cst = cst[0];
        if (cst && cst.context) {
          if (!cst.lineStarts)
            cst.lineStarts = findLineStarts(cst.context.src);
          lineStarts = cst.lineStarts;
          src = cst.context.src;
        }
      }
      return {
        lineStarts,
        src
      };
    }
    function getLinePos(offset, cst) {
      if (typeof offset !== "number" || offset < 0)
        return null;
      const {
        lineStarts,
        src
      } = getSrcInfo(cst);
      if (!lineStarts || !src || offset > src.length)
        return null;
      for (let i = 0; i < lineStarts.length; ++i) {
        const start = lineStarts[i];
        if (offset < start) {
          return {
            line: i,
            col: offset - lineStarts[i - 1] + 1
          };
        }
        if (offset === start)
          return {
            line: i + 1,
            col: 1
          };
      }
      const line = lineStarts.length;
      return {
        line,
        col: offset - lineStarts[line - 1] + 1
      };
    }
    function getLine(line, cst) {
      const {
        lineStarts,
        src
      } = getSrcInfo(cst);
      if (!lineStarts || !(line >= 1) || line > lineStarts.length)
        return null;
      const start = lineStarts[line - 1];
      let end = lineStarts[line];
      while (end && end > start && src[end - 1] === "\n")
        --end;
      return src.slice(start, end);
    }
    function getPrettyContext({
      start,
      end
    }, cst, maxWidth = 80) {
      let src = getLine(start.line, cst);
      if (!src)
        return null;
      let {
        col
      } = start;
      if (src.length > maxWidth) {
        if (col <= maxWidth - 10) {
          src = src.substr(0, maxWidth - 1) + "\u2026";
        } else {
          const halfWidth = Math.round(maxWidth / 2);
          if (src.length > col + halfWidth)
            src = src.substr(0, col + halfWidth - 1) + "\u2026";
          col -= src.length - maxWidth;
          src = "\u2026" + src.substr(1 - maxWidth);
        }
      }
      let errLen = 1;
      let errEnd = "";
      if (end) {
        if (end.line === start.line && col + (end.col - start.col) <= maxWidth + 1) {
          errLen = end.col - start.col;
        } else {
          errLen = Math.min(src.length + 1, maxWidth) - col;
          errEnd = "\u2026";
        }
      }
      const offset = col > 1 ? " ".repeat(col - 1) : "";
      const err = "^".repeat(errLen);
      return `${src}
${offset}${err}${errEnd}`;
    }
    var Range = class {
      static copy(orig) {
        return new Range(orig.start, orig.end);
      }
      constructor(start, end) {
        this.start = start;
        this.end = end || start;
      }
      isEmpty() {
        return typeof this.start !== "number" || !this.end || this.end <= this.start;
      }
      setOrigRange(cr, offset) {
        const {
          start,
          end
        } = this;
        if (cr.length === 0 || end <= cr[0]) {
          this.origStart = start;
          this.origEnd = end;
          return offset;
        }
        let i = offset;
        while (i < cr.length) {
          if (cr[i] > start)
            break;
          else
            ++i;
        }
        this.origStart = start + i;
        const nextOffset = i;
        while (i < cr.length) {
          if (cr[i] >= end)
            break;
          else
            ++i;
        }
        this.origEnd = end + i;
        return nextOffset;
      }
    };
    var Node = class {
      static addStringTerminator(src, offset, str) {
        if (str[str.length - 1] === "\n")
          return str;
        const next = Node.endOfWhiteSpace(src, offset);
        return next >= src.length || src[next] === "\n" ? str + "\n" : str;
      }
      static atDocumentBoundary(src, offset, sep) {
        const ch0 = src[offset];
        if (!ch0)
          return true;
        const prev = src[offset - 1];
        if (prev && prev !== "\n")
          return false;
        if (sep) {
          if (ch0 !== sep)
            return false;
        } else {
          if (ch0 !== Char.DIRECTIVES_END && ch0 !== Char.DOCUMENT_END)
            return false;
        }
        const ch1 = src[offset + 1];
        const ch2 = src[offset + 2];
        if (ch1 !== ch0 || ch2 !== ch0)
          return false;
        const ch3 = src[offset + 3];
        return !ch3 || ch3 === "\n" || ch3 === "	" || ch3 === " ";
      }
      static endOfIdentifier(src, offset) {
        let ch = src[offset];
        const isVerbatim = ch === "<";
        const notOk = isVerbatim ? ["\n", "	", " ", ">"] : ["\n", "	", " ", "[", "]", "{", "}", ","];
        while (ch && notOk.indexOf(ch) === -1)
          ch = src[offset += 1];
        if (isVerbatim && ch === ">")
          offset += 1;
        return offset;
      }
      static endOfIndent(src, offset) {
        let ch = src[offset];
        while (ch === " ")
          ch = src[offset += 1];
        return offset;
      }
      static endOfLine(src, offset) {
        let ch = src[offset];
        while (ch && ch !== "\n")
          ch = src[offset += 1];
        return offset;
      }
      static endOfWhiteSpace(src, offset) {
        let ch = src[offset];
        while (ch === "	" || ch === " ")
          ch = src[offset += 1];
        return offset;
      }
      static startOfLine(src, offset) {
        let ch = src[offset - 1];
        if (ch === "\n")
          return offset;
        while (ch && ch !== "\n")
          ch = src[offset -= 1];
        return offset + 1;
      }
      static endOfBlockIndent(src, indent, lineStart) {
        const inEnd = Node.endOfIndent(src, lineStart);
        if (inEnd > lineStart + indent) {
          return inEnd;
        } else {
          const wsEnd = Node.endOfWhiteSpace(src, inEnd);
          const ch = src[wsEnd];
          if (!ch || ch === "\n")
            return wsEnd;
        }
        return null;
      }
      static atBlank(src, offset, endAsBlank) {
        const ch = src[offset];
        return ch === "\n" || ch === "	" || ch === " " || endAsBlank && !ch;
      }
      static nextNodeIsIndented(ch, indentDiff, indicatorAsIndent) {
        if (!ch || indentDiff < 0)
          return false;
        if (indentDiff > 0)
          return true;
        return indicatorAsIndent && ch === "-";
      }
      static normalizeOffset(src, offset) {
        const ch = src[offset];
        return !ch ? offset : ch !== "\n" && src[offset - 1] === "\n" ? offset - 1 : Node.endOfWhiteSpace(src, offset);
      }
      static foldNewline(src, offset, indent) {
        let inCount = 0;
        let error = false;
        let fold = "";
        let ch = src[offset + 1];
        while (ch === " " || ch === "	" || ch === "\n") {
          switch (ch) {
            case "\n":
              inCount = 0;
              offset += 1;
              fold += "\n";
              break;
            case "	":
              if (inCount <= indent)
                error = true;
              offset = Node.endOfWhiteSpace(src, offset + 2) - 1;
              break;
            case " ":
              inCount += 1;
              offset += 1;
              break;
          }
          ch = src[offset + 1];
        }
        if (!fold)
          fold = " ";
        if (ch && inCount <= indent)
          error = true;
        return {
          fold,
          offset,
          error
        };
      }
      constructor(type, props, context) {
        Object.defineProperty(this, "context", {
          value: context || null,
          writable: true
        });
        this.error = null;
        this.range = null;
        this.valueRange = null;
        this.props = props || [];
        this.type = type;
        this.value = null;
      }
      getPropValue(idx, key, skipKey) {
        if (!this.context)
          return null;
        const {
          src
        } = this.context;
        const prop = this.props[idx];
        return prop && src[prop.start] === key ? src.slice(prop.start + (skipKey ? 1 : 0), prop.end) : null;
      }
      get anchor() {
        for (let i = 0; i < this.props.length; ++i) {
          const anchor = this.getPropValue(i, Char.ANCHOR, true);
          if (anchor != null)
            return anchor;
        }
        return null;
      }
      get comment() {
        const comments = [];
        for (let i = 0; i < this.props.length; ++i) {
          const comment = this.getPropValue(i, Char.COMMENT, true);
          if (comment != null)
            comments.push(comment);
        }
        return comments.length > 0 ? comments.join("\n") : null;
      }
      commentHasRequiredWhitespace(start) {
        const {
          src
        } = this.context;
        if (this.header && start === this.header.end)
          return false;
        if (!this.valueRange)
          return false;
        const {
          end
        } = this.valueRange;
        return start !== end || Node.atBlank(src, end - 1);
      }
      get hasComment() {
        if (this.context) {
          const {
            src
          } = this.context;
          for (let i = 0; i < this.props.length; ++i) {
            if (src[this.props[i].start] === Char.COMMENT)
              return true;
          }
        }
        return false;
      }
      get hasProps() {
        if (this.context) {
          const {
            src
          } = this.context;
          for (let i = 0; i < this.props.length; ++i) {
            if (src[this.props[i].start] !== Char.COMMENT)
              return true;
          }
        }
        return false;
      }
      get includesTrailingLines() {
        return false;
      }
      get jsonLike() {
        const jsonLikeTypes = [Type.FLOW_MAP, Type.FLOW_SEQ, Type.QUOTE_DOUBLE, Type.QUOTE_SINGLE];
        return jsonLikeTypes.indexOf(this.type) !== -1;
      }
      get rangeAsLinePos() {
        if (!this.range || !this.context)
          return void 0;
        const start = getLinePos(this.range.start, this.context.root);
        if (!start)
          return void 0;
        const end = getLinePos(this.range.end, this.context.root);
        return {
          start,
          end
        };
      }
      get rawValue() {
        if (!this.valueRange || !this.context)
          return null;
        const {
          start,
          end
        } = this.valueRange;
        return this.context.src.slice(start, end);
      }
      get tag() {
        for (let i = 0; i < this.props.length; ++i) {
          const tag = this.getPropValue(i, Char.TAG, false);
          if (tag != null) {
            if (tag[1] === "<") {
              return {
                verbatim: tag.slice(2, -1)
              };
            } else {
              const [_, handle, suffix] = tag.match(/^(.*!)([^!]*)$/);
              return {
                handle,
                suffix
              };
            }
          }
        }
        return null;
      }
      get valueRangeContainsNewline() {
        if (!this.valueRange || !this.context)
          return false;
        const {
          start,
          end
        } = this.valueRange;
        const {
          src
        } = this.context;
        for (let i = start; i < end; ++i) {
          if (src[i] === "\n")
            return true;
        }
        return false;
      }
      parseComment(start) {
        const {
          src
        } = this.context;
        if (src[start] === Char.COMMENT) {
          const end = Node.endOfLine(src, start + 1);
          const commentRange = new Range(start, end);
          this.props.push(commentRange);
          return end;
        }
        return start;
      }
      setOrigRanges(cr, offset) {
        if (this.range)
          offset = this.range.setOrigRange(cr, offset);
        if (this.valueRange)
          this.valueRange.setOrigRange(cr, offset);
        this.props.forEach((prop) => prop.setOrigRange(cr, offset));
        return offset;
      }
      toString() {
        const {
          context: {
            src
          },
          range,
          value
        } = this;
        if (value != null)
          return value;
        const str = src.slice(range.start, range.end);
        return Node.addStringTerminator(src, range.end, str);
      }
    };
    var YAMLError = class extends Error {
      constructor(name, source, message) {
        if (!message || !(source instanceof Node))
          throw new Error(`Invalid arguments for new ${name}`);
        super();
        this.name = name;
        this.message = message;
        this.source = source;
      }
      makePretty() {
        if (!this.source)
          return;
        this.nodeType = this.source.type;
        const cst = this.source.context && this.source.context.root;
        if (typeof this.offset === "number") {
          this.range = new Range(this.offset, this.offset + 1);
          const start = cst && getLinePos(this.offset, cst);
          if (start) {
            const end = {
              line: start.line,
              col: start.col + 1
            };
            this.linePos = {
              start,
              end
            };
          }
          delete this.offset;
        } else {
          this.range = this.source.range;
          this.linePos = this.source.rangeAsLinePos;
        }
        if (this.linePos) {
          const {
            line,
            col
          } = this.linePos.start;
          this.message += ` at line ${line}, column ${col}`;
          const ctx = cst && getPrettyContext(this.linePos, cst);
          if (ctx)
            this.message += `:

${ctx}
`;
        }
        delete this.source;
      }
    };
    var YAMLReferenceError = class extends YAMLError {
      constructor(source, message) {
        super("YAMLReferenceError", source, message);
      }
    };
    var YAMLSemanticError = class extends YAMLError {
      constructor(source, message) {
        super("YAMLSemanticError", source, message);
      }
    };
    var YAMLSyntaxError = class extends YAMLError {
      constructor(source, message) {
        super("YAMLSyntaxError", source, message);
      }
    };
    var YAMLWarning = class extends YAMLError {
      constructor(source, message) {
        super("YAMLWarning", source, message);
      }
    };
    function _defineProperty(obj, key, value) {
      if (key in obj) {
        Object.defineProperty(obj, key, {
          value,
          enumerable: true,
          configurable: true,
          writable: true
        });
      } else {
        obj[key] = value;
      }
      return obj;
    }
    var PlainValue = class extends Node {
      static endOfLine(src, start, inFlow) {
        let ch = src[start];
        let offset = start;
        while (ch && ch !== "\n") {
          if (inFlow && (ch === "[" || ch === "]" || ch === "{" || ch === "}" || ch === ","))
            break;
          const next = src[offset + 1];
          if (ch === ":" && (!next || next === "\n" || next === "	" || next === " " || inFlow && next === ","))
            break;
          if ((ch === " " || ch === "	") && next === "#")
            break;
          offset += 1;
          ch = next;
        }
        return offset;
      }
      get strValue() {
        if (!this.valueRange || !this.context)
          return null;
        let {
          start,
          end
        } = this.valueRange;
        const {
          src
        } = this.context;
        let ch = src[end - 1];
        while (start < end && (ch === "\n" || ch === "	" || ch === " "))
          ch = src[--end - 1];
        let str = "";
        for (let i = start; i < end; ++i) {
          const ch2 = src[i];
          if (ch2 === "\n") {
            const {
              fold,
              offset
            } = Node.foldNewline(src, i, -1);
            str += fold;
            i = offset;
          } else if (ch2 === " " || ch2 === "	") {
            const wsStart = i;
            let next = src[i + 1];
            while (i < end && (next === " " || next === "	")) {
              i += 1;
              next = src[i + 1];
            }
            if (next !== "\n")
              str += i > wsStart ? src.slice(wsStart, i + 1) : ch2;
          } else {
            str += ch2;
          }
        }
        const ch0 = src[start];
        switch (ch0) {
          case "	": {
            const msg = "Plain value cannot start with a tab character";
            const errors = [new YAMLSemanticError(this, msg)];
            return {
              errors,
              str
            };
          }
          case "@":
          case "`": {
            const msg = `Plain value cannot start with reserved character ${ch0}`;
            const errors = [new YAMLSemanticError(this, msg)];
            return {
              errors,
              str
            };
          }
          default:
            return str;
        }
      }
      parseBlockValue(start) {
        const {
          indent,
          inFlow,
          src
        } = this.context;
        let offset = start;
        let valueEnd = start;
        for (let ch = src[offset]; ch === "\n"; ch = src[offset]) {
          if (Node.atDocumentBoundary(src, offset + 1))
            break;
          const end = Node.endOfBlockIndent(src, indent, offset + 1);
          if (end === null || src[end] === "#")
            break;
          if (src[end] === "\n") {
            offset = end;
          } else {
            valueEnd = PlainValue.endOfLine(src, end, inFlow);
            offset = valueEnd;
          }
        }
        if (this.valueRange.isEmpty())
          this.valueRange.start = start;
        this.valueRange.end = valueEnd;
        return valueEnd;
      }
      parse(context, start) {
        this.context = context;
        const {
          inFlow,
          src
        } = context;
        let offset = start;
        const ch = src[offset];
        if (ch && ch !== "#" && ch !== "\n") {
          offset = PlainValue.endOfLine(src, start, inFlow);
        }
        this.valueRange = new Range(start, offset);
        offset = Node.endOfWhiteSpace(src, offset);
        offset = this.parseComment(offset);
        if (!this.hasComment || this.valueRange.isEmpty()) {
          offset = this.parseBlockValue(offset);
        }
        return offset;
      }
    };
    exports2.Char = Char;
    exports2.Node = Node;
    exports2.PlainValue = PlainValue;
    exports2.Range = Range;
    exports2.Type = Type;
    exports2.YAMLError = YAMLError;
    exports2.YAMLReferenceError = YAMLReferenceError;
    exports2.YAMLSemanticError = YAMLSemanticError;
    exports2.YAMLSyntaxError = YAMLSyntaxError;
    exports2.YAMLWarning = YAMLWarning;
    exports2._defineProperty = _defineProperty;
    exports2.defaultTagPrefix = defaultTagPrefix;
    exports2.defaultTags = defaultTags;
  }
});

// node_modules/yaml/dist/parse-cst.js
var require_parse_cst = __commonJS({
  "node_modules/yaml/dist/parse-cst.js"(exports2) {
    "use strict";
    var PlainValue = require_PlainValue_ec8e588e();
    var BlankLine = class extends PlainValue.Node {
      constructor() {
        super(PlainValue.Type.BLANK_LINE);
      }
      get includesTrailingLines() {
        return true;
      }
      parse(context, start) {
        this.context = context;
        this.range = new PlainValue.Range(start, start + 1);
        return start + 1;
      }
    };
    var CollectionItem = class extends PlainValue.Node {
      constructor(type, props) {
        super(type, props);
        this.node = null;
      }
      get includesTrailingLines() {
        return !!this.node && this.node.includesTrailingLines;
      }
      parse(context, start) {
        this.context = context;
        const {
          parseNode,
          src
        } = context;
        let {
          atLineStart,
          lineStart
        } = context;
        if (!atLineStart && this.type === PlainValue.Type.SEQ_ITEM)
          this.error = new PlainValue.YAMLSemanticError(this, "Sequence items must not have preceding content on the same line");
        const indent = atLineStart ? start - lineStart : context.indent;
        let offset = PlainValue.Node.endOfWhiteSpace(src, start + 1);
        let ch = src[offset];
        const inlineComment = ch === "#";
        const comments = [];
        let blankLine = null;
        while (ch === "\n" || ch === "#") {
          if (ch === "#") {
            const end2 = PlainValue.Node.endOfLine(src, offset + 1);
            comments.push(new PlainValue.Range(offset, end2));
            offset = end2;
          } else {
            atLineStart = true;
            lineStart = offset + 1;
            const wsEnd = PlainValue.Node.endOfWhiteSpace(src, lineStart);
            if (src[wsEnd] === "\n" && comments.length === 0) {
              blankLine = new BlankLine();
              lineStart = blankLine.parse({
                src
              }, lineStart);
            }
            offset = PlainValue.Node.endOfIndent(src, lineStart);
          }
          ch = src[offset];
        }
        if (PlainValue.Node.nextNodeIsIndented(ch, offset - (lineStart + indent), this.type !== PlainValue.Type.SEQ_ITEM)) {
          this.node = parseNode({
            atLineStart,
            inCollection: false,
            indent,
            lineStart,
            parent: this
          }, offset);
        } else if (ch && lineStart > start + 1) {
          offset = lineStart - 1;
        }
        if (this.node) {
          if (blankLine) {
            const items = context.parent.items || context.parent.contents;
            if (items)
              items.push(blankLine);
          }
          if (comments.length)
            Array.prototype.push.apply(this.props, comments);
          offset = this.node.range.end;
        } else {
          if (inlineComment) {
            const c = comments[0];
            this.props.push(c);
            offset = c.end;
          } else {
            offset = PlainValue.Node.endOfLine(src, start + 1);
          }
        }
        const end = this.node ? this.node.valueRange.end : offset;
        this.valueRange = new PlainValue.Range(start, end);
        return offset;
      }
      setOrigRanges(cr, offset) {
        offset = super.setOrigRanges(cr, offset);
        return this.node ? this.node.setOrigRanges(cr, offset) : offset;
      }
      toString() {
        const {
          context: {
            src
          },
          node,
          range,
          value
        } = this;
        if (value != null)
          return value;
        const str = node ? src.slice(range.start, node.range.start) + String(node) : src.slice(range.start, range.end);
        return PlainValue.Node.addStringTerminator(src, range.end, str);
      }
    };
    var Comment = class extends PlainValue.Node {
      constructor() {
        super(PlainValue.Type.COMMENT);
      }
      parse(context, start) {
        this.context = context;
        const offset = this.parseComment(start);
        this.range = new PlainValue.Range(start, offset);
        return offset;
      }
    };
    function grabCollectionEndComments(node) {
      let cnode = node;
      while (cnode instanceof CollectionItem)
        cnode = cnode.node;
      if (!(cnode instanceof Collection))
        return null;
      const len = cnode.items.length;
      let ci = -1;
      for (let i = len - 1; i >= 0; --i) {
        const n = cnode.items[i];
        if (n.type === PlainValue.Type.COMMENT) {
          const {
            indent,
            lineStart
          } = n.context;
          if (indent > 0 && n.range.start >= lineStart + indent)
            break;
          ci = i;
        } else if (n.type === PlainValue.Type.BLANK_LINE)
          ci = i;
        else
          break;
      }
      if (ci === -1)
        return null;
      const ca = cnode.items.splice(ci, len - ci);
      const prevEnd = ca[0].range.start;
      while (true) {
        cnode.range.end = prevEnd;
        if (cnode.valueRange && cnode.valueRange.end > prevEnd)
          cnode.valueRange.end = prevEnd;
        if (cnode === node)
          break;
        cnode = cnode.context.parent;
      }
      return ca;
    }
    var Collection = class extends PlainValue.Node {
      static nextContentHasIndent(src, offset, indent) {
        const lineStart = PlainValue.Node.endOfLine(src, offset) + 1;
        offset = PlainValue.Node.endOfWhiteSpace(src, lineStart);
        const ch = src[offset];
        if (!ch)
          return false;
        if (offset >= lineStart + indent)
          return true;
        if (ch !== "#" && ch !== "\n")
          return false;
        return Collection.nextContentHasIndent(src, offset, indent);
      }
      constructor(firstItem) {
        super(firstItem.type === PlainValue.Type.SEQ_ITEM ? PlainValue.Type.SEQ : PlainValue.Type.MAP);
        for (let i = firstItem.props.length - 1; i >= 0; --i) {
          if (firstItem.props[i].start < firstItem.context.lineStart) {
            this.props = firstItem.props.slice(0, i + 1);
            firstItem.props = firstItem.props.slice(i + 1);
            const itemRange = firstItem.props[0] || firstItem.valueRange;
            firstItem.range.start = itemRange.start;
            break;
          }
        }
        this.items = [firstItem];
        const ec = grabCollectionEndComments(firstItem);
        if (ec)
          Array.prototype.push.apply(this.items, ec);
      }
      get includesTrailingLines() {
        return this.items.length > 0;
      }
      parse(context, start) {
        this.context = context;
        const {
          parseNode,
          src
        } = context;
        let lineStart = PlainValue.Node.startOfLine(src, start);
        const firstItem = this.items[0];
        firstItem.context.parent = this;
        this.valueRange = PlainValue.Range.copy(firstItem.valueRange);
        const indent = firstItem.range.start - firstItem.context.lineStart;
        let offset = start;
        offset = PlainValue.Node.normalizeOffset(src, offset);
        let ch = src[offset];
        let atLineStart = PlainValue.Node.endOfWhiteSpace(src, lineStart) === offset;
        let prevIncludesTrailingLines = false;
        while (ch) {
          while (ch === "\n" || ch === "#") {
            if (atLineStart && ch === "\n" && !prevIncludesTrailingLines) {
              const blankLine = new BlankLine();
              offset = blankLine.parse({
                src
              }, offset);
              this.valueRange.end = offset;
              if (offset >= src.length) {
                ch = null;
                break;
              }
              this.items.push(blankLine);
              offset -= 1;
            } else if (ch === "#") {
              if (offset < lineStart + indent && !Collection.nextContentHasIndent(src, offset, indent)) {
                return offset;
              }
              const comment = new Comment();
              offset = comment.parse({
                indent,
                lineStart,
                src
              }, offset);
              this.items.push(comment);
              this.valueRange.end = offset;
              if (offset >= src.length) {
                ch = null;
                break;
              }
            }
            lineStart = offset + 1;
            offset = PlainValue.Node.endOfIndent(src, lineStart);
            if (PlainValue.Node.atBlank(src, offset)) {
              const wsEnd = PlainValue.Node.endOfWhiteSpace(src, offset);
              const next = src[wsEnd];
              if (!next || next === "\n" || next === "#") {
                offset = wsEnd;
              }
            }
            ch = src[offset];
            atLineStart = true;
          }
          if (!ch) {
            break;
          }
          if (offset !== lineStart + indent && (atLineStart || ch !== ":")) {
            if (offset < lineStart + indent) {
              if (lineStart > start)
                offset = lineStart;
              break;
            } else if (!this.error) {
              const msg = "All collection items must start at the same column";
              this.error = new PlainValue.YAMLSyntaxError(this, msg);
            }
          }
          if (firstItem.type === PlainValue.Type.SEQ_ITEM) {
            if (ch !== "-") {
              if (lineStart > start)
                offset = lineStart;
              break;
            }
          } else if (ch === "-" && !this.error) {
            const next = src[offset + 1];
            if (!next || next === "\n" || next === "	" || next === " ") {
              const msg = "A collection cannot be both a mapping and a sequence";
              this.error = new PlainValue.YAMLSyntaxError(this, msg);
            }
          }
          const node = parseNode({
            atLineStart,
            inCollection: true,
            indent,
            lineStart,
            parent: this
          }, offset);
          if (!node)
            return offset;
          this.items.push(node);
          this.valueRange.end = node.valueRange.end;
          offset = PlainValue.Node.normalizeOffset(src, node.range.end);
          ch = src[offset];
          atLineStart = false;
          prevIncludesTrailingLines = node.includesTrailingLines;
          if (ch) {
            let ls = offset - 1;
            let prev = src[ls];
            while (prev === " " || prev === "	")
              prev = src[--ls];
            if (prev === "\n") {
              lineStart = ls + 1;
              atLineStart = true;
            }
          }
          const ec = grabCollectionEndComments(node);
          if (ec)
            Array.prototype.push.apply(this.items, ec);
        }
        return offset;
      }
      setOrigRanges(cr, offset) {
        offset = super.setOrigRanges(cr, offset);
        this.items.forEach((node) => {
          offset = node.setOrigRanges(cr, offset);
        });
        return offset;
      }
      toString() {
        const {
          context: {
            src
          },
          items,
          range,
          value
        } = this;
        if (value != null)
          return value;
        let str = src.slice(range.start, items[0].range.start) + String(items[0]);
        for (let i = 1; i < items.length; ++i) {
          const item = items[i];
          const {
            atLineStart,
            indent
          } = item.context;
          if (atLineStart)
            for (let i2 = 0; i2 < indent; ++i2)
              str += " ";
          str += String(item);
        }
        return PlainValue.Node.addStringTerminator(src, range.end, str);
      }
    };
    var Directive = class extends PlainValue.Node {
      constructor() {
        super(PlainValue.Type.DIRECTIVE);
        this.name = null;
      }
      get parameters() {
        const raw = this.rawValue;
        return raw ? raw.trim().split(/[ \t]+/) : [];
      }
      parseName(start) {
        const {
          src
        } = this.context;
        let offset = start;
        let ch = src[offset];
        while (ch && ch !== "\n" && ch !== "	" && ch !== " ")
          ch = src[offset += 1];
        this.name = src.slice(start, offset);
        return offset;
      }
      parseParameters(start) {
        const {
          src
        } = this.context;
        let offset = start;
        let ch = src[offset];
        while (ch && ch !== "\n" && ch !== "#")
          ch = src[offset += 1];
        this.valueRange = new PlainValue.Range(start, offset);
        return offset;
      }
      parse(context, start) {
        this.context = context;
        let offset = this.parseName(start + 1);
        offset = this.parseParameters(offset);
        offset = this.parseComment(offset);
        this.range = new PlainValue.Range(start, offset);
        return offset;
      }
    };
    var Document = class extends PlainValue.Node {
      static startCommentOrEndBlankLine(src, start) {
        const offset = PlainValue.Node.endOfWhiteSpace(src, start);
        const ch = src[offset];
        return ch === "#" || ch === "\n" ? offset : start;
      }
      constructor() {
        super(PlainValue.Type.DOCUMENT);
        this.directives = null;
        this.contents = null;
        this.directivesEndMarker = null;
        this.documentEndMarker = null;
      }
      parseDirectives(start) {
        const {
          src
        } = this.context;
        this.directives = [];
        let atLineStart = true;
        let hasDirectives = false;
        let offset = start;
        while (!PlainValue.Node.atDocumentBoundary(src, offset, PlainValue.Char.DIRECTIVES_END)) {
          offset = Document.startCommentOrEndBlankLine(src, offset);
          switch (src[offset]) {
            case "\n":
              if (atLineStart) {
                const blankLine = new BlankLine();
                offset = blankLine.parse({
                  src
                }, offset);
                if (offset < src.length) {
                  this.directives.push(blankLine);
                }
              } else {
                offset += 1;
                atLineStart = true;
              }
              break;
            case "#":
              {
                const comment = new Comment();
                offset = comment.parse({
                  src
                }, offset);
                this.directives.push(comment);
                atLineStart = false;
              }
              break;
            case "%":
              {
                const directive = new Directive();
                offset = directive.parse({
                  parent: this,
                  src
                }, offset);
                this.directives.push(directive);
                hasDirectives = true;
                atLineStart = false;
              }
              break;
            default:
              if (hasDirectives) {
                this.error = new PlainValue.YAMLSemanticError(this, "Missing directives-end indicator line");
              } else if (this.directives.length > 0) {
                this.contents = this.directives;
                this.directives = [];
              }
              return offset;
          }
        }
        if (src[offset]) {
          this.directivesEndMarker = new PlainValue.Range(offset, offset + 3);
          return offset + 3;
        }
        if (hasDirectives) {
          this.error = new PlainValue.YAMLSemanticError(this, "Missing directives-end indicator line");
        } else if (this.directives.length > 0) {
          this.contents = this.directives;
          this.directives = [];
        }
        return offset;
      }
      parseContents(start) {
        const {
          parseNode,
          src
        } = this.context;
        if (!this.contents)
          this.contents = [];
        let lineStart = start;
        while (src[lineStart - 1] === "-")
          lineStart -= 1;
        let offset = PlainValue.Node.endOfWhiteSpace(src, start);
        let atLineStart = lineStart === start;
        this.valueRange = new PlainValue.Range(offset);
        while (!PlainValue.Node.atDocumentBoundary(src, offset, PlainValue.Char.DOCUMENT_END)) {
          switch (src[offset]) {
            case "\n":
              if (atLineStart) {
                const blankLine = new BlankLine();
                offset = blankLine.parse({
                  src
                }, offset);
                if (offset < src.length) {
                  this.contents.push(blankLine);
                }
              } else {
                offset += 1;
                atLineStart = true;
              }
              lineStart = offset;
              break;
            case "#":
              {
                const comment = new Comment();
                offset = comment.parse({
                  src
                }, offset);
                this.contents.push(comment);
                atLineStart = false;
              }
              break;
            default: {
              const iEnd = PlainValue.Node.endOfIndent(src, offset);
              const context = {
                atLineStart,
                indent: -1,
                inFlow: false,
                inCollection: false,
                lineStart,
                parent: this
              };
              const node = parseNode(context, iEnd);
              if (!node)
                return this.valueRange.end = iEnd;
              this.contents.push(node);
              offset = node.range.end;
              atLineStart = false;
              const ec = grabCollectionEndComments(node);
              if (ec)
                Array.prototype.push.apply(this.contents, ec);
            }
          }
          offset = Document.startCommentOrEndBlankLine(src, offset);
        }
        this.valueRange.end = offset;
        if (src[offset]) {
          this.documentEndMarker = new PlainValue.Range(offset, offset + 3);
          offset += 3;
          if (src[offset]) {
            offset = PlainValue.Node.endOfWhiteSpace(src, offset);
            if (src[offset] === "#") {
              const comment = new Comment();
              offset = comment.parse({
                src
              }, offset);
              this.contents.push(comment);
            }
            switch (src[offset]) {
              case "\n":
                offset += 1;
                break;
              case void 0:
                break;
              default:
                this.error = new PlainValue.YAMLSyntaxError(this, "Document end marker line cannot have a non-comment suffix");
            }
          }
        }
        return offset;
      }
      parse(context, start) {
        context.root = this;
        this.context = context;
        const {
          src
        } = context;
        let offset = src.charCodeAt(start) === 65279 ? start + 1 : start;
        offset = this.parseDirectives(offset);
        offset = this.parseContents(offset);
        return offset;
      }
      setOrigRanges(cr, offset) {
        offset = super.setOrigRanges(cr, offset);
        this.directives.forEach((node) => {
          offset = node.setOrigRanges(cr, offset);
        });
        if (this.directivesEndMarker)
          offset = this.directivesEndMarker.setOrigRange(cr, offset);
        this.contents.forEach((node) => {
          offset = node.setOrigRanges(cr, offset);
        });
        if (this.documentEndMarker)
          offset = this.documentEndMarker.setOrigRange(cr, offset);
        return offset;
      }
      toString() {
        const {
          contents,
          directives,
          value
        } = this;
        if (value != null)
          return value;
        let str = directives.join("");
        if (contents.length > 0) {
          if (directives.length > 0 || contents[0].type === PlainValue.Type.COMMENT)
            str += "---\n";
          str += contents.join("");
        }
        if (str[str.length - 1] !== "\n")
          str += "\n";
        return str;
      }
    };
    var Alias = class extends PlainValue.Node {
      parse(context, start) {
        this.context = context;
        const {
          src
        } = context;
        let offset = PlainValue.Node.endOfIdentifier(src, start + 1);
        this.valueRange = new PlainValue.Range(start + 1, offset);
        offset = PlainValue.Node.endOfWhiteSpace(src, offset);
        offset = this.parseComment(offset);
        return offset;
      }
    };
    var Chomp = {
      CLIP: "CLIP",
      KEEP: "KEEP",
      STRIP: "STRIP"
    };
    var BlockValue = class extends PlainValue.Node {
      constructor(type, props) {
        super(type, props);
        this.blockIndent = null;
        this.chomping = Chomp.CLIP;
        this.header = null;
      }
      get includesTrailingLines() {
        return this.chomping === Chomp.KEEP;
      }
      get strValue() {
        if (!this.valueRange || !this.context)
          return null;
        let {
          start,
          end
        } = this.valueRange;
        const {
          indent,
          src
        } = this.context;
        if (this.valueRange.isEmpty())
          return "";
        let lastNewLine = null;
        let ch = src[end - 1];
        while (ch === "\n" || ch === "	" || ch === " ") {
          end -= 1;
          if (end <= start) {
            if (this.chomping === Chomp.KEEP)
              break;
            else
              return "";
          }
          if (ch === "\n")
            lastNewLine = end;
          ch = src[end - 1];
        }
        let keepStart = end + 1;
        if (lastNewLine) {
          if (this.chomping === Chomp.KEEP) {
            keepStart = lastNewLine;
            end = this.valueRange.end;
          } else {
            end = lastNewLine;
          }
        }
        const bi = indent + this.blockIndent;
        const folded = this.type === PlainValue.Type.BLOCK_FOLDED;
        let atStart = true;
        let str = "";
        let sep = "";
        let prevMoreIndented = false;
        for (let i = start; i < end; ++i) {
          for (let j = 0; j < bi; ++j) {
            if (src[i] !== " ")
              break;
            i += 1;
          }
          const ch2 = src[i];
          if (ch2 === "\n") {
            if (sep === "\n")
              str += "\n";
            else
              sep = "\n";
          } else {
            const lineEnd = PlainValue.Node.endOfLine(src, i);
            const line = src.slice(i, lineEnd);
            i = lineEnd;
            if (folded && (ch2 === " " || ch2 === "	") && i < keepStart) {
              if (sep === " ")
                sep = "\n";
              else if (!prevMoreIndented && !atStart && sep === "\n")
                sep = "\n\n";
              str += sep + line;
              sep = lineEnd < end && src[lineEnd] || "";
              prevMoreIndented = true;
            } else {
              str += sep + line;
              sep = folded && i < keepStart ? " " : "\n";
              prevMoreIndented = false;
            }
            if (atStart && line !== "")
              atStart = false;
          }
        }
        return this.chomping === Chomp.STRIP ? str : str + "\n";
      }
      parseBlockHeader(start) {
        const {
          src
        } = this.context;
        let offset = start + 1;
        let bi = "";
        while (true) {
          const ch = src[offset];
          switch (ch) {
            case "-":
              this.chomping = Chomp.STRIP;
              break;
            case "+":
              this.chomping = Chomp.KEEP;
              break;
            case "0":
            case "1":
            case "2":
            case "3":
            case "4":
            case "5":
            case "6":
            case "7":
            case "8":
            case "9":
              bi += ch;
              break;
            default:
              this.blockIndent = Number(bi) || null;
              this.header = new PlainValue.Range(start, offset);
              return offset;
          }
          offset += 1;
        }
      }
      parseBlockValue(start) {
        const {
          indent,
          src
        } = this.context;
        const explicit = !!this.blockIndent;
        let offset = start;
        let valueEnd = start;
        let minBlockIndent = 1;
        for (let ch = src[offset]; ch === "\n"; ch = src[offset]) {
          offset += 1;
          if (PlainValue.Node.atDocumentBoundary(src, offset))
            break;
          const end = PlainValue.Node.endOfBlockIndent(src, indent, offset);
          if (end === null)
            break;
          const ch2 = src[end];
          const lineIndent = end - (offset + indent);
          if (!this.blockIndent) {
            if (src[end] !== "\n") {
              if (lineIndent < minBlockIndent) {
                const msg = "Block scalars with more-indented leading empty lines must use an explicit indentation indicator";
                this.error = new PlainValue.YAMLSemanticError(this, msg);
              }
              this.blockIndent = lineIndent;
            } else if (lineIndent > minBlockIndent) {
              minBlockIndent = lineIndent;
            }
          } else if (ch2 && ch2 !== "\n" && lineIndent < this.blockIndent) {
            if (src[end] === "#")
              break;
            if (!this.error) {
              const src2 = explicit ? "explicit indentation indicator" : "first line";
              const msg = `Block scalars must not be less indented than their ${src2}`;
              this.error = new PlainValue.YAMLSemanticError(this, msg);
            }
          }
          if (src[end] === "\n") {
            offset = end;
          } else {
            offset = valueEnd = PlainValue.Node.endOfLine(src, end);
          }
        }
        if (this.chomping !== Chomp.KEEP) {
          offset = src[valueEnd] ? valueEnd + 1 : valueEnd;
        }
        this.valueRange = new PlainValue.Range(start + 1, offset);
        return offset;
      }
      parse(context, start) {
        this.context = context;
        const {
          src
        } = context;
        let offset = this.parseBlockHeader(start);
        offset = PlainValue.Node.endOfWhiteSpace(src, offset);
        offset = this.parseComment(offset);
        offset = this.parseBlockValue(offset);
        return offset;
      }
      setOrigRanges(cr, offset) {
        offset = super.setOrigRanges(cr, offset);
        return this.header ? this.header.setOrigRange(cr, offset) : offset;
      }
    };
    var FlowCollection = class extends PlainValue.Node {
      constructor(type, props) {
        super(type, props);
        this.items = null;
      }
      prevNodeIsJsonLike(idx = this.items.length) {
        const node = this.items[idx - 1];
        return !!node && (node.jsonLike || node.type === PlainValue.Type.COMMENT && this.prevNodeIsJsonLike(idx - 1));
      }
      parse(context, start) {
        this.context = context;
        const {
          parseNode,
          src
        } = context;
        let {
          indent,
          lineStart
        } = context;
        let char = src[start];
        this.items = [{
          char,
          offset: start
        }];
        let offset = PlainValue.Node.endOfWhiteSpace(src, start + 1);
        char = src[offset];
        while (char && char !== "]" && char !== "}") {
          switch (char) {
            case "\n":
              {
                lineStart = offset + 1;
                const wsEnd = PlainValue.Node.endOfWhiteSpace(src, lineStart);
                if (src[wsEnd] === "\n") {
                  const blankLine = new BlankLine();
                  lineStart = blankLine.parse({
                    src
                  }, lineStart);
                  this.items.push(blankLine);
                }
                offset = PlainValue.Node.endOfIndent(src, lineStart);
                if (offset <= lineStart + indent) {
                  char = src[offset];
                  if (offset < lineStart + indent || char !== "]" && char !== "}") {
                    const msg = "Insufficient indentation in flow collection";
                    this.error = new PlainValue.YAMLSemanticError(this, msg);
                  }
                }
              }
              break;
            case ",":
              {
                this.items.push({
                  char,
                  offset
                });
                offset += 1;
              }
              break;
            case "#":
              {
                const comment = new Comment();
                offset = comment.parse({
                  src
                }, offset);
                this.items.push(comment);
              }
              break;
            case "?":
            case ":": {
              const next = src[offset + 1];
              if (next === "\n" || next === "	" || next === " " || next === "," || char === ":" && this.prevNodeIsJsonLike()) {
                this.items.push({
                  char,
                  offset
                });
                offset += 1;
                break;
              }
            }
            default: {
              const node = parseNode({
                atLineStart: false,
                inCollection: false,
                inFlow: true,
                indent: -1,
                lineStart,
                parent: this
              }, offset);
              if (!node) {
                this.valueRange = new PlainValue.Range(start, offset);
                return offset;
              }
              this.items.push(node);
              offset = PlainValue.Node.normalizeOffset(src, node.range.end);
            }
          }
          offset = PlainValue.Node.endOfWhiteSpace(src, offset);
          char = src[offset];
        }
        this.valueRange = new PlainValue.Range(start, offset + 1);
        if (char) {
          this.items.push({
            char,
            offset
          });
          offset = PlainValue.Node.endOfWhiteSpace(src, offset + 1);
          offset = this.parseComment(offset);
        }
        return offset;
      }
      setOrigRanges(cr, offset) {
        offset = super.setOrigRanges(cr, offset);
        this.items.forEach((node) => {
          if (node instanceof PlainValue.Node) {
            offset = node.setOrigRanges(cr, offset);
          } else if (cr.length === 0) {
            node.origOffset = node.offset;
          } else {
            let i = offset;
            while (i < cr.length) {
              if (cr[i] > node.offset)
                break;
              else
                ++i;
            }
            node.origOffset = node.offset + i;
            offset = i;
          }
        });
        return offset;
      }
      toString() {
        const {
          context: {
            src
          },
          items,
          range,
          value
        } = this;
        if (value != null)
          return value;
        const nodes = items.filter((item) => item instanceof PlainValue.Node);
        let str = "";
        let prevEnd = range.start;
        nodes.forEach((node) => {
          const prefix = src.slice(prevEnd, node.range.start);
          prevEnd = node.range.end;
          str += prefix + String(node);
          if (str[str.length - 1] === "\n" && src[prevEnd - 1] !== "\n" && src[prevEnd] === "\n") {
            prevEnd += 1;
          }
        });
        str += src.slice(prevEnd, range.end);
        return PlainValue.Node.addStringTerminator(src, range.end, str);
      }
    };
    var QuoteDouble = class extends PlainValue.Node {
      static endOfQuote(src, offset) {
        let ch = src[offset];
        while (ch && ch !== '"') {
          offset += ch === "\\" ? 2 : 1;
          ch = src[offset];
        }
        return offset + 1;
      }
      get strValue() {
        if (!this.valueRange || !this.context)
          return null;
        const errors = [];
        const {
          start,
          end
        } = this.valueRange;
        const {
          indent,
          src
        } = this.context;
        if (src[end - 1] !== '"')
          errors.push(new PlainValue.YAMLSyntaxError(this, 'Missing closing "quote'));
        let str = "";
        for (let i = start + 1; i < end - 1; ++i) {
          const ch = src[i];
          if (ch === "\n") {
            if (PlainValue.Node.atDocumentBoundary(src, i + 1))
              errors.push(new PlainValue.YAMLSemanticError(this, "Document boundary indicators are not allowed within string values"));
            const {
              fold,
              offset,
              error
            } = PlainValue.Node.foldNewline(src, i, indent);
            str += fold;
            i = offset;
            if (error)
              errors.push(new PlainValue.YAMLSemanticError(this, "Multi-line double-quoted string needs to be sufficiently indented"));
          } else if (ch === "\\") {
            i += 1;
            switch (src[i]) {
              case "0":
                str += "\0";
                break;
              case "a":
                str += "\x07";
                break;
              case "b":
                str += "\b";
                break;
              case "e":
                str += "\x1B";
                break;
              case "f":
                str += "\f";
                break;
              case "n":
                str += "\n";
                break;
              case "r":
                str += "\r";
                break;
              case "t":
                str += "	";
                break;
              case "v":
                str += "\v";
                break;
              case "N":
                str += "\x85";
                break;
              case "_":
                str += "\xA0";
                break;
              case "L":
                str += "\u2028";
                break;
              case "P":
                str += "\u2029";
                break;
              case " ":
                str += " ";
                break;
              case '"':
                str += '"';
                break;
              case "/":
                str += "/";
                break;
              case "\\":
                str += "\\";
                break;
              case "	":
                str += "	";
                break;
              case "x":
                str += this.parseCharCode(i + 1, 2, errors);
                i += 2;
                break;
              case "u":
                str += this.parseCharCode(i + 1, 4, errors);
                i += 4;
                break;
              case "U":
                str += this.parseCharCode(i + 1, 8, errors);
                i += 8;
                break;
              case "\n":
                while (src[i + 1] === " " || src[i + 1] === "	")
                  i += 1;
                break;
              default:
                errors.push(new PlainValue.YAMLSyntaxError(this, `Invalid escape sequence ${src.substr(i - 1, 2)}`));
                str += "\\" + src[i];
            }
          } else if (ch === " " || ch === "	") {
            const wsStart = i;
            let next = src[i + 1];
            while (next === " " || next === "	") {
              i += 1;
              next = src[i + 1];
            }
            if (next !== "\n")
              str += i > wsStart ? src.slice(wsStart, i + 1) : ch;
          } else {
            str += ch;
          }
        }
        return errors.length > 0 ? {
          errors,
          str
        } : str;
      }
      parseCharCode(offset, length, errors) {
        const {
          src
        } = this.context;
        const cc = src.substr(offset, length);
        const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
        const code = ok ? parseInt(cc, 16) : NaN;
        if (isNaN(code)) {
          errors.push(new PlainValue.YAMLSyntaxError(this, `Invalid escape sequence ${src.substr(offset - 2, length + 2)}`));
          return src.substr(offset - 2, length + 2);
        }
        return String.fromCodePoint(code);
      }
      parse(context, start) {
        this.context = context;
        const {
          src
        } = context;
        let offset = QuoteDouble.endOfQuote(src, start + 1);
        this.valueRange = new PlainValue.Range(start, offset);
        offset = PlainValue.Node.endOfWhiteSpace(src, offset);
        offset = this.parseComment(offset);
        return offset;
      }
    };
    var QuoteSingle = class extends PlainValue.Node {
      static endOfQuote(src, offset) {
        let ch = src[offset];
        while (ch) {
          if (ch === "'") {
            if (src[offset + 1] !== "'")
              break;
            ch = src[offset += 2];
          } else {
            ch = src[offset += 1];
          }
        }
        return offset + 1;
      }
      get strValue() {
        if (!this.valueRange || !this.context)
          return null;
        const errors = [];
        const {
          start,
          end
        } = this.valueRange;
        const {
          indent,
          src
        } = this.context;
        if (src[end - 1] !== "'")
          errors.push(new PlainValue.YAMLSyntaxError(this, "Missing closing 'quote"));
        let str = "";
        for (let i = start + 1; i < end - 1; ++i) {
          const ch = src[i];
          if (ch === "\n") {
            if (PlainValue.Node.atDocumentBoundary(src, i + 1))
              errors.push(new PlainValue.YAMLSemanticError(this, "Document boundary indicators are not allowed within string values"));
            const {
              fold,
              offset,
              error
            } = PlainValue.Node.foldNewline(src, i, indent);
            str += fold;
            i = offset;
            if (error)
              errors.push(new PlainValue.YAMLSemanticError(this, "Multi-line single-quoted string needs to be sufficiently indented"));
          } else if (ch === "'") {
            str += ch;
            i += 1;
            if (src[i] !== "'")
              errors.push(new PlainValue.YAMLSyntaxError(this, "Unescaped single quote? This should not happen."));
          } else if (ch === " " || ch === "	") {
            const wsStart = i;
            let next = src[i + 1];
            while (next === " " || next === "	") {
              i += 1;
              next = src[i + 1];
            }
            if (next !== "\n")
              str += i > wsStart ? src.slice(wsStart, i + 1) : ch;
          } else {
            str += ch;
          }
        }
        return errors.length > 0 ? {
          errors,
          str
        } : str;
      }
      parse(context, start) {
        this.context = context;
        const {
          src
        } = context;
        let offset = QuoteSingle.endOfQuote(src, start + 1);
        this.valueRange = new PlainValue.Range(start, offset);
        offset = PlainValue.Node.endOfWhiteSpace(src, offset);
        offset = this.parseComment(offset);
        return offset;
      }
    };
    function createNewNode(type, props) {
      switch (type) {
        case PlainValue.Type.ALIAS:
          return new Alias(type, props);
        case PlainValue.Type.BLOCK_FOLDED:
        case PlainValue.Type.BLOCK_LITERAL:
          return new BlockValue(type, props);
        case PlainValue.Type.FLOW_MAP:
        case PlainValue.Type.FLOW_SEQ:
          return new FlowCollection(type, props);
        case PlainValue.Type.MAP_KEY:
        case PlainValue.Type.MAP_VALUE:
        case PlainValue.Type.SEQ_ITEM:
          return new CollectionItem(type, props);
        case PlainValue.Type.COMMENT:
        case PlainValue.Type.PLAIN:
          return new PlainValue.PlainValue(type, props);
        case PlainValue.Type.QUOTE_DOUBLE:
          return new QuoteDouble(type, props);
        case PlainValue.Type.QUOTE_SINGLE:
          return new QuoteSingle(type, props);
        default:
          return null;
      }
    }
    var ParseContext = class {
      static parseType(src, offset, inFlow) {
        switch (src[offset]) {
          case "*":
            return PlainValue.Type.ALIAS;
          case ">":
            return PlainValue.Type.BLOCK_FOLDED;
          case "|":
            return PlainValue.Type.BLOCK_LITERAL;
          case "{":
            return PlainValue.Type.FLOW_MAP;
          case "[":
            return PlainValue.Type.FLOW_SEQ;
          case "?":
            return !inFlow && PlainValue.Node.atBlank(src, offset + 1, true) ? PlainValue.Type.MAP_KEY : PlainValue.Type.PLAIN;
          case ":":
            return !inFlow && PlainValue.Node.atBlank(src, offset + 1, true) ? PlainValue.Type.MAP_VALUE : PlainValue.Type.PLAIN;
          case "-":
            return !inFlow && PlainValue.Node.atBlank(src, offset + 1, true) ? PlainValue.Type.SEQ_ITEM : PlainValue.Type.PLAIN;
          case '"':
            return PlainValue.Type.QUOTE_DOUBLE;
          case "'":
            return PlainValue.Type.QUOTE_SINGLE;
          default:
            return PlainValue.Type.PLAIN;
        }
      }
      constructor(orig = {}, {
        atLineStart,
        inCollection,
        inFlow,
        indent,
        lineStart,
        parent
      } = {}) {
        PlainValue._defineProperty(this, "parseNode", (overlay, start) => {
          if (PlainValue.Node.atDocumentBoundary(this.src, start))
            return null;
          const context = new ParseContext(this, overlay);
          const {
            props,
            type,
            valueStart
          } = context.parseProps(start);
          const node = createNewNode(type, props);
          let offset = node.parse(context, valueStart);
          node.range = new PlainValue.Range(start, offset);
          if (offset <= start) {
            node.error = new Error(`Node#parse consumed no characters`);
            node.error.parseEnd = offset;
            node.error.source = node;
            node.range.end = start + 1;
          }
          if (context.nodeStartsCollection(node)) {
            if (!node.error && !context.atLineStart && context.parent.type === PlainValue.Type.DOCUMENT) {
              node.error = new PlainValue.YAMLSyntaxError(node, "Block collection must not have preceding content here (e.g. directives-end indicator)");
            }
            const collection = new Collection(node);
            offset = collection.parse(new ParseContext(context), offset);
            collection.range = new PlainValue.Range(start, offset);
            return collection;
          }
          return node;
        });
        this.atLineStart = atLineStart != null ? atLineStart : orig.atLineStart || false;
        this.inCollection = inCollection != null ? inCollection : orig.inCollection || false;
        this.inFlow = inFlow != null ? inFlow : orig.inFlow || false;
        this.indent = indent != null ? indent : orig.indent;
        this.lineStart = lineStart != null ? lineStart : orig.lineStart;
        this.parent = parent != null ? parent : orig.parent || {};
        this.root = orig.root;
        this.src = orig.src;
      }
      nodeStartsCollection(node) {
        const {
          inCollection,
          inFlow,
          src
        } = this;
        if (inCollection || inFlow)
          return false;
        if (node instanceof CollectionItem)
          return true;
        let offset = node.range.end;
        if (src[offset] === "\n" || src[offset - 1] === "\n")
          return false;
        offset = PlainValue.Node.endOfWhiteSpace(src, offset);
        return src[offset] === ":";
      }
      parseProps(offset) {
        const {
          inFlow,
          parent,
          src
        } = this;
        const props = [];
        let lineHasProps = false;
        offset = this.atLineStart ? PlainValue.Node.endOfIndent(src, offset) : PlainValue.Node.endOfWhiteSpace(src, offset);
        let ch = src[offset];
        while (ch === PlainValue.Char.ANCHOR || ch === PlainValue.Char.COMMENT || ch === PlainValue.Char.TAG || ch === "\n") {
          if (ch === "\n") {
            let inEnd = offset;
            let lineStart;
            do {
              lineStart = inEnd + 1;
              inEnd = PlainValue.Node.endOfIndent(src, lineStart);
            } while (src[inEnd] === "\n");
            const indentDiff = inEnd - (lineStart + this.indent);
            const noIndicatorAsIndent = parent.type === PlainValue.Type.SEQ_ITEM && parent.context.atLineStart;
            if (src[inEnd] !== "#" && !PlainValue.Node.nextNodeIsIndented(src[inEnd], indentDiff, !noIndicatorAsIndent))
              break;
            this.atLineStart = true;
            this.lineStart = lineStart;
            lineHasProps = false;
            offset = inEnd;
          } else if (ch === PlainValue.Char.COMMENT) {
            const end = PlainValue.Node.endOfLine(src, offset + 1);
            props.push(new PlainValue.Range(offset, end));
            offset = end;
          } else {
            let end = PlainValue.Node.endOfIdentifier(src, offset + 1);
            if (ch === PlainValue.Char.TAG && src[end] === "," && /^[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+,\d\d\d\d(-\d\d){0,2}\/\S/.test(src.slice(offset + 1, end + 13))) {
              end = PlainValue.Node.endOfIdentifier(src, end + 5);
            }
            props.push(new PlainValue.Range(offset, end));
            lineHasProps = true;
            offset = PlainValue.Node.endOfWhiteSpace(src, end);
          }
          ch = src[offset];
        }
        if (lineHasProps && ch === ":" && PlainValue.Node.atBlank(src, offset + 1, true))
          offset -= 1;
        const type = ParseContext.parseType(src, offset, inFlow);
        return {
          props,
          type,
          valueStart: offset
        };
      }
    };
    function parse(src) {
      const cr = [];
      if (src.indexOf("\r") !== -1) {
        src = src.replace(/\r\n?/g, (match, offset2) => {
          if (match.length > 1)
            cr.push(offset2);
          return "\n";
        });
      }
      const documents = [];
      let offset = 0;
      do {
        const doc = new Document();
        const context = new ParseContext({
          src
        });
        offset = doc.parse(context, offset);
        documents.push(doc);
      } while (offset < src.length);
      documents.setOrigRanges = () => {
        if (cr.length === 0)
          return false;
        for (let i = 1; i < cr.length; ++i)
          cr[i] -= i;
        let crOffset = 0;
        for (let i = 0; i < documents.length; ++i) {
          crOffset = documents[i].setOrigRanges(cr, crOffset);
        }
        cr.splice(0, cr.length);
        return true;
      };
      documents.toString = () => documents.join("...\n");
      return documents;
    }
    exports2.parse = parse;
  }
});

// node_modules/yaml/dist/resolveSeq-d03cb037.js
var require_resolveSeq_d03cb037 = __commonJS({
  "node_modules/yaml/dist/resolveSeq-d03cb037.js"(exports2) {
    "use strict";
    var PlainValue = require_PlainValue_ec8e588e();
    function addCommentBefore(str, indent, comment) {
      if (!comment)
        return str;
      const cc = comment.replace(/[\s\S]^/gm, `$&${indent}#`);
      return `#${cc}
${indent}${str}`;
    }
    function addComment(str, indent, comment) {
      return !comment ? str : comment.indexOf("\n") === -1 ? `${str} #${comment}` : `${str}
` + comment.replace(/^/gm, `${indent || ""}#`);
    }
    var Node = class {
    };
    function toJSON(value, arg, ctx) {
      if (Array.isArray(value))
        return value.map((v, i) => toJSON(v, String(i), ctx));
      if (value && typeof value.toJSON === "function") {
        const anchor = ctx && ctx.anchors && ctx.anchors.get(value);
        if (anchor)
          ctx.onCreate = (res2) => {
            anchor.res = res2;
            delete ctx.onCreate;
          };
        const res = value.toJSON(arg, ctx);
        if (anchor && ctx.onCreate)
          ctx.onCreate(res);
        return res;
      }
      if ((!ctx || !ctx.keep) && typeof value === "bigint")
        return Number(value);
      return value;
    }
    var Scalar = class extends Node {
      constructor(value) {
        super();
        this.value = value;
      }
      toJSON(arg, ctx) {
        return ctx && ctx.keep ? this.value : toJSON(this.value, arg, ctx);
      }
      toString() {
        return String(this.value);
      }
    };
    function collectionFromPath(schema, path, value) {
      let v = value;
      for (let i = path.length - 1; i >= 0; --i) {
        const k = path[i];
        if (Number.isInteger(k) && k >= 0) {
          const a = [];
          a[k] = v;
          v = a;
        } else {
          const o = {};
          Object.defineProperty(o, k, {
            value: v,
            writable: true,
            enumerable: true,
            configurable: true
          });
          v = o;
        }
      }
      return schema.createNode(v, false);
    }
    var isEmptyPath = (path) => path == null || typeof path === "object" && path[Symbol.iterator]().next().done;
    var Collection = class extends Node {
      constructor(schema) {
        super();
        PlainValue._defineProperty(this, "items", []);
        this.schema = schema;
      }
      addIn(path, value) {
        if (isEmptyPath(path))
          this.add(value);
        else {
          const [key, ...rest] = path;
          const node = this.get(key, true);
          if (node instanceof Collection)
            node.addIn(rest, value);
          else if (node === void 0 && this.schema)
            this.set(key, collectionFromPath(this.schema, rest, value));
          else
            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
        }
      }
      deleteIn([key, ...rest]) {
        if (rest.length === 0)
          return this.delete(key);
        const node = this.get(key, true);
        if (node instanceof Collection)
          return node.deleteIn(rest);
        else
          throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
      }
      getIn([key, ...rest], keepScalar) {
        const node = this.get(key, true);
        if (rest.length === 0)
          return !keepScalar && node instanceof Scalar ? node.value : node;
        else
          return node instanceof Collection ? node.getIn(rest, keepScalar) : void 0;
      }
      hasAllNullValues() {
        return this.items.every((node) => {
          if (!node || node.type !== "PAIR")
            return false;
          const n = node.value;
          return n == null || n instanceof Scalar && n.value == null && !n.commentBefore && !n.comment && !n.tag;
        });
      }
      hasIn([key, ...rest]) {
        if (rest.length === 0)
          return this.has(key);
        const node = this.get(key, true);
        return node instanceof Collection ? node.hasIn(rest) : false;
      }
      setIn([key, ...rest], value) {
        if (rest.length === 0) {
          this.set(key, value);
        } else {
          const node = this.get(key, true);
          if (node instanceof Collection)
            node.setIn(rest, value);
          else if (node === void 0 && this.schema)
            this.set(key, collectionFromPath(this.schema, rest, value));
          else
            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
        }
      }
      toJSON() {
        return null;
      }
      toString(ctx, {
        blockItem,
        flowChars,
        isMap,
        itemIndent
      }, onComment, onChompKeep) {
        const {
          indent,
          indentStep,
          stringify
        } = ctx;
        const inFlow = this.type === PlainValue.Type.FLOW_MAP || this.type === PlainValue.Type.FLOW_SEQ || ctx.inFlow;
        if (inFlow)
          itemIndent += indentStep;
        const allNullValues = isMap && this.hasAllNullValues();
        ctx = Object.assign({}, ctx, {
          allNullValues,
          indent: itemIndent,
          inFlow,
          type: null
        });
        let chompKeep = false;
        let hasItemWithNewLine = false;
        const nodes = this.items.reduce((nodes2, item, i) => {
          let comment;
          if (item) {
            if (!chompKeep && item.spaceBefore)
              nodes2.push({
                type: "comment",
                str: ""
              });
            if (item.commentBefore)
              item.commentBefore.match(/^.*$/gm).forEach((line) => {
                nodes2.push({
                  type: "comment",
                  str: `#${line}`
                });
              });
            if (item.comment)
              comment = item.comment;
            if (inFlow && (!chompKeep && item.spaceBefore || item.commentBefore || item.comment || item.key && (item.key.commentBefore || item.key.comment) || item.value && (item.value.commentBefore || item.value.comment)))
              hasItemWithNewLine = true;
          }
          chompKeep = false;
          let str2 = stringify(item, ctx, () => comment = null, () => chompKeep = true);
          if (inFlow && !hasItemWithNewLine && str2.includes("\n"))
            hasItemWithNewLine = true;
          if (inFlow && i < this.items.length - 1)
            str2 += ",";
          str2 = addComment(str2, itemIndent, comment);
          if (chompKeep && (comment || inFlow))
            chompKeep = false;
          nodes2.push({
            type: "item",
            str: str2
          });
          return nodes2;
        }, []);
        let str;
        if (nodes.length === 0) {
          str = flowChars.start + flowChars.end;
        } else if (inFlow) {
          const {
            start,
            end
          } = flowChars;
          const strings = nodes.map((n) => n.str);
          if (hasItemWithNewLine || strings.reduce((sum, str2) => sum + str2.length + 2, 2) > Collection.maxFlowStringSingleLineLength) {
            str = start;
            for (const s of strings) {
              str += s ? `
${indentStep}${indent}${s}` : "\n";
            }
            str += `
${indent}${end}`;
          } else {
            str = `${start} ${strings.join(" ")} ${end}`;
          }
        } else {
          const strings = nodes.map(blockItem);
          str = strings.shift();
          for (const s of strings)
            str += s ? `
${indent}${s}` : "\n";
        }
        if (this.comment) {
          str += "\n" + this.comment.replace(/^/gm, `${indent}#`);
          if (onComment)
            onComment();
        } else if (chompKeep && onChompKeep)
          onChompKeep();
        return str;
      }
    };
    PlainValue._defineProperty(Collection, "maxFlowStringSingleLineLength", 60);
    function asItemIndex(key) {
      let idx = key instanceof Scalar ? key.value : key;
      if (idx && typeof idx === "string")
        idx = Number(idx);
      return Number.isInteger(idx) && idx >= 0 ? idx : null;
    }
    var YAMLSeq = class extends Collection {
      add(value) {
        this.items.push(value);
      }
      delete(key) {
        const idx = asItemIndex(key);
        if (typeof idx !== "number")
          return false;
        const del = this.items.splice(idx, 1);
        return del.length > 0;
      }
      get(key, keepScalar) {
        const idx = asItemIndex(key);
        if (typeof idx !== "number")
          return void 0;
        const it = this.items[idx];
        return !keepScalar && it instanceof Scalar ? it.value : it;
      }
      has(key) {
        const idx = asItemIndex(key);
        return typeof idx === "number" && idx < this.items.length;
      }
      set(key, value) {
        const idx = asItemIndex(key);
        if (typeof idx !== "number")
          throw new Error(`Expected a valid index, not ${key}.`);
        this.items[idx] = value;
      }
      toJSON(_, ctx) {
        const seq = [];
        if (ctx && ctx.onCreate)
          ctx.onCreate(seq);
        let i = 0;
        for (const item of this.items)
          seq.push(toJSON(item, String(i++), ctx));
        return seq;
      }
      toString(ctx, onComment, onChompKeep) {
        if (!ctx)
          return JSON.stringify(this);
        return super.toString(ctx, {
          blockItem: (n) => n.type === "comment" ? n.str : `- ${n.str}`,
          flowChars: {
            start: "[",
            end: "]"
          },
          isMap: false,
          itemIndent: (ctx.indent || "") + "  "
        }, onComment, onChompKeep);
      }
    };
    var stringifyKey = (key, jsKey, ctx) => {
      if (jsKey === null)
        return "";
      if (typeof jsKey !== "object")
        return String(jsKey);
      if (key instanceof Node && ctx && ctx.doc)
        return key.toString({
          anchors: /* @__PURE__ */ Object.create(null),
          doc: ctx.doc,
          indent: "",
          indentStep: ctx.indentStep,
          inFlow: true,
          inStringifyKey: true,
          stringify: ctx.stringify
        });
      return JSON.stringify(jsKey);
    };
    var Pair = class extends Node {
      constructor(key, value = null) {
        super();
        this.key = key;
        this.value = value;
        this.type = Pair.Type.PAIR;
      }
      get commentBefore() {
        return this.key instanceof Node ? this.key.commentBefore : void 0;
      }
      set commentBefore(cb) {
        if (this.key == null)
          this.key = new Scalar(null);
        if (this.key instanceof Node)
          this.key.commentBefore = cb;
        else {
          const msg = "Pair.commentBefore is an alias for Pair.key.commentBefore. To set it, the key must be a Node.";
          throw new Error(msg);
        }
      }
      addToJSMap(ctx, map) {
        const key = toJSON(this.key, "", ctx);
        if (map instanceof Map) {
          const value = toJSON(this.value, key, ctx);
          map.set(key, value);
        } else if (map instanceof Set) {
          map.add(key);
        } else {
          const stringKey = stringifyKey(this.key, key, ctx);
          const value = toJSON(this.value, stringKey, ctx);
          if (stringKey in map)
            Object.defineProperty(map, stringKey, {
              value,
              writable: true,
              enumerable: true,
              configurable: true
            });
          else
            map[stringKey] = value;
        }
        return map;
      }
      toJSON(_, ctx) {
        const pair = ctx && ctx.mapAsMap ? /* @__PURE__ */ new Map() : {};
        return this.addToJSMap(ctx, pair);
      }
      toString(ctx, onComment, onChompKeep) {
        if (!ctx || !ctx.doc)
          return JSON.stringify(this);
        const {
          indent: indentSize,
          indentSeq,
          simpleKeys
        } = ctx.doc.options;
        let {
          key,
          value
        } = this;
        let keyComment = key instanceof Node && key.comment;
        if (simpleKeys) {
          if (keyComment) {
            throw new Error("With simple keys, key nodes cannot have comments");
          }
          if (key instanceof Collection) {
            const msg = "With simple keys, collection cannot be used as a key value";
            throw new Error(msg);
          }
        }
        let explicitKey = !simpleKeys && (!key || keyComment || (key instanceof Node ? key instanceof Collection || key.type === PlainValue.Type.BLOCK_FOLDED || key.type === PlainValue.Type.BLOCK_LITERAL : typeof key === "object"));
        const {
          doc,
          indent,
          indentStep,
          stringify
        } = ctx;
        ctx = Object.assign({}, ctx, {
          implicitKey: !explicitKey,
          indent: indent + indentStep
        });
        let chompKeep = false;
        let str = stringify(key, ctx, () => keyComment = null, () => chompKeep = true);
        str = addComment(str, ctx.indent, keyComment);
        if (!explicitKey && str.length > 1024) {
          if (simpleKeys)
            throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
          explicitKey = true;
        }
        if (ctx.allNullValues && !simpleKeys) {
          if (this.comment) {
            str = addComment(str, ctx.indent, this.comment);
            if (onComment)
              onComment();
          } else if (chompKeep && !keyComment && onChompKeep)
            onChompKeep();
          return ctx.inFlow && !explicitKey ? str : `? ${str}`;
        }
        str = explicitKey ? `? ${str}
${indent}:` : `${str}:`;
        if (this.comment) {
          str = addComment(str, ctx.indent, this.comment);
          if (onComment)
            onComment();
        }
        let vcb = "";
        let valueComment = null;
        if (value instanceof Node) {
          if (value.spaceBefore)
            vcb = "\n";
          if (value.commentBefore) {
            const cs = value.commentBefore.replace(/^/gm, `${ctx.indent}#`);
            vcb += `
${cs}`;
          }
          valueComment = value.comment;
        } else if (value && typeof value === "object") {
          value = doc.schema.createNode(value, true);
        }
        ctx.implicitKey = false;
        if (!explicitKey && !this.comment && value instanceof Scalar)
          ctx.indentAtStart = str.length + 1;
        chompKeep = false;
        if (!indentSeq && indentSize >= 2 && !ctx.inFlow && !explicitKey && value instanceof YAMLSeq && value.type !== PlainValue.Type.FLOW_SEQ && !value.tag && !doc.anchors.getName(value)) {
          ctx.indent = ctx.indent.substr(2);
        }
        const valueStr = stringify(value, ctx, () => valueComment = null, () => chompKeep = true);
        let ws = " ";
        if (vcb || this.comment) {
          ws = `${vcb}
${ctx.indent}`;
        } else if (!explicitKey && value instanceof Collection) {
          const flow = valueStr[0] === "[" || valueStr[0] === "{";
          if (!flow || valueStr.includes("\n"))
            ws = `
${ctx.indent}`;
        } else if (valueStr[0] === "\n")
          ws = "";
        if (chompKeep && !valueComment && onChompKeep)
          onChompKeep();
        return addComment(str + ws + valueStr, ctx.indent, valueComment);
      }
    };
    PlainValue._defineProperty(Pair, "Type", {
      PAIR: "PAIR",
      MERGE_PAIR: "MERGE_PAIR"
    });
    var getAliasCount = (node, anchors) => {
      if (node instanceof Alias) {
        const anchor = anchors.get(node.source);
        return anchor.count * anchor.aliasCount;
      } else if (node instanceof Collection) {
        let count = 0;
        for (const item of node.items) {
          const c = getAliasCount(item, anchors);
          if (c > count)
            count = c;
        }
        return count;
      } else if (node instanceof Pair) {
        const kc = getAliasCount(node.key, anchors);
        const vc = getAliasCount(node.value, anchors);
        return Math.max(kc, vc);
      }
      return 1;
    };
    var Alias = class extends Node {
      static stringify({
        range,
        source
      }, {
        anchors,
        doc,
        implicitKey,
        inStringifyKey
      }) {
        let anchor = Object.keys(anchors).find((a) => anchors[a] === source);
        if (!anchor && inStringifyKey)
          anchor = doc.anchors.getName(source) || doc.anchors.newName();
        if (anchor)
          return `*${anchor}${implicitKey ? " " : ""}`;
        const msg = doc.anchors.getName(source) ? "Alias node must be after source node" : "Source node not found for alias node";
        throw new Error(`${msg} [${range}]`);
      }
      constructor(source) {
        super();
        this.source = source;
        this.type = PlainValue.Type.ALIAS;
      }
      set tag(t) {
        throw new Error("Alias nodes cannot have tags");
      }
      toJSON(arg, ctx) {
        if (!ctx)
          return toJSON(this.source, arg, ctx);
        const {
          anchors,
          maxAliasCount
        } = ctx;
        const anchor = anchors.get(this.source);
        if (!anchor || anchor.res === void 0) {
          const msg = "This should not happen: Alias anchor was not resolved?";
          if (this.cstNode)
            throw new PlainValue.YAMLReferenceError(this.cstNode, msg);
          else
            throw new ReferenceError(msg);
        }
        if (maxAliasCount >= 0) {
          anchor.count += 1;
          if (anchor.aliasCount === 0)
            anchor.aliasCount = getAliasCount(this.source, anchors);
          if (anchor.count * anchor.aliasCount > maxAliasCount) {
            const msg = "Excessive alias count indicates a resource exhaustion attack";
            if (this.cstNode)
              throw new PlainValue.YAMLReferenceError(this.cstNode, msg);
            else
              throw new ReferenceError(msg);
          }
        }
        return anchor.res;
      }
      toString(ctx) {
        return Alias.stringify(this, ctx);
      }
    };
    PlainValue._defineProperty(Alias, "default", true);
    function findPair(items, key) {
      const k = key instanceof Scalar ? key.value : key;
      for (const it of items) {
        if (it instanceof Pair) {
          if (it.key === key || it.key === k)
            return it;
          if (it.key && it.key.value === k)
            return it;
        }
      }
      return void 0;
    }
    var YAMLMap = class extends Collection {
      add(pair, overwrite) {
        if (!pair)
          pair = new Pair(pair);
        else if (!(pair instanceof Pair))
          pair = new Pair(pair.key || pair, pair.value);
        const prev = findPair(this.items, pair.key);
        const sortEntries = this.schema && this.schema.sortMapEntries;
        if (prev) {
          if (overwrite)
            prev.value = pair.value;
          else
            throw new Error(`Key ${pair.key} already set`);
        } else if (sortEntries) {
          const i = this.items.findIndex((item) => sortEntries(pair, item) < 0);
          if (i === -1)
            this.items.push(pair);
          else
            this.items.splice(i, 0, pair);
        } else {
          this.items.push(pair);
        }
      }
      delete(key) {
        const it = findPair(this.items, key);
        if (!it)
          return false;
        const del = this.items.splice(this.items.indexOf(it), 1);
        return del.length > 0;
      }
      get(key, keepScalar) {
        const it = findPair(this.items, key);
        const node = it && it.value;
        return !keepScalar && node instanceof Scalar ? node.value : node;
      }
      has(key) {
        return !!findPair(this.items, key);
      }
      set(key, value) {
        this.add(new Pair(key, value), true);
      }
      toJSON(_, ctx, Type) {
        const map = Type ? new Type() : ctx && ctx.mapAsMap ? /* @__PURE__ */ new Map() : {};
        if (ctx && ctx.onCreate)
          ctx.onCreate(map);
        for (const item of this.items)
          item.addToJSMap(ctx, map);
        return map;
      }
      toString(ctx, onComment, onChompKeep) {
        if (!ctx)
          return JSON.stringify(this);
        for (const item of this.items) {
          if (!(item instanceof Pair))
            throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
        }
        return super.toString(ctx, {
          blockItem: (n) => n.str,
          flowChars: {
            start: "{",
            end: "}"
          },
          isMap: true,
          itemIndent: ctx.indent || ""
        }, onComment, onChompKeep);
      }
    };
    var MERGE_KEY = "<<";
    var Merge = class extends Pair {
      constructor(pair) {
        if (pair instanceof Pair) {
          let seq = pair.value;
          if (!(seq instanceof YAMLSeq)) {
            seq = new YAMLSeq();
            seq.items.push(pair.value);
            seq.range = pair.value.range;
          }
          super(pair.key, seq);
          this.range = pair.range;
        } else {
          super(new Scalar(MERGE_KEY), new YAMLSeq());
        }
        this.type = Pair.Type.MERGE_PAIR;
      }
      addToJSMap(ctx, map) {
        for (const {
          source
        } of this.value.items) {
          if (!(source instanceof YAMLMap))
            throw new Error("Merge sources must be maps");
          const srcMap = source.toJSON(null, ctx, Map);
          for (const [key, value] of srcMap) {
            if (map instanceof Map) {
              if (!map.has(key))
                map.set(key, value);
            } else if (map instanceof Set) {
              map.add(key);
            } else if (!Object.prototype.hasOwnProperty.call(map, key)) {
              Object.defineProperty(map, key, {
                value,
                writable: true,
                enumerable: true,
                configurable: true
              });
            }
          }
        }
        return map;
      }
      toString(ctx, onComment) {
        const seq = this.value;
        if (seq.items.length > 1)
          return super.toString(ctx, onComment);
        this.value = seq.items[0];
        const str = super.toString(ctx, onComment);
        this.value = seq;
        return str;
      }
    };
    var binaryOptions = {
      defaultType: PlainValue.Type.BLOCK_LITERAL,
      lineWidth: 76
    };
    var boolOptions = {
      trueStr: "true",
      falseStr: "false"
    };
    var intOptions = {
      asBigInt: false
    };
    var nullOptions = {
      nullStr: "null"
    };
    var strOptions = {
      defaultType: PlainValue.Type.PLAIN,
      doubleQuoted: {
        jsonEncoding: false,
        minMultiLineLength: 40
      },
      fold: {
        lineWidth: 80,
        minContentWidth: 20
      }
    };
    function resolveScalar(str, tags, scalarFallback) {
      for (const {
        format,
        test,
        resolve
      } of tags) {
        if (test) {
          const match = str.match(test);
          if (match) {
            let res = resolve.apply(null, match);
            if (!(res instanceof Scalar))
              res = new Scalar(res);
            if (format)
              res.format = format;
            return res;
          }
        }
      }
      if (scalarFallback)
        str = scalarFallback(str);
      return new Scalar(str);
    }
    var FOLD_FLOW = "flow";
    var FOLD_BLOCK = "block";
    var FOLD_QUOTED = "quoted";
    var consumeMoreIndentedLines = (text, i) => {
      let ch = text[i + 1];
      while (ch === " " || ch === "	") {
        do {
          ch = text[i += 1];
        } while (ch && ch !== "\n");
        ch = text[i + 1];
      }
      return i;
    };
    function foldFlowLines(text, indent, mode, {
      indentAtStart,
      lineWidth = 80,
      minContentWidth = 20,
      onFold,
      onOverflow
    }) {
      if (!lineWidth || lineWidth < 0)
        return text;
      const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
      if (text.length <= endStep)
        return text;
      const folds = [];
      const escapedFolds = {};
      let end = lineWidth - indent.length;
      if (typeof indentAtStart === "number") {
        if (indentAtStart > lineWidth - Math.max(2, minContentWidth))
          folds.push(0);
        else
          end = lineWidth - indentAtStart;
      }
      let split = void 0;
      let prev = void 0;
      let overflow = false;
      let i = -1;
      let escStart = -1;
      let escEnd = -1;
      if (mode === FOLD_BLOCK) {
        i = consumeMoreIndentedLines(text, i);
        if (i !== -1)
          end = i + endStep;
      }
      for (let ch; ch = text[i += 1]; ) {
        if (mode === FOLD_QUOTED && ch === "\\") {
          escStart = i;
          switch (text[i + 1]) {
            case "x":
              i += 3;
              break;
            case "u":
              i += 5;
              break;
            case "U":
              i += 9;
              break;
            default:
              i += 1;
          }
          escEnd = i;
        }
        if (ch === "\n") {
          if (mode === FOLD_BLOCK)
            i = consumeMoreIndentedLines(text, i);
          end = i + endStep;
          split = void 0;
        } else {
          if (ch === " " && prev && prev !== " " && prev !== "\n" && prev !== "	") {
            const next = text[i + 1];
            if (next && next !== " " && next !== "\n" && next !== "	")
              split = i;
          }
          if (i >= end) {
            if (split) {
              folds.push(split);
              end = split + endStep;
              split = void 0;
            } else if (mode === FOLD_QUOTED) {
              while (prev === " " || prev === "	") {
                prev = ch;
                ch = text[i += 1];
                overflow = true;
              }
              const j = i > escEnd + 1 ? i - 2 : escStart - 1;
              if (escapedFolds[j])
                return text;
              folds.push(j);
              escapedFolds[j] = true;
              end = j + endStep;
              split = void 0;
            } else {
              overflow = true;
            }
          }
        }
        prev = ch;
      }
      if (overflow && onOverflow)
        onOverflow();
      if (folds.length === 0)
        return text;
      if (onFold)
        onFold();
      let res = text.slice(0, folds[0]);
      for (let i2 = 0; i2 < folds.length; ++i2) {
        const fold = folds[i2];
        const end2 = folds[i2 + 1] || text.length;
        if (fold === 0)
          res = `
${indent}${text.slice(0, end2)}`;
        else {
          if (mode === FOLD_QUOTED && escapedFolds[fold])
            res += `${text[fold]}\\`;
          res += `
${indent}${text.slice(fold + 1, end2)}`;
        }
      }
      return res;
    }
    var getFoldOptions = ({
      indentAtStart
    }) => indentAtStart ? Object.assign({
      indentAtStart
    }, strOptions.fold) : strOptions.fold;
    var containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str);
    function lineLengthOverLimit(str, lineWidth, indentLength) {
      if (!lineWidth || lineWidth < 0)
        return false;
      const limit = lineWidth - indentLength;
      const strLen = str.length;
      if (strLen <= limit)
        return false;
      for (let i = 0, start = 0; i < strLen; ++i) {
        if (str[i] === "\n") {
          if (i - start > limit)
            return true;
          start = i + 1;
          if (strLen - start <= limit)
            return false;
        }
      }
      return true;
    }
    function doubleQuotedString(value, ctx) {
      const {
        implicitKey
      } = ctx;
      const {
        jsonEncoding,
        minMultiLineLength
      } = strOptions.doubleQuoted;
      const json = JSON.stringify(value);
      if (jsonEncoding)
        return json;
      const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
      let str = "";
      let start = 0;
      for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
        if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") {
          str += json.slice(start, i) + "\\ ";
          i += 1;
          start = i;
          ch = "\\";
        }
        if (ch === "\\")
          switch (json[i + 1]) {
            case "u":
              {
                str += json.slice(start, i);
                const code = json.substr(i + 2, 4);
                switch (code) {
                  case "0000":
                    str += "\\0";
                    break;
                  case "0007":
                    str += "\\a";
                    break;
                  case "000b":
                    str += "\\v";
                    break;
                  case "001b":
                    str += "\\e";
                    break;
                  case "0085":
                    str += "\\N";
                    break;
                  case "00a0":
                    str += "\\_";
                    break;
                  case "2028":
                    str += "\\L";
                    break;
                  case "2029":
                    str += "\\P";
                    break;
                  default:
                    if (code.substr(0, 2) === "00")
                      str += "\\x" + code.substr(2);
                    else
                      str += json.substr(i, 6);
                }
                i += 5;
                start = i + 1;
              }
              break;
            case "n":
              if (implicitKey || json[i + 2] === '"' || json.length < minMultiLineLength) {
                i += 1;
              } else {
                str += json.slice(start, i) + "\n\n";
                while (json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== '"') {
                  str += "\n";
                  i += 2;
                }
                str += indent;
                if (json[i + 2] === " ")
                  str += "\\";
                i += 1;
                start = i + 1;
              }
              break;
            default:
              i += 1;
          }
      }
      str = start ? str + json.slice(start) : json;
      return implicitKey ? str : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx));
    }
    function singleQuotedString(value, ctx) {
      if (ctx.implicitKey) {
        if (/\n/.test(value))
          return doubleQuotedString(value, ctx);
      } else {
        if (/[ \t]\n|\n[ \t]/.test(value))
          return doubleQuotedString(value, ctx);
      }
      const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
      const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&
${indent}`) + "'";
      return ctx.implicitKey ? res : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx));
    }
    function blockString({
      comment,
      type,
      value
    }, ctx, onComment, onChompKeep) {
      if (/\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
        return doubleQuotedString(value, ctx);
      }
      const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? "  " : "");
      const indentSize = indent ? "2" : "1";
      const literal = type === PlainValue.Type.BLOCK_FOLDED ? false : type === PlainValue.Type.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, strOptions.fold.lineWidth, indent.length);
      let header = literal ? "|" : ">";
      if (!value)
        return header + "\n";
      let wsStart = "";
      let wsEnd = "";
      value = value.replace(/[\n\t ]*$/, (ws) => {
        const n = ws.indexOf("\n");
        if (n === -1) {
          header += "-";
        } else if (value === ws || n !== ws.length - 1) {
          header += "+";
          if (onChompKeep)
            onChompKeep();
        }
        wsEnd = ws.replace(/\n$/, "");
        return "";
      }).replace(/^[\n ]*/, (ws) => {
        if (ws.indexOf(" ") !== -1)
          header += indentSize;
        const m = ws.match(/ +$/);
        if (m) {
          wsStart = ws.slice(0, -m[0].length);
          return m[0];
        } else {
          wsStart = ws;
          return "";
        }
      });
      if (wsEnd)
        wsEnd = wsEnd.replace(/\n+(?!\n|$)/g, `$&${indent}`);
      if (wsStart)
        wsStart = wsStart.replace(/\n+/g, `$&${indent}`);
      if (comment) {
        header += " #" + comment.replace(/ ?[\r\n]+/g, " ");
        if (onComment)
          onComment();
      }
      if (!value)
        return `${header}${indentSize}
${indent}${wsEnd}`;
      if (literal) {
        value = value.replace(/\n+/g, `$&${indent}`);
        return `${header}
${indent}${wsStart}${value}${wsEnd}`;
      }
      value = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`);
      const body = foldFlowLines(`${wsStart}${value}${wsEnd}`, indent, FOLD_BLOCK, strOptions.fold);
      return `${header}
${indent}${body}`;
    }
    function plainString(item, ctx, onComment, onChompKeep) {
      const {
        comment,
        type,
        value
      } = item;
      const {
        actualString,
        implicitKey,
        indent,
        inFlow
      } = ctx;
      if (implicitKey && /[\n[\]{},]/.test(value) || inFlow && /[[\]{},]/.test(value)) {
        return doubleQuotedString(value, ctx);
      }
      if (!value || /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
        return implicitKey || inFlow || value.indexOf("\n") === -1 ? value.indexOf('"') !== -1 && value.indexOf("'") === -1 ? singleQuotedString(value, ctx) : doubleQuotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
      }
      if (!implicitKey && !inFlow && type !== PlainValue.Type.PLAIN && value.indexOf("\n") !== -1) {
        return blockString(item, ctx, onComment, onChompKeep);
      }
      if (indent === "" && containsDocumentMarker(value)) {
        ctx.forceBlockIndent = true;
        return blockString(item, ctx, onComment, onChompKeep);
      }
      const str = value.replace(/\n+/g, `$&
${indent}`);
      if (actualString) {
        const {
          tags
        } = ctx.doc.schema;
        const resolved = resolveScalar(str, tags, tags.scalarFallback).value;
        if (typeof resolved !== "string")
          return doubleQuotedString(value, ctx);
      }
      const body = implicitKey ? str : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx));
      if (comment && !inFlow && (body.indexOf("\n") !== -1 || comment.indexOf("\n") !== -1)) {
        if (onComment)
          onComment();
        return addCommentBefore(body, indent, comment);
      }
      return body;
    }
    function stringifyString(item, ctx, onComment, onChompKeep) {
      const {
        defaultType
      } = strOptions;
      const {
        implicitKey,
        inFlow
      } = ctx;
      let {
        type,
        value
      } = item;
      if (typeof value !== "string") {
        value = String(value);
        item = Object.assign({}, item, {
          value
        });
      }
      const _stringify = (_type) => {
        switch (_type) {
          case PlainValue.Type.BLOCK_FOLDED:
          case PlainValue.Type.BLOCK_LITERAL:
            return blockString(item, ctx, onComment, onChompKeep);
          case PlainValue.Type.QUOTE_DOUBLE:
            return doubleQuotedString(value, ctx);
          case PlainValue.Type.QUOTE_SINGLE:
            return singleQuotedString(value, ctx);
          case PlainValue.Type.PLAIN:
            return plainString(item, ctx, onComment, onChompKeep);
          default:
            return null;
        }
      };
      if (type !== PlainValue.Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(value)) {
        type = PlainValue.Type.QUOTE_DOUBLE;
      } else if ((implicitKey || inFlow) && (type === PlainValue.Type.BLOCK_FOLDED || type === PlainValue.Type.BLOCK_LITERAL)) {
        type = PlainValue.Type.QUOTE_DOUBLE;
      }
      let res = _stringify(type);
      if (res === null) {
        res = _stringify(defaultType);
        if (res === null)
          throw new Error(`Unsupported default string type ${defaultType}`);
      }
      return res;
    }
    function stringifyNumber({
      format,
      minFractionDigits,
      tag,
      value
    }) {
      if (typeof value === "bigint")
        return String(value);
      if (!isFinite(value))
        return isNaN(value) ? ".nan" : value < 0 ? "-.inf" : ".inf";
      let n = JSON.stringify(value);
      if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
        let i = n.indexOf(".");
        if (i < 0) {
          i = n.length;
          n += ".";
        }
        let d = minFractionDigits - (n.length - i - 1);
        while (d-- > 0)
          n += "0";
      }
      return n;
    }
    function checkFlowCollectionEnd(errors, cst) {
      let char, name;
      switch (cst.type) {
        case PlainValue.Type.FLOW_MAP:
          char = "}";
          name = "flow map";
          break;
        case PlainValue.Type.FLOW_SEQ:
          char = "]";
          name = "flow sequence";
          break;
        default:
          errors.push(new PlainValue.YAMLSemanticError(cst, "Not a flow collection!?"));
          return;
      }
      let lastItem;
      for (let i = cst.items.length - 1; i >= 0; --i) {
        const item = cst.items[i];
        if (!item || item.type !== PlainValue.Type.COMMENT) {
          lastItem = item;
          break;
        }
      }
      if (lastItem && lastItem.char !== char) {
        const msg = `Expected ${name} to end with ${char}`;
        let err;
        if (typeof lastItem.offset === "number") {
          err = new PlainValue.YAMLSemanticError(cst, msg);
          err.offset = lastItem.offset + 1;
        } else {
          err = new PlainValue.YAMLSemanticError(lastItem, msg);
          if (lastItem.range && lastItem.range.end)
            err.offset = lastItem.range.end - lastItem.range.start;
        }
        errors.push(err);
      }
    }
    function checkFlowCommentSpace(errors, comment) {
      const prev = comment.context.src[comment.range.start - 1];
      if (prev !== "\n" && prev !== "	" && prev !== " ") {
        const msg = "Comments must be separated from other tokens by white space characters";
        errors.push(new PlainValue.YAMLSemanticError(comment, msg));
      }
    }
    function getLongKeyError(source, key) {
      const sk = String(key);
      const k = sk.substr(0, 8) + "..." + sk.substr(-8);
      return new PlainValue.YAMLSemanticError(source, `The "${k}" key is too long`);
    }
    function resolveComments(collection, comments) {
      for (const {
        afterKey,
        before,
        comment
      } of comments) {
        let item = collection.items[before];
        if (!item) {
          if (comment !== void 0) {
            if (collection.comment)
              collection.comment += "\n" + comment;
            else
              collection.comment = comment;
          }
        } else {
          if (afterKey && item.value)
            item = item.value;
          if (comment === void 0) {
            if (afterKey || !item.commentBefore)
              item.spaceBefore = true;
          } else {
            if (item.commentBefore)
              item.commentBefore += "\n" + comment;
            else
              item.commentBefore = comment;
          }
        }
      }
    }
    function resolveString(doc, node) {
      const res = node.strValue;
      if (!res)
        return "";
      if (typeof res === "string")
        return res;
      res.errors.forEach((error) => {
        if (!error.source)
          error.source = node;
        doc.errors.push(error);
      });
      return res.str;
    }
    function resolveTagHandle(doc, node) {
      const {
        handle,
        suffix
      } = node.tag;
      let prefix = doc.tagPrefixes.find((p) => p.handle === handle);
      if (!prefix) {
        const dtp = doc.getDefaults().tagPrefixes;
        if (dtp)
          prefix = dtp.find((p) => p.handle === handle);
        if (!prefix)
          throw new PlainValue.YAMLSemanticError(node, `The ${handle} tag handle is non-default and was not declared.`);
      }
      if (!suffix)
        throw new PlainValue.YAMLSemanticError(node, `The ${handle} tag has no suffix.`);
      if (handle === "!" && (doc.version || doc.options.version) === "1.0") {
        if (suffix[0] === "^") {
          doc.warnings.push(new PlainValue.YAMLWarning(node, "YAML 1.0 ^ tag expansion is not supported"));
          return suffix;
        }
        if (/[:/]/.test(suffix)) {
          const vocab = suffix.match(/^([a-z0-9-]+)\/(.*)/i);
          return vocab ? `tag:${vocab[1]}.yaml.org,2002:${vocab[2]}` : `tag:${suffix}`;
        }
      }
      return prefix.prefix + decodeURIComponent(suffix);
    }
    function resolveTagName(doc, node) {
      const {
        tag,
        type
      } = node;
      let nonSpecific = false;
      if (tag) {
        const {
          handle,
          suffix,
          verbatim
        } = tag;
        if (verbatim) {
          if (verbatim !== "!" && verbatim !== "!!")
            return verbatim;
          const msg = `Verbatim tags aren't resolved, so ${verbatim} is invalid.`;
          doc.errors.push(new PlainValue.YAMLSemanticError(node, msg));
        } else if (handle === "!" && !suffix) {
          nonSpecific = true;
        } else {
          try {
            return resolveTagHandle(doc, node);
          } catch (error) {
            doc.errors.push(error);
          }
        }
      }
      switch (type) {
        case PlainValue.Type.BLOCK_FOLDED:
        case PlainValue.Type.BLOCK_LITERAL:
        case PlainValue.Type.QUOTE_DOUBLE:
        case PlainValue.Type.QUOTE_SINGLE:
          return PlainValue.defaultTags.STR;
        case PlainValue.Type.FLOW_MAP:
        case PlainValue.Type.MAP:
          return PlainValue.defaultTags.MAP;
        case PlainValue.Type.FLOW_SEQ:
        case PlainValue.Type.SEQ:
          return PlainValue.defaultTags.SEQ;
        case PlainValue.Type.PLAIN:
          return nonSpecific ? PlainValue.defaultTags.STR : null;
        default:
          return null;
      }
    }
    function resolveByTagName(doc, node, tagName) {
      const {
        tags
      } = doc.schema;
      const matchWithTest = [];
      for (const tag of tags) {
        if (tag.tag === tagName) {
          if (tag.test)
            matchWithTest.push(tag);
          else {
            const res = tag.resolve(doc, node);
            return res instanceof Collection ? res : new Scalar(res);
          }
        }
      }
      const str = resolveString(doc, node);
      if (typeof str === "string" && matchWithTest.length > 0)
        return resolveScalar(str, matchWithTest, tags.scalarFallback);
      return null;
    }
    function getFallbackTagName({
      type
    }) {
      switch (type) {
        case PlainValue.Type.FLOW_MAP:
        case PlainValue.Type.MAP:
          return PlainValue.defaultTags.MAP;
        case PlainValue.Type.FLOW_SEQ:
        case PlainValue.Type.SEQ:
          return PlainValue.defaultTags.SEQ;
        default:
          return PlainValue.defaultTags.STR;
      }
    }
    function resolveTag(doc, node, tagName) {
      try {
        const res = resolveByTagName(doc, node, tagName);
        if (res) {
          if (tagName && node.tag)
            res.tag = tagName;
          return res;
        }
      } catch (error) {
        if (!error.source)
          error.source = node;
        doc.errors.push(error);
        return null;
      }
      try {
        const fallback = getFallbackTagName(node);
        if (!fallback)
          throw new Error(`The tag ${tagName} is unavailable`);
        const msg = `The tag ${tagName} is unavailable, falling back to ${fallback}`;
        doc.warnings.push(new PlainValue.YAMLWarning(node, msg));
        const res = resolveByTagName(doc, node, fallback);
        res.tag = tagName;
        return res;
      } catch (error) {
        const refError = new PlainValue.YAMLReferenceError(node, error.message);
        refError.stack = error.stack;
        doc.errors.push(refError);
        return null;
      }
    }
    var isCollectionItem = (node) => {
      if (!node)
        return false;
      const {
        type
      } = node;
      return type === PlainValue.Type.MAP_KEY || type === PlainValue.Type.MAP_VALUE || type === PlainValue.Type.SEQ_ITEM;
    };
    function resolveNodeProps(errors, node) {
      const comments = {
        before: [],
        after: []
      };
      let hasAnchor = false;
      let hasTag = false;
      const props = isCollectionItem(node.context.parent) ? node.context.parent.props.concat(node.props) : node.props;
      for (const {
        start,
        end
      } of props) {
        switch (node.context.src[start]) {
          case PlainValue.Char.COMMENT: {
            if (!node.commentHasRequiredWhitespace(start)) {
              const msg = "Comments must be separated from other tokens by white space characters";
              errors.push(new PlainValue.YAMLSemanticError(node, msg));
            }
            const {
              header,
              valueRange
            } = node;
            const cc = valueRange && (start > valueRange.start || header && start > header.start) ? comments.after : comments.before;
            cc.push(node.context.src.slice(start + 1, end));
            break;
          }
          case PlainValue.Char.ANCHOR:
            if (hasAnchor) {
              const msg = "A node can have at most one anchor";
              errors.push(new PlainValue.YAMLSemanticError(node, msg));
            }
            hasAnchor = true;
            break;
          case PlainValue.Char.TAG:
            if (hasTag) {
              const msg = "A node can have at most one tag";
              errors.push(new PlainValue.YAMLSemanticError(node, msg));
            }
            hasTag = true;
            break;
        }
      }
      return {
        comments,
        hasAnchor,
        hasTag
      };
    }
    function resolveNodeValue(doc, node) {
      const {
        anchors,
        errors,
        schema
      } = doc;
      if (node.type === PlainValue.Type.ALIAS) {
        const name = node.rawValue;
        const src = anchors.getNode(name);
        if (!src) {
          const msg = `Aliased anchor not found: ${name}`;
          errors.push(new PlainValue.YAMLReferenceError(node, msg));
          return null;
        }
        const res = new Alias(src);
        anchors._cstAliases.push(res);
        return res;
      }
      const tagName = resolveTagName(doc, node);
      if (tagName)
        return resolveTag(doc, node, tagName);
      if (node.type !== PlainValue.Type.PLAIN) {
        const msg = `Failed to resolve ${node.type} node here`;
        errors.push(new PlainValue.YAMLSyntaxError(node, msg));
        return null;
      }
      try {
        const str = resolveString(doc, node);
        return resolveScalar(str, schema.tags, schema.tags.scalarFallback);
      } catch (error) {
        if (!error.source)
          error.source = node;
        errors.push(error);
        return null;
      }
    }
    function resolveNode(doc, node) {
      if (!node)
        return null;
      if (node.error)
        doc.errors.push(node.error);
      const {
        comments,
        hasAnchor,
        hasTag
      } = resolveNodeProps(doc.errors, node);
      if (hasAnchor) {
        const {
          anchors
        } = doc;
        const name = node.anchor;
        const prev = anchors.getNode(name);
        if (prev)
          anchors.map[anchors.newName(name)] = prev;
        anchors.map[name] = node;
      }
      if (node.type === PlainValue.Type.ALIAS && (hasAnchor || hasTag)) {
        const msg = "An alias node must not specify any properties";
        doc.errors.push(new PlainValue.YAMLSemanticError(node, msg));
      }
      const res = resolveNodeValue(doc, node);
      if (res) {
        res.range = [node.range.start, node.range.end];
        if (doc.options.keepCstNodes)
          res.cstNode = node;
        if (doc.options.keepNodeTypes)
          res.type = node.type;
        const cb = comments.before.join("\n");
        if (cb) {
          res.commentBefore = res.commentBefore ? `${res.commentBefore}
${cb}` : cb;
        }
        const ca = comments.after.join("\n");
        if (ca)
          res.comment = res.comment ? `${res.comment}
${ca}` : ca;
      }
      return node.resolved = res;
    }
    function resolveMap(doc, cst) {
      if (cst.type !== PlainValue.Type.MAP && cst.type !== PlainValue.Type.FLOW_MAP) {
        const msg = `A ${cst.type} node cannot be resolved as a mapping`;
        doc.errors.push(new PlainValue.YAMLSyntaxError(cst, msg));
        return null;
      }
      const {
        comments,
        items
      } = cst.type === PlainValue.Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst);
      const map = new YAMLMap();
      map.items = items;
      resolveComments(map, comments);
      let hasCollectionKey = false;
      for (let i = 0; i < items.length; ++i) {
        const {
          key: iKey
        } = items[i];
        if (iKey instanceof Collection)
          hasCollectionKey = true;
        if (doc.schema.merge && iKey && iKey.value === MERGE_KEY) {
          items[i] = new Merge(items[i]);
          const sources = items[i].value.items;
          let error = null;
          sources.some((node) => {
            if (node instanceof Alias) {
              const {
                type
              } = node.source;
              if (type === PlainValue.Type.MAP || type === PlainValue.Type.FLOW_MAP)
                return false;
              return error = "Merge nodes aliases can only point to maps";
            }
            return error = "Merge nodes can only have Alias nodes as values";
          });
          if (error)
            doc.errors.push(new PlainValue.YAMLSemanticError(cst, error));
        } else {
          for (let j = i + 1; j < items.length; ++j) {
            const {
              key: jKey
            } = items[j];
            if (iKey === jKey || iKey && jKey && Object.prototype.hasOwnProperty.call(iKey, "value") && iKey.value === jKey.value) {
              const msg = `Map keys must be unique; "${iKey}" is repeated`;
              doc.errors.push(new PlainValue.YAMLSemanticError(cst, msg));
              break;
            }
          }
        }
      }
      if (hasCollectionKey && !doc.options.mapAsMap) {
        const warn = "Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.";
        doc.warnings.push(new PlainValue.YAMLWarning(cst, warn));
      }
      cst.resolved = map;
      return map;
    }
    var valueHasPairComment = ({
      context: {
        lineStart,
        node,
        src
      },
      props
    }) => {
      if (props.length === 0)
        return false;
      const {
        start
      } = props[0];
      if (node && start > node.valueRange.start)
        return false;
      if (src[start] !== PlainValue.Char.COMMENT)
        return false;
      for (let i = lineStart; i < start; ++i)
        if (src[i] === "\n")
          return false;
      return true;
    };
    function resolvePairComment(item, pair) {
      if (!valueHasPairComment(item))
        return;
      const comment = item.getPropValue(0, PlainValue.Char.COMMENT, true);
      let found = false;
      const cb = pair.value.commentBefore;
      if (cb && cb.startsWith(comment)) {
        pair.value.commentBefore = cb.substr(comment.length + 1);
        found = true;
      } else {
        const cc = pair.value.comment;
        if (!item.node && cc && cc.startsWith(comment)) {
          pair.value.comment = cc.substr(comment.length + 1);
          found = true;
        }
      }
      if (found)
        pair.comment = comment;
    }
    function resolveBlockMapItems(doc, cst) {
      const comments = [];
      const items = [];
      let key = void 0;
      let keyStart = null;
      for (let i = 0; i < cst.items.length; ++i) {
        const item = cst.items[i];
        switch (item.type) {
          case PlainValue.Type.BLANK_LINE:
            comments.push({
              afterKey: !!key,
              before: items.length
            });
            break;
          case PlainValue.Type.COMMENT:
            comments.push({
              afterKey: !!key,
              before: items.length,
              comment: item.comment
            });
            break;
          case PlainValue.Type.MAP_KEY:
            if (key !== void 0)
              items.push(new Pair(key));
            if (item.error)
              doc.errors.push(item.error);
            key = resolveNode(doc, item.node);
            keyStart = null;
            break;
          case PlainValue.Type.MAP_VALUE:
            {
              if (key === void 0)
                key = null;
              if (item.error)
                doc.errors.push(item.error);
              if (!item.context.atLineStart && item.node && item.node.type === PlainValue.Type.MAP && !item.node.context.atLineStart) {
                const msg = "Nested mappings are not allowed in compact mappings";
                doc.errors.push(new PlainValue.YAMLSemanticError(item.node, msg));
              }
              let valueNode = item.node;
              if (!valueNode && item.props.length > 0) {
                valueNode = new PlainValue.PlainValue(PlainValue.Type.PLAIN, []);
                valueNode.context = {
                  parent: item,
                  src: item.context.src
                };
                const pos = item.range.start + 1;
                valueNode.range = {
                  start: pos,
                  end: pos
                };
                valueNode.valueRange = {
                  start: pos,
                  end: pos
                };
                if (typeof item.range.origStart === "number") {
                  const origPos = item.range.origStart + 1;
                  valueNode.range.origStart = valueNode.range.origEnd = origPos;
                  valueNode.valueRange.origStart = valueNode.valueRange.origEnd = origPos;
                }
              }
              const pair = new Pair(key, resolveNode(doc, valueNode));
              resolvePairComment(item, pair);
              items.push(pair);
              if (key && typeof keyStart === "number") {
                if (item.range.start > keyStart + 1024)
                  doc.errors.push(getLongKeyError(cst, key));
              }
              key = void 0;
              keyStart = null;
            }
            break;
          default:
            if (key !== void 0)
              items.push(new Pair(key));
            key = resolveNode(doc, item);
            keyStart = item.range.start;
            if (item.error)
              doc.errors.push(item.error);
            next:
              for (let j = i + 1; ; ++j) {
                const nextItem = cst.items[j];
                switch (nextItem && nextItem.type) {
                  case PlainValue.Type.BLANK_LINE:
                  case PlainValue.Type.COMMENT:
                    continue next;
                  case PlainValue.Type.MAP_VALUE:
                    break next;
                  default: {
                    const msg = "Implicit map keys need to be followed by map values";
                    doc.errors.push(new PlainValue.YAMLSemanticError(item, msg));
                    break next;
                  }
                }
              }
            if (item.valueRangeContainsNewline) {
              const msg = "Implicit map keys need to be on a single line";
              doc.errors.push(new PlainValue.YAMLSemanticError(item, msg));
            }
        }
      }
      if (key !== void 0)
        items.push(new Pair(key));
      return {
        comments,
        items
      };
    }
    function resolveFlowMapItems(doc, cst) {
      const comments = [];
      const items = [];
      let key = void 0;
      let explicitKey = false;
      let next = "{";
      for (let i = 0; i < cst.items.length; ++i) {
        const item = cst.items[i];
        if (typeof item.char === "string") {
          const {
            char,
            offset
          } = item;
          if (char === "?" && key === void 0 && !explicitKey) {
            explicitKey = true;
            next = ":";
            continue;
          }
          if (char === ":") {
            if (key === void 0)
              key = null;
            if (next === ":") {
              next = ",";
              continue;
            }
          } else {
            if (explicitKey) {
              if (key === void 0 && char !== ",")
                key = null;
              explicitKey = false;
            }
            if (key !== void 0) {
              items.push(new Pair(key));
              key = void 0;
              if (char === ",") {
                next = ":";
                continue;
              }
            }
          }
          if (char === "}") {
            if (i === cst.items.length - 1)
              continue;
          } else if (char === next) {
            next = ":";
            continue;
          }
          const msg = `Flow map contains an unexpected ${char}`;
          const err = new PlainValue.YAMLSyntaxError(cst, msg);
          err.offset = offset;
          doc.errors.push(err);
        } else if (item.type === PlainValue.Type.BLANK_LINE) {
          comments.push({
            afterKey: !!key,
            before: items.length
          });
        } else if (item.type === PlainValue.Type.COMMENT) {
          checkFlowCommentSpace(doc.errors, item);
          comments.push({
            afterKey: !!key,
            before: items.length,
            comment: item.comment
          });
        } else if (key === void 0) {
          if (next === ",")
            doc.errors.push(new PlainValue.YAMLSemanticError(item, "Separator , missing in flow map"));
          key = resolveNode(doc, item);
        } else {
          if (next !== ",")
            doc.errors.push(new PlainValue.YAMLSemanticError(item, "Indicator : missing in flow map entry"));
          items.push(new Pair(key, resolveNode(doc, item)));
          key = void 0;
          explicitKey = false;
        }
      }
      checkFlowCollectionEnd(doc.errors, cst);
      if (key !== void 0)
        items.push(new Pair(key));
      return {
        comments,
        items
      };
    }
    function resolveSeq(doc, cst) {
      if (cst.type !== PlainValue.Type.SEQ && cst.type !== PlainValue.Type.FLOW_SEQ) {
        const msg = `A ${cst.type} node cannot be resolved as a sequence`;
        doc.errors.push(new PlainValue.YAMLSyntaxError(cst, msg));
        return null;
      }
      const {
        comments,
        items
      } = cst.type === PlainValue.Type.FLOW_SEQ ? resolveFlowSeqItems(doc, cst) : resolveBlockSeqItems(doc, cst);
      const seq = new YAMLSeq();
      seq.items = items;
      resolveComments(seq, comments);
      if (!doc.options.mapAsMap && items.some((it) => it instanceof Pair && it.key instanceof Collection)) {
        const warn = "Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.";
        doc.warnings.push(new PlainValue.YAMLWarning(cst, warn));
      }
      cst.resolved = seq;
      return seq;
    }
    function resolveBlockSeqItems(doc, cst) {
      const comments = [];
      const items = [];
      for (let i = 0; i < cst.items.length; ++i) {
        const item = cst.items[i];
        switch (item.type) {
          case PlainValue.Type.BLANK_LINE:
            comments.push({
              before: items.length
            });
            break;
          case PlainValue.Type.COMMENT:
            comments.push({
              comment: item.comment,
              before: items.length
            });
            break;
          case PlainValue.Type.SEQ_ITEM:
            if (item.error)
              doc.errors.push(item.error);
            items.push(resolveNode(doc, item.node));
            if (item.hasProps) {
              const msg = "Sequence items cannot have tags or anchors before the - indicator";
              doc.errors.push(new PlainValue.YAMLSemanticError(item, msg));
            }
            break;
          default:
            if (item.error)
              doc.errors.push(item.error);
            doc.errors.push(new PlainValue.YAMLSyntaxError(item, `Unexpected ${item.type} node in sequence`));
        }
      }
      return {
        comments,
        items
      };
    }
    function resolveFlowSeqItems(doc, cst) {
      const comments = [];
      const items = [];
      let explicitKey = false;
      let key = void 0;
      let keyStart = null;
      let next = "[";
      let prevItem = null;
      for (let i = 0; i < cst.items.length; ++i) {
        const item = cst.items[i];
        if (typeof item.char === "string") {
          const {
            char,
            offset
          } = item;
          if (char !== ":" && (explicitKey || key !== void 0)) {
            if (explicitKey && key === void 0)
              key = next ? items.pop() : null;
            items.push(new Pair(key));
            explicitKey = false;
            key = void 0;
            keyStart = null;
          }
          if (char === next) {
            next = null;
          } else if (!next && char === "?") {
            explicitKey = true;
          } else if (next !== "[" && char === ":" && key === void 0) {
            if (next === ",") {
              key = items.pop();
              if (key instanceof Pair) {
                const msg = "Chaining flow sequence pairs is invalid";
                const err = new PlainValue.YAMLSemanticError(cst, msg);
                err.offset = offset;
                doc.errors.push(err);
              }
              if (!explicitKey && typeof keyStart === "number") {
                const keyEnd = item.range ? item.range.start : item.offset;
                if (keyEnd > keyStart + 1024)
                  doc.errors.push(getLongKeyError(cst, key));
                const {
                  src
                } = prevItem.context;
                for (let i2 = keyStart; i2 < keyEnd; ++i2)
                  if (src[i2] === "\n") {
                    const msg = "Implicit keys of flow sequence pairs need to be on a single line";
                    doc.errors.push(new PlainValue.YAMLSemanticError(prevItem, msg));
                    break;
                  }
              }
            } else {
              key = null;
            }
            keyStart = null;
            explicitKey = false;
            next = null;
          } else if (next === "[" || char !== "]" || i < cst.items.length - 1) {
            const msg = `Flow sequence contains an unexpected ${char}`;
            const err = new PlainValue.YAMLSyntaxError(cst, msg);
            err.offset = offset;
            doc.errors.push(err);
          }
        } else if (item.type === PlainValue.Type.BLANK_LINE) {
          comments.push({
            before: items.length
          });
        } else if (item.type === PlainValue.Type.COMMENT) {
          checkFlowCommentSpace(doc.errors, item);
          comments.push({
            comment: item.comment,
            before: items.length
          });
        } else {
          if (next) {
            const msg = `Expected a ${next} in flow sequence`;
            doc.errors.push(new PlainValue.YAMLSemanticError(item, msg));
          }
          const value = resolveNode(doc, item);
          if (key === void 0) {
            items.push(value);
            prevItem = item;
          } else {
            items.push(new Pair(key, value));
            key = void 0;
          }
          keyStart = item.range.start;
          next = ",";
        }
      }
      checkFlowCollectionEnd(doc.errors, cst);
      if (key !== void 0)
        items.push(new Pair(key));
      return {
        comments,
        items
      };
    }
    exports2.Alias = Alias;
    exports2.Collection = Collection;
    exports2.Merge = Merge;
    exports2.Node = Node;
    exports2.Pair = Pair;
    exports2.Scalar = Scalar;
    exports2.YAMLMap = YAMLMap;
    exports2.YAMLSeq = YAMLSeq;
    exports2.addComment = addComment;
    exports2.binaryOptions = binaryOptions;
    exports2.boolOptions = boolOptions;
    exports2.findPair = findPair;
    exports2.intOptions = intOptions;
    exports2.isEmptyPath = isEmptyPath;
    exports2.nullOptions = nullOptions;
    exports2.resolveMap = resolveMap;
    exports2.resolveNode = resolveNode;
    exports2.resolveSeq = resolveSeq;
    exports2.resolveString = resolveString;
    exports2.strOptions = strOptions;
    exports2.stringifyNumber = stringifyNumber;
    exports2.stringifyString = stringifyString;
    exports2.toJSON = toJSON;
  }
});

// node_modules/yaml/dist/warnings-1000a372.js
var require_warnings_1000a372 = __commonJS({
  "node_modules/yaml/dist/warnings-1000a372.js"(exports2) {
    "use strict";
    var PlainValue = require_PlainValue_ec8e588e();
    var resolveSeq = require_resolveSeq_d03cb037();
    var binary = {
      identify: (value) => value instanceof Uint8Array,
      default: false,
      tag: "tag:yaml.org,2002:binary",
      resolve: (doc, node) => {
        const src = resolveSeq.resolveString(doc, node);
        if (typeof Buffer === "function") {
          return Buffer.from(src, "base64");
        } else if (typeof atob === "function") {
          const str = atob(src.replace(/[\n\r]/g, ""));
          const buffer = new Uint8Array(str.length);
          for (let i = 0; i < str.length; ++i)
            buffer[i] = str.charCodeAt(i);
          return buffer;
        } else {
          const msg = "This environment does not support reading binary tags; either Buffer or atob is required";
          doc.errors.push(new PlainValue.YAMLReferenceError(node, msg));
          return null;
        }
      },
      options: resolveSeq.binaryOptions,
      stringify: ({
        comment,
        type,
        value
      }, ctx, onComment, onChompKeep) => {
        let src;
        if (typeof Buffer === "function") {
          src = value instanceof Buffer ? value.toString("base64") : Buffer.from(value.buffer).toString("base64");
        } else if (typeof btoa === "function") {
          let s = "";
          for (let i = 0; i < value.length; ++i)
            s += String.fromCharCode(value[i]);
          src = btoa(s);
        } else {
          throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required");
        }
        if (!type)
          type = resolveSeq.binaryOptions.defaultType;
        if (type === PlainValue.Type.QUOTE_DOUBLE) {
          value = src;
        } else {
          const {
            lineWidth
          } = resolveSeq.binaryOptions;
          const n = Math.ceil(src.length / lineWidth);
          const lines = new Array(n);
          for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {
            lines[i] = src.substr(o, lineWidth);
          }
          value = lines.join(type === PlainValue.Type.BLOCK_LITERAL ? "\n" : " ");
        }
        return resolveSeq.stringifyString({
          comment,
          type,
          value
        }, ctx, onComment, onChompKeep);
      }
    };
    function parsePairs(doc, cst) {
      const seq = resolveSeq.resolveSeq(doc, cst);
      for (let i = 0; i < seq.items.length; ++i) {
        let item = seq.items[i];
        if (item instanceof resolveSeq.Pair)
          continue;
        else if (item instanceof resolveSeq.YAMLMap) {
          if (item.items.length > 1) {
            const msg = "Each pair must have its own sequence indicator";
            throw new PlainValue.YAMLSemanticError(cst, msg);
          }
          const pair = item.items[0] || new resolveSeq.Pair();
          if (item.commentBefore)
            pair.commentBefore = pair.commentBefore ? `${item.commentBefore}
${pair.commentBefore}` : item.commentBefore;
          if (item.comment)
            pair.comment = pair.comment ? `${item.comment}
${pair.comment}` : item.comment;
          item = pair;
        }
        seq.items[i] = item instanceof resolveSeq.Pair ? item : new resolveSeq.Pair(item);
      }
      return seq;
    }
    function createPairs(schema, iterable, ctx) {
      const pairs2 = new resolveSeq.YAMLSeq(schema);
      pairs2.tag = "tag:yaml.org,2002:pairs";
      for (const it of iterable) {
        let key, value;
        if (Array.isArray(it)) {
          if (it.length === 2) {
            key = it[0];
            value = it[1];
          } else
            throw new TypeError(`Expected [key, value] tuple: ${it}`);
        } else if (it && it instanceof Object) {
          const keys = Object.keys(it);
          if (keys.length === 1) {
            key = keys[0];
            value = it[key];
          } else
            throw new TypeError(`Expected { key: value } tuple: ${it}`);
        } else {
          key = it;
        }
        const pair = schema.createPair(key, value, ctx);
        pairs2.items.push(pair);
      }
      return pairs2;
    }
    var pairs = {
      default: false,
      tag: "tag:yaml.org,2002:pairs",
      resolve: parsePairs,
      createNode: createPairs
    };
    var YAMLOMap = class extends resolveSeq.YAMLSeq {
      constructor() {
        super();
        PlainValue._defineProperty(this, "add", resolveSeq.YAMLMap.prototype.add.bind(this));
        PlainValue._defineProperty(this, "delete", resolveSeq.YAMLMap.prototype.delete.bind(this));
        PlainValue._defineProperty(this, "get", resolveSeq.YAMLMap.prototype.get.bind(this));
        PlainValue._defineProperty(this, "has", resolveSeq.YAMLMap.prototype.has.bind(this));
        PlainValue._defineProperty(this, "set", resolveSeq.YAMLMap.prototype.set.bind(this));
        this.tag = YAMLOMap.tag;
      }
      toJSON(_, ctx) {
        const map = /* @__PURE__ */ new Map();
        if (ctx && ctx.onCreate)
          ctx.onCreate(map);
        for (const pair of this.items) {
          let key, value;
          if (pair instanceof resolveSeq.Pair) {
            key = resolveSeq.toJSON(pair.key, "", ctx);
            value = resolveSeq.toJSON(pair.value, key, ctx);
          } else {
            key = resolveSeq.toJSON(pair, "", ctx);
          }
          if (map.has(key))
            throw new Error("Ordered maps must not include duplicate keys");
          map.set(key, value);
        }
        return map;
      }
    };
    PlainValue._defineProperty(YAMLOMap, "tag", "tag:yaml.org,2002:omap");
    function parseOMap(doc, cst) {
      const pairs2 = parsePairs(doc, cst);
      const seenKeys = [];
      for (const {
        key
      } of pairs2.items) {
        if (key instanceof resolveSeq.Scalar) {
          if (seenKeys.includes(key.value)) {
            const msg = "Ordered maps must not include duplicate keys";
            throw new PlainValue.YAMLSemanticError(cst, msg);
          } else {
            seenKeys.push(key.value);
          }
        }
      }
      return Object.assign(new YAMLOMap(), pairs2);
    }
    function createOMap(schema, iterable, ctx) {
      const pairs2 = createPairs(schema, iterable, ctx);
      const omap2 = new YAMLOMap();
      omap2.items = pairs2.items;
      return omap2;
    }
    var omap = {
      identify: (value) => value instanceof Map,
      nodeClass: YAMLOMap,
      default: false,
      tag: "tag:yaml.org,2002:omap",
      resolve: parseOMap,
      createNode: createOMap
    };
    var YAMLSet = class extends resolveSeq.YAMLMap {
      constructor() {
        super();
        this.tag = YAMLSet.tag;
      }
      add(key) {
        const pair = key instanceof resolveSeq.Pair ? key : new resolveSeq.Pair(key);
        const prev = resolveSeq.findPair(this.items, pair.key);
        if (!prev)
          this.items.push(pair);
      }
      get(key, keepPair) {
        const pair = resolveSeq.findPair(this.items, key);
        return !keepPair && pair instanceof resolveSeq.Pair ? pair.key instanceof resolveSeq.Scalar ? pair.key.value : pair.key : pair;
      }
      set(key, value) {
        if (typeof value !== "boolean")
          throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
        const prev = resolveSeq.findPair(this.items, key);
        if (prev && !value) {
          this.items.splice(this.items.indexOf(prev), 1);
        } else if (!prev && value) {
          this.items.push(new resolveSeq.Pair(key));
        }
      }
      toJSON(_, ctx) {
        return super.toJSON(_, ctx, Set);
      }
      toString(ctx, onComment, onChompKeep) {
        if (!ctx)
          return JSON.stringify(this);
        if (this.hasAllNullValues())
          return super.toString(ctx, onComment, onChompKeep);
        else
          throw new Error("Set items must all have null values");
      }
    };
    PlainValue._defineProperty(YAMLSet, "tag", "tag:yaml.org,2002:set");
    function parseSet(doc, cst) {
      const map = resolveSeq.resolveMap(doc, cst);
      if (!map.hasAllNullValues())
        throw new PlainValue.YAMLSemanticError(cst, "Set items must all have null values");
      return Object.assign(new YAMLSet(), map);
    }
    function createSet(schema, iterable, ctx) {
      const set2 = new YAMLSet();
      for (const value of iterable)
        set2.items.push(schema.createPair(value, null, ctx));
      return set2;
    }
    var set = {
      identify: (value) => value instanceof Set,
      nodeClass: YAMLSet,
      default: false,
      tag: "tag:yaml.org,2002:set",
      resolve: parseSet,
      createNode: createSet
    };
    var parseSexagesimal = (sign, parts) => {
      const n = parts.split(":").reduce((n2, p) => n2 * 60 + Number(p), 0);
      return sign === "-" ? -n : n;
    };
    var stringifySexagesimal = ({
      value
    }) => {
      if (isNaN(value) || !isFinite(value))
        return resolveSeq.stringifyNumber(value);
      let sign = "";
      if (value < 0) {
        sign = "-";
        value = Math.abs(value);
      }
      const parts = [value % 60];
      if (value < 60) {
        parts.unshift(0);
      } else {
        value = Math.round((value - parts[0]) / 60);
        parts.unshift(value % 60);
        if (value >= 60) {
          value = Math.round((value - parts[0]) / 60);
          parts.unshift(value);
        }
      }
      return sign + parts.map((n) => n < 10 ? "0" + String(n) : String(n)).join(":").replace(/000000\d*$/, "");
    };
    var intTime = {
      identify: (value) => typeof value === "number",
      default: true,
      tag: "tag:yaml.org,2002:int",
      format: "TIME",
      test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+)$/,
      resolve: (str, sign, parts) => parseSexagesimal(sign, parts.replace(/_/g, "")),
      stringify: stringifySexagesimal
    };
    var floatTime = {
      identify: (value) => typeof value === "number",
      default: true,
      tag: "tag:yaml.org,2002:float",
      format: "TIME",
      test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*)$/,
      resolve: (str, sign, parts) => parseSexagesimal(sign, parts.replace(/_/g, "")),
      stringify: stringifySexagesimal
    };
    var timestamp = {
      identify: (value) => value instanceof Date,
      default: true,
      tag: "tag:yaml.org,2002:timestamp",
      test: RegExp("^(?:([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?)$"),
      resolve: (str, year, month, day, hour, minute, second, millisec, tz) => {
        if (millisec)
          millisec = (millisec + "00").substr(1, 3);
        let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec || 0);
        if (tz && tz !== "Z") {
          let d = parseSexagesimal(tz[0], tz.slice(1));
          if (Math.abs(d) < 30)
            d *= 60;
          date -= 6e4 * d;
        }
        return new Date(date);
      },
      stringify: ({
        value
      }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, "")
    };
    function shouldWarn(deprecation) {
      const env = typeof process !== "undefined" && process.env || {};
      if (deprecation) {
        if (typeof YAML_SILENCE_DEPRECATION_WARNINGS !== "undefined")
          return !YAML_SILENCE_DEPRECATION_WARNINGS;
        return !env.YAML_SILENCE_DEPRECATION_WARNINGS;
      }
      if (typeof YAML_SILENCE_WARNINGS !== "undefined")
        return !YAML_SILENCE_WARNINGS;
      return !env.YAML_SILENCE_WARNINGS;
    }
    function warn(warning, type) {
      if (shouldWarn(false)) {
        const emit = typeof process !== "undefined" && process.emitWarning;
        if (emit)
          emit(warning, type);
        else {
          console.warn(type ? `${type}: ${warning}` : warning);
        }
      }
    }
    function warnFileDeprecation(filename) {
      if (shouldWarn(true)) {
        const path = filename.replace(/.*yaml[/\\]/i, "").replace(/\.js$/, "").replace(/\\/g, "/");
        warn(`The endpoint 'yaml/${path}' will be removed in a future release.`, "DeprecationWarning");
      }
    }
    var warned = {};
    function warnOptionDeprecation(name, alternative) {
      if (!warned[name] && shouldWarn(true)) {
        warned[name] = true;
        let msg = `The option '${name}' will be removed in a future release`;
        msg += alternative ? `, use '${alternative}' instead.` : ".";
        warn(msg, "DeprecationWarning");
      }
    }
    exports2.binary = binary;
    exports2.floatTime = floatTime;
    exports2.intTime = intTime;
    exports2.omap = omap;
    exports2.pairs = pairs;
    exports2.set = set;
    exports2.timestamp = timestamp;
    exports2.warn = warn;
    exports2.warnFileDeprecation = warnFileDeprecation;
    exports2.warnOptionDeprecation = warnOptionDeprecation;
  }
});

// node_modules/yaml/dist/Schema-88e323a7.js
var require_Schema_88e323a7 = __commonJS({
  "node_modules/yaml/dist/Schema-88e323a7.js"(exports2) {
    "use strict";
    var PlainValue = require_PlainValue_ec8e588e();
    var resolveSeq = require_resolveSeq_d03cb037();
    var warnings = require_warnings_1000a372();
    function createMap(schema, obj, ctx) {
      const map2 = new resolveSeq.YAMLMap(schema);
      if (obj instanceof Map) {
        for (const [key, value] of obj)
          map2.items.push(schema.createPair(key, value, ctx));
      } else if (obj && typeof obj === "object") {
        for (const key of Object.keys(obj))
          map2.items.push(schema.createPair(key, obj[key], ctx));
      }
      if (typeof schema.sortMapEntries === "function") {
        map2.items.sort(schema.sortMapEntries);
      }
      return map2;
    }
    var map = {
      createNode: createMap,
      default: true,
      nodeClass: resolveSeq.YAMLMap,
      tag: "tag:yaml.org,2002:map",
      resolve: resolveSeq.resolveMap
    };
    function createSeq(schema, obj, ctx) {
      const seq2 = new resolveSeq.YAMLSeq(schema);
      if (obj && obj[Symbol.iterator]) {
        for (const it of obj) {
          const v = schema.createNode(it, ctx.wrapScalars, null, ctx);
          seq2.items.push(v);
        }
      }
      return seq2;
    }
    var seq = {
      createNode: createSeq,
      default: true,
      nodeClass: resolveSeq.YAMLSeq,
      tag: "tag:yaml.org,2002:seq",
      resolve: resolveSeq.resolveSeq
    };
    var string = {
      identify: (value) => typeof value === "string",
      default: true,
      tag: "tag:yaml.org,2002:str",
      resolve: resolveSeq.resolveString,
      stringify(item, ctx, onComment, onChompKeep) {
        ctx = Object.assign({
          actualString: true
        }, ctx);
        return resolveSeq.stringifyString(item, ctx, onComment, onChompKeep);
      },
      options: resolveSeq.strOptions
    };
    var failsafe = [map, seq, string];
    var intIdentify$2 = (value) => typeof value === "bigint" || Number.isInteger(value);
    var intResolve$1 = (src, part, radix) => resolveSeq.intOptions.asBigInt ? BigInt(src) : parseInt(part, radix);
    function intStringify$1(node, radix, prefix) {
      const {
        value
      } = node;
      if (intIdentify$2(value) && value >= 0)
        return prefix + value.toString(radix);
      return resolveSeq.stringifyNumber(node);
    }
    var nullObj = {
      identify: (value) => value == null,
      createNode: (schema, value, ctx) => ctx.wrapScalars ? new resolveSeq.Scalar(null) : null,
      default: true,
      tag: "tag:yaml.org,2002:null",
      test: /^(?:~|[Nn]ull|NULL)?$/,
      resolve: () => null,
      options: resolveSeq.nullOptions,
      stringify: () => resolveSeq.nullOptions.nullStr
    };
    var boolObj = {
      identify: (value) => typeof value === "boolean",
      default: true,
      tag: "tag:yaml.org,2002:bool",
      test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
      resolve: (str) => str[0] === "t" || str[0] === "T",
      options: resolveSeq.boolOptions,
      stringify: ({
        value
      }) => value ? resolveSeq.boolOptions.trueStr : resolveSeq.boolOptions.falseStr
    };
    var octObj = {
      identify: (value) => intIdentify$2(value) && value >= 0,
      default: true,
      tag: "tag:yaml.org,2002:int",
      format: "OCT",
      test: /^0o([0-7]+)$/,
      resolve: (str, oct) => intResolve$1(str, oct, 8),
      options: resolveSeq.intOptions,
      stringify: (node) => intStringify$1(node, 8, "0o")
    };
    var intObj = {
      identify: intIdentify$2,
      default: true,
      tag: "tag:yaml.org,2002:int",
      test: /^[-+]?[0-9]+$/,
      resolve: (str) => intResolve$1(str, str, 10),
      options: resolveSeq.intOptions,
      stringify: resolveSeq.stringifyNumber
    };
    var hexObj = {
      identify: (value) => intIdentify$2(value) && value >= 0,
      default: true,
      tag: "tag:yaml.org,2002:int",
      format: "HEX",
      test: /^0x([0-9a-fA-F]+)$/,
      resolve: (str, hex) => intResolve$1(str, hex, 16),
      options: resolveSeq.intOptions,
      stringify: (node) => intStringify$1(node, 16, "0x")
    };
    var nanObj = {
      identify: (value) => typeof value === "number",
      default: true,
      tag: "tag:yaml.org,2002:float",
      test: /^(?:[-+]?\.inf|(\.nan))$/i,
      resolve: (str, nan) => nan ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
      stringify: resolveSeq.stringifyNumber
    };
    var expObj = {
      identify: (value) => typeof value === "number",
      default: true,
      tag: "tag:yaml.org,2002:float",
      format: "EXP",
      test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
      resolve: (str) => parseFloat(str),
      stringify: ({
        value
      }) => Number(value).toExponential()
    };
    var floatObj = {
      identify: (value) => typeof value === "number",
      default: true,
      tag: "tag:yaml.org,2002:float",
      test: /^[-+]?(?:\.([0-9]+)|[0-9]+\.([0-9]*))$/,
      resolve(str, frac1, frac2) {
        const frac = frac1 || frac2;
        const node = new resolveSeq.Scalar(parseFloat(str));
        if (frac && frac[frac.length - 1] === "0")
          node.minFractionDigits = frac.length;
        return node;
      },
      stringify: resolveSeq.stringifyNumber
    };
    var core = failsafe.concat([nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj]);
    var intIdentify$1 = (value) => typeof value === "bigint" || Number.isInteger(value);
    var stringifyJSON = ({
      value
    }) => JSON.stringify(value);
    var json = [map, seq, {
      identify: (value) => typeof value === "string",
      default: true,
      tag: "tag:yaml.org,2002:str",
      resolve: resolveSeq.resolveString,
      stringify: stringifyJSON
    }, {
      identify: (value) => value == null,
      createNode: (schema, value, ctx) => ctx.wrapScalars ? new resolveSeq.Scalar(null) : null,
      default: true,
      tag: "tag:yaml.org,2002:null",
      test: /^null$/,
      resolve: () => null,
      stringify: stringifyJSON
    }, {
      identify: (value) => typeof value === "boolean",
      default: true,
      tag: "tag:yaml.org,2002:bool",
      test: /^true|false$/,
      resolve: (str) => str === "true",
      stringify: stringifyJSON
    }, {
      identify: intIdentify$1,
      default: true,
      tag: "tag:yaml.org,2002:int",
      test: /^-?(?:0|[1-9][0-9]*)$/,
      resolve: (str) => resolveSeq.intOptions.asBigInt ? BigInt(str) : parseInt(str, 10),
      stringify: ({
        value
      }) => intIdentify$1(value) ? value.toString() : JSON.stringify(value)
    }, {
      identify: (value) => typeof value === "number",
      default: true,
      tag: "tag:yaml.org,2002:float",
      test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
      resolve: (str) => parseFloat(str),
      stringify: stringifyJSON
    }];
    json.scalarFallback = (str) => {
      throw new SyntaxError(`Unresolved plain scalar ${JSON.stringify(str)}`);
    };
    var boolStringify = ({
      value
    }) => value ? resolveSeq.boolOptions.trueStr : resolveSeq.boolOptions.falseStr;
    var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
    function intResolve(sign, src, radix) {
      let str = src.replace(/_/g, "");
      if (resolveSeq.intOptions.asBigInt) {
        switch (radix) {
          case 2:
            str = `0b${str}`;
            break;
          case 8:
            str = `0o${str}`;
            break;
          case 16:
            str = `0x${str}`;
            break;
        }
        const n2 = BigInt(str);
        return sign === "-" ? BigInt(-1) * n2 : n2;
      }
      const n = parseInt(str, radix);
      return sign === "-" ? -1 * n : n;
    }
    function intStringify(node, radix, prefix) {
      const {
        value
      } = node;
      if (intIdentify(value)) {
        const str = value.toString(radix);
        return value < 0 ? "-" + prefix + str.substr(1) : prefix + str;
      }
      return resolveSeq.stringifyNumber(node);
    }
    var yaml11 = failsafe.concat([{
      identify: (value) => value == null,
      createNode: (schema, value, ctx) => ctx.wrapScalars ? new resolveSeq.Scalar(null) : null,
      default: true,
      tag: "tag:yaml.org,2002:null",
      test: /^(?:~|[Nn]ull|NULL)?$/,
      resolve: () => null,
      options: resolveSeq.nullOptions,
      stringify: () => resolveSeq.nullOptions.nullStr
    }, {
      identify: (value) => typeof value === "boolean",
      default: true,
      tag: "tag:yaml.org,2002:bool",
      test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
      resolve: () => true,
      options: resolveSeq.boolOptions,
      stringify: boolStringify
    }, {
      identify: (value) => typeof value === "boolean",
      default: true,
      tag: "tag:yaml.org,2002:bool",
      test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
      resolve: () => false,
      options: resolveSeq.boolOptions,
      stringify: boolStringify
    }, {
      identify: intIdentify,
      default: true,
      tag: "tag:yaml.org,2002:int",
      format: "BIN",
      test: /^([-+]?)0b([0-1_]+)$/,
      resolve: (str, sign, bin) => intResolve(sign, bin, 2),
      stringify: (node) => intStringify(node, 2, "0b")
    }, {
      identify: intIdentify,
      default: true,
      tag: "tag:yaml.org,2002:int",
      format: "OCT",
      test: /^([-+]?)0([0-7_]+)$/,
      resolve: (str, sign, oct) => intResolve(sign, oct, 8),
      stringify: (node) => intStringify(node, 8, "0")
    }, {
      identify: intIdentify,
      default: true,
      tag: "tag:yaml.org,2002:int",
      test: /^([-+]?)([0-9][0-9_]*)$/,
      resolve: (str, sign, abs) => intResolve(sign, abs, 10),
      stringify: resolveSeq.stringifyNumber
    }, {
      identify: intIdentify,
      default: true,
      tag: "tag:yaml.org,2002:int",
      format: "HEX",
      test: /^([-+]?)0x([0-9a-fA-F_]+)$/,
      resolve: (str, sign, hex) => intResolve(sign, hex, 16),
      stringify: (node) => intStringify(node, 16, "0x")
    }, {
      identify: (value) => typeof value === "number",
      default: true,
      tag: "tag:yaml.org,2002:float",
      test: /^(?:[-+]?\.inf|(\.nan))$/i,
      resolve: (str, nan) => nan ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
      stringify: resolveSeq.stringifyNumber
    }, {
      identify: (value) => typeof value === "number",
      default: true,
      tag: "tag:yaml.org,2002:float",
      format: "EXP",
      test: /^[-+]?([0-9][0-9_]*)?(\.[0-9_]*)?[eE][-+]?[0-9]+$/,
      resolve: (str) => parseFloat(str.replace(/_/g, "")),
      stringify: ({
        value
      }) => Number(value).toExponential()
    }, {
      identify: (value) => typeof value === "number",
      default: true,
      tag: "tag:yaml.org,2002:float",
      test: /^[-+]?(?:[0-9][0-9_]*)?\.([0-9_]*)$/,
      resolve(str, frac) {
        const node = new resolveSeq.Scalar(parseFloat(str.replace(/_/g, "")));
        if (frac) {
          const f = frac.replace(/_/g, "");
          if (f[f.length - 1] === "0")
            node.minFractionDigits = f.length;
        }
        return node;
      },
      stringify: resolveSeq.stringifyNumber
    }], warnings.binary, warnings.omap, warnings.pairs, warnings.set, warnings.intTime, warnings.floatTime, warnings.timestamp);
    var schemas = {
      core,
      failsafe,
      json,
      yaml11
    };
    var tags = {
      binary: warnings.binary,
      bool: boolObj,
      float: floatObj,
      floatExp: expObj,
      floatNaN: nanObj,
      floatTime: warnings.floatTime,
      int: intObj,
      intHex: hexObj,
      intOct: octObj,
      intTime: warnings.intTime,
      map,
      null: nullObj,
      omap: warnings.omap,
      pairs: warnings.pairs,
      seq,
      set: warnings.set,
      timestamp: warnings.timestamp
    };
    function findTagObject(value, tagName, tags2) {
      if (tagName) {
        const match = tags2.filter((t) => t.tag === tagName);
        const tagObj = match.find((t) => !t.format) || match[0];
        if (!tagObj)
          throw new Error(`Tag ${tagName} not found`);
        return tagObj;
      }
      return tags2.find((t) => (t.identify && t.identify(value) || t.class && value instanceof t.class) && !t.format);
    }
    function createNode(value, tagName, ctx) {
      if (value instanceof resolveSeq.Node)
        return value;
      const {
        defaultPrefix,
        onTagObj,
        prevObjects,
        schema,
        wrapScalars
      } = ctx;
      if (tagName && tagName.startsWith("!!"))
        tagName = defaultPrefix + tagName.slice(2);
      let tagObj = findTagObject(value, tagName, schema.tags);
      if (!tagObj) {
        if (typeof value.toJSON === "function")
          value = value.toJSON();
        if (!value || typeof value !== "object")
          return wrapScalars ? new resolveSeq.Scalar(value) : value;
        tagObj = value instanceof Map ? map : value[Symbol.iterator] ? seq : map;
      }
      if (onTagObj) {
        onTagObj(tagObj);
        delete ctx.onTagObj;
      }
      const obj = {
        value: void 0,
        node: void 0
      };
      if (value && typeof value === "object" && prevObjects) {
        const prev = prevObjects.get(value);
        if (prev) {
          const alias = new resolveSeq.Alias(prev);
          ctx.aliasNodes.push(alias);
          return alias;
        }
        obj.value = value;
        prevObjects.set(value, obj);
      }
      obj.node = tagObj.createNode ? tagObj.createNode(ctx.schema, value, ctx) : wrapScalars ? new resolveSeq.Scalar(value) : value;
      if (tagName && obj.node instanceof resolveSeq.Node)
        obj.node.tag = tagName;
      return obj.node;
    }
    function getSchemaTags(schemas2, knownTags, customTags, schemaId) {
      let tags2 = schemas2[schemaId.replace(/\W/g, "")];
      if (!tags2) {
        const keys = Object.keys(schemas2).map((key) => JSON.stringify(key)).join(", ");
        throw new Error(`Unknown schema "${schemaId}"; use one of ${keys}`);
      }
      if (Array.isArray(customTags)) {
        for (const tag of customTags)
          tags2 = tags2.concat(tag);
      } else if (typeof customTags === "function") {
        tags2 = customTags(tags2.slice());
      }
      for (let i = 0; i < tags2.length; ++i) {
        const tag = tags2[i];
        if (typeof tag === "string") {
          const tagObj = knownTags[tag];
          if (!tagObj) {
            const keys = Object.keys(knownTags).map((key) => JSON.stringify(key)).join(", ");
            throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
          }
          tags2[i] = tagObj;
        }
      }
      return tags2;
    }
    var sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
    var Schema = class {
      constructor({
        customTags,
        merge,
        schema,
        sortMapEntries,
        tags: deprecatedCustomTags
      }) {
        this.merge = !!merge;
        this.name = schema;
        this.sortMapEntries = sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null;
        if (!customTags && deprecatedCustomTags)
          warnings.warnOptionDeprecation("tags", "customTags");
        this.tags = getSchemaTags(schemas, tags, customTags || deprecatedCustomTags, schema);
      }
      createNode(value, wrapScalars, tagName, ctx) {
        const baseCtx = {
          defaultPrefix: Schema.defaultPrefix,
          schema: this,
          wrapScalars
        };
        const createCtx = ctx ? Object.assign(ctx, baseCtx) : baseCtx;
        return createNode(value, tagName, createCtx);
      }
      createPair(key, value, ctx) {
        if (!ctx)
          ctx = {
            wrapScalars: true
          };
        const k = this.createNode(key, ctx.wrapScalars, null, ctx);
        const v = this.createNode(value, ctx.wrapScalars, null, ctx);
        return new resolveSeq.Pair(k, v);
      }
    };
    PlainValue._defineProperty(Schema, "defaultPrefix", PlainValue.defaultTagPrefix);
    PlainValue._defineProperty(Schema, "defaultTags", PlainValue.defaultTags);
    exports2.Schema = Schema;
  }
});

// node_modules/yaml/dist/Document-9b4560a1.js
var require_Document_9b4560a1 = __commonJS({
  "node_modules/yaml/dist/Document-9b4560a1.js"(exports2) {
    "use strict";
    var PlainValue = require_PlainValue_ec8e588e();
    var resolveSeq = require_resolveSeq_d03cb037();
    var Schema = require_Schema_88e323a7();
    var defaultOptions = {
      anchorPrefix: "a",
      customTags: null,
      indent: 2,
      indentSeq: true,
      keepCstNodes: false,
      keepNodeTypes: true,
      keepBlobsInJSON: true,
      mapAsMap: false,
      maxAliasCount: 100,
      prettyErrors: false,
      simpleKeys: false,
      version: "1.2"
    };
    var scalarOptions = {
      get binary() {
        return resolveSeq.binaryOptions;
      },
      set binary(opt) {
        Object.assign(resolveSeq.binaryOptions, opt);
      },
      get bool() {
        return resolveSeq.boolOptions;
      },
      set bool(opt) {
        Object.assign(resolveSeq.boolOptions, opt);
      },
      get int() {
        return resolveSeq.intOptions;
      },
      set int(opt) {
        Object.assign(resolveSeq.intOptions, opt);
      },
      get null() {
        return resolveSeq.nullOptions;
      },
      set null(opt) {
        Object.assign(resolveSeq.nullOptions, opt);
      },
      get str() {
        return resolveSeq.strOptions;
      },
      set str(opt) {
        Object.assign(resolveSeq.strOptions, opt);
      }
    };
    var documentOptions = {
      "1.0": {
        schema: "yaml-1.1",
        merge: true,
        tagPrefixes: [{
          handle: "!",
          prefix: PlainValue.defaultTagPrefix
        }, {
          handle: "!!",
          prefix: "tag:private.yaml.org,2002:"
        }]
      },
      1.1: {
        schema: "yaml-1.1",
        merge: true,
        tagPrefixes: [{
          handle: "!",
          prefix: "!"
        }, {
          handle: "!!",
          prefix: PlainValue.defaultTagPrefix
        }]
      },
      1.2: {
        schema: "core",
        merge: false,
        tagPrefixes: [{
          handle: "!",
          prefix: "!"
        }, {
          handle: "!!",
          prefix: PlainValue.defaultTagPrefix
        }]
      }
    };
    function stringifyTag(doc, tag) {
      if ((doc.version || doc.options.version) === "1.0") {
        const priv = tag.match(/^tag:private\.yaml\.org,2002:([^:/]+)$/);
        if (priv)
          return "!" + priv[1];
        const vocab = tag.match(/^tag:([a-zA-Z0-9-]+)\.yaml\.org,2002:(.*)/);
        return vocab ? `!${vocab[1]}/${vocab[2]}` : `!${tag.replace(/^tag:/, "")}`;
      }
      let p = doc.tagPrefixes.find((p2) => tag.indexOf(p2.prefix) === 0);
      if (!p) {
        const dtp = doc.getDefaults().tagPrefixes;
        p = dtp && dtp.find((p2) => tag.indexOf(p2.prefix) === 0);
      }
      if (!p)
        return tag[0] === "!" ? tag : `!<${tag}>`;
      const suffix = tag.substr(p.prefix.length).replace(/[!,[\]{}]/g, (ch) => ({
        "!": "%21",
        ",": "%2C",
        "[": "%5B",
        "]": "%5D",
        "{": "%7B",
        "}": "%7D"
      })[ch]);
      return p.handle + suffix;
    }
    function getTagObject(tags, item) {
      if (item instanceof resolveSeq.Alias)
        return resolveSeq.Alias;
      if (item.tag) {
        const match = tags.filter((t) => t.tag === item.tag);
        if (match.length > 0)
          return match.find((t) => t.format === item.format) || match[0];
      }
      let tagObj, obj;
      if (item instanceof resolveSeq.Scalar) {
        obj = item.value;
        const match = tags.filter((t) => t.identify && t.identify(obj) || t.class && obj instanceof t.class);
        tagObj = match.find((t) => t.format === item.format) || match.find((t) => !t.format);
      } else {
        obj = item;
        tagObj = tags.find((t) => t.nodeClass && obj instanceof t.nodeClass);
      }
      if (!tagObj) {
        const name = obj && obj.constructor ? obj.constructor.name : typeof obj;
        throw new Error(`Tag not resolved for ${name} value`);
      }
      return tagObj;
    }
    function stringifyProps(node, tagObj, {
      anchors,
      doc
    }) {
      const props = [];
      const anchor = doc.anchors.getName(node);
      if (anchor) {
        anchors[anchor] = node;
        props.push(`&${anchor}`);
      }
      if (node.tag) {
        props.push(stringifyTag(doc, node.tag));
      } else if (!tagObj.default) {
        props.push(stringifyTag(doc, tagObj.tag));
      }
      return props.join(" ");
    }
    function stringify(item, ctx, onComment, onChompKeep) {
      const {
        anchors,
        schema
      } = ctx.doc;
      let tagObj;
      if (!(item instanceof resolveSeq.Node)) {
        const createCtx = {
          aliasNodes: [],
          onTagObj: (o) => tagObj = o,
          prevObjects: /* @__PURE__ */ new Map()
        };
        item = schema.createNode(item, true, null, createCtx);
        for (const alias of createCtx.aliasNodes) {
          alias.source = alias.source.node;
          let name = anchors.getName(alias.source);
          if (!name) {
            name = anchors.newName();
            anchors.map[name] = alias.source;
          }
        }
      }
      if (item instanceof resolveSeq.Pair)
        return item.toString(ctx, onComment, onChompKeep);
      if (!tagObj)
        tagObj = getTagObject(schema.tags, item);
      const props = stringifyProps(item, tagObj, ctx);
      if (props.length > 0)
        ctx.indentAtStart = (ctx.indentAtStart || 0) + props.length + 1;
      const str = typeof tagObj.stringify === "function" ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof resolveSeq.Scalar ? resolveSeq.stringifyString(item, ctx, onComment, onChompKeep) : item.toString(ctx, onComment, onChompKeep);
      if (!props)
        return str;
      return item instanceof resolveSeq.Scalar || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props}
${ctx.indent}${str}`;
    }
    var Anchors = class {
      static validAnchorNode(node) {
        return node instanceof resolveSeq.Scalar || node instanceof resolveSeq.YAMLSeq || node instanceof resolveSeq.YAMLMap;
      }
      constructor(prefix) {
        PlainValue._defineProperty(this, "map", /* @__PURE__ */ Object.create(null));
        this.prefix = prefix;
      }
      createAlias(node, name) {
        this.setAnchor(node, name);
        return new resolveSeq.Alias(node);
      }
      createMergePair(...sources) {
        const merge = new resolveSeq.Merge();
        merge.value.items = sources.map((s) => {
          if (s instanceof resolveSeq.Alias) {
            if (s.source instanceof resolveSeq.YAMLMap)
              return s;
          } else if (s instanceof resolveSeq.YAMLMap) {
            return this.createAlias(s);
          }
          throw new Error("Merge sources must be Map nodes or their Aliases");
        });
        return merge;
      }
      getName(node) {
        const {
          map
        } = this;
        return Object.keys(map).find((a) => map[a] === node);
      }
      getNames() {
        return Object.keys(this.map);
      }
      getNode(name) {
        return this.map[name];
      }
      newName(prefix) {
        if (!prefix)
          prefix = this.prefix;
        const names = Object.keys(this.map);
        for (let i = 1; true; ++i) {
          const name = `${prefix}${i}`;
          if (!names.includes(name))
            return name;
        }
      }
      resolveNodes() {
        const {
          map,
          _cstAliases
        } = this;
        Object.keys(map).forEach((a) => {
          map[a] = map[a].resolved;
        });
        _cstAliases.forEach((a) => {
          a.source = a.source.resolved;
        });
        delete this._cstAliases;
      }
      setAnchor(node, name) {
        if (node != null && !Anchors.validAnchorNode(node)) {
          throw new Error("Anchors may only be set for Scalar, Seq and Map nodes");
        }
        if (name && /[\x00-\x19\s,[\]{}]/.test(name)) {
          throw new Error("Anchor names must not contain whitespace or control characters");
        }
        const {
          map
        } = this;
        const prev = node && Object.keys(map).find((a) => map[a] === node);
        if (prev) {
          if (!name) {
            return prev;
          } else if (prev !== name) {
            delete map[prev];
            map[name] = node;
          }
        } else {
          if (!name) {
            if (!node)
              return null;
            name = this.newName();
          }
          map[name] = node;
        }
        return name;
      }
    };
    var visit = (node, tags) => {
      if (node && typeof node === "object") {
        const {
          tag
        } = node;
        if (node instanceof resolveSeq.Collection) {
          if (tag)
            tags[tag] = true;
          node.items.forEach((n) => visit(n, tags));
        } else if (node instanceof resolveSeq.Pair) {
          visit(node.key, tags);
          visit(node.value, tags);
        } else if (node instanceof resolveSeq.Scalar) {
          if (tag)
            tags[tag] = true;
        }
      }
      return tags;
    };
    var listTagNames = (node) => Object.keys(visit(node, {}));
    function parseContents(doc, contents) {
      const comments = {
        before: [],
        after: []
      };
      let body = void 0;
      let spaceBefore = false;
      for (const node of contents) {
        if (node.valueRange) {
          if (body !== void 0) {
            const msg = "Document contains trailing content not separated by a ... or --- line";
            doc.errors.push(new PlainValue.YAMLSyntaxError(node, msg));
            break;
          }
          const res = resolveSeq.resolveNode(doc, node);
          if (spaceBefore) {
            res.spaceBefore = true;
            spaceBefore = false;
          }
          body = res;
        } else if (node.comment !== null) {
          const cc = body === void 0 ? comments.before : comments.after;
          cc.push(node.comment);
        } else if (node.type === PlainValue.Type.BLANK_LINE) {
          spaceBefore = true;
          if (body === void 0 && comments.before.length > 0 && !doc.commentBefore) {
            doc.commentBefore = comments.before.join("\n");
            comments.before = [];
          }
        }
      }
      doc.contents = body || null;
      if (!body) {
        doc.comment = comments.before.concat(comments.after).join("\n") || null;
      } else {
        const cb = comments.before.join("\n");
        if (cb) {
          const cbNode = body instanceof resolveSeq.Collection && body.items[0] ? body.items[0] : body;
          cbNode.commentBefore = cbNode.commentBefore ? `${cb}
${cbNode.commentBefore}` : cb;
        }
        doc.comment = comments.after.join("\n") || null;
      }
    }
    function resolveTagDirective({
      tagPrefixes
    }, directive) {
      const [handle, prefix] = directive.parameters;
      if (!handle || !prefix) {
        const msg = "Insufficient parameters given for %TAG directive";
        throw new PlainValue.YAMLSemanticError(directive, msg);
      }
      if (tagPrefixes.some((p) => p.handle === handle)) {
        const msg = "The %TAG directive must only be given at most once per handle in the same document.";
        throw new PlainValue.YAMLSemanticError(directive, msg);
      }
      return {
        handle,
        prefix
      };
    }
    function resolveYamlDirective(doc, directive) {
      let [version] = directive.parameters;
      if (directive.name === "YAML:1.0")
        version = "1.0";
      if (!version) {
        const msg = "Insufficient parameters given for %YAML directive";
        throw new PlainValue.YAMLSemanticError(directive, msg);
      }
      if (!documentOptions[version]) {
        const v0 = doc.version || doc.options.version;
        const msg = `Document will be parsed as YAML ${v0} rather than YAML ${version}`;
        doc.warnings.push(new PlainValue.YAMLWarning(directive, msg));
      }
      return version;
    }
    function parseDirectives(doc, directives, prevDoc) {
      const directiveComments = [];
      let hasDirectives = false;
      for (const directive of directives) {
        const {
          comment,
          name
        } = directive;
        switch (name) {
          case "TAG":
            try {
              doc.tagPrefixes.push(resolveTagDirective(doc, directive));
            } catch (error) {
              doc.errors.push(error);
            }
            hasDirectives = true;
            break;
          case "YAML":
          case "YAML:1.0":
            if (doc.version) {
              const msg = "The %YAML directive must only be given at most once per document.";
              doc.errors.push(new PlainValue.YAMLSemanticError(directive, msg));
            }
            try {
              doc.version = resolveYamlDirective(doc, directive);
            } catch (error) {
              doc.errors.push(error);
            }
            hasDirectives = true;
            break;
          default:
            if (name) {
              const msg = `YAML only supports %TAG and %YAML directives, and not %${name}`;
              doc.warnings.push(new PlainValue.YAMLWarning(directive, msg));
            }
        }
        if (comment)
          directiveComments.push(comment);
      }
      if (prevDoc && !hasDirectives && (doc.version || prevDoc.version || doc.options.version) === "1.1") {
        const copyTagPrefix = ({
          handle,
          prefix
        }) => ({
          handle,
          prefix
        });
        doc.tagPrefixes = prevDoc.tagPrefixes.map(copyTagPrefix);
        doc.version = prevDoc.version;
      }
      doc.commentBefore = directiveComments.join("\n") || null;
    }
    function assertCollection(contents) {
      if (contents instanceof resolveSeq.Collection)
        return true;
      throw new Error("Expected a YAML collection as document contents");
    }
    var Document = class {
      constructor(options) {
        this.anchors = new Anchors(options.anchorPrefix);
        this.commentBefore = null;
        this.comment = null;
        this.contents = null;
        this.directivesEndMarker = null;
        this.errors = [];
        this.options = options;
        this.schema = null;
        this.tagPrefixes = [];
        this.version = null;
        this.warnings = [];
      }
      add(value) {
        assertCollection(this.contents);
        return this.contents.add(value);
      }
      addIn(path, value) {
        assertCollection(this.contents);
        this.contents.addIn(path, value);
      }
      delete(key) {
        assertCollection(this.contents);
        return this.contents.delete(key);
      }
      deleteIn(path) {
        if (resolveSeq.isEmptyPath(path)) {
          if (this.contents == null)
            return false;
          this.contents = null;
          return true;
        }
        assertCollection(this.contents);
        return this.contents.deleteIn(path);
      }
      getDefaults() {
        return Document.defaults[this.version] || Document.defaults[this.options.version] || {};
      }
      get(key, keepScalar) {
        return this.contents instanceof resolveSeq.Collection ? this.contents.get(key, keepScalar) : void 0;
      }
      getIn(path, keepScalar) {
        if (resolveSeq.isEmptyPath(path))
          return !keepScalar && this.contents instanceof resolveSeq.Scalar ? this.contents.value : this.contents;
        return this.contents instanceof resolveSeq.Collection ? this.contents.getIn(path, keepScalar) : void 0;
      }
      has(key) {
        return this.contents instanceof resolveSeq.Collection ? this.contents.has(key) : false;
      }
      hasIn(path) {
        if (resolveSeq.isEmptyPath(path))
          return this.contents !== void 0;
        return this.contents instanceof resolveSeq.Collection ? this.contents.hasIn(path) : false;
      }
      set(key, value) {
        assertCollection(this.contents);
        this.contents.set(key, value);
      }
      setIn(path, value) {
        if (resolveSeq.isEmptyPath(path))
          this.contents = value;
        else {
          assertCollection(this.contents);
          this.contents.setIn(path, value);
        }
      }
      setSchema(id, customTags) {
        if (!id && !customTags && this.schema)
          return;
        if (typeof id === "number")
          id = id.toFixed(1);
        if (id === "1.0" || id === "1.1" || id === "1.2") {
          if (this.version)
            this.version = id;
          else
            this.options.version = id;
          delete this.options.schema;
        } else if (id && typeof id === "string") {
          this.options.schema = id;
        }
        if (Array.isArray(customTags))
          this.options.customTags = customTags;
        const opt = Object.assign({}, this.getDefaults(), this.options);
        this.schema = new Schema.Schema(opt);
      }
      parse(node, prevDoc) {
        if (this.options.keepCstNodes)
          this.cstNode = node;
        if (this.options.keepNodeTypes)
          this.type = "DOCUMENT";
        const {
          directives = [],
          contents = [],
          directivesEndMarker,
          error,
          valueRange
        } = node;
        if (error) {
          if (!error.source)
            error.source = this;
          this.errors.push(error);
        }
        parseDirectives(this, directives, prevDoc);
        if (directivesEndMarker)
          this.directivesEndMarker = true;
        this.range = valueRange ? [valueRange.start, valueRange.end] : null;
        this.setSchema();
        this.anchors._cstAliases = [];
        parseContents(this, contents);
        this.anchors.resolveNodes();
        if (this.options.prettyErrors) {
          for (const error2 of this.errors)
            if (error2 instanceof PlainValue.YAMLError)
              error2.makePretty();
          for (const warn of this.warnings)
            if (warn instanceof PlainValue.YAMLError)
              warn.makePretty();
        }
        return this;
      }
      listNonDefaultTags() {
        return listTagNames(this.contents).filter((t) => t.indexOf(Schema.Schema.defaultPrefix) !== 0);
      }
      setTagPrefix(handle, prefix) {
        if (handle[0] !== "!" || handle[handle.length - 1] !== "!")
          throw new Error("Handle must start and end with !");
        if (prefix) {
          const prev = this.tagPrefixes.find((p) => p.handle === handle);
          if (prev)
            prev.prefix = prefix;
          else
            this.tagPrefixes.push({
              handle,
              prefix
            });
        } else {
          this.tagPrefixes = this.tagPrefixes.filter((p) => p.handle !== handle);
        }
      }
      toJSON(arg, onAnchor) {
        const {
          keepBlobsInJSON,
          mapAsMap,
          maxAliasCount
        } = this.options;
        const keep = keepBlobsInJSON && (typeof arg !== "string" || !(this.contents instanceof resolveSeq.Scalar));
        const ctx = {
          doc: this,
          indentStep: "  ",
          keep,
          mapAsMap: keep && !!mapAsMap,
          maxAliasCount,
          stringify
        };
        const anchorNames = Object.keys(this.anchors.map);
        if (anchorNames.length > 0)
          ctx.anchors = new Map(anchorNames.map((name) => [this.anchors.map[name], {
            alias: [],
            aliasCount: 0,
            count: 1
          }]));
        const res = resolveSeq.toJSON(this.contents, arg, ctx);
        if (typeof onAnchor === "function" && ctx.anchors)
          for (const {
            count,
            res: res2
          } of ctx.anchors.values())
            onAnchor(res2, count);
        return res;
      }
      toString() {
        if (this.errors.length > 0)
          throw new Error("Document with errors cannot be stringified");
        const indentSize = this.options.indent;
        if (!Number.isInteger(indentSize) || indentSize <= 0) {
          const s = JSON.stringify(indentSize);
          throw new Error(`"indent" option must be a positive integer, not ${s}`);
        }
        this.setSchema();
        const lines = [];
        let hasDirectives = false;
        if (this.version) {
          let vd = "%YAML 1.2";
          if (this.schema.name === "yaml-1.1") {
            if (this.version === "1.0")
              vd = "%YAML:1.0";
            else if (this.version === "1.1")
              vd = "%YAML 1.1";
          }
          lines.push(vd);
          hasDirectives = true;
        }
        const tagNames = this.listNonDefaultTags();
        this.tagPrefixes.forEach(({
          handle,
          prefix
        }) => {
          if (tagNames.some((t) => t.indexOf(prefix) === 0)) {
            lines.push(`%TAG ${handle} ${prefix}`);
            hasDirectives = true;
          }
        });
        if (hasDirectives || this.directivesEndMarker)
          lines.push("---");
        if (this.commentBefore) {
          if (hasDirectives || !this.directivesEndMarker)
            lines.unshift("");
          lines.unshift(this.commentBefore.replace(/^/gm, "#"));
        }
        const ctx = {
          anchors: /* @__PURE__ */ Object.create(null),
          doc: this,
          indent: "",
          indentStep: " ".repeat(indentSize),
          stringify
        };
        let chompKeep = false;
        let contentComment = null;
        if (this.contents) {
          if (this.contents instanceof resolveSeq.Node) {
            if (this.contents.spaceBefore && (hasDirectives || this.directivesEndMarker))
              lines.push("");
            if (this.contents.commentBefore)
              lines.push(this.contents.commentBefore.replace(/^/gm, "#"));
            ctx.forceBlockIndent = !!this.comment;
            contentComment = this.contents.comment;
          }
          const onChompKeep = contentComment ? null : () => chompKeep = true;
          const body = stringify(this.contents, ctx, () => contentComment = null, onChompKeep);
          lines.push(resolveSeq.addComment(body, "", contentComment));
        } else if (this.contents !== void 0) {
          lines.push(stringify(this.contents, ctx));
        }
        if (this.comment) {
          if ((!chompKeep || contentComment) && lines[lines.length - 1] !== "")
            lines.push("");
          lines.push(this.comment.replace(/^/gm, "#"));
        }
        return lines.join("\n") + "\n";
      }
    };
    PlainValue._defineProperty(Document, "defaults", documentOptions);
    exports2.Document = Document;
    exports2.defaultOptions = defaultOptions;
    exports2.scalarOptions = scalarOptions;
  }
});

// node_modules/yaml/dist/index.js
var require_dist = __commonJS({
  "node_modules/yaml/dist/index.js"(exports2) {
    "use strict";
    var parseCst = require_parse_cst();
    var Document$1 = require_Document_9b4560a1();
    var Schema = require_Schema_88e323a7();
    var PlainValue = require_PlainValue_ec8e588e();
    var warnings = require_warnings_1000a372();
    require_resolveSeq_d03cb037();
    function createNode(value, wrapScalars = true, tag) {
      if (tag === void 0 && typeof wrapScalars === "string") {
        tag = wrapScalars;
        wrapScalars = true;
      }
      const options = Object.assign({}, Document$1.Document.defaults[Document$1.defaultOptions.version], Document$1.defaultOptions);
      const schema = new Schema.Schema(options);
      return schema.createNode(value, wrapScalars, tag);
    }
    var Document = class extends Document$1.Document {
      constructor(options) {
        super(Object.assign({}, Document$1.defaultOptions, options));
      }
    };
    function parseAllDocuments(src, options) {
      const stream = [];
      let prev;
      for (const cstDoc of parseCst.parse(src)) {
        const doc = new Document(options);
        doc.parse(cstDoc, prev);
        stream.push(doc);
        prev = doc;
      }
      return stream;
    }
    function parseDocument(src, options) {
      const cst = parseCst.parse(src);
      const doc = new Document(options).parse(cst[0]);
      if (cst.length > 1) {
        const errMsg = "Source contains multiple documents; please use YAML.parseAllDocuments()";
        doc.errors.unshift(new PlainValue.YAMLSemanticError(cst[1], errMsg));
      }
      return doc;
    }
    function parse(src, options) {
      const doc = parseDocument(src, options);
      doc.warnings.forEach((warning) => warnings.warn(warning));
      if (doc.errors.length > 0)
        throw doc.errors[0];
      return doc.toJSON();
    }
    function stringify(value, options) {
      const doc = new Document(options);
      doc.contents = value;
      return String(doc);
    }
    var YAML = {
      createNode,
      defaultOptions: Document$1.defaultOptions,
      Document,
      parse,
      parseAllDocuments,
      parseCST: parseCst.parse,
      parseDocument,
      scalarOptions: Document$1.scalarOptions,
      stringify
    };
    exports2.YAML = YAML;
  }
});

// node_modules/yaml/index.js
var require_yaml = __commonJS({
  "node_modules/yaml/index.js"(exports2, module2) {
    module2.exports = require_dist().YAML;
  }
});

// node_modules/lilconfig/dist/index.js
var require_dist2 = __commonJS({
  "node_modules/lilconfig/dist/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.lilconfigSync = exports2.lilconfig = exports2.defaultLoaders = void 0;
    var path = require("path");
    var fs = require("fs");
    var os = require("os");
    var fsReadFileAsync = fs.promises.readFile;
    function getDefaultSearchPlaces(name) {
      return [
        "package.json",
        `.${name}rc.json`,
        `.${name}rc.js`,
        `${name}.config.js`,
        `.${name}rc.cjs`,
        `${name}.config.cjs`
      ];
    }
    function getSearchPaths(startDir, stopDir) {
      return startDir.split(path.sep).reduceRight((acc, _, ind, arr) => {
        const currentPath = arr.slice(0, ind + 1).join(path.sep);
        if (!acc.passedStopDir)
          acc.searchPlaces.push(currentPath || path.sep);
        if (currentPath === stopDir)
          acc.passedStopDir = true;
        return acc;
      }, { searchPlaces: [], passedStopDir: false }).searchPlaces;
    }
    exports2.defaultLoaders = Object.freeze({
      ".js": require,
      ".json": require,
      ".cjs": require,
      noExt(_, content) {
        return JSON.parse(content);
      }
    });
    function getExtDesc(ext) {
      return ext === "noExt" ? "files without extensions" : `extension "${ext}"`;
    }
    function getOptions(name, options = {}) {
      const conf = {
        stopDir: os.homedir(),
        searchPlaces: getDefaultSearchPlaces(name),
        ignoreEmptySearchPlaces: true,
        transform: (x) => x,
        packageProp: [name],
        ...options,
        loaders: { ...exports2.defaultLoaders, ...options.loaders }
      };
      conf.searchPlaces.forEach((place) => {
        const key = path.extname(place) || "noExt";
        const loader = conf.loaders[key];
        if (!loader) {
          throw new Error(`No loader specified for ${getExtDesc(key)}, so searchPlaces item "${place}" is invalid`);
        }
        if (typeof loader !== "function") {
          throw new Error(`loader for ${getExtDesc(key)} is not a function (type provided: "${typeof loader}"), so searchPlaces item "${place}" is invalid`);
        }
      });
      return conf;
    }
    function getPackageProp(props, obj) {
      if (typeof props === "string" && props in obj)
        return obj[props];
      return (Array.isArray(props) ? props : props.split(".")).reduce((acc, prop) => acc === void 0 ? acc : acc[prop], obj) || null;
    }
    function getSearchItems(searchPlaces, searchPaths) {
      return searchPaths.reduce((acc, searchPath) => {
        searchPlaces.forEach((fileName) => acc.push({
          fileName,
          filepath: path.join(searchPath, fileName),
          loaderKey: path.extname(fileName) || "noExt"
        }));
        return acc;
      }, []);
    }
    function validateFilePath(filepath) {
      if (!filepath)
        throw new Error("load must pass a non-empty string");
    }
    function validateLoader(loader, ext) {
      if (!loader)
        throw new Error(`No loader specified for extension "${ext}"`);
      if (typeof loader !== "function")
        throw new Error("loader is not a function");
    }
    function lilconfig(name, options) {
      const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform } = getOptions(name, options);
      return {
        async search(searchFrom = process.cwd()) {
          const searchPaths = getSearchPaths(searchFrom, stopDir);
          const result = {
            config: null,
            filepath: ""
          };
          const searchItems = getSearchItems(searchPlaces, searchPaths);
          for (const { fileName, filepath, loaderKey } of searchItems) {
            try {
              await fs.promises.access(filepath);
            } catch (_a) {
              continue;
            }
            const content = String(await fsReadFileAsync(filepath));
            const loader = loaders[loaderKey];
            if (fileName === "package.json") {
              const pkg = await loader(filepath, content);
              const maybeConfig = getPackageProp(packageProp, pkg);
              if (maybeConfig != null) {
                result.config = maybeConfig;
                result.filepath = filepath;
                break;
              }
              continue;
            }
            const isEmpty = content.trim() === "";
            if (isEmpty && ignoreEmptySearchPlaces)
              continue;
            if (isEmpty) {
              result.isEmpty = true;
              result.config = void 0;
            } else {
              validateLoader(loader, loaderKey);
              result.config = await loader(filepath, content);
            }
            result.filepath = filepath;
            break;
          }
          if (result.filepath === "" && result.config === null)
            return transform(null);
          return transform(result);
        },
        async load(filepath) {
          validateFilePath(filepath);
          const absPath = path.resolve(process.cwd(), filepath);
          const { base, ext } = path.parse(absPath);
          const loaderKey = ext || "noExt";
          const loader = loaders[loaderKey];
          validateLoader(loader, loaderKey);
          const content = String(await fsReadFileAsync(absPath));
          if (base === "package.json") {
            const pkg = await loader(absPath, content);
            return transform({
              config: getPackageProp(packageProp, pkg),
              filepath: absPath
            });
          }
          const result = {
            config: null,
            filepath: absPath
          };
          const isEmpty = content.trim() === "";
          if (isEmpty && ignoreEmptySearchPlaces)
            return transform({
              config: void 0,
              filepath: absPath,
              isEmpty: true
            });
          result.config = isEmpty ? void 0 : await loader(absPath, content);
          return transform(isEmpty ? { ...result, isEmpty, config: void 0 } : result);
        }
      };
    }
    exports2.lilconfig = lilconfig;
    function lilconfigSync(name, options) {
      const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform } = getOptions(name, options);
      return {
        search(searchFrom = process.cwd()) {
          const searchPaths = getSearchPaths(searchFrom, stopDir);
          const result = {
            config: null,
            filepath: ""
          };
          const searchItems = getSearchItems(searchPlaces, searchPaths);
          for (const { fileName, filepath, loaderKey } of searchItems) {
            try {
              fs.accessSync(filepath);
            } catch (_a) {
              continue;
            }
            const loader = loaders[loaderKey];
            const content = String(fs.readFileSync(filepath));
            if (fileName === "package.json") {
              const pkg = loader(filepath, content);
              const maybeConfig = getPackageProp(packageProp, pkg);
              if (maybeConfig != null) {
                result.config = maybeConfig;
                result.filepath = filepath;
                break;
              }
              continue;
            }
            const isEmpty = content.trim() === "";
            if (isEmpty && ignoreEmptySearchPlaces)
              continue;
            if (isEmpty) {
              result.isEmpty = true;
              result.config = void 0;
            } else {
              validateLoader(loader, loaderKey);
              result.config = loader(filepath, content);
            }
            result.filepath = filepath;
            break;
          }
          if (result.filepath === "" && result.config === null)
            return transform(null);
          return transform(result);
        },
        load(filepath) {
          validateFilePath(filepath);
          const absPath = path.resolve(process.cwd(), filepath);
          const { base, ext } = path.parse(absPath);
          const loaderKey = ext || "noExt";
          const loader = loaders[loaderKey];
          validateLoader(loader, loaderKey);
          const content = String(fs.readFileSync(absPath));
          if (base === "package.json") {
            const pkg = loader(absPath, content);
            return transform({
              config: getPackageProp(packageProp, pkg),
              filepath: absPath
            });
          }
          const result = {
            config: null,
            filepath: absPath
          };
          const isEmpty = content.trim() === "";
          if (isEmpty && ignoreEmptySearchPlaces)
            return transform({
              filepath: absPath,
              config: void 0,
              isEmpty: true
            });
          result.config = isEmpty ? void 0 : loader(absPath, content);
          return transform(isEmpty ? { ...result, isEmpty, config: void 0 } : result);
        }
      };
    }
    exports2.lilconfigSync = lilconfigSync;
  }
});

// node_modules/css-declaration-sorter/dist/stable-sort.cjs
var require_stable_sort = __commonJS({
  "node_modules/css-declaration-sorter/dist/stable-sort.cjs"(exports2, module2) {
    "use strict";
    module2.exports = function(items, comparator) {
      comparator = comparator ? comparator : (a, b) => {
        if (a < b)
          return -1;
        if (a > b)
          return 1;
        return 0;
      };
      let stabilizedItems = items.map((el, index) => [el, index]);
      const stableComparator = (a, b) => {
        let order = comparator(a[0], b[0]);
        if (order != 0)
          return order;
        return a[1] - b[1];
      };
      stabilizedItems.sort(stableComparator);
      for (let i = 0; i < items.length; i++) {
        items[i] = stabilizedItems[i][0];
      }
      return items;
    };
  }
});

// node_modules/css-declaration-sorter/dist/main.cjs
var require_main = __commonJS({
  "node_modules/css-declaration-sorter/dist/main.cjs"(exports2, module2) {
    "use strict";
    var stableSort = require_stable_sort();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var shorthandData = {
      "animation": [
        "animation-name",
        "animation-duration",
        "animation-timing-function",
        "animation-delay",
        "animation-iteration-count",
        "animation-direction",
        "animation-fill-mode",
        "animation-play-state"
      ],
      "background": [
        "background-image",
        "background-size",
        "background-position",
        "background-repeat",
        "background-origin",
        "background-clip",
        "background-attachment",
        "background-color"
      ],
      "columns": [
        "column-width",
        "column-count"
      ],
      "column-rule": [
        "column-rule-width",
        "column-rule-style",
        "column-rule-color"
      ],
      "flex": [
        "flex-grow",
        "flex-shrink",
        "flex-basis"
      ],
      "flex-flow": [
        "flex-direction",
        "flex-wrap"
      ],
      "font": [
        "font-style",
        "font-variant",
        "font-weight",
        "font-stretch",
        "font-size",
        "font-family",
        "line-height"
      ],
      "grid": [
        "grid-template-rows",
        "grid-template-columns",
        "grid-template-areas",
        "grid-auto-rows",
        "grid-auto-columns",
        "grid-auto-flow",
        "column-gap",
        "row-gap"
      ],
      "grid-area": [
        "grid-row-start",
        "grid-column-start",
        "grid-row-end",
        "grid-column-end"
      ],
      "grid-column": [
        "grid-column-start",
        "grid-column-end"
      ],
      "grid-row": [
        "grid-row-start",
        "grid-row-end"
      ],
      "grid-template": [
        "grid-template-columns",
        "grid-template-rows",
        "grid-template-areas"
      ],
      "list-style": [
        "list-style-type",
        "list-style-position",
        "list-style-image"
      ],
      "padding": [
        "padding-block",
        "padding-block-start",
        "padding-block-end",
        "padding-inline",
        "padding-inline-start",
        "padding-inline-end",
        "padding-top",
        "padding-right",
        "padding-bottom",
        "padding-left"
      ],
      "padding-block": [
        "padding-block-start",
        "padding-block-end",
        "padding-top",
        "padding-right",
        "padding-bottom",
        "padding-left"
      ],
      "padding-block-start": [
        "padding-top",
        "padding-right",
        "padding-left"
      ],
      "padding-block-end": [
        "padding-right",
        "padding-bottom",
        "padding-left"
      ],
      "padding-inline": [
        "padding-inline-start",
        "padding-inline-end",
        "padding-top",
        "padding-right",
        "padding-bottom",
        "padding-left"
      ],
      "padding-inline-start": [
        "padding-top",
        "padding-right",
        "padding-left"
      ],
      "padding-inline-end": [
        "padding-right",
        "padding-bottom",
        "padding-left"
      ],
      "margin": [
        "margin-block",
        "margin-block-start",
        "margin-block-end",
        "margin-inline",
        "margin-inline-start",
        "margin-inline-end",
        "margin-top",
        "margin-right",
        "margin-bottom",
        "margin-left"
      ],
      "margin-block": [
        "margin-block-start",
        "margin-block-end",
        "margin-top",
        "margin-right",
        "margin-bottom",
        "margin-left"
      ],
      "margin-inline": [
        "margin-inline-start",
        "margin-inline-end",
        "margin-top",
        "margin-right",
        "margin-bottom",
        "margin-left"
      ],
      "margin-inline-start": [
        "margin-top",
        "margin-right",
        "margin-bottom",
        "margin-left"
      ],
      "margin-inline-end": [
        "margin-top",
        "margin-right",
        "margin-bottom",
        "margin-left"
      ],
      "border": [
        "border-top",
        "border-right",
        "border-bottom",
        "border-left",
        "border-width",
        "border-style",
        "border-color",
        "border-top-width",
        "border-right-width",
        "border-bottom-width",
        "border-left-width",
        "border-top-style",
        "border-right-style",
        "border-bottom-style",
        "border-left-style",
        "border-top-color",
        "border-right-color",
        "border-bottom-color",
        "border-left-color",
        "border-block",
        "border-block-start",
        "border-block-end",
        "border-block-width",
        "border-block-style",
        "border-block-color",
        "border-inline",
        "border-inline-start",
        "border-inline-end",
        "border-inline-width",
        "border-inline-style",
        "border-inline-color"
      ],
      "border-top": [
        "border-width",
        "border-style",
        "border-color",
        "border-top-width",
        "border-top-style",
        "border-top-color"
      ],
      "border-right": [
        "border-width",
        "border-style",
        "border-color",
        "border-right-width",
        "border-right-style",
        "border-right-color"
      ],
      "border-bottom": [
        "border-width",
        "border-style",
        "border-color",
        "border-bottom-width",
        "border-bottom-style",
        "border-bottom-color"
      ],
      "border-left": [
        "border-width",
        "border-style",
        "border-color",
        "border-left-width",
        "border-left-style",
        "border-left-color"
      ],
      "border-color": [
        "border-top-color",
        "border-bottom-color",
        "border-left-color",
        "border-right-color"
      ],
      "border-width": [
        "border-top-width",
        "border-bottom-width",
        "border-left-width",
        "border-right-width"
      ],
      "border-style": [
        "border-top-style",
        "border-bottom-style",
        "border-left-style",
        "border-right-style"
      ],
      "border-radius": [
        "border-top-right-radius",
        "border-top-left-radius",
        "border-bottom-right-radius",
        "border-bottom-left-radius"
      ],
      "border-block": [
        "border-block-start",
        "border-block-end",
        "border-block-width",
        "border-width",
        "border-block-style",
        "border-style",
        "border-block-color",
        "border-color"
      ],
      "border-block-start": [
        "border-block-start-width",
        "border-width",
        "border-block-start-style",
        "border-style",
        "border-block-start-color",
        "border-color"
      ],
      "border-block-end": [
        "border-block-end-width",
        "border-width",
        "border-block-end-style",
        "border-style",
        "border-block-end-color",
        "border-color"
      ],
      "border-inline": [
        "border-inline-start",
        "border-inline-end",
        "border-inline-width",
        "border-width",
        "border-inline-style",
        "border-style",
        "border-inline-color",
        "border-color"
      ],
      "border-inline-start": [
        "border-inline-start-width",
        "border-width",
        "border-inline-start-style",
        "border-style",
        "border-inline-start-color",
        "border-color"
      ],
      "border-inline-end": [
        "border-inline-end-width",
        "border-width",
        "border-inline-end-style",
        "border-style",
        "border-inline-end-color",
        "border-color"
      ],
      "border-image": [
        "border-image-source",
        "border-image-slice",
        "border-image-width",
        "border-image-outset",
        "border-image-repeat"
      ],
      "mask": [
        "mask-image",
        "mask-mode",
        "mask-position",
        "mask-size",
        "mask-repeat",
        "mask-origin",
        "mask-clip",
        "mask-composite"
      ],
      "inline-size": [
        "width",
        "height"
      ],
      "block-size": [
        "width",
        "height"
      ],
      "max-inline-size": [
        "max-width",
        "max-height"
      ],
      "max-block-size": [
        "max-width",
        "max-height"
      ],
      "inset": [
        "inset-block",
        "inset-block-start",
        "inset-block-end",
        "inset-inline",
        "inset-inline-start",
        "inset-inline-end",
        "top",
        "right",
        "bottom",
        "left"
      ],
      "inset-block": [
        "inset-block-start",
        "inset-block-end",
        "top",
        "right",
        "bottom",
        "left"
      ],
      "inset-inline": [
        "inset-inline-start",
        "inset-inline-end",
        "top",
        "right",
        "bottom",
        "left"
      ],
      "outline": [
        "outline-color",
        "outline-style",
        "outline-width"
      ],
      "overflow": [
        "overflow-x",
        "overflow-y"
      ],
      "place-content": [
        "align-content",
        "justify-content"
      ],
      "place-items": [
        "align-items",
        "justify-items"
      ],
      "place-self": [
        "align-self",
        "justify-self"
      ],
      "text-decoration": [
        "text-decoration-color",
        "text-decoration-style",
        "text-decoration-line"
      ],
      "transition": [
        "transition-delay",
        "transition-duration",
        "transition-property",
        "transition-timing-function"
      ],
      "text-emphasis": [
        "text-emphasis-style",
        "text-emphasis-color"
      ]
    };
    function __variableDynamicImportRuntime0__(path) {
      switch (path) {
        case "../orders/alphabetical.mjs":
          return Promise.resolve().then(function() {
            return alphabetical;
          });
        case "../orders/concentric-css.mjs":
          return Promise.resolve().then(function() {
            return concentricCss;
          });
        case "../orders/smacss.mjs":
          return Promise.resolve().then(function() {
            return smacss;
          });
        default:
          return new Promise(function(resolve, reject) {
            (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(reject.bind(null, new Error("Unknown variable dynamic import: " + path)));
          });
      }
    }
    var builtInOrders = [
      "alphabetical",
      "concentric-css",
      "smacss"
    ];
    var cssDeclarationSorter = ({ order = "alphabetical", keepOverrides = false } = {}) => ({
      postcssPlugin: "css-declaration-sorter",
      OnceExit(css) {
        let withKeepOverrides = (comparator) => comparator;
        if (keepOverrides) {
          withKeepOverrides = withOverridesComparator(shorthandData);
        }
        if (typeof order === "function") {
          return processCss({ css, comparator: withKeepOverrides(order) });
        }
        if (!builtInOrders.includes(order))
          return Promise.reject(Error([
            `Invalid built-in order '${order}' provided.`,
            `Available built-in orders are: ${builtInOrders}`
          ].join("\n")));
        return __variableDynamicImportRuntime0__(`../orders/${order}.mjs`).then(({ properties: properties2 }) => processCss({
          css,
          comparator: withKeepOverrides(orderComparator(properties2))
        }));
      }
    });
    cssDeclarationSorter.postcss = true;
    function processCss({ css, comparator }) {
      const comments = [];
      const rulesCache = [];
      css.walk((node) => {
        const nodes = node.nodes;
        const type = node.type;
        if (type === "comment") {
          const isNewlineNode = node.raws.before && node.raws.before.includes("\n");
          const lastNewlineNode = isNewlineNode && !node.next();
          const onlyNode = !node.prev() && !node.next() || !node.parent;
          if (lastNewlineNode || onlyNode || node.parent.type === "root") {
            return;
          }
          if (isNewlineNode) {
            const pairedNode = node.next() || node.prev();
            if (pairedNode) {
              comments.unshift({
                "comment": node,
                "pairedNode": pairedNode,
                "insertPosition": node.next() ? "Before" : "After"
              });
              node.remove();
            }
          } else {
            const pairedNode = node.prev() || node.next();
            if (pairedNode) {
              comments.push({
                "comment": node,
                "pairedNode": pairedNode,
                "insertPosition": "After"
              });
              node.remove();
            }
          }
          return;
        }
        const isRule = type === "rule" || type === "atrule";
        if (isRule && nodes && nodes.length > 1) {
          rulesCache.push(nodes);
        }
      });
      rulesCache.forEach((nodes) => {
        sortCssDeclarations({ nodes, comparator });
      });
      comments.forEach((node) => {
        const pairedNode = node.pairedNode;
        node.comment.remove();
        pairedNode.parent && pairedNode.parent["insert" + node.insertPosition](pairedNode, node.comment);
      });
    }
    function sortCssDeclarations({ nodes, comparator }) {
      stableSort(nodes, (a, b) => {
        if (a.type === "decl" && b.type === "decl") {
          return comparator(a.prop, b.prop);
        } else {
          return compareDifferentType(a, b);
        }
      });
    }
    function withOverridesComparator(shorthandData2) {
      return function(comparator) {
        return function(a, b) {
          a = removeVendorPrefix(a);
          b = removeVendorPrefix(b);
          if (shorthandData2[a] && shorthandData2[a].includes(b))
            return 0;
          if (shorthandData2[b] && shorthandData2[b].includes(a))
            return 0;
          return comparator(a, b);
        };
      };
    }
    function orderComparator(order) {
      return function(a, b) {
        return order.indexOf(a) - order.indexOf(b);
      };
    }
    function compareDifferentType(a, b) {
      if (b.type === "atrule") {
        return 0;
      }
      return a.type === "decl" ? -1 : b.type === "decl" ? 1 : 0;
    }
    function removeVendorPrefix(property) {
      return property.replace(/^-\w+-/, "");
    }
    var properties$2 = [
      "all",
      "-webkit-line-clamp",
      "accent-color",
      "align-content",
      "align-items",
      "align-self",
      "animation",
      "animation-delay",
      "animation-direction",
      "animation-duration",
      "animation-fill-mode",
      "animation-iteration-count",
      "animation-name",
      "animation-play-state",
      "animation-timing-function",
      "appearance",
      "ascent-override",
      "aspect-ratio",
      "backdrop-filter",
      "backface-visibility",
      "background",
      "background-attachment",
      "background-blend-mode",
      "background-clip",
      "background-color",
      "background-image",
      "background-origin",
      "background-position",
      "background-position-x",
      "background-position-y",
      "background-repeat",
      "background-size",
      "block-size",
      "border",
      "border-block",
      "border-block-color",
      "border-block-end",
      "border-block-end-color",
      "border-block-end-style",
      "border-block-end-width",
      "border-block-start",
      "border-block-start-color",
      "border-block-start-style",
      "border-block-start-width",
      "border-block-style",
      "border-block-width",
      "border-bottom",
      "border-bottom-color",
      "border-bottom-left-radius",
      "border-bottom-right-radius",
      "border-bottom-style",
      "border-bottom-width",
      "border-collapse",
      "border-color",
      "border-end-end-radius",
      "border-end-start-radius",
      "border-image",
      "border-image-outset",
      "border-image-repeat",
      "border-image-slice",
      "border-image-source",
      "border-image-width",
      "border-inline",
      "border-inline-color",
      "border-inline-end",
      "border-inline-end-color",
      "border-inline-end-style",
      "border-inline-end-width",
      "border-inline-start",
      "border-inline-start-color",
      "border-inline-start-style",
      "border-inline-start-width",
      "border-inline-style",
      "border-inline-width",
      "border-left",
      "border-left-color",
      "border-left-style",
      "border-left-width",
      "border-radius",
      "border-right",
      "border-right-color",
      "border-right-style",
      "border-right-width",
      "border-spacing",
      "border-start-end-radius",
      "border-start-start-radius",
      "border-style",
      "border-top",
      "border-top-color",
      "border-top-left-radius",
      "border-top-right-radius",
      "border-top-style",
      "border-top-width",
      "border-width",
      "bottom",
      "box-decoration-break",
      "box-shadow",
      "box-sizing",
      "break-after",
      "break-before",
      "break-inside",
      "caption-side",
      "caret-color",
      "clear",
      "clip-path",
      "color",
      "color-scheme",
      "column-count",
      "column-fill",
      "column-gap",
      "column-rule",
      "column-rule-color",
      "column-rule-style",
      "column-rule-width",
      "column-span",
      "column-width",
      "columns",
      "contain",
      "content",
      "content-visibility",
      "counter-increment",
      "counter-reset",
      "counter-set",
      "cursor",
      "descent-override",
      "direction",
      "display",
      "empty-cells",
      "filter",
      "flex",
      "flex-basis",
      "flex-direction",
      "flex-flow",
      "flex-grow",
      "flex-shrink",
      "flex-wrap",
      "float",
      "font",
      "font-display",
      "font-family",
      "font-kerning",
      "font-language-override",
      "font-optical-sizing",
      "font-size",
      "font-size-adjust",
      "font-stretch",
      "font-style",
      "font-synthesis",
      "font-variant",
      "font-variant-alternates",
      "font-variant-caps",
      "font-variant-east-asian",
      "font-variant-ligatures",
      "font-variant-numeric",
      "font-variant-position",
      "font-variation-settings",
      "font-weight",
      "forced-color-adjust",
      "gap",
      "grid",
      "grid-area",
      "grid-auto-columns",
      "grid-auto-flow",
      "grid-auto-rows",
      "grid-column",
      "grid-column-end",
      "grid-column-start",
      "grid-row",
      "grid-row-end",
      "grid-row-start",
      "grid-template",
      "grid-template-areas",
      "grid-template-columns",
      "grid-template-rows",
      "hanging-punctuation",
      "height",
      "hyphenate-character",
      "hyphens",
      "image-orientation",
      "image-rendering",
      "inline-size",
      "inset",
      "inset-block",
      "inset-block-end",
      "inset-block-start",
      "inset-inline",
      "inset-inline-end",
      "inset-inline-start",
      "isolation",
      "justify-content",
      "justify-items",
      "justify-self",
      "left",
      "letter-spacing",
      "line-break",
      "line-gap-override",
      "line-height",
      "list-style",
      "list-style-image",
      "list-style-position",
      "list-style-type",
      "margin",
      "margin-block",
      "margin-block-end",
      "margin-block-start",
      "margin-bottom",
      "margin-inline",
      "margin-inline-end",
      "margin-inline-start",
      "margin-left",
      "margin-right",
      "margin-top",
      "mask",
      "mask-border",
      "mask-border-outset",
      "mask-border-repeat",
      "mask-border-slice",
      "mask-border-source",
      "mask-border-width",
      "mask-clip",
      "mask-composite",
      "mask-image",
      "mask-mode",
      "mask-origin",
      "mask-position",
      "mask-repeat",
      "mask-size",
      "mask-type",
      "max-block-size",
      "max-height",
      "max-inline-size",
      "max-width",
      "min-block-size",
      "min-height",
      "min-inline-size",
      "min-width",
      "mix-blend-mode",
      "object-fit",
      "object-position",
      "offset",
      "offset-anchor",
      "offset-distance",
      "offset-path",
      "offset-rotate",
      "opacity",
      "order",
      "orphans",
      "outline",
      "outline-color",
      "outline-offset",
      "outline-style",
      "outline-width",
      "overflow",
      "overflow-anchor",
      "overflow-block",
      "overflow-inline",
      "overflow-wrap",
      "overflow-x",
      "overflow-y",
      "overscroll-behavior",
      "overscroll-behavior-block",
      "overscroll-behavior-inline",
      "overscroll-behavior-x",
      "overscroll-behavior-y",
      "padding",
      "padding-block",
      "padding-block-end",
      "padding-block-start",
      "padding-bottom",
      "padding-inline",
      "padding-inline-end",
      "padding-inline-start",
      "padding-left",
      "padding-right",
      "padding-top",
      "page",
      "page-break-after",
      "page-break-before",
      "page-break-inside",
      "paint-order",
      "perspective",
      "perspective-origin",
      "place-content",
      "place-items",
      "place-self",
      "pointer-events",
      "position",
      "print-color-adjust",
      "quotes",
      "resize",
      "right",
      "rotate",
      "row-gap",
      "ruby-position",
      "scale",
      "scroll-behavior",
      "scroll-margin",
      "scroll-margin-block",
      "scroll-margin-block-end",
      "scroll-margin-block-start",
      "scroll-margin-bottom",
      "scroll-margin-inline",
      "scroll-margin-inline-end",
      "scroll-margin-inline-start",
      "scroll-margin-left",
      "scroll-margin-right",
      "scroll-margin-top",
      "scroll-padding",
      "scroll-padding-block",
      "scroll-padding-block-end",
      "scroll-padding-block-start",
      "scroll-padding-bottom",
      "scroll-padding-inline",
      "scroll-padding-inline-end",
      "scroll-padding-inline-start",
      "scroll-padding-left",
      "scroll-padding-right",
      "scroll-padding-top",
      "scroll-snap-align",
      "scroll-snap-stop",
      "scroll-snap-type",
      "scrollbar-color",
      "scrollbar-gutter",
      "scrollbar-width",
      "shape-image-threshold",
      "shape-margin",
      "shape-outside",
      "size-adjust",
      "src",
      "tab-size",
      "table-layout",
      "text-align",
      "text-align-last",
      "text-combine-upright",
      "text-decoration",
      "text-decoration-color",
      "text-decoration-line",
      "text-decoration-skip-ink",
      "text-decoration-style",
      "text-decoration-thickness",
      "text-emphasis",
      "text-emphasis-color",
      "text-emphasis-position",
      "text-emphasis-style",
      "text-indent",
      "text-justify",
      "text-orientation",
      "text-overflow",
      "text-shadow",
      "text-transform",
      "text-underline-offset",
      "text-underline-position",
      "top",
      "touch-action",
      "transform",
      "transform-box",
      "transform-origin",
      "transform-style",
      "transition",
      "transition-delay",
      "transition-duration",
      "transition-property",
      "transition-timing-function",
      "translate",
      "unicode-bidi",
      "unicode-range",
      "user-select",
      "vertical-align",
      "visibility",
      "white-space",
      "widows",
      "width",
      "will-change",
      "word-break",
      "word-spacing",
      "writing-mode",
      "z-index"
    ];
    var alphabetical = /* @__PURE__ */ Object.freeze({
      __proto__: null,
      properties: properties$2
    });
    var properties$1 = [
      "all",
      "display",
      "position",
      "top",
      "right",
      "bottom",
      "left",
      "offset",
      "offset-anchor",
      "offset-distance",
      "offset-path",
      "offset-rotate",
      "grid",
      "grid-template-rows",
      "grid-template-columns",
      "grid-template-areas",
      "grid-auto-rows",
      "grid-auto-columns",
      "grid-auto-flow",
      "column-gap",
      "row-gap",
      "grid-area",
      "grid-row",
      "grid-row-start",
      "grid-row-end",
      "grid-column",
      "grid-column-start",
      "grid-column-end",
      "grid-template",
      "flex",
      "flex-grow",
      "flex-shrink",
      "flex-basis",
      "flex-direction",
      "flex-flow",
      "flex-wrap",
      "box-decoration-break",
      "place-content",
      "align-content",
      "justify-content",
      "place-items",
      "align-items",
      "justify-items",
      "place-self",
      "align-self",
      "justify-self",
      "vertical-align",
      "order",
      "float",
      "clear",
      "shape-margin",
      "shape-outside",
      "shape-image-threshold",
      "orphans",
      "gap",
      "columns",
      "column-fill",
      "column-rule",
      "column-rule-width",
      "column-rule-style",
      "column-rule-color",
      "column-width",
      "column-span",
      "column-count",
      "break-before",
      "break-after",
      "break-inside",
      "page",
      "page-break-before",
      "page-break-after",
      "page-break-inside",
      "transform",
      "transform-box",
      "transform-origin",
      "transform-style",
      "translate",
      "rotate",
      "scale",
      "perspective",
      "perspective-origin",
      "appearance",
      "visibility",
      "content-visibility",
      "opacity",
      "z-index",
      "paint-order",
      "mix-blend-mode",
      "backface-visibility",
      "backdrop-filter",
      "clip-path",
      "mask",
      "mask-border",
      "mask-border-outset",
      "mask-border-repeat",
      "mask-border-slice",
      "mask-border-source",
      "mask-border-width",
      "mask-image",
      "mask-mode",
      "mask-position",
      "mask-size",
      "mask-repeat",
      "mask-origin",
      "mask-clip",
      "mask-composite",
      "mask-type",
      "filter",
      "animation",
      "animation-duration",
      "animation-timing-function",
      "animation-delay",
      "animation-iteration-count",
      "animation-direction",
      "animation-fill-mode",
      "animation-play-state",
      "animation-name",
      "transition",
      "transition-delay",
      "transition-duration",
      "transition-property",
      "transition-timing-function",
      "will-change",
      "counter-increment",
      "counter-reset",
      "counter-set",
      "cursor",
      "box-sizing",
      "contain",
      "margin",
      "margin-top",
      "margin-right",
      "margin-bottom",
      "margin-left",
      "margin-inline",
      "margin-inline-start",
      "margin-inline-end",
      "margin-block",
      "margin-block-start",
      "margin-block-end",
      "inset",
      "inset-block",
      "inset-block-end",
      "inset-block-start",
      "inset-inline",
      "inset-inline-end",
      "inset-inline-start",
      "outline",
      "outline-color",
      "outline-style",
      "outline-width",
      "outline-offset",
      "box-shadow",
      "border",
      "border-top",
      "border-right",
      "border-bottom",
      "border-left",
      "border-width",
      "border-top-width",
      "border-right-width",
      "border-bottom-width",
      "border-left-width",
      "border-style",
      "border-top-style",
      "border-right-style",
      "border-bottom-style",
      "border-left-style",
      "border-color",
      "border-top-color",
      "border-right-color",
      "border-bottom-color",
      "border-left-color",
      "border-radius",
      "border-top-right-radius",
      "border-top-left-radius",
      "border-bottom-right-radius",
      "border-bottom-left-radius",
      "border-inline",
      "border-inline-width",
      "border-inline-style",
      "border-inline-color",
      "border-inline-start",
      "border-inline-start-width",
      "border-inline-start-style",
      "border-inline-start-color",
      "border-inline-end",
      "border-inline-end-width",
      "border-inline-end-style",
      "border-inline-end-color",
      "border-block",
      "border-block-width",
      "border-block-style",
      "border-block-color",
      "border-block-start",
      "border-block-start-width",
      "border-block-start-style",
      "border-block-start-color",
      "border-block-end",
      "border-block-end-width",
      "border-block-end-style",
      "border-block-end-color",
      "border-image",
      "border-image-source",
      "border-image-slice",
      "border-image-width",
      "border-image-outset",
      "border-image-repeat",
      "border-collapse",
      "border-spacing",
      "border-start-start-radius",
      "border-start-end-radius",
      "border-end-start-radius",
      "border-end-end-radius",
      "background",
      "background-image",
      "background-position",
      "background-size",
      "background-repeat",
      "background-origin",
      "background-clip",
      "background-attachment",
      "background-color",
      "background-blend-mode",
      "background-position-x",
      "background-position-y",
      "isolation",
      "padding",
      "padding-top",
      "padding-right",
      "padding-bottom",
      "padding-left",
      "padding-inline",
      "padding-inline-start",
      "padding-inline-end",
      "padding-block",
      "padding-block-start",
      "padding-block-end",
      "image-orientation",
      "image-rendering",
      "aspect-ratio",
      "width",
      "min-width",
      "max-width",
      "height",
      "min-height",
      "max-height",
      "-webkit-line-clamp",
      "inline-size",
      "min-inline-size",
      "max-inline-size",
      "block-size",
      "min-block-size",
      "max-block-size",
      "table-layout",
      "caption-side",
      "empty-cells",
      "overflow",
      "overflow-anchor",
      "overflow-block",
      "overflow-inline",
      "overflow-x",
      "overflow-y",
      "overscroll-behavior",
      "overscroll-behavior-block",
      "overscroll-behavior-inline",
      "overscroll-behavior-x",
      "overscroll-behavior-y",
      "resize",
      "object-fit",
      "object-position",
      "scroll-behavior",
      "scroll-margin",
      "scroll-margin-block",
      "scroll-margin-block-end",
      "scroll-margin-block-start",
      "scroll-margin-bottom",
      "scroll-margin-inline",
      "scroll-margin-inline-end",
      "scroll-margin-inline-start",
      "scroll-margin-left",
      "scroll-margin-right",
      "scroll-margin-top",
      "scroll-padding",
      "scroll-padding-block",
      "scroll-padding-block-end",
      "scroll-padding-block-start",
      "scroll-padding-bottom",
      "scroll-padding-inline",
      "scroll-padding-inline-end",
      "scroll-padding-inline-start",
      "scroll-padding-left",
      "scroll-padding-right",
      "scroll-padding-top",
      "scroll-snap-align",
      "scroll-snap-stop",
      "scroll-snap-type",
      "scrollbar-color",
      "scrollbar-gutter",
      "scrollbar-width",
      "touch-action",
      "pointer-events",
      "content",
      "quotes",
      "hanging-punctuation",
      "color",
      "accent-color",
      "print-color-adjust",
      "forced-color-adjust",
      "color-scheme",
      "caret-color",
      "font",
      "font-style",
      "font-variant",
      "font-weight",
      "font-stretch",
      "font-size",
      "size-adjust",
      "line-height",
      "src",
      "font-family",
      "font-display",
      "font-kerning",
      "font-language-override",
      "font-optical-sizing",
      "font-size-adjust",
      "font-synthesis",
      "font-variant-alternates",
      "font-variant-caps",
      "font-variant-east-asian",
      "font-variant-ligatures",
      "font-variant-numeric",
      "font-variant-position",
      "font-variation-settings",
      "ascent-override",
      "descent-override",
      "line-gap-override",
      "hyphens",
      "hyphenate-character",
      "letter-spacing",
      "line-break",
      "list-style",
      "list-style-type",
      "list-style-image",
      "list-style-position",
      "writing-mode",
      "direction",
      "unicode-bidi",
      "unicode-range",
      "user-select",
      "ruby-position",
      "text-combine-upright",
      "text-align",
      "text-align-last",
      "text-decoration",
      "text-decoration-line",
      "text-decoration-style",
      "text-decoration-color",
      "text-decoration-thickness",
      "text-decoration-skip-ink",
      "text-emphasis",
      "text-emphasis-style",
      "text-emphasis-color",
      "text-emphasis-position",
      "text-indent",
      "text-justify",
      "text-underline-position",
      "text-underline-offset",
      "text-orientation",
      "text-overflow",
      "text-shadow",
      "text-transform",
      "white-space",
      "word-break",
      "word-spacing",
      "overflow-wrap",
      "tab-size",
      "widows"
    ];
    var concentricCss = /* @__PURE__ */ Object.freeze({
      __proto__: null,
      properties: properties$1
    });
    var properties = [
      "all",
      "box-sizing",
      "contain",
      "display",
      "appearance",
      "visibility",
      "content-visibility",
      "z-index",
      "paint-order",
      "position",
      "top",
      "right",
      "bottom",
      "left",
      "offset",
      "offset-anchor",
      "offset-distance",
      "offset-path",
      "offset-rotate",
      "grid",
      "grid-template-rows",
      "grid-template-columns",
      "grid-template-areas",
      "grid-auto-rows",
      "grid-auto-columns",
      "grid-auto-flow",
      "column-gap",
      "row-gap",
      "grid-area",
      "grid-row",
      "grid-row-start",
      "grid-row-end",
      "grid-column",
      "grid-column-start",
      "grid-column-end",
      "grid-template",
      "flex",
      "flex-grow",
      "flex-shrink",
      "flex-basis",
      "flex-direction",
      "flex-flow",
      "flex-wrap",
      "box-decoration-break",
      "place-content",
      "place-items",
      "place-self",
      "align-content",
      "align-items",
      "align-self",
      "justify-content",
      "justify-items",
      "justify-self",
      "order",
      "aspect-ratio",
      "width",
      "min-width",
      "max-width",
      "height",
      "min-height",
      "max-height",
      "-webkit-line-clamp",
      "inline-size",
      "min-inline-size",
      "max-inline-size",
      "block-size",
      "min-block-size",
      "max-block-size",
      "margin",
      "margin-top",
      "margin-right",
      "margin-bottom",
      "margin-left",
      "margin-inline",
      "margin-inline-start",
      "margin-inline-end",
      "margin-block",
      "margin-block-start",
      "margin-block-end",
      "inset",
      "inset-block",
      "inset-block-end",
      "inset-block-start",
      "inset-inline",
      "inset-inline-end",
      "inset-inline-start",
      "padding",
      "padding-top",
      "padding-right",
      "padding-bottom",
      "padding-left",
      "padding-inline",
      "padding-inline-start",
      "padding-inline-end",
      "padding-block",
      "padding-block-start",
      "padding-block-end",
      "float",
      "clear",
      "overflow",
      "overflow-anchor",
      "overflow-block",
      "overflow-inline",
      "overflow-x",
      "overflow-y",
      "overscroll-behavior",
      "overscroll-behavior-block",
      "overscroll-behavior-inline",
      "overscroll-behavior-x",
      "overscroll-behavior-y",
      "orphans",
      "gap",
      "columns",
      "column-fill",
      "column-rule",
      "column-rule-color",
      "column-rule-style",
      "column-rule-width",
      "column-span",
      "column-count",
      "column-width",
      "object-fit",
      "object-position",
      "transform",
      "transform-box",
      "transform-origin",
      "transform-style",
      "translate",
      "rotate",
      "scale",
      "border",
      "border-top",
      "border-right",
      "border-bottom",
      "border-left",
      "border-width",
      "border-top-width",
      "border-right-width",
      "border-bottom-width",
      "border-left-width",
      "border-style",
      "border-top-style",
      "border-right-style",
      "border-bottom-style",
      "border-left-style",
      "border-radius",
      "border-top-right-radius",
      "border-top-left-radius",
      "border-bottom-right-radius",
      "border-bottom-left-radius",
      "border-inline",
      "border-inline-color",
      "border-inline-style",
      "border-inline-width",
      "border-inline-start",
      "border-inline-start-color",
      "border-inline-start-style",
      "border-inline-start-width",
      "border-inline-end",
      "border-inline-end-color",
      "border-inline-end-style",
      "border-inline-end-width",
      "border-block",
      "border-block-color",
      "border-block-style",
      "border-block-width",
      "border-block-start",
      "border-block-start-color",
      "border-block-start-style",
      "border-block-start-width",
      "border-block-end",
      "border-block-end-color",
      "border-block-end-style",
      "border-block-end-width",
      "border-color",
      "border-image",
      "border-image-outset",
      "border-image-repeat",
      "border-image-slice",
      "border-image-source",
      "border-image-width",
      "border-top-color",
      "border-right-color",
      "border-bottom-color",
      "border-left-color",
      "border-collapse",
      "border-spacing",
      "border-start-start-radius",
      "border-start-end-radius",
      "border-end-start-radius",
      "border-end-end-radius",
      "outline",
      "outline-color",
      "outline-style",
      "outline-width",
      "outline-offset",
      "backdrop-filter",
      "backface-visibility",
      "background",
      "background-image",
      "background-position",
      "background-size",
      "background-repeat",
      "background-origin",
      "background-clip",
      "background-attachment",
      "background-color",
      "background-blend-mode",
      "background-position-x",
      "background-position-y",
      "box-shadow",
      "isolation",
      "content",
      "quotes",
      "hanging-punctuation",
      "color",
      "accent-color",
      "print-color-adjust",
      "forced-color-adjust",
      "color-scheme",
      "caret-color",
      "font",
      "font-style",
      "font-variant",
      "font-weight",
      "src",
      "font-stretch",
      "font-size",
      "size-adjust",
      "line-height",
      "font-family",
      "font-display",
      "font-kerning",
      "font-language-override",
      "font-optical-sizing",
      "font-size-adjust",
      "font-synthesis",
      "font-variant-alternates",
      "font-variant-caps",
      "font-variant-east-asian",
      "font-variant-ligatures",
      "font-variant-numeric",
      "font-variant-position",
      "font-variation-settings",
      "ascent-override",
      "descent-override",
      "line-gap-override",
      "hyphens",
      "hyphenate-character",
      "letter-spacing",
      "line-break",
      "list-style",
      "list-style-image",
      "list-style-position",
      "list-style-type",
      "direction",
      "text-align",
      "text-align-last",
      "text-decoration",
      "text-decoration-line",
      "text-decoration-style",
      "text-decoration-color",
      "text-decoration-thickness",
      "text-decoration-skip-ink",
      "text-emphasis",
      "text-emphasis-style",
      "text-emphasis-color",
      "text-emphasis-position",
      "text-indent",
      "text-justify",
      "text-underline-position",
      "text-underline-offset",
      "text-orientation",
      "text-overflow",
      "text-shadow",
      "text-transform",
      "vertical-align",
      "white-space",
      "word-break",
      "word-spacing",
      "overflow-wrap",
      "animation",
      "animation-duration",
      "animation-timing-function",
      "animation-delay",
      "animation-iteration-count",
      "animation-direction",
      "animation-fill-mode",
      "animation-play-state",
      "animation-name",
      "mix-blend-mode",
      "break-before",
      "break-after",
      "break-inside",
      "page",
      "page-break-before",
      "page-break-after",
      "page-break-inside",
      "caption-side",
      "clip-path",
      "counter-increment",
      "counter-reset",
      "counter-set",
      "cursor",
      "empty-cells",
      "filter",
      "image-orientation",
      "image-rendering",
      "mask",
      "mask-border",
      "mask-border-outset",
      "mask-border-repeat",
      "mask-border-slice",
      "mask-border-source",
      "mask-border-width",
      "mask-clip",
      "mask-composite",
      "mask-image",
      "mask-mode",
      "mask-origin",
      "mask-position",
      "mask-repeat",
      "mask-size",
      "mask-type",
      "opacity",
      "perspective",
      "perspective-origin",
      "pointer-events",
      "resize",
      "scroll-behavior",
      "scroll-margin",
      "scroll-margin-block",
      "scroll-margin-block-end",
      "scroll-margin-block-start",
      "scroll-margin-bottom",
      "scroll-margin-inline",
      "scroll-margin-inline-end",
      "scroll-margin-inline-start",
      "scroll-margin-left",
      "scroll-margin-right",
      "scroll-margin-top",
      "scroll-padding",
      "scroll-padding-block",
      "scroll-padding-block-end",
      "scroll-padding-block-start",
      "scroll-padding-bottom",
      "scroll-padding-inline",
      "scroll-padding-inline-end",
      "scroll-padding-inline-start",
      "scroll-padding-left",
      "scroll-padding-right",
      "scroll-padding-top",
      "scroll-snap-align",
      "scroll-snap-stop",
      "scroll-snap-type",
      "scrollbar-color",
      "scrollbar-gutter",
      "scrollbar-width",
      "shape-image-threshold",
      "shape-margin",
      "shape-outside",
      "tab-size",
      "table-layout",
      "ruby-position",
      "text-combine-upright",
      "touch-action",
      "transition",
      "transition-delay",
      "transition-duration",
      "transition-property",
      "transition-timing-function",
      "will-change",
      "unicode-bidi",
      "unicode-range",
      "user-select",
      "widows",
      "writing-mode"
    ];
    var smacss = /* @__PURE__ */ Object.freeze({
      __proto__: null,
      properties
    });
    exports2.cssDeclarationSorter = cssDeclarationSorter;
    exports2["default"] = cssDeclarationSorter;
    module2.exports = cssDeclarationSorter;
  }
});

// node_modules/postcss-discard-comments/src/lib/commentRemover.js
var require_commentRemover = __commonJS({
  "node_modules/postcss-discard-comments/src/lib/commentRemover.js"(exports2, module2) {
    "use strict";
    function CommentRemover(options) {
      this.options = options;
    }
    CommentRemover.prototype.canRemove = function(comment) {
      const remove = this.options.remove;
      if (remove) {
        return remove(comment);
      } else {
        const isImportant = comment.indexOf("!") === 0;
        if (!isImportant) {
          return true;
        }
        if (this.options.removeAll || this._hasFirst) {
          return true;
        } else if (this.options.removeAllButFirst && !this._hasFirst) {
          this._hasFirst = true;
          return false;
        }
      }
    };
    module2.exports = CommentRemover;
  }
});

// node_modules/postcss-discard-comments/src/lib/commentParser.js
var require_commentParser = __commonJS({
  "node_modules/postcss-discard-comments/src/lib/commentParser.js"(exports2, module2) {
    "use strict";
    module2.exports = function commentParser(input) {
      const tokens = [];
      const length = input.length;
      let pos = 0;
      let next;
      while (pos < length) {
        next = input.indexOf("/*", pos);
        if (~next) {
          tokens.push([0, pos, next]);
          pos = next;
          next = input.indexOf("*/", pos + 2);
          tokens.push([1, pos + 2, next]);
          pos = next + 2;
        } else {
          tokens.push([0, pos, length]);
          pos = length;
        }
      }
      return tokens;
    };
  }
});

// node_modules/postcss-discard-comments/src/index.js
var require_src2 = __commonJS({
  "node_modules/postcss-discard-comments/src/index.js"(exports2, module2) {
    "use strict";
    var CommentRemover = require_commentRemover();
    var commentParser = require_commentParser();
    function pluginCreator(opts = {}) {
      const remover = new CommentRemover(opts);
      const matcherCache = /* @__PURE__ */ new Map();
      const replacerCache = /* @__PURE__ */ new Map();
      function matchesComments(source) {
        if (matcherCache.has(source)) {
          return matcherCache.get(source);
        }
        const result = commentParser(source).filter(([type]) => type);
        matcherCache.set(source, result);
        return result;
      }
      function replaceComments(source, space, separator = " ") {
        const key = source + "@|@" + separator;
        if (replacerCache.has(key)) {
          return replacerCache.get(key);
        }
        const parsed = commentParser(source).reduce((value, [type, start, end]) => {
          const contents = source.slice(start, end);
          if (!type) {
            return value + contents;
          }
          if (remover.canRemove(contents)) {
            return value + separator;
          }
          return `${value}/*${contents}*/`;
        }, "");
        const result = space(parsed).join(" ");
        replacerCache.set(key, result);
        return result;
      }
      return {
        postcssPlugin: "postcss-discard-comments",
        OnceExit(css, { list }) {
          css.walk((node) => {
            if (node.type === "comment" && remover.canRemove(node.text)) {
              node.remove();
              return;
            }
            if (typeof node.raws.between === "string") {
              node.raws.between = replaceComments(node.raws.between, list.space);
            }
            if (node.type === "decl") {
              if (node.raws.value && node.raws.value.raw) {
                if (node.raws.value.value === node.value) {
                  node.value = replaceComments(node.raws.value.raw, list.space);
                } else {
                  node.value = replaceComments(node.value, list.space);
                }
                node.raws.value = null;
              }
              if (node.raws.important) {
                node.raws.important = replaceComments(node.raws.important, list.space);
                const b = matchesComments(node.raws.important);
                node.raws.important = b.length ? node.raws.important : "!important";
              } else {
                node.value = replaceComments(node.value, list.space);
              }
              return;
            }
            if (node.type === "rule" && node.raws.selector && node.raws.selector.raw) {
              node.raws.selector.raw = replaceComments(node.raws.selector.raw, list.space, "");
              return;
            }
            if (node.type === "atrule") {
              if (node.raws.afterName) {
                const commentsReplaced = replaceComments(node.raws.afterName, list.space);
                if (!commentsReplaced.length) {
                  node.raws.afterName = commentsReplaced + " ";
                } else {
                  node.raws.afterName = " " + commentsReplaced + " ";
                }
              }
              if (node.raws.params && node.raws.params.raw) {
                node.raws.params.raw = replaceComments(node.raws.params.raw, list.space);
              }
            }
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/lodash.memoize/index.js
var require_lodash = __commonJS({
  "node_modules/lodash.memoize/index.js"(exports2, module2) {
    var FUNC_ERROR_TEXT = "Expected a function";
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    var funcTag = "[object Function]";
    var genTag = "[object GeneratorFunction]";
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor = /^\[object .+?Constructor\]$/;
    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
    var root = freeGlobal || freeSelf || Function("return this")();
    function getValue(object, key) {
      return object == null ? void 0 : object[key];
    }
    function isHostObject(value) {
      var result = false;
      if (value != null && typeof value.toString != "function") {
        try {
          result = !!(value + "");
        } catch (e) {
        }
      }
      return result;
    }
    var arrayProto = Array.prototype;
    var funcProto = Function.prototype;
    var objectProto = Object.prototype;
    var coreJsData = root["__core-js_shared__"];
    var maskSrcKey = function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
      return uid ? "Symbol(src)_1." + uid : "";
    }();
    var funcToString = funcProto.toString;
    var hasOwnProperty2 = objectProto.hasOwnProperty;
    var objectToString = objectProto.toString;
    var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
    var splice = arrayProto.splice;
    var Map2 = getNative(root, "Map");
    var nativeCreate = getNative(Object, "create");
    function Hash(entries) {
      var index = -1, length = entries ? entries.length : 0;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    function hashClear() {
      this.__data__ = nativeCreate ? nativeCreate(null) : {};
    }
    function hashDelete(key) {
      return this.has(key) && delete this.__data__[key];
    }
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate) {
        var result = data[key];
        return result === HASH_UNDEFINED ? void 0 : result;
      }
      return hasOwnProperty2.call(data, key) ? data[key] : void 0;
    }
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate ? data[key] !== void 0 : hasOwnProperty2.call(data, key);
    }
    function hashSet(key, value) {
      var data = this.__data__;
      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
      return this;
    }
    Hash.prototype.clear = hashClear;
    Hash.prototype["delete"] = hashDelete;
    Hash.prototype.get = hashGet;
    Hash.prototype.has = hashHas;
    Hash.prototype.set = hashSet;
    function ListCache(entries) {
      var index = -1, length = entries ? entries.length : 0;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    function listCacheClear() {
      this.__data__ = [];
    }
    function listCacheDelete(key) {
      var data = this.__data__, index = assocIndexOf(data, key);
      if (index < 0) {
        return false;
      }
      var lastIndex = data.length - 1;
      if (index == lastIndex) {
        data.pop();
      } else {
        splice.call(data, index, 1);
      }
      return true;
    }
    function listCacheGet(key) {
      var data = this.__data__, index = assocIndexOf(data, key);
      return index < 0 ? void 0 : data[index][1];
    }
    function listCacheHas(key) {
      return assocIndexOf(this.__data__, key) > -1;
    }
    function listCacheSet(key, value) {
      var data = this.__data__, index = assocIndexOf(data, key);
      if (index < 0) {
        data.push([key, value]);
      } else {
        data[index][1] = value;
      }
      return this;
    }
    ListCache.prototype.clear = listCacheClear;
    ListCache.prototype["delete"] = listCacheDelete;
    ListCache.prototype.get = listCacheGet;
    ListCache.prototype.has = listCacheHas;
    ListCache.prototype.set = listCacheSet;
    function MapCache(entries) {
      var index = -1, length = entries ? entries.length : 0;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    function mapCacheClear() {
      this.__data__ = {
        "hash": new Hash(),
        "map": new (Map2 || ListCache)(),
        "string": new Hash()
      };
    }
    function mapCacheDelete(key) {
      return getMapData(this, key)["delete"](key);
    }
    function mapCacheGet(key) {
      return getMapData(this, key).get(key);
    }
    function mapCacheHas(key) {
      return getMapData(this, key).has(key);
    }
    function mapCacheSet(key, value) {
      getMapData(this, key).set(key, value);
      return this;
    }
    MapCache.prototype.clear = mapCacheClear;
    MapCache.prototype["delete"] = mapCacheDelete;
    MapCache.prototype.get = mapCacheGet;
    MapCache.prototype.has = mapCacheHas;
    MapCache.prototype.set = mapCacheSet;
    function assocIndexOf(array, key) {
      var length = array.length;
      while (length--) {
        if (eq(array[length][0], key)) {
          return length;
        }
      }
      return -1;
    }
    function baseIsNative(value) {
      if (!isObject(value) || isMasked(value)) {
        return false;
      }
      var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }
    function getMapData(map, key) {
      var data = map.__data__;
      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
    }
    function getNative(object, key) {
      var value = getValue(object, key);
      return baseIsNative(value) ? value : void 0;
    }
    function isKeyable(value) {
      var type = typeof value;
      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
    }
    function isMasked(func) {
      return !!maskSrcKey && maskSrcKey in func;
    }
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e) {
        }
        try {
          return func + "";
        } catch (e) {
        }
      }
      return "";
    }
    function memoize(func, resolver) {
      if (typeof func != "function" || resolver && typeof resolver != "function") {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      var memoized = function() {
        var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
        if (cache.has(key)) {
          return cache.get(key);
        }
        var result = func.apply(this, args);
        memoized.cache = cache.set(key, result);
        return result;
      };
      memoized.cache = new (memoize.Cache || MapCache)();
      return memoized;
    }
    memoize.Cache = MapCache;
    function eq(value, other) {
      return value === other || value !== value && other !== other;
    }
    function isFunction(value) {
      var tag = isObject(value) ? objectToString.call(value) : "";
      return tag == funcTag || tag == genTag;
    }
    function isObject(value) {
      var type = typeof value;
      return !!value && (type == "object" || type == "function");
    }
    module2.exports = memoize;
  }
});

// node_modules/lodash.uniq/index.js
var require_lodash2 = __commonJS({
  "node_modules/lodash.uniq/index.js"(exports2, module2) {
    var LARGE_ARRAY_SIZE = 200;
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    var INFINITY = 1 / 0;
    var funcTag = "[object Function]";
    var genTag = "[object GeneratorFunction]";
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor = /^\[object .+?Constructor\]$/;
    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
    var root = freeGlobal || freeSelf || Function("return this")();
    function arrayIncludes(array, value) {
      var length = array ? array.length : 0;
      return !!length && baseIndexOf(array, value, 0) > -1;
    }
    function arrayIncludesWith(array, value, comparator) {
      var index = -1, length = array ? array.length : 0;
      while (++index < length) {
        if (comparator(value, array[index])) {
          return true;
        }
      }
      return false;
    }
    function baseFindIndex(array, predicate, fromIndex, fromRight) {
      var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
      while (fromRight ? index-- : ++index < length) {
        if (predicate(array[index], index, array)) {
          return index;
        }
      }
      return -1;
    }
    function baseIndexOf(array, value, fromIndex) {
      if (value !== value) {
        return baseFindIndex(array, baseIsNaN, fromIndex);
      }
      var index = fromIndex - 1, length = array.length;
      while (++index < length) {
        if (array[index] === value) {
          return index;
        }
      }
      return -1;
    }
    function baseIsNaN(value) {
      return value !== value;
    }
    function cacheHas(cache, key) {
      return cache.has(key);
    }
    function getValue(object, key) {
      return object == null ? void 0 : object[key];
    }
    function isHostObject(value) {
      var result = false;
      if (value != null && typeof value.toString != "function") {
        try {
          result = !!(value + "");
        } catch (e) {
        }
      }
      return result;
    }
    function setToArray(set) {
      var index = -1, result = Array(set.size);
      set.forEach(function(value) {
        result[++index] = value;
      });
      return result;
    }
    var arrayProto = Array.prototype;
    var funcProto = Function.prototype;
    var objectProto = Object.prototype;
    var coreJsData = root["__core-js_shared__"];
    var maskSrcKey = function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
      return uid ? "Symbol(src)_1." + uid : "";
    }();
    var funcToString = funcProto.toString;
    var hasOwnProperty2 = objectProto.hasOwnProperty;
    var objectToString = objectProto.toString;
    var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
    var splice = arrayProto.splice;
    var Map2 = getNative(root, "Map");
    var Set2 = getNative(root, "Set");
    var nativeCreate = getNative(Object, "create");
    function Hash(entries) {
      var index = -1, length = entries ? entries.length : 0;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    function hashClear() {
      this.__data__ = nativeCreate ? nativeCreate(null) : {};
    }
    function hashDelete(key) {
      return this.has(key) && delete this.__data__[key];
    }
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate) {
        var result = data[key];
        return result === HASH_UNDEFINED ? void 0 : result;
      }
      return hasOwnProperty2.call(data, key) ? data[key] : void 0;
    }
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate ? data[key] !== void 0 : hasOwnProperty2.call(data, key);
    }
    function hashSet(key, value) {
      var data = this.__data__;
      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
      return this;
    }
    Hash.prototype.clear = hashClear;
    Hash.prototype["delete"] = hashDelete;
    Hash.prototype.get = hashGet;
    Hash.prototype.has = hashHas;
    Hash.prototype.set = hashSet;
    function ListCache(entries) {
      var index = -1, length = entries ? entries.length : 0;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    function listCacheClear() {
      this.__data__ = [];
    }
    function listCacheDelete(key) {
      var data = this.__data__, index = assocIndexOf(data, key);
      if (index < 0) {
        return false;
      }
      var lastIndex = data.length - 1;
      if (index == lastIndex) {
        data.pop();
      } else {
        splice.call(data, index, 1);
      }
      return true;
    }
    function listCacheGet(key) {
      var data = this.__data__, index = assocIndexOf(data, key);
      return index < 0 ? void 0 : data[index][1];
    }
    function listCacheHas(key) {
      return assocIndexOf(this.__data__, key) > -1;
    }
    function listCacheSet(key, value) {
      var data = this.__data__, index = assocIndexOf(data, key);
      if (index < 0) {
        data.push([key, value]);
      } else {
        data[index][1] = value;
      }
      return this;
    }
    ListCache.prototype.clear = listCacheClear;
    ListCache.prototype["delete"] = listCacheDelete;
    ListCache.prototype.get = listCacheGet;
    ListCache.prototype.has = listCacheHas;
    ListCache.prototype.set = listCacheSet;
    function MapCache(entries) {
      var index = -1, length = entries ? entries.length : 0;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    function mapCacheClear() {
      this.__data__ = {
        "hash": new Hash(),
        "map": new (Map2 || ListCache)(),
        "string": new Hash()
      };
    }
    function mapCacheDelete(key) {
      return getMapData(this, key)["delete"](key);
    }
    function mapCacheGet(key) {
      return getMapData(this, key).get(key);
    }
    function mapCacheHas(key) {
      return getMapData(this, key).has(key);
    }
    function mapCacheSet(key, value) {
      getMapData(this, key).set(key, value);
      return this;
    }
    MapCache.prototype.clear = mapCacheClear;
    MapCache.prototype["delete"] = mapCacheDelete;
    MapCache.prototype.get = mapCacheGet;
    MapCache.prototype.has = mapCacheHas;
    MapCache.prototype.set = mapCacheSet;
    function SetCache(values) {
      var index = -1, length = values ? values.length : 0;
      this.__data__ = new MapCache();
      while (++index < length) {
        this.add(values[index]);
      }
    }
    function setCacheAdd(value) {
      this.__data__.set(value, HASH_UNDEFINED);
      return this;
    }
    function setCacheHas(value) {
      return this.__data__.has(value);
    }
    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
    SetCache.prototype.has = setCacheHas;
    function assocIndexOf(array, key) {
      var length = array.length;
      while (length--) {
        if (eq(array[length][0], key)) {
          return length;
        }
      }
      return -1;
    }
    function baseIsNative(value) {
      if (!isObject(value) || isMasked(value)) {
        return false;
      }
      var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }
    function baseUniq(array, iteratee, comparator) {
      var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
      if (comparator) {
        isCommon = false;
        includes = arrayIncludesWith;
      } else if (length >= LARGE_ARRAY_SIZE) {
        var set = iteratee ? null : createSet(array);
        if (set) {
          return setToArray(set);
        }
        isCommon = false;
        includes = cacheHas;
        seen = new SetCache();
      } else {
        seen = iteratee ? [] : result;
      }
      outer:
        while (++index < length) {
          var value = array[index], computed = iteratee ? iteratee(value) : value;
          value = comparator || value !== 0 ? value : 0;
          if (isCommon && computed === computed) {
            var seenIndex = seen.length;
            while (seenIndex--) {
              if (seen[seenIndex] === computed) {
                continue outer;
              }
            }
            if (iteratee) {
              seen.push(computed);
            }
            result.push(value);
          } else if (!includes(seen, computed, comparator)) {
            if (seen !== result) {
              seen.push(computed);
            }
            result.push(value);
          }
        }
      return result;
    }
    var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY) ? noop : function(values) {
      return new Set2(values);
    };
    function getMapData(map, key) {
      var data = map.__data__;
      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
    }
    function getNative(object, key) {
      var value = getValue(object, key);
      return baseIsNative(value) ? value : void 0;
    }
    function isKeyable(value) {
      var type = typeof value;
      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
    }
    function isMasked(func) {
      return !!maskSrcKey && maskSrcKey in func;
    }
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e) {
        }
        try {
          return func + "";
        } catch (e) {
        }
      }
      return "";
    }
    function uniq(array) {
      return array && array.length ? baseUniq(array) : [];
    }
    function eq(value, other) {
      return value === other || value !== value && other !== other;
    }
    function isFunction(value) {
      var tag = isObject(value) ? objectToString.call(value) : "";
      return tag == funcTag || tag == genTag;
    }
    function isObject(value) {
      var type = typeof value;
      return !!value && (type == "object" || type == "function");
    }
    function noop() {
    }
    module2.exports = uniq;
  }
});

// node_modules/caniuse-api/dist/utils.js
var require_utils2 = __commonJS({
  "node_modules/caniuse-api/dist/utils.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.contains = contains;
    exports2.parseCaniuseData = parseCaniuseData;
    exports2.cleanBrowsersList = cleanBrowsersList;
    var _lodash = require_lodash2();
    var _lodash2 = _interopRequireDefault(_lodash);
    var _browserslist = require_browserslist();
    var _browserslist2 = _interopRequireDefault(_browserslist);
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    function contains(str, substr) {
      return !!~str.indexOf(substr);
    }
    function parseCaniuseData(feature, browsers) {
      var support = {};
      var letters;
      var letter;
      browsers.forEach(function(browser) {
        support[browser] = {};
        for (var info in feature.stats[browser]) {
          letters = feature.stats[browser][info].replace(/#\d+/, "").trim().split(" ");
          info = parseFloat(info.split("-")[0]);
          if (isNaN(info))
            continue;
          for (var i = 0; i < letters.length; i++) {
            letter = letters[i];
            if (letter === "d") {
              continue;
            } else if (letter === "y") {
              if (typeof support[browser][letter] === "undefined" || info < support[browser][letter]) {
                support[browser][letter] = info;
              }
            } else {
              if (typeof support[browser][letter] === "undefined" || info > support[browser][letter]) {
                support[browser][letter] = info;
              }
            }
          }
        }
      });
      return support;
    }
    function cleanBrowsersList(browserList) {
      return (0, _lodash2.default)((0, _browserslist2.default)(browserList).map(function(browser) {
        return browser.split(" ")[0];
      }));
    }
  }
});

// node_modules/caniuse-api/dist/index.js
var require_dist3 = __commonJS({
  "node_modules/caniuse-api/dist/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.getBrowserScope = exports2.setBrowserScope = exports2.getLatestStableBrowsers = exports2.find = exports2.isSupported = exports2.getSupport = exports2.features = void 0;
    var _lodash = require_lodash();
    var _lodash2 = _interopRequireDefault(_lodash);
    var _browserslist = require_browserslist();
    var _browserslist2 = _interopRequireDefault(_browserslist);
    var _caniuseLite = require_unpacker();
    var _utils = require_utils2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var featuresList = Object.keys(_caniuseLite.features);
    var browsers = void 0;
    function setBrowserScope(browserList) {
      browsers = (0, _utils.cleanBrowsersList)(browserList);
    }
    function getBrowserScope() {
      return browsers;
    }
    var parse = (0, _lodash2.default)(_utils.parseCaniuseData, function(feat, browsers2) {
      return feat.title + browsers2;
    });
    function getSupport(query) {
      var feature = void 0;
      try {
        feature = (0, _caniuseLite.feature)(_caniuseLite.features[query]);
      } catch (e) {
        var res = find(query);
        if (res.length === 1)
          return getSupport(res[0]);
        throw new ReferenceError("Please provide a proper feature name. Cannot find " + query);
      }
      return parse(feature, browsers);
    }
    function isSupported(feature, browsers2) {
      var data = void 0;
      try {
        data = (0, _caniuseLite.feature)(_caniuseLite.features[feature]);
      } catch (e) {
        var res = find(feature);
        if (res.length === 1) {
          data = _caniuseLite.features[res[0]];
        } else {
          throw new ReferenceError("Please provide a proper feature name. Cannot find " + feature);
        }
      }
      return (0, _browserslist2.default)(browsers2, { ignoreUnknownVersions: true }).map(function(browser) {
        return browser.split(" ");
      }).every(function(browser) {
        return data.stats[browser[0]] && data.stats[browser[0]][browser[1]] === "y";
      });
    }
    function find(query) {
      if (typeof query !== "string") {
        throw new TypeError("The `query` parameter should be a string.");
      }
      if (~featuresList.indexOf(query)) {
        return query;
      }
      return featuresList.filter(function(file) {
        return (0, _utils.contains)(file, query);
      });
    }
    function getLatestStableBrowsers() {
      return (0, _browserslist2.default)("last 1 version");
    }
    setBrowserScope();
    exports2.features = featuresList;
    exports2.getSupport = getSupport;
    exports2.isSupported = isSupported;
    exports2.find = find;
    exports2.getLatestStableBrowsers = getLatestStableBrowsers;
    exports2.setBrowserScope = setBrowserScope;
    exports2.getBrowserScope = getBrowserScope;
  }
});

// node_modules/postcss-reduce-initial/src/data/fromInitial.json
var require_fromInitial = __commonJS({
  "node_modules/postcss-reduce-initial/src/data/fromInitial.json"(exports2, module2) {
    module2.exports = {
      "-webkit-line-clamp": "none",
      "accent-color": "auto",
      "align-content": "normal",
      "align-items": "normal",
      "align-self": "auto",
      "align-tracks": "normal",
      "animation-delay": "0s",
      "animation-direction": "normal",
      "animation-duration": "0s",
      "animation-fill-mode": "none",
      "animation-iteration-count": "1",
      "animation-name": "none",
      "animation-timing-function": "ease",
      appearance: "auto",
      "aspect-ratio": "auto",
      azimuth: "center",
      "backdrop-filter": "none",
      "background-attachment": "scroll",
      "background-blend-mode": "normal",
      "background-image": "none",
      "background-position": "0% 0%",
      "background-position-x": "left",
      "background-position-y": "top",
      "background-repeat": "repeat",
      "block-overflow": "clip",
      "block-size": "auto",
      "border-block-style": "none",
      "border-block-width": "medium",
      "border-block-end-style": "none",
      "border-block-end-width": "medium",
      "border-block-start-style": "none",
      "border-block-start-width": "medium",
      "border-bottom-left-radius": "0",
      "border-bottom-right-radius": "0",
      "border-bottom-style": "none",
      "border-bottom-width": "medium",
      "border-end-end-radius": "0",
      "border-end-start-radius": "0",
      "border-image-outset": "0",
      "border-image-slice": "100%",
      "border-image-source": "none",
      "border-image-width": "1",
      "border-inline-style": "none",
      "border-inline-width": "medium",
      "border-inline-end-style": "none",
      "border-inline-end-width": "medium",
      "border-inline-start-style": "none",
      "border-inline-start-width": "medium",
      "border-left-style": "none",
      "border-left-width": "medium",
      "border-right-style": "none",
      "border-right-width": "medium",
      "border-spacing": "0",
      "border-start-end-radius": "0",
      "border-start-start-radius": "0",
      "border-top-left-radius": "0",
      "border-top-right-radius": "0",
      "border-top-style": "none",
      "border-top-width": "medium",
      bottom: "auto",
      "box-decoration-break": "slice",
      "box-shadow": "none",
      "break-after": "auto",
      "break-before": "auto",
      "break-inside": "auto",
      "caption-side": "top",
      "caret-color": "auto",
      clear: "none",
      clip: "auto",
      "clip-path": "none",
      "color-scheme": "normal",
      "column-count": "auto",
      "column-gap": "normal",
      "column-rule-style": "none",
      "column-rule-width": "medium",
      "column-span": "none",
      "column-width": "auto",
      contain: "none",
      content: "normal",
      "counter-increment": "none",
      "counter-reset": "none",
      "counter-set": "none",
      cursor: "auto",
      direction: "ltr",
      "empty-cells": "show",
      filter: "none",
      "flex-basis": "auto",
      "flex-direction": "row",
      "flex-grow": "0",
      "flex-shrink": "1",
      "flex-wrap": "nowrap",
      float: "none",
      "font-feature-settings": "normal",
      "font-kerning": "auto",
      "font-language-override": "normal",
      "font-optical-sizing": "auto",
      "font-variation-settings": "normal",
      "font-size": "medium",
      "font-size-adjust": "none",
      "font-stretch": "normal",
      "font-style": "normal",
      "font-variant": "normal",
      "font-variant-alternates": "normal",
      "font-variant-caps": "normal",
      "font-variant-east-asian": "normal",
      "font-variant-ligatures": "normal",
      "font-variant-numeric": "normal",
      "font-variant-position": "normal",
      "font-weight": "normal",
      "forced-color-adjust": "auto",
      "grid-auto-columns": "auto",
      "grid-auto-flow": "row",
      "grid-auto-rows": "auto",
      "grid-column-end": "auto",
      "grid-column-gap": "0",
      "grid-column-start": "auto",
      "grid-row-end": "auto",
      "grid-row-gap": "0",
      "grid-row-start": "auto",
      "grid-template-areas": "none",
      "grid-template-columns": "none",
      "grid-template-rows": "none",
      "hanging-punctuation": "none",
      height: "auto",
      hyphens: "manual",
      "image-rendering": "auto",
      "image-resolution": "1dppx",
      "ime-mode": "auto",
      "initial-letter": "normal",
      "initial-letter-align": "auto",
      "inline-size": "auto",
      inset: "auto",
      "inset-block": "auto",
      "inset-block-end": "auto",
      "inset-block-start": "auto",
      "inset-inline": "auto",
      "inset-inline-end": "auto",
      "inset-inline-start": "auto",
      isolation: "auto",
      "justify-content": "normal",
      "justify-items": "legacy",
      "justify-self": "auto",
      "justify-tracks": "normal",
      left: "auto",
      "letter-spacing": "normal",
      "line-break": "auto",
      "line-clamp": "none",
      "line-height": "normal",
      "line-height-step": "0",
      "list-style-image": "none",
      "list-style-type": "disc",
      "margin-block": "0",
      "margin-block-end": "0",
      "margin-block-start": "0",
      "margin-bottom": "0",
      "margin-inline": "0",
      "margin-inline-end": "0",
      "margin-inline-start": "0",
      "margin-left": "0",
      "margin-right": "0",
      "margin-top": "0",
      "margin-trim": "none",
      "mask-border-mode": "alpha",
      "mask-border-outset": "0",
      "mask-border-slice": "0",
      "mask-border-source": "none",
      "mask-border-width": "auto",
      "mask-composite": "add",
      "mask-image": "none",
      "mask-position": "center",
      "mask-repeat": "repeat",
      "mask-size": "auto",
      "masonry-auto-flow": "pack",
      "math-style": "normal",
      "max-block-size": "0",
      "max-height": "none",
      "max-inline-size": "0",
      "max-lines": "none",
      "max-width": "none",
      "min-block-size": "0",
      "min-height": "auto",
      "min-inline-size": "0",
      "min-width": "auto",
      "mix-blend-mode": "normal",
      "object-fit": "fill",
      "offset-anchor": "auto",
      "offset-distance": "0",
      "offset-path": "none",
      "offset-position": "auto",
      "offset-rotate": "auto",
      opacity: "1.0",
      order: "0",
      orphans: "2",
      "outline-offset": "0",
      "outline-style": "none",
      "outline-width": "medium",
      "overflow-anchor": "auto",
      "overflow-block": "auto",
      "overflow-clip-margin": "0px",
      "overflow-inline": "auto",
      "overflow-wrap": "normal",
      "overscroll-behavior": "auto",
      "overscroll-behavior-block": "auto",
      "overscroll-behavior-inline": "auto",
      "overscroll-behavior-x": "auto",
      "overscroll-behavior-y": "auto",
      "padding-block": "0",
      "padding-block-end": "0",
      "padding-block-start": "0",
      "padding-bottom": "0",
      "padding-inline": "0",
      "padding-inline-end": "0",
      "padding-inline-start": "0",
      "padding-left": "0",
      "padding-right": "0",
      "padding-top": "0",
      "page-break-after": "auto",
      "page-break-before": "auto",
      "page-break-inside": "auto",
      "paint-order": "normal",
      perspective: "none",
      "place-content": "normal",
      "pointer-events": "auto",
      position: "static",
      resize: "none",
      right: "auto",
      rotate: "none",
      "row-gap": "normal",
      scale: "none",
      "scrollbar-color": "auto",
      "scrollbar-gutter": "auto",
      "scrollbar-width": "auto",
      "scroll-behavior": "auto",
      "scroll-margin": "0",
      "scroll-margin-block": "0",
      "scroll-margin-block-start": "0",
      "scroll-margin-block-end": "0",
      "scroll-margin-bottom": "0",
      "scroll-margin-inline": "0",
      "scroll-margin-inline-start": "0",
      "scroll-margin-inline-end": "0",
      "scroll-margin-left": "0",
      "scroll-margin-right": "0",
      "scroll-margin-top": "0",
      "scroll-padding": "auto",
      "scroll-padding-block": "auto",
      "scroll-padding-block-start": "auto",
      "scroll-padding-block-end": "auto",
      "scroll-padding-bottom": "auto",
      "scroll-padding-inline": "auto",
      "scroll-padding-inline-start": "auto",
      "scroll-padding-inline-end": "auto",
      "scroll-padding-left": "auto",
      "scroll-padding-right": "auto",
      "scroll-padding-top": "auto",
      "scroll-snap-align": "none",
      "scroll-snap-coordinate": "none",
      "scroll-snap-points-x": "none",
      "scroll-snap-points-y": "none",
      "scroll-snap-stop": "normal",
      "scroll-snap-type": "none",
      "scroll-snap-type-x": "none",
      "scroll-snap-type-y": "none",
      "shape-image-threshold": "0.0",
      "shape-margin": "0",
      "shape-outside": "none",
      "tab-size": "8",
      "table-layout": "auto",
      "text-align-last": "auto",
      "text-combine-upright": "none",
      "text-decoration-line": "none",
      "text-decoration-skip-ink": "auto",
      "text-decoration-style": "solid",
      "text-decoration-thickness": "auto",
      "text-emphasis-style": "none",
      "text-indent": "0",
      "text-justify": "auto",
      "text-orientation": "mixed",
      "text-overflow": "clip",
      "text-rendering": "auto",
      "text-shadow": "none",
      "text-transform": "none",
      "text-underline-offset": "auto",
      "text-underline-position": "auto",
      top: "auto",
      "touch-action": "auto",
      transform: "none",
      "transform-style": "flat",
      "transition-delay": "0s",
      "transition-duration": "0s",
      "transition-property": "all",
      "transition-timing-function": "ease",
      translate: "none",
      "unicode-bidi": "normal",
      "user-select": "auto",
      "white-space": "normal",
      widows: "2",
      width: "auto",
      "will-change": "auto",
      "word-break": "normal",
      "word-spacing": "normal",
      "word-wrap": "normal",
      "z-index": "auto"
    };
  }
});

// node_modules/postcss-reduce-initial/src/data/toInitial.json
var require_toInitial = __commonJS({
  "node_modules/postcss-reduce-initial/src/data/toInitial.json"(exports2, module2) {
    module2.exports = {
      "background-clip": "border-box",
      "background-color": "transparent",
      "background-origin": "padding-box",
      "background-size": "auto auto",
      "border-block-color": "currentcolor",
      "border-block-end-color": "currentcolor",
      "border-block-start-color": "currentcolor",
      "border-bottom-color": "currentcolor",
      "border-collapse": "separate",
      "border-inline-color": "currentcolor",
      "border-inline-end-color": "currentcolor",
      "border-inline-start-color": "currentcolor",
      "border-left-color": "currentcolor",
      "border-right-color": "currentcolor",
      "border-top-color": "currentcolor",
      "box-sizing": "content-box",
      "column-rule-color": "currentcolor",
      "font-synthesis": "weight style",
      "image-orientation": "from-image",
      "mask-clip": "border-box",
      "mask-mode": "match-source",
      "mask-origin": "border-box",
      "mask-type": "luminance",
      "ruby-align": "space-around",
      "ruby-merge": "separate",
      "ruby-position": "alternate",
      "text-decoration-color": "currentcolor",
      "text-emphasis-color": "currentcolor",
      "text-emphasis-position": "over right",
      "transform-box": "view-box",
      "transform-origin": "50% 50% 0",
      "vertical-align": "baseline",
      "writing-mode": "horizontal-tb"
    };
  }
});

// node_modules/postcss-reduce-initial/src/index.js
var require_src3 = __commonJS({
  "node_modules/postcss-reduce-initial/src/index.js"(exports2, module2) {
    "use strict";
    var browserslist = require_browserslist();
    var { isSupported } = require_dist3();
    var fromInitial = require_fromInitial();
    var toInitial = require_toInitial();
    var initial = "initial";
    var defaultIgnoreProps = ["writing-mode", "transform-box"];
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-reduce-initial",
        prepare(result) {
          const resultOpts = result.opts || {};
          const browsers = browserslist(null, {
            stats: resultOpts.stats,
            path: __dirname,
            env: resultOpts.env
          });
          const initialSupport = isSupported("css-initial-value", browsers);
          return {
            OnceExit(css) {
              css.walkDecls((decl) => {
                const lowerCasedProp = decl.prop.toLowerCase();
                const ignoreProp = new Set(defaultIgnoreProps.concat(resultOpts.ignore || []));
                if (ignoreProp.has(lowerCasedProp)) {
                  return;
                }
                if (initialSupport && Object.prototype.hasOwnProperty.call(toInitial, lowerCasedProp) && decl.value.toLowerCase() === toInitial[lowerCasedProp]) {
                  decl.value = initial;
                  return;
                }
                if (decl.value.toLowerCase() !== initial || !fromInitial[lowerCasedProp]) {
                  return;
                }
                decl.value = fromInitial[lowerCasedProp];
              });
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/cssnano-utils/src/rawCache.js
var require_rawCache = __commonJS({
  "node_modules/cssnano-utils/src/rawCache.js"(exports2, module2) {
    "use strict";
    function pluginCreator() {
      return {
        postcssPlugin: "cssnano-util-raw-cache",
        OnceExit(css, { result }) {
          result.root.rawCache = {
            colon: ":",
            indent: "",
            beforeDecl: "",
            beforeRule: "",
            beforeOpen: "",
            beforeClose: "",
            beforeComment: "",
            after: "",
            emptyBody: "",
            commentLeft: "",
            commentRight: ""
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/cssnano-utils/src/getArguments.js
var require_getArguments = __commonJS({
  "node_modules/cssnano-utils/src/getArguments.js"(exports2, module2) {
    "use strict";
    module2.exports = function getArguments(node) {
      const list = [[]];
      for (const child of node.nodes) {
        if (child.type !== "div") {
          list[list.length - 1].push(child);
        } else {
          list.push([]);
        }
      }
      return list;
    };
  }
});

// node_modules/cssnano-utils/src/sameParent.js
var require_sameParent = __commonJS({
  "node_modules/cssnano-utils/src/sameParent.js"(exports2, module2) {
    "use strict";
    function checkMatch(nodeA, nodeB) {
      if (nodeA.type === "atrule" && nodeB.type === "atrule") {
        return nodeA.params === nodeB.params && nodeA.name.toLowerCase() === nodeB.name.toLowerCase();
      }
      return nodeA.type === nodeB.type;
    }
    function sameParent(nodeA, nodeB) {
      if (!nodeA.parent) {
        return !nodeB.parent;
      }
      if (!nodeB.parent) {
        return false;
      }
      if (!checkMatch(nodeA.parent, nodeB.parent)) {
        return false;
      }
      return sameParent(nodeA.parent, nodeB.parent);
    }
    module2.exports = sameParent;
  }
});

// node_modules/cssnano-utils/src/index.js
var require_src4 = __commonJS({
  "node_modules/cssnano-utils/src/index.js"(exports2, module2) {
    "use strict";
    var rawCache = require_rawCache();
    var getArguments = require_getArguments();
    var sameParent = require_sameParent();
    module2.exports = { rawCache, getArguments, sameParent };
  }
});

// node_modules/colord/index.js
var require_colord = __commonJS({
  "node_modules/colord/index.js"(exports2) {
    Object.defineProperty(exports2, "__esModule", { value: true });
    var r = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) };
    var t = function(r2) {
      return typeof r2 == "string" ? r2.length > 0 : typeof r2 == "number";
    };
    var n = function(r2, t2, n2) {
      return t2 === void 0 && (t2 = 0), n2 === void 0 && (n2 = Math.pow(10, t2)), Math.round(n2 * r2) / n2 + 0;
    };
    var e = function(r2, t2, n2) {
      return t2 === void 0 && (t2 = 0), n2 === void 0 && (n2 = 1), r2 > n2 ? n2 : r2 > t2 ? r2 : t2;
    };
    var u = function(r2) {
      return (r2 = isFinite(r2) ? r2 % 360 : 0) > 0 ? r2 : r2 + 360;
    };
    var o = function(r2) {
      return { r: e(r2.r, 0, 255), g: e(r2.g, 0, 255), b: e(r2.b, 0, 255), a: e(r2.a) };
    };
    var a = function(r2) {
      return { r: n(r2.r), g: n(r2.g), b: n(r2.b), a: n(r2.a, 3) };
    };
    var s = /^#([0-9a-f]{3,8})$/i;
    var i = function(r2) {
      var t2 = r2.toString(16);
      return t2.length < 2 ? "0" + t2 : t2;
    };
    var h = function(r2) {
      var t2 = r2.r, n2 = r2.g, e2 = r2.b, u2 = r2.a, o2 = Math.max(t2, n2, e2), a2 = o2 - Math.min(t2, n2, e2), s2 = a2 ? o2 === t2 ? (n2 - e2) / a2 : o2 === n2 ? 2 + (e2 - t2) / a2 : 4 + (t2 - n2) / a2 : 0;
      return { h: 60 * (s2 < 0 ? s2 + 6 : s2), s: o2 ? a2 / o2 * 100 : 0, v: o2 / 255 * 100, a: u2 };
    };
    var b = function(r2) {
      var t2 = r2.h, n2 = r2.s, e2 = r2.v, u2 = r2.a;
      t2 = t2 / 360 * 6, n2 /= 100, e2 /= 100;
      var o2 = Math.floor(t2), a2 = e2 * (1 - n2), s2 = e2 * (1 - (t2 - o2) * n2), i2 = e2 * (1 - (1 - t2 + o2) * n2), h2 = o2 % 6;
      return { r: 255 * [e2, s2, a2, a2, i2, e2][h2], g: 255 * [i2, e2, e2, s2, a2, a2][h2], b: 255 * [a2, a2, i2, e2, e2, s2][h2], a: u2 };
    };
    var d = function(r2) {
      return { h: u(r2.h), s: e(r2.s, 0, 100), l: e(r2.l, 0, 100), a: e(r2.a) };
    };
    var g = function(r2) {
      return { h: n(r2.h), s: n(r2.s), l: n(r2.l), a: n(r2.a, 3) };
    };
    var f = function(r2) {
      return b((n2 = (t2 = r2).s, { h: t2.h, s: (n2 *= ((e2 = t2.l) < 50 ? e2 : 100 - e2) / 100) > 0 ? 2 * n2 / (e2 + n2) * 100 : 0, v: e2 + n2, a: t2.a }));
      var t2, n2, e2;
    };
    var p = function(r2) {
      return { h: (t2 = h(r2)).h, s: (u2 = (200 - (n2 = t2.s)) * (e2 = t2.v) / 100) > 0 && u2 < 200 ? n2 * e2 / 100 / (u2 <= 100 ? u2 : 200 - u2) * 100 : 0, l: u2 / 2, a: t2.a };
      var t2, n2, e2, u2;
    };
    var l = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
    var c = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
    var v = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
    var m = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
    var y = { string: [[function(r2) {
      var t2 = s.exec(r2);
      return t2 ? (r2 = t2[1]).length <= 4 ? { r: parseInt(r2[0] + r2[0], 16), g: parseInt(r2[1] + r2[1], 16), b: parseInt(r2[2] + r2[2], 16), a: r2.length === 4 ? n(parseInt(r2[3] + r2[3], 16) / 255, 2) : 1 } : r2.length === 6 || r2.length === 8 ? { r: parseInt(r2.substr(0, 2), 16), g: parseInt(r2.substr(2, 2), 16), b: parseInt(r2.substr(4, 2), 16), a: r2.length === 8 ? n(parseInt(r2.substr(6, 2), 16) / 255, 2) : 1 } : null : null;
    }, "hex"], [function(r2) {
      var t2 = v.exec(r2) || m.exec(r2);
      return t2 ? t2[2] !== t2[4] || t2[4] !== t2[6] ? null : o({ r: Number(t2[1]) / (t2[2] ? 100 / 255 : 1), g: Number(t2[3]) / (t2[4] ? 100 / 255 : 1), b: Number(t2[5]) / (t2[6] ? 100 / 255 : 1), a: t2[7] === void 0 ? 1 : Number(t2[7]) / (t2[8] ? 100 : 1) }) : null;
    }, "rgb"], [function(t2) {
      var n2 = l.exec(t2) || c.exec(t2);
      if (!n2)
        return null;
      var e2, u2, o2 = d({ h: (e2 = n2[1], u2 = n2[2], u2 === void 0 && (u2 = "deg"), Number(e2) * (r[u2] || 1)), s: Number(n2[3]), l: Number(n2[4]), a: n2[5] === void 0 ? 1 : Number(n2[5]) / (n2[6] ? 100 : 1) });
      return f(o2);
    }, "hsl"]], object: [[function(r2) {
      var n2 = r2.r, e2 = r2.g, u2 = r2.b, a2 = r2.a, s2 = a2 === void 0 ? 1 : a2;
      return t(n2) && t(e2) && t(u2) ? o({ r: Number(n2), g: Number(e2), b: Number(u2), a: Number(s2) }) : null;
    }, "rgb"], [function(r2) {
      var n2 = r2.h, e2 = r2.s, u2 = r2.l, o2 = r2.a, a2 = o2 === void 0 ? 1 : o2;
      if (!t(n2) || !t(e2) || !t(u2))
        return null;
      var s2 = d({ h: Number(n2), s: Number(e2), l: Number(u2), a: Number(a2) });
      return f(s2);
    }, "hsl"], [function(r2) {
      var n2 = r2.h, o2 = r2.s, a2 = r2.v, s2 = r2.a, i2 = s2 === void 0 ? 1 : s2;
      if (!t(n2) || !t(o2) || !t(a2))
        return null;
      var h2 = function(r3) {
        return { h: u(r3.h), s: e(r3.s, 0, 100), v: e(r3.v, 0, 100), a: e(r3.a) };
      }({ h: Number(n2), s: Number(o2), v: Number(a2), a: Number(i2) });
      return b(h2);
    }, "hsv"]] };
    var N = function(r2, t2) {
      for (var n2 = 0; n2 < t2.length; n2++) {
        var e2 = t2[n2][0](r2);
        if (e2)
          return [e2, t2[n2][1]];
      }
      return [null, void 0];
    };
    var x = function(r2) {
      return typeof r2 == "string" ? N(r2.trim(), y.string) : typeof r2 == "object" && r2 !== null ? N(r2, y.object) : [null, void 0];
    };
    var M = function(r2, t2) {
      var n2 = p(r2);
      return { h: n2.h, s: e(n2.s + 100 * t2, 0, 100), l: n2.l, a: n2.a };
    };
    var I = function(r2) {
      return (299 * r2.r + 587 * r2.g + 114 * r2.b) / 1e3 / 255;
    };
    var H = function(r2, t2) {
      var n2 = p(r2);
      return { h: n2.h, s: n2.s, l: e(n2.l + 100 * t2, 0, 100), a: n2.a };
    };
    var $ = function() {
      function r2(r3) {
        this.parsed = x(r3)[0], this.rgba = this.parsed || { r: 0, g: 0, b: 0, a: 1 };
      }
      return r2.prototype.isValid = function() {
        return this.parsed !== null;
      }, r2.prototype.brightness = function() {
        return n(I(this.rgba), 2);
      }, r2.prototype.isDark = function() {
        return I(this.rgba) < 0.5;
      }, r2.prototype.isLight = function() {
        return I(this.rgba) >= 0.5;
      }, r2.prototype.toHex = function() {
        return r3 = a(this.rgba), t2 = r3.r, e2 = r3.g, u2 = r3.b, s2 = (o2 = r3.a) < 1 ? i(n(255 * o2)) : "", "#" + i(t2) + i(e2) + i(u2) + s2;
        var r3, t2, e2, u2, o2, s2;
      }, r2.prototype.toRgb = function() {
        return a(this.rgba);
      }, r2.prototype.toRgbString = function() {
        return r3 = a(this.rgba), t2 = r3.r, n2 = r3.g, e2 = r3.b, (u2 = r3.a) < 1 ? "rgba(" + t2 + ", " + n2 + ", " + e2 + ", " + u2 + ")" : "rgb(" + t2 + ", " + n2 + ", " + e2 + ")";
        var r3, t2, n2, e2, u2;
      }, r2.prototype.toHsl = function() {
        return g(p(this.rgba));
      }, r2.prototype.toHslString = function() {
        return r3 = g(p(this.rgba)), t2 = r3.h, n2 = r3.s, e2 = r3.l, (u2 = r3.a) < 1 ? "hsla(" + t2 + ", " + n2 + "%, " + e2 + "%, " + u2 + ")" : "hsl(" + t2 + ", " + n2 + "%, " + e2 + "%)";
        var r3, t2, n2, e2, u2;
      }, r2.prototype.toHsv = function() {
        return r3 = h(this.rgba), { h: n(r3.h), s: n(r3.s), v: n(r3.v), a: n(r3.a, 3) };
        var r3;
      }, r2.prototype.invert = function() {
        return j({ r: 255 - (r3 = this.rgba).r, g: 255 - r3.g, b: 255 - r3.b, a: r3.a });
        var r3;
      }, r2.prototype.saturate = function(r3) {
        return r3 === void 0 && (r3 = 0.1), j(M(this.rgba, r3));
      }, r2.prototype.desaturate = function(r3) {
        return r3 === void 0 && (r3 = 0.1), j(M(this.rgba, -r3));
      }, r2.prototype.grayscale = function() {
        return j(M(this.rgba, -1));
      }, r2.prototype.lighten = function(r3) {
        return r3 === void 0 && (r3 = 0.1), j(H(this.rgba, r3));
      }, r2.prototype.darken = function(r3) {
        return r3 === void 0 && (r3 = 0.1), j(H(this.rgba, -r3));
      }, r2.prototype.rotate = function(r3) {
        return r3 === void 0 && (r3 = 15), this.hue(this.hue() + r3);
      }, r2.prototype.alpha = function(r3) {
        return typeof r3 == "number" ? j({ r: (t2 = this.rgba).r, g: t2.g, b: t2.b, a: r3 }) : n(this.rgba.a, 3);
        var t2;
      }, r2.prototype.hue = function(r3) {
        var t2 = p(this.rgba);
        return typeof r3 == "number" ? j({ h: r3, s: t2.s, l: t2.l, a: t2.a }) : n(t2.h);
      }, r2.prototype.isEqual = function(r3) {
        return this.toHex() === j(r3).toHex();
      }, r2;
    }();
    var j = function(r2) {
      return r2 instanceof $ ? r2 : new $(r2);
    };
    var w = [];
    exports2.Colord = $, exports2.colord = j, exports2.extend = function(r2) {
      r2.forEach(function(r3) {
        w.indexOf(r3) < 0 && (r3($, y), w.push(r3));
      });
    }, exports2.getFormat = function(r2) {
      return x(r2)[1];
    }, exports2.random = function() {
      return new $({ r: 255 * Math.random(), g: 255 * Math.random(), b: 255 * Math.random() });
    };
  }
});

// node_modules/colord/plugins/names.js
var require_names = __commonJS({
  "node_modules/colord/plugins/names.js"(exports2, module2) {
    module2.exports = function(e, f) {
      var a = { white: "#ffffff", bisque: "#ffe4c4", blue: "#0000ff", cadetblue: "#5f9ea0", chartreuse: "#7fff00", chocolate: "#d2691e", coral: "#ff7f50", antiquewhite: "#faebd7", aqua: "#00ffff", azure: "#f0ffff", whitesmoke: "#f5f5f5", papayawhip: "#ffefd5", plum: "#dda0dd", blanchedalmond: "#ffebcd", black: "#000000", gold: "#ffd700", goldenrod: "#daa520", gainsboro: "#dcdcdc", cornsilk: "#fff8dc", cornflowerblue: "#6495ed", burlywood: "#deb887", aquamarine: "#7fffd4", beige: "#f5f5dc", crimson: "#dc143c", cyan: "#00ffff", darkblue: "#00008b", darkcyan: "#008b8b", darkgoldenrod: "#b8860b", darkkhaki: "#bdb76b", darkgray: "#a9a9a9", darkgreen: "#006400", darkgrey: "#a9a9a9", peachpuff: "#ffdab9", darkmagenta: "#8b008b", darkred: "#8b0000", darkorchid: "#9932cc", darkorange: "#ff8c00", darkslateblue: "#483d8b", gray: "#808080", darkslategray: "#2f4f4f", darkslategrey: "#2f4f4f", deeppink: "#ff1493", deepskyblue: "#00bfff", wheat: "#f5deb3", firebrick: "#b22222", floralwhite: "#fffaf0", ghostwhite: "#f8f8ff", darkviolet: "#9400d3", magenta: "#ff00ff", green: "#008000", dodgerblue: "#1e90ff", grey: "#808080", honeydew: "#f0fff0", hotpink: "#ff69b4", blueviolet: "#8a2be2", forestgreen: "#228b22", lawngreen: "#7cfc00", indianred: "#cd5c5c", indigo: "#4b0082", fuchsia: "#ff00ff", brown: "#a52a2a", maroon: "#800000", mediumblue: "#0000cd", lightcoral: "#f08080", darkturquoise: "#00ced1", lightcyan: "#e0ffff", ivory: "#fffff0", lightyellow: "#ffffe0", lightsalmon: "#ffa07a", lightseagreen: "#20b2aa", linen: "#faf0e6", mediumaquamarine: "#66cdaa", lemonchiffon: "#fffacd", lime: "#00ff00", khaki: "#f0e68c", mediumseagreen: "#3cb371", limegreen: "#32cd32", mediumspringgreen: "#00fa9a", lightskyblue: "#87cefa", lightblue: "#add8e6", midnightblue: "#191970", lightpink: "#ffb6c1", mistyrose: "#ffe4e1", moccasin: "#ffe4b5", mintcream: "#f5fffa", lightslategray: "#778899", lightslategrey: "#778899", navajowhite: "#ffdead", navy: "#000080", mediumvioletred: "#c71585", powderblue: "#b0e0e6", palegoldenrod: "#eee8aa", oldlace: "#fdf5e6", paleturquoise: "#afeeee", mediumturquoise: "#48d1cc", mediumorchid: "#ba55d3", rebeccapurple: "#663399", lightsteelblue: "#b0c4de", mediumslateblue: "#7b68ee", thistle: "#d8bfd8", tan: "#d2b48c", orchid: "#da70d6", mediumpurple: "#9370db", purple: "#800080", pink: "#ffc0cb", skyblue: "#87ceeb", springgreen: "#00ff7f", palegreen: "#98fb98", red: "#ff0000", yellow: "#ffff00", slateblue: "#6a5acd", lavenderblush: "#fff0f5", peru: "#cd853f", palevioletred: "#db7093", violet: "#ee82ee", teal: "#008080", slategray: "#708090", slategrey: "#708090", aliceblue: "#f0f8ff", darkseagreen: "#8fbc8f", darkolivegreen: "#556b2f", greenyellow: "#adff2f", seagreen: "#2e8b57", seashell: "#fff5ee", tomato: "#ff6347", silver: "#c0c0c0", sienna: "#a0522d", lavender: "#e6e6fa", lightgreen: "#90ee90", orange: "#ffa500", orangered: "#ff4500", steelblue: "#4682b4", royalblue: "#4169e1", turquoise: "#40e0d0", yellowgreen: "#9acd32", salmon: "#fa8072", saddlebrown: "#8b4513", sandybrown: "#f4a460", rosybrown: "#bc8f8f", darksalmon: "#e9967a", lightgoldenrodyellow: "#fafad2", snow: "#fffafa", lightgrey: "#d3d3d3", lightgray: "#d3d3d3", dimgray: "#696969", dimgrey: "#696969", olivedrab: "#6b8e23", olive: "#808000" }, r = {};
      for (var d in a)
        r[a[d]] = d;
      var l = {};
      e.prototype.toName = function(f2) {
        if (!(this.rgba.a || this.rgba.r || this.rgba.g || this.rgba.b))
          return "transparent";
        var d2, i, o = r[this.toHex()];
        if (o)
          return o;
        if (f2 == null ? void 0 : f2.closest) {
          var n = this.toRgb(), t = 1 / 0, b = "black";
          if (!l.length)
            for (var c in a)
              l[c] = new e(a[c]).toRgb();
          for (var g in a) {
            var u = (d2 = n, i = l[g], Math.pow(d2.r - i.r, 2) + Math.pow(d2.g - i.g, 2) + Math.pow(d2.b - i.b, 2));
            u < t && (t = u, b = g);
          }
          return b;
        }
      };
      f.string.push([function(f2) {
        var r2 = f2.toLowerCase(), d2 = r2 === "transparent" ? "#0000" : a[r2];
        return d2 ? new e(d2).toRgb() : null;
      }, "name"]);
    };
  }
});

// node_modules/postcss-minify-gradients/src/isColorStop.js
var require_isColorStop = __commonJS({
  "node_modules/postcss-minify-gradients/src/isColorStop.js"(exports2, module2) {
    "use strict";
    var { unit } = require_lib();
    var { colord, extend } = require_colord();
    var namesPlugin = require_names();
    extend([namesPlugin]);
    var lengthUnits = /* @__PURE__ */ new Set([
      "PX",
      "IN",
      "CM",
      "MM",
      "EM",
      "REM",
      "POINTS",
      "PC",
      "EX",
      "CH",
      "VW",
      "VH",
      "VMIN",
      "VMAX",
      "%"
    ]);
    function isCSSLengthUnit(input) {
      return lengthUnits.has(input.toUpperCase());
    }
    function isStop(str) {
      if (str) {
        let stop = false;
        const node = unit(str);
        if (node) {
          const number = Number(node.number);
          if (number === 0 || !isNaN(number) && isCSSLengthUnit(node.unit)) {
            stop = true;
          }
        } else {
          stop = /^calc\(\S+\)$/g.test(str);
        }
        return stop;
      }
      return true;
    }
    module2.exports = function isColorStop(color, stop) {
      return colord(color).isValid() && isStop(stop);
    };
  }
});

// node_modules/postcss-minify-gradients/src/index.js
var require_src5 = __commonJS({
  "node_modules/postcss-minify-gradients/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var { getArguments } = require_src4();
    var isColorStop = require_isColorStop();
    var angles = {
      top: "0deg",
      right: "90deg",
      bottom: "180deg",
      left: "270deg"
    };
    function isLessThan(a, b) {
      return a.unit.toLowerCase() === b.unit.toLowerCase() && parseFloat(a.number) >= parseFloat(b.number);
    }
    function optimise(decl) {
      const value = decl.value;
      if (!value) {
        return;
      }
      const normalizedValue = value.toLowerCase();
      if (normalizedValue.includes("var(") || normalizedValue.includes("env(")) {
        return;
      }
      if (!normalizedValue.includes("gradient")) {
        return;
      }
      decl.value = valueParser(value).walk((node) => {
        if (node.type !== "function" || !node.nodes.length) {
          return false;
        }
        const lowerCasedValue = node.value.toLowerCase();
        if (lowerCasedValue === "linear-gradient" || lowerCasedValue === "repeating-linear-gradient" || lowerCasedValue === "-webkit-linear-gradient" || lowerCasedValue === "-webkit-repeating-linear-gradient") {
          let args = getArguments(node);
          if (node.nodes[0].value.toLowerCase() === "to" && args[0].length === 3) {
            node.nodes = node.nodes.slice(2);
            node.nodes[0].value = angles[node.nodes[0].value.toLowerCase()];
          }
          let lastStop;
          args.forEach((arg, index) => {
            if (arg.length !== 3) {
              return;
            }
            let isFinalStop = index === args.length - 1;
            let thisStop = valueParser.unit(arg[2].value);
            if (lastStop === void 0) {
              lastStop = thisStop;
              if (!isFinalStop && lastStop && lastStop.number === "0" && lastStop.unit.toLowerCase() !== "deg") {
                arg[1].value = arg[2].value = "";
              }
              return;
            }
            if (lastStop && thisStop && isLessThan(lastStop, thisStop)) {
              arg[2].value = "0";
            }
            lastStop = thisStop;
            if (isFinalStop && arg[2].value === "100%") {
              arg[1].value = arg[2].value = "";
            }
          });
          return false;
        }
        if (lowerCasedValue === "radial-gradient" || lowerCasedValue === "repeating-radial-gradient") {
          let args = getArguments(node);
          let lastStop;
          const hasAt = args[0].find((n) => n.value.toLowerCase() === "at");
          args.forEach((arg, index) => {
            if (!arg[2] || !index && hasAt) {
              return;
            }
            let thisStop = valueParser.unit(arg[2].value);
            if (!lastStop) {
              lastStop = thisStop;
              return;
            }
            if (lastStop && thisStop && isLessThan(lastStop, thisStop)) {
              arg[2].value = "0";
            }
            lastStop = thisStop;
          });
          return false;
        }
        if (lowerCasedValue === "-webkit-radial-gradient" || lowerCasedValue === "-webkit-repeating-radial-gradient") {
          let args = getArguments(node);
          let lastStop;
          args.forEach((arg) => {
            let color;
            let stop;
            if (arg[2] !== void 0) {
              if (arg[0].type === "function") {
                color = `${arg[0].value}(${valueParser.stringify(arg[0].nodes)})`;
              } else {
                color = arg[0].value;
              }
              if (arg[2].type === "function") {
                stop = `${arg[2].value}(${valueParser.stringify(arg[2].nodes)})`;
              } else {
                stop = arg[2].value;
              }
            } else {
              if (arg[0].type === "function") {
                color = `${arg[0].value}(${valueParser.stringify(arg[0].nodes)})`;
              }
              color = arg[0].value;
            }
            color = color.toLowerCase();
            const colorStop = stop !== void 0 ? isColorStop(color, stop.toLowerCase()) : isColorStop(color);
            if (!colorStop || !arg[2]) {
              return;
            }
            let thisStop = valueParser.unit(arg[2].value);
            if (!lastStop) {
              lastStop = thisStop;
              return;
            }
            if (lastStop && thisStop && isLessThan(lastStop, thisStop)) {
              arg[2].value = "0";
            }
            lastStop = thisStop;
          });
          return false;
        }
      }).toString();
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-minify-gradients",
        OnceExit(css) {
          css.walkDecls(optimise);
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/domelementtype/lib/index.js
var require_lib2 = __commonJS({
  "node_modules/domelementtype/lib/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Doctype = exports2.CDATA = exports2.Tag = exports2.Style = exports2.Script = exports2.Comment = exports2.Directive = exports2.Text = exports2.Root = exports2.isTag = exports2.ElementType = void 0;
    var ElementType;
    (function(ElementType2) {
      ElementType2["Root"] = "root";
      ElementType2["Text"] = "text";
      ElementType2["Directive"] = "directive";
      ElementType2["Comment"] = "comment";
      ElementType2["Script"] = "script";
      ElementType2["Style"] = "style";
      ElementType2["Tag"] = "tag";
      ElementType2["CDATA"] = "cdata";
      ElementType2["Doctype"] = "doctype";
    })(ElementType = exports2.ElementType || (exports2.ElementType = {}));
    function isTag(elem) {
      return elem.type === ElementType.Tag || elem.type === ElementType.Script || elem.type === ElementType.Style;
    }
    exports2.isTag = isTag;
    exports2.Root = ElementType.Root;
    exports2.Text = ElementType.Text;
    exports2.Directive = ElementType.Directive;
    exports2.Comment = ElementType.Comment;
    exports2.Script = ElementType.Script;
    exports2.Style = ElementType.Style;
    exports2.Tag = ElementType.Tag;
    exports2.CDATA = ElementType.CDATA;
    exports2.Doctype = ElementType.Doctype;
  }
});

// node_modules/domhandler/lib/node.js
var require_node3 = __commonJS({
  "node_modules/domhandler/lib/node.js"(exports2) {
    "use strict";
    var __extends = exports2 && exports2.__extends || function() {
      var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
          d2.__proto__ = b2;
        } || function(d2, b2) {
          for (var p in b2)
            if (Object.prototype.hasOwnProperty.call(b2, p))
              d2[p] = b2[p];
        };
        return extendStatics(d, b);
      };
      return function(d, b) {
        if (typeof b !== "function" && b !== null)
          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() {
          this.constructor = d;
        }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
    }();
    var __assign = exports2 && exports2.__assign || function() {
      __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
          s = arguments[i];
          for (var p in s)
            if (Object.prototype.hasOwnProperty.call(s, p))
              t[p] = s[p];
        }
        return t;
      };
      return __assign.apply(this, arguments);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.cloneNode = exports2.hasChildren = exports2.isDocument = exports2.isDirective = exports2.isComment = exports2.isText = exports2.isCDATA = exports2.isTag = exports2.Element = exports2.Document = exports2.NodeWithChildren = exports2.ProcessingInstruction = exports2.Comment = exports2.Text = exports2.DataNode = exports2.Node = void 0;
    var domelementtype_1 = require_lib2();
    var nodeTypes = /* @__PURE__ */ new Map([
      [domelementtype_1.ElementType.Tag, 1],
      [domelementtype_1.ElementType.Script, 1],
      [domelementtype_1.ElementType.Style, 1],
      [domelementtype_1.ElementType.Directive, 1],
      [domelementtype_1.ElementType.Text, 3],
      [domelementtype_1.ElementType.CDATA, 4],
      [domelementtype_1.ElementType.Comment, 8],
      [domelementtype_1.ElementType.Root, 9]
    ]);
    var Node = function() {
      function Node2(type) {
        this.type = type;
        this.parent = null;
        this.prev = null;
        this.next = null;
        this.startIndex = null;
        this.endIndex = null;
      }
      Object.defineProperty(Node2.prototype, "nodeType", {
        get: function() {
          var _a;
          return (_a = nodeTypes.get(this.type)) !== null && _a !== void 0 ? _a : 1;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(Node2.prototype, "parentNode", {
        get: function() {
          return this.parent;
        },
        set: function(parent) {
          this.parent = parent;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(Node2.prototype, "previousSibling", {
        get: function() {
          return this.prev;
        },
        set: function(prev) {
          this.prev = prev;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(Node2.prototype, "nextSibling", {
        get: function() {
          return this.next;
        },
        set: function(next) {
          this.next = next;
        },
        enumerable: false,
        configurable: true
      });
      Node2.prototype.cloneNode = function(recursive) {
        if (recursive === void 0) {
          recursive = false;
        }
        return cloneNode(this, recursive);
      };
      return Node2;
    }();
    exports2.Node = Node;
    var DataNode = function(_super) {
      __extends(DataNode2, _super);
      function DataNode2(type, data) {
        var _this = _super.call(this, type) || this;
        _this.data = data;
        return _this;
      }
      Object.defineProperty(DataNode2.prototype, "nodeValue", {
        get: function() {
          return this.data;
        },
        set: function(data) {
          this.data = data;
        },
        enumerable: false,
        configurable: true
      });
      return DataNode2;
    }(Node);
    exports2.DataNode = DataNode;
    var Text = function(_super) {
      __extends(Text2, _super);
      function Text2(data) {
        return _super.call(this, domelementtype_1.ElementType.Text, data) || this;
      }
      return Text2;
    }(DataNode);
    exports2.Text = Text;
    var Comment = function(_super) {
      __extends(Comment2, _super);
      function Comment2(data) {
        return _super.call(this, domelementtype_1.ElementType.Comment, data) || this;
      }
      return Comment2;
    }(DataNode);
    exports2.Comment = Comment;
    var ProcessingInstruction = function(_super) {
      __extends(ProcessingInstruction2, _super);
      function ProcessingInstruction2(name, data) {
        var _this = _super.call(this, domelementtype_1.ElementType.Directive, data) || this;
        _this.name = name;
        return _this;
      }
      return ProcessingInstruction2;
    }(DataNode);
    exports2.ProcessingInstruction = ProcessingInstruction;
    var NodeWithChildren = function(_super) {
      __extends(NodeWithChildren2, _super);
      function NodeWithChildren2(type, children) {
        var _this = _super.call(this, type) || this;
        _this.children = children;
        return _this;
      }
      Object.defineProperty(NodeWithChildren2.prototype, "firstChild", {
        get: function() {
          var _a;
          return (_a = this.children[0]) !== null && _a !== void 0 ? _a : null;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(NodeWithChildren2.prototype, "lastChild", {
        get: function() {
          return this.children.length > 0 ? this.children[this.children.length - 1] : null;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(NodeWithChildren2.prototype, "childNodes", {
        get: function() {
          return this.children;
        },
        set: function(children) {
          this.children = children;
        },
        enumerable: false,
        configurable: true
      });
      return NodeWithChildren2;
    }(Node);
    exports2.NodeWithChildren = NodeWithChildren;
    var Document = function(_super) {
      __extends(Document2, _super);
      function Document2(children) {
        return _super.call(this, domelementtype_1.ElementType.Root, children) || this;
      }
      return Document2;
    }(NodeWithChildren);
    exports2.Document = Document;
    var Element = function(_super) {
      __extends(Element2, _super);
      function Element2(name, attribs, children, type) {
        if (children === void 0) {
          children = [];
        }
        if (type === void 0) {
          type = name === "script" ? domelementtype_1.ElementType.Script : name === "style" ? domelementtype_1.ElementType.Style : domelementtype_1.ElementType.Tag;
        }
        var _this = _super.call(this, type, children) || this;
        _this.name = name;
        _this.attribs = attribs;
        return _this;
      }
      Object.defineProperty(Element2.prototype, "tagName", {
        get: function() {
          return this.name;
        },
        set: function(name) {
          this.name = name;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(Element2.prototype, "attributes", {
        get: function() {
          var _this = this;
          return Object.keys(this.attribs).map(function(name) {
            var _a, _b;
            return {
              name,
              value: _this.attribs[name],
              namespace: (_a = _this["x-attribsNamespace"]) === null || _a === void 0 ? void 0 : _a[name],
              prefix: (_b = _this["x-attribsPrefix"]) === null || _b === void 0 ? void 0 : _b[name]
            };
          });
        },
        enumerable: false,
        configurable: true
      });
      return Element2;
    }(NodeWithChildren);
    exports2.Element = Element;
    function isTag(node) {
      return (0, domelementtype_1.isTag)(node);
    }
    exports2.isTag = isTag;
    function isCDATA(node) {
      return node.type === domelementtype_1.ElementType.CDATA;
    }
    exports2.isCDATA = isCDATA;
    function isText(node) {
      return node.type === domelementtype_1.ElementType.Text;
    }
    exports2.isText = isText;
    function isComment(node) {
      return node.type === domelementtype_1.ElementType.Comment;
    }
    exports2.isComment = isComment;
    function isDirective(node) {
      return node.type === domelementtype_1.ElementType.Directive;
    }
    exports2.isDirective = isDirective;
    function isDocument(node) {
      return node.type === domelementtype_1.ElementType.Root;
    }
    exports2.isDocument = isDocument;
    function hasChildren(node) {
      return Object.prototype.hasOwnProperty.call(node, "children");
    }
    exports2.hasChildren = hasChildren;
    function cloneNode(node, recursive) {
      if (recursive === void 0) {
        recursive = false;
      }
      var result;
      if (isText(node)) {
        result = new Text(node.data);
      } else if (isComment(node)) {
        result = new Comment(node.data);
      } else if (isTag(node)) {
        var children = recursive ? cloneChildren(node.children) : [];
        var clone_1 = new Element(node.name, __assign({}, node.attribs), children);
        children.forEach(function(child) {
          return child.parent = clone_1;
        });
        if (node.namespace != null) {
          clone_1.namespace = node.namespace;
        }
        if (node["x-attribsNamespace"]) {
          clone_1["x-attribsNamespace"] = __assign({}, node["x-attribsNamespace"]);
        }
        if (node["x-attribsPrefix"]) {
          clone_1["x-attribsPrefix"] = __assign({}, node["x-attribsPrefix"]);
        }
        result = clone_1;
      } else if (isCDATA(node)) {
        var children = recursive ? cloneChildren(node.children) : [];
        var clone_2 = new NodeWithChildren(domelementtype_1.ElementType.CDATA, children);
        children.forEach(function(child) {
          return child.parent = clone_2;
        });
        result = clone_2;
      } else if (isDocument(node)) {
        var children = recursive ? cloneChildren(node.children) : [];
        var clone_3 = new Document(children);
        children.forEach(function(child) {
          return child.parent = clone_3;
        });
        if (node["x-mode"]) {
          clone_3["x-mode"] = node["x-mode"];
        }
        result = clone_3;
      } else if (isDirective(node)) {
        var instruction = new ProcessingInstruction(node.name, node.data);
        if (node["x-name"] != null) {
          instruction["x-name"] = node["x-name"];
          instruction["x-publicId"] = node["x-publicId"];
          instruction["x-systemId"] = node["x-systemId"];
        }
        result = instruction;
      } else {
        throw new Error("Not implemented yet: ".concat(node.type));
      }
      result.startIndex = node.startIndex;
      result.endIndex = node.endIndex;
      if (node.sourceCodeLocation != null) {
        result.sourceCodeLocation = node.sourceCodeLocation;
      }
      return result;
    }
    exports2.cloneNode = cloneNode;
    function cloneChildren(childs) {
      var children = childs.map(function(child) {
        return cloneNode(child, true);
      });
      for (var i = 1; i < children.length; i++) {
        children[i].prev = children[i - 1];
        children[i - 1].next = children[i];
      }
      return children;
    }
  }
});

// node_modules/domhandler/lib/index.js
var require_lib3 = __commonJS({
  "node_modules/domhandler/lib/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m)
        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
          __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.DomHandler = void 0;
    var domelementtype_1 = require_lib2();
    var node_1 = require_node3();
    __exportStar(require_node3(), exports2);
    var reWhitespace = /\s+/g;
    var defaultOpts = {
      normalizeWhitespace: false,
      withStartIndices: false,
      withEndIndices: false,
      xmlMode: false
    };
    var DomHandler = function() {
      function DomHandler2(callback, options, elementCB) {
        this.dom = [];
        this.root = new node_1.Document(this.dom);
        this.done = false;
        this.tagStack = [this.root];
        this.lastNode = null;
        this.parser = null;
        if (typeof options === "function") {
          elementCB = options;
          options = defaultOpts;
        }
        if (typeof callback === "object") {
          options = callback;
          callback = void 0;
        }
        this.callback = callback !== null && callback !== void 0 ? callback : null;
        this.options = options !== null && options !== void 0 ? options : defaultOpts;
        this.elementCB = elementCB !== null && elementCB !== void 0 ? elementCB : null;
      }
      DomHandler2.prototype.onparserinit = function(parser) {
        this.parser = parser;
      };
      DomHandler2.prototype.onreset = function() {
        this.dom = [];
        this.root = new node_1.Document(this.dom);
        this.done = false;
        this.tagStack = [this.root];
        this.lastNode = null;
        this.parser = null;
      };
      DomHandler2.prototype.onend = function() {
        if (this.done)
          return;
        this.done = true;
        this.parser = null;
        this.handleCallback(null);
      };
      DomHandler2.prototype.onerror = function(error) {
        this.handleCallback(error);
      };
      DomHandler2.prototype.onclosetag = function() {
        this.lastNode = null;
        var elem = this.tagStack.pop();
        if (this.options.withEndIndices) {
          elem.endIndex = this.parser.endIndex;
        }
        if (this.elementCB)
          this.elementCB(elem);
      };
      DomHandler2.prototype.onopentag = function(name, attribs) {
        var type = this.options.xmlMode ? domelementtype_1.ElementType.Tag : void 0;
        var element = new node_1.Element(name, attribs, void 0, type);
        this.addNode(element);
        this.tagStack.push(element);
      };
      DomHandler2.prototype.ontext = function(data) {
        var normalizeWhitespace = this.options.normalizeWhitespace;
        var lastNode = this.lastNode;
        if (lastNode && lastNode.type === domelementtype_1.ElementType.Text) {
          if (normalizeWhitespace) {
            lastNode.data = (lastNode.data + data).replace(reWhitespace, " ");
          } else {
            lastNode.data += data;
          }
          if (this.options.withEndIndices) {
            lastNode.endIndex = this.parser.endIndex;
          }
        } else {
          if (normalizeWhitespace) {
            data = data.replace(reWhitespace, " ");
          }
          var node = new node_1.Text(data);
          this.addNode(node);
          this.lastNode = node;
        }
      };
      DomHandler2.prototype.oncomment = function(data) {
        if (this.lastNode && this.lastNode.type === domelementtype_1.ElementType.Comment) {
          this.lastNode.data += data;
          return;
        }
        var node = new node_1.Comment(data);
        this.addNode(node);
        this.lastNode = node;
      };
      DomHandler2.prototype.oncommentend = function() {
        this.lastNode = null;
      };
      DomHandler2.prototype.oncdatastart = function() {
        var text = new node_1.Text("");
        var node = new node_1.NodeWithChildren(domelementtype_1.ElementType.CDATA, [text]);
        this.addNode(node);
        text.parent = node;
        this.lastNode = text;
      };
      DomHandler2.prototype.oncdataend = function() {
        this.lastNode = null;
      };
      DomHandler2.prototype.onprocessinginstruction = function(name, data) {
        var node = new node_1.ProcessingInstruction(name, data);
        this.addNode(node);
      };
      DomHandler2.prototype.handleCallback = function(error) {
        if (typeof this.callback === "function") {
          this.callback(error, this.dom);
        } else if (error) {
          throw error;
        }
      };
      DomHandler2.prototype.addNode = function(node) {
        var parent = this.tagStack[this.tagStack.length - 1];
        var previousSibling = parent.children[parent.children.length - 1];
        if (this.options.withStartIndices) {
          node.startIndex = this.parser.startIndex;
        }
        if (this.options.withEndIndices) {
          node.endIndex = this.parser.endIndex;
        }
        parent.children.push(node);
        if (previousSibling) {
          node.prev = previousSibling;
          previousSibling.next = node;
        }
        node.parent = parent;
        this.lastNode = null;
      };
      return DomHandler2;
    }();
    exports2.DomHandler = DomHandler;
    exports2.default = DomHandler;
  }
});

// node_modules/entities/lib/maps/entities.json
var require_entities = __commonJS({
  "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/entities/lib/maps/legacy.json
var require_legacy = __commonJS({
  "node_modules/entities/lib/maps/legacy.json"(exports2, module2) {
    module2.exports = { Aacute: "\xC1", aacute: "\xE1", Acirc: "\xC2", acirc: "\xE2", acute: "\xB4", AElig: "\xC6", aelig: "\xE6", Agrave: "\xC0", agrave: "\xE0", amp: "&", AMP: "&", Aring: "\xC5", aring: "\xE5", Atilde: "\xC3", atilde: "\xE3", Auml: "\xC4", auml: "\xE4", brvbar: "\xA6", Ccedil: "\xC7", ccedil: "\xE7", cedil: "\xB8", cent: "\xA2", copy: "\xA9", COPY: "\xA9", curren: "\xA4", deg: "\xB0", divide: "\xF7", Eacute: "\xC9", eacute: "\xE9", Ecirc: "\xCA", ecirc: "\xEA", Egrave: "\xC8", egrave: "\xE8", ETH: "\xD0", eth: "\xF0", Euml: "\xCB", euml: "\xEB", frac12: "\xBD", frac14: "\xBC", frac34: "\xBE", gt: ">", GT: ">", Iacute: "\xCD", iacute: "\xED", Icirc: "\xCE", icirc: "\xEE", iexcl: "\xA1", Igrave: "\xCC", igrave: "\xEC", iquest: "\xBF", Iuml: "\xCF", iuml: "\xEF", laquo: "\xAB", lt: "<", LT: "<", macr: "\xAF", micro: "\xB5", middot: "\xB7", nbsp: "\xA0", not: "\xAC", Ntilde: "\xD1", ntilde: "\xF1", Oacute: "\xD3", oacute: "\xF3", Ocirc: "\xD4", ocirc: "\xF4", Ograve: "\xD2", ograve: "\xF2", ordf: "\xAA", ordm: "\xBA", Oslash: "\xD8", oslash: "\xF8", Otilde: "\xD5", otilde: "\xF5", Ouml: "\xD6", ouml: "\xF6", para: "\xB6", plusmn: "\xB1", pound: "\xA3", quot: '"', QUOT: '"', raquo: "\xBB", reg: "\xAE", REG: "\xAE", sect: "\xA7", shy: "\xAD", sup1: "\xB9", sup2: "\xB2", sup3: "\xB3", szlig: "\xDF", THORN: "\xDE", thorn: "\xFE", times: "\xD7", Uacute: "\xDA", uacute: "\xFA", Ucirc: "\xDB", ucirc: "\xFB", Ugrave: "\xD9", ugrave: "\xF9", uml: "\xA8", Uuml: "\xDC", uuml: "\xFC", Yacute: "\xDD", yacute: "\xFD", yen: "\xA5", yuml: "\xFF" };
  }
});

// node_modules/entities/lib/maps/xml.json
var require_xml = __commonJS({
  "node_modules/entities/lib/maps/xml.json"(exports2, module2) {
    module2.exports = { amp: "&", apos: "'", gt: ">", lt: "<", quot: '"' };
  }
});

// node_modules/entities/lib/maps/decode.json
var require_decode = __commonJS({
  "node_modules/entities/lib/maps/decode.json"(exports2, module2) {
    module2.exports = { "0": 65533, "128": 8364, "130": 8218, "131": 402, "132": 8222, "133": 8230, "134": 8224, "135": 8225, "136": 710, "137": 8240, "138": 352, "139": 8249, "140": 338, "142": 381, "145": 8216, "146": 8217, "147": 8220, "148": 8221, "149": 8226, "150": 8211, "151": 8212, "152": 732, "153": 8482, "154": 353, "155": 8250, "156": 339, "158": 382, "159": 376 };
  }
});

// node_modules/entities/lib/decode_codepoint.js
var require_decode_codepoint = __commonJS({
  "node_modules/entities/lib/decode_codepoint.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var decode_json_1 = __importDefault(require_decode());
    var fromCodePoint = String.fromCodePoint || function(codePoint) {
      var output = "";
      if (codePoint > 65535) {
        codePoint -= 65536;
        output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296);
        codePoint = 56320 | codePoint & 1023;
      }
      output += String.fromCharCode(codePoint);
      return output;
    };
    function decodeCodePoint(codePoint) {
      if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) {
        return "\uFFFD";
      }
      if (codePoint in decode_json_1.default) {
        codePoint = decode_json_1.default[codePoint];
      }
      return fromCodePoint(codePoint);
    }
    exports2.default = decodeCodePoint;
  }
});

// node_modules/entities/lib/decode.js
var require_decode2 = __commonJS({
  "node_modules/entities/lib/decode.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.decodeHTML = exports2.decodeHTMLStrict = exports2.decodeXML = void 0;
    var entities_json_1 = __importDefault(require_entities());
    var legacy_json_1 = __importDefault(require_legacy());
    var xml_json_1 = __importDefault(require_xml());
    var decode_codepoint_1 = __importDefault(require_decode_codepoint());
    var strictEntityRe = /&(?:[a-zA-Z0-9]+|#[xX][\da-fA-F]+|#\d+);/g;
    exports2.decodeXML = getStrictDecoder(xml_json_1.default);
    exports2.decodeHTMLStrict = getStrictDecoder(entities_json_1.default);
    function getStrictDecoder(map) {
      var replace = getReplacer(map);
      return function(str) {
        return String(str).replace(strictEntityRe, replace);
      };
    }
    var sorter = function(a, b) {
      return a < b ? 1 : -1;
    };
    exports2.decodeHTML = function() {
      var legacy = Object.keys(legacy_json_1.default).sort(sorter);
      var keys = Object.keys(entities_json_1.default).sort(sorter);
      for (var i = 0, j = 0; i < keys.length; i++) {
        if (legacy[j] === keys[i]) {
          keys[i] += ";?";
          j++;
        } else {
          keys[i] += ";";
        }
      }
      var re = new RegExp("&(?:" + keys.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)", "g");
      var replace = getReplacer(entities_json_1.default);
      function replacer(str) {
        if (str.substr(-1) !== ";")
          str += ";";
        return replace(str);
      }
      return function(str) {
        return String(str).replace(re, replacer);
      };
    }();
    function getReplacer(map) {
      return function replace(str) {
        if (str.charAt(1) === "#") {
          var secondChar = str.charAt(2);
          if (secondChar === "X" || secondChar === "x") {
            return decode_codepoint_1.default(parseInt(str.substr(3), 16));
          }
          return decode_codepoint_1.default(parseInt(str.substr(2), 10));
        }
        return map[str.slice(1, -1)] || str;
      };
    }
  }
});

// node_modules/entities/lib/encode.js
var require_encode = __commonJS({
  "node_modules/entities/lib/encode.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.escapeUTF8 = exports2.escape = exports2.encodeNonAsciiHTML = exports2.encodeHTML = exports2.encodeXML = void 0;
    var xml_json_1 = __importDefault(require_xml());
    var inverseXML = getInverseObj(xml_json_1.default);
    var xmlReplacer = getInverseReplacer(inverseXML);
    exports2.encodeXML = getASCIIEncoder(inverseXML);
    var entities_json_1 = __importDefault(require_entities());
    var inverseHTML = getInverseObj(entities_json_1.default);
    var htmlReplacer = getInverseReplacer(inverseHTML);
    exports2.encodeHTML = getInverse(inverseHTML, htmlReplacer);
    exports2.encodeNonAsciiHTML = getASCIIEncoder(inverseHTML);
    function getInverseObj(obj) {
      return Object.keys(obj).sort().reduce(function(inverse, name) {
        inverse[obj[name]] = "&" + name + ";";
        return inverse;
      }, {});
    }
    function getInverseReplacer(inverse) {
      var single = [];
      var multiple = [];
      for (var _i = 0, _a = Object.keys(inverse); _i < _a.length; _i++) {
        var k = _a[_i];
        if (k.length === 1) {
          single.push("\\" + k);
        } else {
          multiple.push(k);
        }
      }
      single.sort();
      for (var start = 0; start < single.length - 1; start++) {
        var end = start;
        while (end < single.length - 1 && single[end].charCodeAt(1) + 1 === single[end + 1].charCodeAt(1)) {
          end += 1;
        }
        var count = 1 + end - start;
        if (count < 3)
          continue;
        single.splice(start, count, single[start] + "-" + single[end]);
      }
      multiple.unshift("[" + single.join("") + "]");
      return new RegExp(multiple.join("|"), "g");
    }
    var reNonASCII = /(?:[\x80-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g;
    var getCodePoint = String.prototype.codePointAt != null ? function(str) {
      return str.codePointAt(0);
    } : function(c) {
      return (c.charCodeAt(0) - 55296) * 1024 + c.charCodeAt(1) - 56320 + 65536;
    };
    function singleCharReplacer(c) {
      return "&#x" + (c.length > 1 ? getCodePoint(c) : c.charCodeAt(0)).toString(16).toUpperCase() + ";";
    }
    function getInverse(inverse, re) {
      return function(data) {
        return data.replace(re, function(name) {
          return inverse[name];
        }).replace(reNonASCII, singleCharReplacer);
      };
    }
    var reEscapeChars = new RegExp(xmlReplacer.source + "|" + reNonASCII.source, "g");
    function escape(data) {
      return data.replace(reEscapeChars, singleCharReplacer);
    }
    exports2.escape = escape;
    function escapeUTF8(data) {
      return data.replace(xmlReplacer, singleCharReplacer);
    }
    exports2.escapeUTF8 = escapeUTF8;
    function getASCIIEncoder(obj) {
      return function(data) {
        return data.replace(reEscapeChars, function(c) {
          return obj[c] || singleCharReplacer(c);
        });
      };
    }
  }
});

// node_modules/entities/lib/index.js
var require_lib4 = __commonJS({
  "node_modules/entities/lib/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.decodeXMLStrict = exports2.decodeHTML5Strict = exports2.decodeHTML4Strict = exports2.decodeHTML5 = exports2.decodeHTML4 = exports2.decodeHTMLStrict = exports2.decodeHTML = exports2.decodeXML = exports2.encodeHTML5 = exports2.encodeHTML4 = exports2.escapeUTF8 = exports2.escape = exports2.encodeNonAsciiHTML = exports2.encodeHTML = exports2.encodeXML = exports2.encode = exports2.decodeStrict = exports2.decode = void 0;
    var decode_1 = require_decode2();
    var encode_1 = require_encode();
    function decode(data, level) {
      return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTML)(data);
    }
    exports2.decode = decode;
    function decodeStrict(data, level) {
      return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTMLStrict)(data);
    }
    exports2.decodeStrict = decodeStrict;
    function encode(data, level) {
      return (!level || level <= 0 ? encode_1.encodeXML : encode_1.encodeHTML)(data);
    }
    exports2.encode = encode;
    var encode_2 = require_encode();
    Object.defineProperty(exports2, "encodeXML", { enumerable: true, get: function() {
      return encode_2.encodeXML;
    } });
    Object.defineProperty(exports2, "encodeHTML", { enumerable: true, get: function() {
      return encode_2.encodeHTML;
    } });
    Object.defineProperty(exports2, "encodeNonAsciiHTML", { enumerable: true, get: function() {
      return encode_2.encodeNonAsciiHTML;
    } });
    Object.defineProperty(exports2, "escape", { enumerable: true, get: function() {
      return encode_2.escape;
    } });
    Object.defineProperty(exports2, "escapeUTF8", { enumerable: true, get: function() {
      return encode_2.escapeUTF8;
    } });
    Object.defineProperty(exports2, "encodeHTML4", { enumerable: true, get: function() {
      return encode_2.encodeHTML;
    } });
    Object.defineProperty(exports2, "encodeHTML5", { enumerable: true, get: function() {
      return encode_2.encodeHTML;
    } });
    var decode_2 = require_decode2();
    Object.defineProperty(exports2, "decodeXML", { enumerable: true, get: function() {
      return decode_2.decodeXML;
    } });
    Object.defineProperty(exports2, "decodeHTML", { enumerable: true, get: function() {
      return decode_2.decodeHTML;
    } });
    Object.defineProperty(exports2, "decodeHTMLStrict", { enumerable: true, get: function() {
      return decode_2.decodeHTMLStrict;
    } });
    Object.defineProperty(exports2, "decodeHTML4", { enumerable: true, get: function() {
      return decode_2.decodeHTML;
    } });
    Object.defineProperty(exports2, "decodeHTML5", { enumerable: true, get: function() {
      return decode_2.decodeHTML;
    } });
    Object.defineProperty(exports2, "decodeHTML4Strict", { enumerable: true, get: function() {
      return decode_2.decodeHTMLStrict;
    } });
    Object.defineProperty(exports2, "decodeHTML5Strict", { enumerable: true, get: function() {
      return decode_2.decodeHTMLStrict;
    } });
    Object.defineProperty(exports2, "decodeXMLStrict", { enumerable: true, get: function() {
      return decode_2.decodeXML;
    } });
  }
});

// node_modules/dom-serializer/lib/foreignNames.js
var require_foreignNames = __commonJS({
  "node_modules/dom-serializer/lib/foreignNames.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.attributeNames = exports2.elementNames = void 0;
    exports2.elementNames = /* @__PURE__ */ new Map([
      ["altglyph", "altGlyph"],
      ["altglyphdef", "altGlyphDef"],
      ["altglyphitem", "altGlyphItem"],
      ["animatecolor", "animateColor"],
      ["animatemotion", "animateMotion"],
      ["animatetransform", "animateTransform"],
      ["clippath", "clipPath"],
      ["feblend", "feBlend"],
      ["fecolormatrix", "feColorMatrix"],
      ["fecomponenttransfer", "feComponentTransfer"],
      ["fecomposite", "feComposite"],
      ["feconvolvematrix", "feConvolveMatrix"],
      ["fediffuselighting", "feDiffuseLighting"],
      ["fedisplacementmap", "feDisplacementMap"],
      ["fedistantlight", "feDistantLight"],
      ["fedropshadow", "feDropShadow"],
      ["feflood", "feFlood"],
      ["fefunca", "feFuncA"],
      ["fefuncb", "feFuncB"],
      ["fefuncg", "feFuncG"],
      ["fefuncr", "feFuncR"],
      ["fegaussianblur", "feGaussianBlur"],
      ["feimage", "feImage"],
      ["femerge", "feMerge"],
      ["femergenode", "feMergeNode"],
      ["femorphology", "feMorphology"],
      ["feoffset", "feOffset"],
      ["fepointlight", "fePointLight"],
      ["fespecularlighting", "feSpecularLighting"],
      ["fespotlight", "feSpotLight"],
      ["fetile", "feTile"],
      ["feturbulence", "feTurbulence"],
      ["foreignobject", "foreignObject"],
      ["glyphref", "glyphRef"],
      ["lineargradient", "linearGradient"],
      ["radialgradient", "radialGradient"],
      ["textpath", "textPath"]
    ]);
    exports2.attributeNames = /* @__PURE__ */ new Map([
      ["definitionurl", "definitionURL"],
      ["attributename", "attributeName"],
      ["attributetype", "attributeType"],
      ["basefrequency", "baseFrequency"],
      ["baseprofile", "baseProfile"],
      ["calcmode", "calcMode"],
      ["clippathunits", "clipPathUnits"],
      ["diffuseconstant", "diffuseConstant"],
      ["edgemode", "edgeMode"],
      ["filterunits", "filterUnits"],
      ["glyphref", "glyphRef"],
      ["gradienttransform", "gradientTransform"],
      ["gradientunits", "gradientUnits"],
      ["kernelmatrix", "kernelMatrix"],
      ["kernelunitlength", "kernelUnitLength"],
      ["keypoints", "keyPoints"],
      ["keysplines", "keySplines"],
      ["keytimes", "keyTimes"],
      ["lengthadjust", "lengthAdjust"],
      ["limitingconeangle", "limitingConeAngle"],
      ["markerheight", "markerHeight"],
      ["markerunits", "markerUnits"],
      ["markerwidth", "markerWidth"],
      ["maskcontentunits", "maskContentUnits"],
      ["maskunits", "maskUnits"],
      ["numoctaves", "numOctaves"],
      ["pathlength", "pathLength"],
      ["patterncontentunits", "patternContentUnits"],
      ["patterntransform", "patternTransform"],
      ["patternunits", "patternUnits"],
      ["pointsatx", "pointsAtX"],
      ["pointsaty", "pointsAtY"],
      ["pointsatz", "pointsAtZ"],
      ["preservealpha", "preserveAlpha"],
      ["preserveaspectratio", "preserveAspectRatio"],
      ["primitiveunits", "primitiveUnits"],
      ["refx", "refX"],
      ["refy", "refY"],
      ["repeatcount", "repeatCount"],
      ["repeatdur", "repeatDur"],
      ["requiredextensions", "requiredExtensions"],
      ["requiredfeatures", "requiredFeatures"],
      ["specularconstant", "specularConstant"],
      ["specularexponent", "specularExponent"],
      ["spreadmethod", "spreadMethod"],
      ["startoffset", "startOffset"],
      ["stddeviation", "stdDeviation"],
      ["stitchtiles", "stitchTiles"],
      ["surfacescale", "surfaceScale"],
      ["systemlanguage", "systemLanguage"],
      ["tablevalues", "tableValues"],
      ["targetx", "targetX"],
      ["targety", "targetY"],
      ["textlength", "textLength"],
      ["viewbox", "viewBox"],
      ["viewtarget", "viewTarget"],
      ["xchannelselector", "xChannelSelector"],
      ["ychannelselector", "yChannelSelector"],
      ["zoomandpan", "zoomAndPan"]
    ]);
  }
});

// node_modules/dom-serializer/lib/index.js
var require_lib5 = __commonJS({
  "node_modules/dom-serializer/lib/index.js"(exports2) {
    "use strict";
    var __assign = exports2 && exports2.__assign || function() {
      __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
          s = arguments[i];
          for (var p in s)
            if (Object.prototype.hasOwnProperty.call(s, p))
              t[p] = s[p];
        }
        return t;
      };
      return __assign.apply(this, arguments);
    };
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() {
        return m[k];
      } });
    } : function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      o[k2] = m[k];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    } : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod)
          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
            __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var ElementType = __importStar(require_lib2());
    var entities_1 = require_lib4();
    var foreignNames_1 = require_foreignNames();
    var unencodedElements = /* @__PURE__ */ new Set([
      "style",
      "script",
      "xmp",
      "iframe",
      "noembed",
      "noframes",
      "plaintext",
      "noscript"
    ]);
    function formatAttributes(attributes, opts) {
      if (!attributes)
        return;
      return Object.keys(attributes).map(function(key) {
        var _a, _b;
        var value = (_a = attributes[key]) !== null && _a !== void 0 ? _a : "";
        if (opts.xmlMode === "foreign") {
          key = (_b = foreignNames_1.attributeNames.get(key)) !== null && _b !== void 0 ? _b : key;
        }
        if (!opts.emptyAttrs && !opts.xmlMode && value === "") {
          return key;
        }
        return key + '="' + (opts.decodeEntities !== false ? entities_1.encodeXML(value) : value.replace(/"/g, "&quot;")) + '"';
      }).join(" ");
    }
    var singleTag = /* @__PURE__ */ new Set([
      "area",
      "base",
      "basefont",
      "br",
      "col",
      "command",
      "embed",
      "frame",
      "hr",
      "img",
      "input",
      "isindex",
      "keygen",
      "link",
      "meta",
      "param",
      "source",
      "track",
      "wbr"
    ]);
    function render(node, options) {
      if (options === void 0) {
        options = {};
      }
      var nodes = "length" in node ? node : [node];
      var output = "";
      for (var i = 0; i < nodes.length; i++) {
        output += renderNode(nodes[i], options);
      }
      return output;
    }
    exports2.default = render;
    function renderNode(node, options) {
      switch (node.type) {
        case ElementType.Root:
          return render(node.children, options);
        case ElementType.Directive:
        case ElementType.Doctype:
          return renderDirective(node);
        case ElementType.Comment:
          return renderComment(node);
        case ElementType.CDATA:
          return renderCdata(node);
        case ElementType.Script:
        case ElementType.Style:
        case ElementType.Tag:
          return renderTag(node, options);
        case ElementType.Text:
          return renderText(node, options);
      }
    }
    var foreignModeIntegrationPoints = /* @__PURE__ */ new Set([
      "mi",
      "mo",
      "mn",
      "ms",
      "mtext",
      "annotation-xml",
      "foreignObject",
      "desc",
      "title"
    ]);
    var foreignElements = /* @__PURE__ */ new Set(["svg", "math"]);
    function renderTag(elem, opts) {
      var _a;
      if (opts.xmlMode === "foreign") {
        elem.name = (_a = foreignNames_1.elementNames.get(elem.name)) !== null && _a !== void 0 ? _a : elem.name;
        if (elem.parent && foreignModeIntegrationPoints.has(elem.parent.name)) {
          opts = __assign(__assign({}, opts), { xmlMode: false });
        }
      }
      if (!opts.xmlMode && foreignElements.has(elem.name)) {
        opts = __assign(__assign({}, opts), { xmlMode: "foreign" });
      }
      var tag = "<" + elem.name;
      var attribs = formatAttributes(elem.attribs, opts);
      if (attribs) {
        tag += " " + attribs;
      }
      if (elem.children.length === 0 && (opts.xmlMode ? opts.selfClosingTags !== false : opts.selfClosingTags && singleTag.has(elem.name))) {
        if (!opts.xmlMode)
          tag += " ";
        tag += "/>";
      } else {
        tag += ">";
        if (elem.children.length > 0) {
          tag += render(elem.children, opts);
        }
        if (opts.xmlMode || !singleTag.has(elem.name)) {
          tag += "</" + elem.name + ">";
        }
      }
      return tag;
    }
    function renderDirective(elem) {
      return "<" + elem.data + ">";
    }
    function renderText(elem, opts) {
      var data = elem.data || "";
      if (opts.decodeEntities !== false && !(!opts.xmlMode && elem.parent && unencodedElements.has(elem.parent.name))) {
        data = entities_1.encodeXML(data);
      }
      return data;
    }
    function renderCdata(elem) {
      return "<![CDATA[" + elem.children[0].data + "]]>";
    }
    function renderComment(elem) {
      return "<!--" + elem.data + "-->";
    }
  }
});

// node_modules/domutils/lib/stringify.js
var require_stringify3 = __commonJS({
  "node_modules/domutils/lib/stringify.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.innerText = exports2.textContent = exports2.getText = exports2.getInnerHTML = exports2.getOuterHTML = void 0;
    var domhandler_1 = require_lib3();
    var dom_serializer_1 = __importDefault(require_lib5());
    var domelementtype_1 = require_lib2();
    function getOuterHTML(node, options) {
      return (0, dom_serializer_1.default)(node, options);
    }
    exports2.getOuterHTML = getOuterHTML;
    function getInnerHTML(node, options) {
      return (0, domhandler_1.hasChildren)(node) ? node.children.map(function(node2) {
        return getOuterHTML(node2, options);
      }).join("") : "";
    }
    exports2.getInnerHTML = getInnerHTML;
    function getText(node) {
      if (Array.isArray(node))
        return node.map(getText).join("");
      if ((0, domhandler_1.isTag)(node))
        return node.name === "br" ? "\n" : getText(node.children);
      if ((0, domhandler_1.isCDATA)(node))
        return getText(node.children);
      if ((0, domhandler_1.isText)(node))
        return node.data;
      return "";
    }
    exports2.getText = getText;
    function textContent(node) {
      if (Array.isArray(node))
        return node.map(textContent).join("");
      if ((0, domhandler_1.hasChildren)(node) && !(0, domhandler_1.isComment)(node)) {
        return textContent(node.children);
      }
      if ((0, domhandler_1.isText)(node))
        return node.data;
      return "";
    }
    exports2.textContent = textContent;
    function innerText(node) {
      if (Array.isArray(node))
        return node.map(innerText).join("");
      if ((0, domhandler_1.hasChildren)(node) && (node.type === domelementtype_1.ElementType.Tag || (0, domhandler_1.isCDATA)(node))) {
        return innerText(node.children);
      }
      if ((0, domhandler_1.isText)(node))
        return node.data;
      return "";
    }
    exports2.innerText = innerText;
  }
});

// node_modules/domutils/lib/traversal.js
var require_traversal = __commonJS({
  "node_modules/domutils/lib/traversal.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.prevElementSibling = exports2.nextElementSibling = exports2.getName = exports2.hasAttrib = exports2.getAttributeValue = exports2.getSiblings = exports2.getParent = exports2.getChildren = void 0;
    var domhandler_1 = require_lib3();
    var emptyArray = [];
    function getChildren(elem) {
      var _a;
      return (_a = elem.children) !== null && _a !== void 0 ? _a : emptyArray;
    }
    exports2.getChildren = getChildren;
    function getParent(elem) {
      return elem.parent || null;
    }
    exports2.getParent = getParent;
    function getSiblings(elem) {
      var _a, _b;
      var parent = getParent(elem);
      if (parent != null)
        return getChildren(parent);
      var siblings = [elem];
      var prev = elem.prev, next = elem.next;
      while (prev != null) {
        siblings.unshift(prev);
        _a = prev, prev = _a.prev;
      }
      while (next != null) {
        siblings.push(next);
        _b = next, next = _b.next;
      }
      return siblings;
    }
    exports2.getSiblings = getSiblings;
    function getAttributeValue(elem, name) {
      var _a;
      return (_a = elem.attribs) === null || _a === void 0 ? void 0 : _a[name];
    }
    exports2.getAttributeValue = getAttributeValue;
    function hasAttrib(elem, name) {
      return elem.attribs != null && Object.prototype.hasOwnProperty.call(elem.attribs, name) && elem.attribs[name] != null;
    }
    exports2.hasAttrib = hasAttrib;
    function getName(elem) {
      return elem.name;
    }
    exports2.getName = getName;
    function nextElementSibling(elem) {
      var _a;
      var next = elem.next;
      while (next !== null && !(0, domhandler_1.isTag)(next))
        _a = next, next = _a.next;
      return next;
    }
    exports2.nextElementSibling = nextElementSibling;
    function prevElementSibling(elem) {
      var _a;
      var prev = elem.prev;
      while (prev !== null && !(0, domhandler_1.isTag)(prev))
        _a = prev, prev = _a.prev;
      return prev;
    }
    exports2.prevElementSibling = prevElementSibling;
  }
});

// node_modules/domutils/lib/manipulation.js
var require_manipulation = __commonJS({
  "node_modules/domutils/lib/manipulation.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.prepend = exports2.prependChild = exports2.append = exports2.appendChild = exports2.replaceElement = exports2.removeElement = void 0;
    function removeElement(elem) {
      if (elem.prev)
        elem.prev.next = elem.next;
      if (elem.next)
        elem.next.prev = elem.prev;
      if (elem.parent) {
        var childs = elem.parent.children;
        childs.splice(childs.lastIndexOf(elem), 1);
      }
    }
    exports2.removeElement = removeElement;
    function replaceElement(elem, replacement) {
      var prev = replacement.prev = elem.prev;
      if (prev) {
        prev.next = replacement;
      }
      var next = replacement.next = elem.next;
      if (next) {
        next.prev = replacement;
      }
      var parent = replacement.parent = elem.parent;
      if (parent) {
        var childs = parent.children;
        childs[childs.lastIndexOf(elem)] = replacement;
      }
    }
    exports2.replaceElement = replaceElement;
    function appendChild(elem, child) {
      removeElement(child);
      child.next = null;
      child.parent = elem;
      if (elem.children.push(child) > 1) {
        var sibling = elem.children[elem.children.length - 2];
        sibling.next = child;
        child.prev = sibling;
      } else {
        child.prev = null;
      }
    }
    exports2.appendChild = appendChild;
    function append(elem, next) {
      removeElement(next);
      var parent = elem.parent;
      var currNext = elem.next;
      next.next = currNext;
      next.prev = elem;
      elem.next = next;
      next.parent = parent;
      if (currNext) {
        currNext.prev = next;
        if (parent) {
          var childs = parent.children;
          childs.splice(childs.lastIndexOf(currNext), 0, next);
        }
      } else if (parent) {
        parent.children.push(next);
      }
    }
    exports2.append = append;
    function prependChild(elem, child) {
      removeElement(child);
      child.parent = elem;
      child.prev = null;
      if (elem.children.unshift(child) !== 1) {
        var sibling = elem.children[1];
        sibling.prev = child;
        child.next = sibling;
      } else {
        child.next = null;
      }
    }
    exports2.prependChild = prependChild;
    function prepend(elem, prev) {
      removeElement(prev);
      var parent = elem.parent;
      if (parent) {
        var childs = parent.children;
        childs.splice(childs.indexOf(elem), 0, prev);
      }
      if (elem.prev) {
        elem.prev.next = prev;
      }
      prev.parent = parent;
      prev.prev = elem.prev;
      prev.next = elem;
      elem.prev = prev;
    }
    exports2.prepend = prepend;
  }
});

// node_modules/domutils/lib/querying.js
var require_querying = __commonJS({
  "node_modules/domutils/lib/querying.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.findAll = exports2.existsOne = exports2.findOne = exports2.findOneChild = exports2.find = exports2.filter = void 0;
    var domhandler_1 = require_lib3();
    function filter(test, node, recurse, limit) {
      if (recurse === void 0) {
        recurse = true;
      }
      if (limit === void 0) {
        limit = Infinity;
      }
      if (!Array.isArray(node))
        node = [node];
      return find(test, node, recurse, limit);
    }
    exports2.filter = filter;
    function find(test, nodes, recurse, limit) {
      var result = [];
      for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
        var elem = nodes_1[_i];
        if (test(elem)) {
          result.push(elem);
          if (--limit <= 0)
            break;
        }
        if (recurse && (0, domhandler_1.hasChildren)(elem) && elem.children.length > 0) {
          var children = find(test, elem.children, recurse, limit);
          result.push.apply(result, children);
          limit -= children.length;
          if (limit <= 0)
            break;
        }
      }
      return result;
    }
    exports2.find = find;
    function findOneChild(test, nodes) {
      return nodes.find(test);
    }
    exports2.findOneChild = findOneChild;
    function findOne(test, nodes, recurse) {
      if (recurse === void 0) {
        recurse = true;
      }
      var elem = null;
      for (var i = 0; i < nodes.length && !elem; i++) {
        var checked = nodes[i];
        if (!(0, domhandler_1.isTag)(checked)) {
          continue;
        } else if (test(checked)) {
          elem = checked;
        } else if (recurse && checked.children.length > 0) {
          elem = findOne(test, checked.children);
        }
      }
      return elem;
    }
    exports2.findOne = findOne;
    function existsOne(test, nodes) {
      return nodes.some(function(checked) {
        return (0, domhandler_1.isTag)(checked) && (test(checked) || checked.children.length > 0 && existsOne(test, checked.children));
      });
    }
    exports2.existsOne = existsOne;
    function findAll(test, nodes) {
      var _a;
      var result = [];
      var stack = nodes.filter(domhandler_1.isTag);
      var elem;
      while (elem = stack.shift()) {
        var children = (_a = elem.children) === null || _a === void 0 ? void 0 : _a.filter(domhandler_1.isTag);
        if (children && children.length > 0) {
          stack.unshift.apply(stack, children);
        }
        if (test(elem))
          result.push(elem);
      }
      return result;
    }
    exports2.findAll = findAll;
  }
});

// node_modules/domutils/lib/legacy.js
var require_legacy2 = __commonJS({
  "node_modules/domutils/lib/legacy.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getElementsByTagType = exports2.getElementsByTagName = exports2.getElementById = exports2.getElements = exports2.testElement = void 0;
    var domhandler_1 = require_lib3();
    var querying_1 = require_querying();
    var Checks = {
      tag_name: function(name) {
        if (typeof name === "function") {
          return function(elem) {
            return (0, domhandler_1.isTag)(elem) && name(elem.name);
          };
        } else if (name === "*") {
          return domhandler_1.isTag;
        }
        return function(elem) {
          return (0, domhandler_1.isTag)(elem) && elem.name === name;
        };
      },
      tag_type: function(type) {
        if (typeof type === "function") {
          return function(elem) {
            return type(elem.type);
          };
        }
        return function(elem) {
          return elem.type === type;
        };
      },
      tag_contains: function(data) {
        if (typeof data === "function") {
          return function(elem) {
            return (0, domhandler_1.isText)(elem) && data(elem.data);
          };
        }
        return function(elem) {
          return (0, domhandler_1.isText)(elem) && elem.data === data;
        };
      }
    };
    function getAttribCheck(attrib, value) {
      if (typeof value === "function") {
        return function(elem) {
          return (0, domhandler_1.isTag)(elem) && value(elem.attribs[attrib]);
        };
      }
      return function(elem) {
        return (0, domhandler_1.isTag)(elem) && elem.attribs[attrib] === value;
      };
    }
    function combineFuncs(a, b) {
      return function(elem) {
        return a(elem) || b(elem);
      };
    }
    function compileTest(options) {
      var funcs = Object.keys(options).map(function(key) {
        var value = options[key];
        return Object.prototype.hasOwnProperty.call(Checks, key) ? Checks[key](value) : getAttribCheck(key, value);
      });
      return funcs.length === 0 ? null : funcs.reduce(combineFuncs);
    }
    function testElement(options, node) {
      var test = compileTest(options);
      return test ? test(node) : true;
    }
    exports2.testElement = testElement;
    function getElements(options, nodes, recurse, limit) {
      if (limit === void 0) {
        limit = Infinity;
      }
      var test = compileTest(options);
      return test ? (0, querying_1.filter)(test, nodes, recurse, limit) : [];
    }
    exports2.getElements = getElements;
    function getElementById(id, nodes, recurse) {
      if (recurse === void 0) {
        recurse = true;
      }
      if (!Array.isArray(nodes))
        nodes = [nodes];
      return (0, querying_1.findOne)(getAttribCheck("id", id), nodes, recurse);
    }
    exports2.getElementById = getElementById;
    function getElementsByTagName(tagName, nodes, recurse, limit) {
      if (recurse === void 0) {
        recurse = true;
      }
      if (limit === void 0) {
        limit = Infinity;
      }
      return (0, querying_1.filter)(Checks.tag_name(tagName), nodes, recurse, limit);
    }
    exports2.getElementsByTagName = getElementsByTagName;
    function getElementsByTagType(type, nodes, recurse, limit) {
      if (recurse === void 0) {
        recurse = true;
      }
      if (limit === void 0) {
        limit = Infinity;
      }
      return (0, querying_1.filter)(Checks.tag_type(type), nodes, recurse, limit);
    }
    exports2.getElementsByTagType = getElementsByTagType;
  }
});

// node_modules/domutils/lib/helpers.js
var require_helpers = __commonJS({
  "node_modules/domutils/lib/helpers.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.uniqueSort = exports2.compareDocumentPosition = exports2.removeSubsets = void 0;
    var domhandler_1 = require_lib3();
    function removeSubsets(nodes) {
      var idx = nodes.length;
      while (--idx >= 0) {
        var node = nodes[idx];
        if (idx > 0 && nodes.lastIndexOf(node, idx - 1) >= 0) {
          nodes.splice(idx, 1);
          continue;
        }
        for (var ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
          if (nodes.includes(ancestor)) {
            nodes.splice(idx, 1);
            break;
          }
        }
      }
      return nodes;
    }
    exports2.removeSubsets = removeSubsets;
    function compareDocumentPosition(nodeA, nodeB) {
      var aParents = [];
      var bParents = [];
      if (nodeA === nodeB) {
        return 0;
      }
      var current = (0, domhandler_1.hasChildren)(nodeA) ? nodeA : nodeA.parent;
      while (current) {
        aParents.unshift(current);
        current = current.parent;
      }
      current = (0, domhandler_1.hasChildren)(nodeB) ? nodeB : nodeB.parent;
      while (current) {
        bParents.unshift(current);
        current = current.parent;
      }
      var maxIdx = Math.min(aParents.length, bParents.length);
      var idx = 0;
      while (idx < maxIdx && aParents[idx] === bParents[idx]) {
        idx++;
      }
      if (idx === 0) {
        return 1;
      }
      var sharedParent = aParents[idx - 1];
      var siblings = sharedParent.children;
      var aSibling = aParents[idx];
      var bSibling = bParents[idx];
      if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {
        if (sharedParent === nodeB) {
          return 4 | 16;
        }
        return 4;
      }
      if (sharedParent === nodeA) {
        return 2 | 8;
      }
      return 2;
    }
    exports2.compareDocumentPosition = compareDocumentPosition;
    function uniqueSort(nodes) {
      nodes = nodes.filter(function(node, i, arr) {
        return !arr.includes(node, i + 1);
      });
      nodes.sort(function(a, b) {
        var relative = compareDocumentPosition(a, b);
        if (relative & 2) {
          return -1;
        } else if (relative & 4) {
          return 1;
        }
        return 0;
      });
      return nodes;
    }
    exports2.uniqueSort = uniqueSort;
  }
});

// node_modules/domutils/lib/feeds.js
var require_feeds = __commonJS({
  "node_modules/domutils/lib/feeds.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getFeed = void 0;
    var stringify_1 = require_stringify3();
    var legacy_1 = require_legacy2();
    function getFeed(doc) {
      var feedRoot = getOneElement(isValidFeed, doc);
      return !feedRoot ? null : feedRoot.name === "feed" ? getAtomFeed(feedRoot) : getRssFeed(feedRoot);
    }
    exports2.getFeed = getFeed;
    function getAtomFeed(feedRoot) {
      var _a;
      var childs = feedRoot.children;
      var feed = {
        type: "atom",
        items: (0, legacy_1.getElementsByTagName)("entry", childs).map(function(item) {
          var _a2;
          var children = item.children;
          var entry = { media: getMediaElements(children) };
          addConditionally(entry, "id", "id", children);
          addConditionally(entry, "title", "title", children);
          var href2 = (_a2 = getOneElement("link", children)) === null || _a2 === void 0 ? void 0 : _a2.attribs.href;
          if (href2) {
            entry.link = href2;
          }
          var description = fetch("summary", children) || fetch("content", children);
          if (description) {
            entry.description = description;
          }
          var pubDate = fetch("updated", children);
          if (pubDate) {
            entry.pubDate = new Date(pubDate);
          }
          return entry;
        })
      };
      addConditionally(feed, "id", "id", childs);
      addConditionally(feed, "title", "title", childs);
      var href = (_a = getOneElement("link", childs)) === null || _a === void 0 ? void 0 : _a.attribs.href;
      if (href) {
        feed.link = href;
      }
      addConditionally(feed, "description", "subtitle", childs);
      var updated = fetch("updated", childs);
      if (updated) {
        feed.updated = new Date(updated);
      }
      addConditionally(feed, "author", "email", childs, true);
      return feed;
    }
    function getRssFeed(feedRoot) {
      var _a, _b;
      var childs = (_b = (_a = getOneElement("channel", feedRoot.children)) === null || _a === void 0 ? void 0 : _a.children) !== null && _b !== void 0 ? _b : [];
      var feed = {
        type: feedRoot.name.substr(0, 3),
        id: "",
        items: (0, legacy_1.getElementsByTagName)("item", feedRoot.children).map(function(item) {
          var children = item.children;
          var entry = { media: getMediaElements(children) };
          addConditionally(entry, "id", "guid", children);
          addConditionally(entry, "title", "title", children);
          addConditionally(entry, "link", "link", children);
          addConditionally(entry, "description", "description", children);
          var pubDate = fetch("pubDate", children);
          if (pubDate)
            entry.pubDate = new Date(pubDate);
          return entry;
        })
      };
      addConditionally(feed, "title", "title", childs);
      addConditionally(feed, "link", "link", childs);
      addConditionally(feed, "description", "description", childs);
      var updated = fetch("lastBuildDate", childs);
      if (updated) {
        feed.updated = new Date(updated);
      }
      addConditionally(feed, "author", "managingEditor", childs, true);
      return feed;
    }
    var MEDIA_KEYS_STRING = ["url", "type", "lang"];
    var MEDIA_KEYS_INT = [
      "fileSize",
      "bitrate",
      "framerate",
      "samplingrate",
      "channels",
      "duration",
      "height",
      "width"
    ];
    function getMediaElements(where) {
      return (0, legacy_1.getElementsByTagName)("media:content", where).map(function(elem) {
        var attribs = elem.attribs;
        var media = {
          medium: attribs.medium,
          isDefault: !!attribs.isDefault
        };
        for (var _i = 0, MEDIA_KEYS_STRING_1 = MEDIA_KEYS_STRING; _i < MEDIA_KEYS_STRING_1.length; _i++) {
          var attrib = MEDIA_KEYS_STRING_1[_i];
          if (attribs[attrib]) {
            media[attrib] = attribs[attrib];
          }
        }
        for (var _a = 0, MEDIA_KEYS_INT_1 = MEDIA_KEYS_INT; _a < MEDIA_KEYS_INT_1.length; _a++) {
          var attrib = MEDIA_KEYS_INT_1[_a];
          if (attribs[attrib]) {
            media[attrib] = parseInt(attribs[attrib], 10);
          }
        }
        if (attribs.expression) {
          media.expression = attribs.expression;
        }
        return media;
      });
    }
    function getOneElement(tagName, node) {
      return (0, legacy_1.getElementsByTagName)(tagName, node, true, 1)[0];
    }
    function fetch(tagName, where, recurse) {
      if (recurse === void 0) {
        recurse = false;
      }
      return (0, stringify_1.textContent)((0, legacy_1.getElementsByTagName)(tagName, where, recurse, 1)).trim();
    }
    function addConditionally(obj, prop, tagName, where, recurse) {
      if (recurse === void 0) {
        recurse = false;
      }
      var val = fetch(tagName, where, recurse);
      if (val)
        obj[prop] = val;
    }
    function isValidFeed(value) {
      return value === "rss" || value === "feed" || value === "rdf:RDF";
    }
  }
});

// node_modules/domutils/lib/index.js
var require_lib6 = __commonJS({
  "node_modules/domutils/lib/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() {
        return m[k];
      } });
    } : function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m)
        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
          __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.hasChildren = exports2.isDocument = exports2.isComment = exports2.isText = exports2.isCDATA = exports2.isTag = void 0;
    __exportStar(require_stringify3(), exports2);
    __exportStar(require_traversal(), exports2);
    __exportStar(require_manipulation(), exports2);
    __exportStar(require_querying(), exports2);
    __exportStar(require_legacy2(), exports2);
    __exportStar(require_helpers(), exports2);
    __exportStar(require_feeds(), exports2);
    var domhandler_1 = require_lib3();
    Object.defineProperty(exports2, "isTag", { enumerable: true, get: function() {
      return domhandler_1.isTag;
    } });
    Object.defineProperty(exports2, "isCDATA", { enumerable: true, get: function() {
      return domhandler_1.isCDATA;
    } });
    Object.defineProperty(exports2, "isText", { enumerable: true, get: function() {
      return domhandler_1.isText;
    } });
    Object.defineProperty(exports2, "isComment", { enumerable: true, get: function() {
      return domhandler_1.isComment;
    } });
    Object.defineProperty(exports2, "isDocument", { enumerable: true, get: function() {
      return domhandler_1.isDocument;
    } });
    Object.defineProperty(exports2, "hasChildren", { enumerable: true, get: function() {
      return domhandler_1.hasChildren;
    } });
  }
});

// node_modules/boolbase/index.js
var require_boolbase = __commonJS({
  "node_modules/boolbase/index.js"(exports2, module2) {
    module2.exports = {
      trueFunc: function trueFunc() {
        return true;
      },
      falseFunc: function falseFunc() {
        return false;
      }
    };
  }
});

// node_modules/css-what/lib/commonjs/types.js
var require_types = __commonJS({
  "node_modules/css-what/lib/commonjs/types.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.AttributeAction = exports2.IgnoreCaseMode = exports2.SelectorType = void 0;
    var SelectorType;
    (function(SelectorType2) {
      SelectorType2["Attribute"] = "attribute";
      SelectorType2["Pseudo"] = "pseudo";
      SelectorType2["PseudoElement"] = "pseudo-element";
      SelectorType2["Tag"] = "tag";
      SelectorType2["Universal"] = "universal";
      SelectorType2["Adjacent"] = "adjacent";
      SelectorType2["Child"] = "child";
      SelectorType2["Descendant"] = "descendant";
      SelectorType2["Parent"] = "parent";
      SelectorType2["Sibling"] = "sibling";
      SelectorType2["ColumnCombinator"] = "column-combinator";
    })(SelectorType = exports2.SelectorType || (exports2.SelectorType = {}));
    exports2.IgnoreCaseMode = {
      Unknown: null,
      QuirksMode: "quirks",
      IgnoreCase: true,
      CaseSensitive: false
    };
    var AttributeAction;
    (function(AttributeAction2) {
      AttributeAction2["Any"] = "any";
      AttributeAction2["Element"] = "element";
      AttributeAction2["End"] = "end";
      AttributeAction2["Equals"] = "equals";
      AttributeAction2["Exists"] = "exists";
      AttributeAction2["Hyphen"] = "hyphen";
      AttributeAction2["Not"] = "not";
      AttributeAction2["Start"] = "start";
    })(AttributeAction = exports2.AttributeAction || (exports2.AttributeAction = {}));
  }
});

// node_modules/css-what/lib/commonjs/parse.js
var require_parse3 = __commonJS({
  "node_modules/css-what/lib/commonjs/parse.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.parse = exports2.isTraversal = void 0;
    var types_1 = require_types();
    var reName = /^[^\\#]?(?:\\(?:[\da-f]{1,6}\s?|.)|[\w\-\u00b0-\uFFFF])+/;
    var reEscape = /\\([\da-f]{1,6}\s?|(\s)|.)/gi;
    var actionTypes = /* @__PURE__ */ new Map([
      [126, types_1.AttributeAction.Element],
      [94, types_1.AttributeAction.Start],
      [36, types_1.AttributeAction.End],
      [42, types_1.AttributeAction.Any],
      [33, types_1.AttributeAction.Not],
      [124, types_1.AttributeAction.Hyphen]
    ]);
    var unpackPseudos = /* @__PURE__ */ new Set([
      "has",
      "not",
      "matches",
      "is",
      "where",
      "host",
      "host-context"
    ]);
    function isTraversal(selector) {
      switch (selector.type) {
        case types_1.SelectorType.Adjacent:
        case types_1.SelectorType.Child:
        case types_1.SelectorType.Descendant:
        case types_1.SelectorType.Parent:
        case types_1.SelectorType.Sibling:
        case types_1.SelectorType.ColumnCombinator:
          return true;
        default:
          return false;
      }
    }
    exports2.isTraversal = isTraversal;
    var stripQuotesFromPseudos = /* @__PURE__ */ new Set(["contains", "icontains"]);
    function funescape(_, escaped, escapedWhitespace) {
      var high = parseInt(escaped, 16) - 65536;
      return high !== high || escapedWhitespace ? escaped : high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320);
    }
    function unescapeCSS(str) {
      return str.replace(reEscape, funescape);
    }
    function isQuote(c) {
      return c === 39 || c === 34;
    }
    function isWhitespace(c) {
      return c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
    }
    function parse(selector) {
      var subselects = [];
      var endIndex = parseSelector(subselects, "".concat(selector), 0);
      if (endIndex < selector.length) {
        throw new Error("Unmatched selector: ".concat(selector.slice(endIndex)));
      }
      return subselects;
    }
    exports2.parse = parse;
    function parseSelector(subselects, selector, selectorIndex) {
      var tokens = [];
      function getName(offset) {
        var match = selector.slice(selectorIndex + offset).match(reName);
        if (!match) {
          throw new Error("Expected name, found ".concat(selector.slice(selectorIndex)));
        }
        var name = match[0];
        selectorIndex += offset + name.length;
        return unescapeCSS(name);
      }
      function stripWhitespace(offset) {
        selectorIndex += offset;
        while (selectorIndex < selector.length && isWhitespace(selector.charCodeAt(selectorIndex))) {
          selectorIndex++;
        }
      }
      function readValueWithParenthesis() {
        selectorIndex += 1;
        var start = selectorIndex;
        var counter = 1;
        for (; counter > 0 && selectorIndex < selector.length; selectorIndex++) {
          if (selector.charCodeAt(selectorIndex) === 40 && !isEscaped(selectorIndex)) {
            counter++;
          } else if (selector.charCodeAt(selectorIndex) === 41 && !isEscaped(selectorIndex)) {
            counter--;
          }
        }
        if (counter) {
          throw new Error("Parenthesis not matched");
        }
        return unescapeCSS(selector.slice(start, selectorIndex - 1));
      }
      function isEscaped(pos) {
        var slashCount = 0;
        while (selector.charCodeAt(--pos) === 92)
          slashCount++;
        return (slashCount & 1) === 1;
      }
      function ensureNotTraversal() {
        if (tokens.length > 0 && isTraversal(tokens[tokens.length - 1])) {
          throw new Error("Did not expect successive traversals.");
        }
      }
      function addTraversal(type) {
        if (tokens.length > 0 && tokens[tokens.length - 1].type === types_1.SelectorType.Descendant) {
          tokens[tokens.length - 1].type = type;
          return;
        }
        ensureNotTraversal();
        tokens.push({ type });
      }
      function addSpecialAttribute(name, action2) {
        tokens.push({
          type: types_1.SelectorType.Attribute,
          name,
          action: action2,
          value: getName(1),
          namespace: null,
          ignoreCase: "quirks"
        });
      }
      function finalizeSubselector() {
        if (tokens.length && tokens[tokens.length - 1].type === types_1.SelectorType.Descendant) {
          tokens.pop();
        }
        if (tokens.length === 0) {
          throw new Error("Empty sub-selector");
        }
        subselects.push(tokens);
      }
      stripWhitespace(0);
      if (selector.length === selectorIndex) {
        return selectorIndex;
      }
      loop:
        while (selectorIndex < selector.length) {
          var firstChar = selector.charCodeAt(selectorIndex);
          switch (firstChar) {
            case 32:
            case 9:
            case 10:
            case 12:
            case 13: {
              if (tokens.length === 0 || tokens[0].type !== types_1.SelectorType.Descendant) {
                ensureNotTraversal();
                tokens.push({ type: types_1.SelectorType.Descendant });
              }
              stripWhitespace(1);
              break;
            }
            case 62: {
              addTraversal(types_1.SelectorType.Child);
              stripWhitespace(1);
              break;
            }
            case 60: {
              addTraversal(types_1.SelectorType.Parent);
              stripWhitespace(1);
              break;
            }
            case 126: {
              addTraversal(types_1.SelectorType.Sibling);
              stripWhitespace(1);
              break;
            }
            case 43: {
              addTraversal(types_1.SelectorType.Adjacent);
              stripWhitespace(1);
              break;
            }
            case 46: {
              addSpecialAttribute("class", types_1.AttributeAction.Element);
              break;
            }
            case 35: {
              addSpecialAttribute("id", types_1.AttributeAction.Equals);
              break;
            }
            case 91: {
              stripWhitespace(1);
              var name_1 = void 0;
              var namespace = null;
              if (selector.charCodeAt(selectorIndex) === 124) {
                name_1 = getName(1);
              } else if (selector.startsWith("*|", selectorIndex)) {
                namespace = "*";
                name_1 = getName(2);
              } else {
                name_1 = getName(0);
                if (selector.charCodeAt(selectorIndex) === 124 && selector.charCodeAt(selectorIndex + 1) !== 61) {
                  namespace = name_1;
                  name_1 = getName(1);
                }
              }
              stripWhitespace(0);
              var action = types_1.AttributeAction.Exists;
              var possibleAction = actionTypes.get(selector.charCodeAt(selectorIndex));
              if (possibleAction) {
                action = possibleAction;
                if (selector.charCodeAt(selectorIndex + 1) !== 61) {
                  throw new Error("Expected `=`");
                }
                stripWhitespace(2);
              } else if (selector.charCodeAt(selectorIndex) === 61) {
                action = types_1.AttributeAction.Equals;
                stripWhitespace(1);
              }
              var value = "";
              var ignoreCase = null;
              if (action !== "exists") {
                if (isQuote(selector.charCodeAt(selectorIndex))) {
                  var quote = selector.charCodeAt(selectorIndex);
                  var sectionEnd = selectorIndex + 1;
                  while (sectionEnd < selector.length && (selector.charCodeAt(sectionEnd) !== quote || isEscaped(sectionEnd))) {
                    sectionEnd += 1;
                  }
                  if (selector.charCodeAt(sectionEnd) !== quote) {
                    throw new Error("Attribute value didn't end");
                  }
                  value = unescapeCSS(selector.slice(selectorIndex + 1, sectionEnd));
                  selectorIndex = sectionEnd + 1;
                } else {
                  var valueStart = selectorIndex;
                  while (selectorIndex < selector.length && (!isWhitespace(selector.charCodeAt(selectorIndex)) && selector.charCodeAt(selectorIndex) !== 93 || isEscaped(selectorIndex))) {
                    selectorIndex += 1;
                  }
                  value = unescapeCSS(selector.slice(valueStart, selectorIndex));
                }
                stripWhitespace(0);
                var forceIgnore = selector.charCodeAt(selectorIndex) | 32;
                if (forceIgnore === 115) {
                  ignoreCase = false;
                  stripWhitespace(1);
                } else if (forceIgnore === 105) {
                  ignoreCase = true;
                  stripWhitespace(1);
                }
              }
              if (selector.charCodeAt(selectorIndex) !== 93) {
                throw new Error("Attribute selector didn't terminate");
              }
              selectorIndex += 1;
              var attributeSelector = {
                type: types_1.SelectorType.Attribute,
                name: name_1,
                action,
                value,
                namespace,
                ignoreCase
              };
              tokens.push(attributeSelector);
              break;
            }
            case 58: {
              if (selector.charCodeAt(selectorIndex + 1) === 58) {
                tokens.push({
                  type: types_1.SelectorType.PseudoElement,
                  name: getName(2).toLowerCase(),
                  data: selector.charCodeAt(selectorIndex) === 40 ? readValueWithParenthesis() : null
                });
                continue;
              }
              var name_2 = getName(1).toLowerCase();
              var data = null;
              if (selector.charCodeAt(selectorIndex) === 40) {
                if (unpackPseudos.has(name_2)) {
                  if (isQuote(selector.charCodeAt(selectorIndex + 1))) {
                    throw new Error("Pseudo-selector ".concat(name_2, " cannot be quoted"));
                  }
                  data = [];
                  selectorIndex = parseSelector(data, selector, selectorIndex + 1);
                  if (selector.charCodeAt(selectorIndex) !== 41) {
                    throw new Error("Missing closing parenthesis in :".concat(name_2, " (").concat(selector, ")"));
                  }
                  selectorIndex += 1;
                } else {
                  data = readValueWithParenthesis();
                  if (stripQuotesFromPseudos.has(name_2)) {
                    var quot = data.charCodeAt(0);
                    if (quot === data.charCodeAt(data.length - 1) && isQuote(quot)) {
                      data = data.slice(1, -1);
                    }
                  }
                  data = unescapeCSS(data);
                }
              }
              tokens.push({ type: types_1.SelectorType.Pseudo, name: name_2, data });
              break;
            }
            case 44: {
              finalizeSubselector();
              tokens = [];
              stripWhitespace(1);
              break;
            }
            default: {
              if (selector.startsWith("/*", selectorIndex)) {
                var endIndex = selector.indexOf("*/", selectorIndex + 2);
                if (endIndex < 0) {
                  throw new Error("Comment was not terminated");
                }
                selectorIndex = endIndex + 2;
                if (tokens.length === 0) {
                  stripWhitespace(0);
                }
                break;
              }
              var namespace = null;
              var name_3 = void 0;
              if (firstChar === 42) {
                selectorIndex += 1;
                name_3 = "*";
              } else if (firstChar === 124) {
                name_3 = "";
                if (selector.charCodeAt(selectorIndex + 1) === 124) {
                  addTraversal(types_1.SelectorType.ColumnCombinator);
                  stripWhitespace(2);
                  break;
                }
              } else if (reName.test(selector.slice(selectorIndex))) {
                name_3 = getName(0);
              } else {
                break loop;
              }
              if (selector.charCodeAt(selectorIndex) === 124 && selector.charCodeAt(selectorIndex + 1) !== 124) {
                namespace = name_3;
                if (selector.charCodeAt(selectorIndex + 1) === 42) {
                  name_3 = "*";
                  selectorIndex += 2;
                } else {
                  name_3 = getName(1);
                }
              }
              tokens.push(name_3 === "*" ? { type: types_1.SelectorType.Universal, namespace } : { type: types_1.SelectorType.Tag, name: name_3, namespace });
            }
          }
        }
      finalizeSubselector();
      return selectorIndex;
    }
  }
});

// node_modules/css-what/lib/commonjs/stringify.js
var require_stringify4 = __commonJS({
  "node_modules/css-what/lib/commonjs/stringify.js"(exports2) {
    "use strict";
    var __spreadArray = exports2 && exports2.__spreadArray || function(to, from, pack) {
      if (pack || arguments.length === 2)
        for (var i = 0, l = from.length, ar; i < l; i++) {
          if (ar || !(i in from)) {
            if (!ar)
              ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
          }
        }
      return to.concat(ar || Array.prototype.slice.call(from));
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.stringify = void 0;
    var types_1 = require_types();
    var attribValChars = ["\\", '"'];
    var pseudoValChars = __spreadArray(__spreadArray([], attribValChars, true), ["(", ")"], false);
    var charsToEscapeInAttributeValue = new Set(attribValChars.map(function(c) {
      return c.charCodeAt(0);
    }));
    var charsToEscapeInPseudoValue = new Set(pseudoValChars.map(function(c) {
      return c.charCodeAt(0);
    }));
    var charsToEscapeInName = new Set(__spreadArray(__spreadArray([], pseudoValChars, true), [
      "~",
      "^",
      "$",
      "*",
      "+",
      "!",
      "|",
      ":",
      "[",
      "]",
      " ",
      "."
    ], false).map(function(c) {
      return c.charCodeAt(0);
    }));
    function stringify(selector) {
      return selector.map(function(token) {
        return token.map(stringifyToken).join("");
      }).join(", ");
    }
    exports2.stringify = stringify;
    function stringifyToken(token, index, arr) {
      switch (token.type) {
        case types_1.SelectorType.Child:
          return index === 0 ? "> " : " > ";
        case types_1.SelectorType.Parent:
          return index === 0 ? "< " : " < ";
        case types_1.SelectorType.Sibling:
          return index === 0 ? "~ " : " ~ ";
        case types_1.SelectorType.Adjacent:
          return index === 0 ? "+ " : " + ";
        case types_1.SelectorType.Descendant:
          return " ";
        case types_1.SelectorType.ColumnCombinator:
          return index === 0 ? "|| " : " || ";
        case types_1.SelectorType.Universal:
          return token.namespace === "*" && index + 1 < arr.length && "name" in arr[index + 1] ? "" : "".concat(getNamespace(token.namespace), "*");
        case types_1.SelectorType.Tag:
          return getNamespacedName(token);
        case types_1.SelectorType.PseudoElement:
          return "::".concat(escapeName(token.name, charsToEscapeInName)).concat(token.data === null ? "" : "(".concat(escapeName(token.data, charsToEscapeInPseudoValue), ")"));
        case types_1.SelectorType.Pseudo:
          return ":".concat(escapeName(token.name, charsToEscapeInName)).concat(token.data === null ? "" : "(".concat(typeof token.data === "string" ? escapeName(token.data, charsToEscapeInPseudoValue) : stringify(token.data), ")"));
        case types_1.SelectorType.Attribute: {
          if (token.name === "id" && token.action === types_1.AttributeAction.Equals && token.ignoreCase === "quirks" && !token.namespace) {
            return "#".concat(escapeName(token.value, charsToEscapeInName));
          }
          if (token.name === "class" && token.action === types_1.AttributeAction.Element && token.ignoreCase === "quirks" && !token.namespace) {
            return ".".concat(escapeName(token.value, charsToEscapeInName));
          }
          var name_1 = getNamespacedName(token);
          if (token.action === types_1.AttributeAction.Exists) {
            return "[".concat(name_1, "]");
          }
          return "[".concat(name_1).concat(getActionValue(token.action), '="').concat(escapeName(token.value, charsToEscapeInAttributeValue), '"').concat(token.ignoreCase === null ? "" : token.ignoreCase ? " i" : " s", "]");
        }
      }
    }
    function getActionValue(action) {
      switch (action) {
        case types_1.AttributeAction.Equals:
          return "";
        case types_1.AttributeAction.Element:
          return "~";
        case types_1.AttributeAction.Start:
          return "^";
        case types_1.AttributeAction.End:
          return "$";
        case types_1.AttributeAction.Any:
          return "*";
        case types_1.AttributeAction.Not:
          return "!";
        case types_1.AttributeAction.Hyphen:
          return "|";
        case types_1.AttributeAction.Exists:
          throw new Error("Shouldn't be here");
      }
    }
    function getNamespacedName(token) {
      return "".concat(getNamespace(token.namespace)).concat(escapeName(token.name, charsToEscapeInName));
    }
    function getNamespace(namespace) {
      return namespace !== null ? "".concat(namespace === "*" ? "*" : escapeName(namespace, charsToEscapeInName), "|") : "";
    }
    function escapeName(str, charsToEscape) {
      var lastIdx = 0;
      var ret = "";
      for (var i = 0; i < str.length; i++) {
        if (charsToEscape.has(str.charCodeAt(i))) {
          ret += "".concat(str.slice(lastIdx, i), "\\").concat(str.charAt(i));
          lastIdx = i + 1;
        }
      }
      return ret.length > 0 ? ret + str.slice(lastIdx) : str;
    }
  }
});

// node_modules/css-what/lib/commonjs/index.js
var require_commonjs = __commonJS({
  "node_modules/css-what/lib/commonjs/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m)
        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
          __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.stringify = exports2.parse = exports2.isTraversal = void 0;
    __exportStar(require_types(), exports2);
    var parse_1 = require_parse3();
    Object.defineProperty(exports2, "isTraversal", { enumerable: true, get: function() {
      return parse_1.isTraversal;
    } });
    Object.defineProperty(exports2, "parse", { enumerable: true, get: function() {
      return parse_1.parse;
    } });
    var stringify_1 = require_stringify4();
    Object.defineProperty(exports2, "stringify", { enumerable: true, get: function() {
      return stringify_1.stringify;
    } });
  }
});

// node_modules/css-select/lib/procedure.js
var require_procedure = __commonJS({
  "node_modules/css-select/lib/procedure.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isTraversal = exports2.procedure = void 0;
    exports2.procedure = {
      universal: 50,
      tag: 30,
      attribute: 1,
      pseudo: 0,
      "pseudo-element": 0,
      "column-combinator": -1,
      descendant: -1,
      child: -1,
      parent: -1,
      sibling: -1,
      adjacent: -1,
      _flexibleDescendant: -1
    };
    function isTraversal(t) {
      return exports2.procedure[t.type] < 0;
    }
    exports2.isTraversal = isTraversal;
  }
});

// node_modules/css-select/lib/sort.js
var require_sort = __commonJS({
  "node_modules/css-select/lib/sort.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var css_what_1 = require_commonjs();
    var procedure_1 = require_procedure();
    var attributes = {
      exists: 10,
      equals: 8,
      not: 7,
      start: 6,
      end: 6,
      any: 5,
      hyphen: 4,
      element: 4
    };
    function sortByProcedure(arr) {
      var procs = arr.map(getProcedure);
      for (var i = 1; i < arr.length; i++) {
        var procNew = procs[i];
        if (procNew < 0)
          continue;
        for (var j = i - 1; j >= 0 && procNew < procs[j]; j--) {
          var token = arr[j + 1];
          arr[j + 1] = arr[j];
          arr[j] = token;
          procs[j + 1] = procs[j];
          procs[j] = procNew;
        }
      }
    }
    exports2.default = sortByProcedure;
    function getProcedure(token) {
      var proc = procedure_1.procedure[token.type];
      if (token.type === css_what_1.SelectorType.Attribute) {
        proc = attributes[token.action];
        if (proc === attributes.equals && token.name === "id") {
          proc = 9;
        }
        if (token.ignoreCase) {
          proc >>= 1;
        }
      } else if (token.type === css_what_1.SelectorType.Pseudo) {
        if (!token.data) {
          proc = 3;
        } else if (token.name === "has" || token.name === "contains") {
          proc = 0;
        } else if (Array.isArray(token.data)) {
          proc = 0;
          for (var i = 0; i < token.data.length; i++) {
            if (token.data[i].length !== 1)
              continue;
            var cur = getProcedure(token.data[i][0]);
            if (cur === 0) {
              proc = 0;
              break;
            }
            if (cur > proc)
              proc = cur;
          }
          if (token.data.length > 1 && proc > 0)
            proc -= 1;
        } else {
          proc = 1;
        }
      }
      return proc;
    }
  }
});

// node_modules/css-select/lib/attributes.js
var require_attributes = __commonJS({
  "node_modules/css-select/lib/attributes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.attributeRules = void 0;
    var boolbase_1 = require_boolbase();
    var reChars = /[-[\]{}()*+?.,\\^$|#\s]/g;
    function escapeRegex(value) {
      return value.replace(reChars, "\\$&");
    }
    var caseInsensitiveAttributes = /* @__PURE__ */ new Set([
      "accept",
      "accept-charset",
      "align",
      "alink",
      "axis",
      "bgcolor",
      "charset",
      "checked",
      "clear",
      "codetype",
      "color",
      "compact",
      "declare",
      "defer",
      "dir",
      "direction",
      "disabled",
      "enctype",
      "face",
      "frame",
      "hreflang",
      "http-equiv",
      "lang",
      "language",
      "link",
      "media",
      "method",
      "multiple",
      "nohref",
      "noresize",
      "noshade",
      "nowrap",
      "readonly",
      "rel",
      "rev",
      "rules",
      "scope",
      "scrolling",
      "selected",
      "shape",
      "target",
      "text",
      "type",
      "valign",
      "valuetype",
      "vlink"
    ]);
    function shouldIgnoreCase(selector, options) {
      return typeof selector.ignoreCase === "boolean" ? selector.ignoreCase : selector.ignoreCase === "quirks" ? !!options.quirksMode : !options.xmlMode && caseInsensitiveAttributes.has(selector.name);
    }
    exports2.attributeRules = {
      equals: function(next, data, options) {
        var adapter = options.adapter;
        var name = data.name;
        var value = data.value;
        if (shouldIgnoreCase(data, options)) {
          value = value.toLowerCase();
          return function(elem) {
            var attr = adapter.getAttributeValue(elem, name);
            return attr != null && attr.length === value.length && attr.toLowerCase() === value && next(elem);
          };
        }
        return function(elem) {
          return adapter.getAttributeValue(elem, name) === value && next(elem);
        };
      },
      hyphen: function(next, data, options) {
        var adapter = options.adapter;
        var name = data.name;
        var value = data.value;
        var len = value.length;
        if (shouldIgnoreCase(data, options)) {
          value = value.toLowerCase();
          return function hyphenIC(elem) {
            var attr = adapter.getAttributeValue(elem, name);
            return attr != null && (attr.length === len || attr.charAt(len) === "-") && attr.substr(0, len).toLowerCase() === value && next(elem);
          };
        }
        return function hyphen(elem) {
          var attr = adapter.getAttributeValue(elem, name);
          return attr != null && (attr.length === len || attr.charAt(len) === "-") && attr.substr(0, len) === value && next(elem);
        };
      },
      element: function(next, data, options) {
        var adapter = options.adapter;
        var name = data.name, value = data.value;
        if (/\s/.test(value)) {
          return boolbase_1.falseFunc;
        }
        var regex = new RegExp("(?:^|\\s)".concat(escapeRegex(value), "(?:$|\\s)"), shouldIgnoreCase(data, options) ? "i" : "");
        return function element(elem) {
          var attr = adapter.getAttributeValue(elem, name);
          return attr != null && attr.length >= value.length && regex.test(attr) && next(elem);
        };
      },
      exists: function(next, _a, _b) {
        var name = _a.name;
        var adapter = _b.adapter;
        return function(elem) {
          return adapter.hasAttrib(elem, name) && next(elem);
        };
      },
      start: function(next, data, options) {
        var adapter = options.adapter;
        var name = data.name;
        var value = data.value;
        var len = value.length;
        if (len === 0) {
          return boolbase_1.falseFunc;
        }
        if (shouldIgnoreCase(data, options)) {
          value = value.toLowerCase();
          return function(elem) {
            var attr = adapter.getAttributeValue(elem, name);
            return attr != null && attr.length >= len && attr.substr(0, len).toLowerCase() === value && next(elem);
          };
        }
        return function(elem) {
          var _a;
          return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.startsWith(value)) && next(elem);
        };
      },
      end: function(next, data, options) {
        var adapter = options.adapter;
        var name = data.name;
        var value = data.value;
        var len = -value.length;
        if (len === 0) {
          return boolbase_1.falseFunc;
        }
        if (shouldIgnoreCase(data, options)) {
          value = value.toLowerCase();
          return function(elem) {
            var _a;
            return ((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.substr(len).toLowerCase()) === value && next(elem);
          };
        }
        return function(elem) {
          var _a;
          return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.endsWith(value)) && next(elem);
        };
      },
      any: function(next, data, options) {
        var adapter = options.adapter;
        var name = data.name, value = data.value;
        if (value === "") {
          return boolbase_1.falseFunc;
        }
        if (shouldIgnoreCase(data, options)) {
          var regex_1 = new RegExp(escapeRegex(value), "i");
          return function anyIC(elem) {
            var attr = adapter.getAttributeValue(elem, name);
            return attr != null && attr.length >= value.length && regex_1.test(attr) && next(elem);
          };
        }
        return function(elem) {
          var _a;
          return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.includes(value)) && next(elem);
        };
      },
      not: function(next, data, options) {
        var adapter = options.adapter;
        var name = data.name;
        var value = data.value;
        if (value === "") {
          return function(elem) {
            return !!adapter.getAttributeValue(elem, name) && next(elem);
          };
        } else if (shouldIgnoreCase(data, options)) {
          value = value.toLowerCase();
          return function(elem) {
            var attr = adapter.getAttributeValue(elem, name);
            return (attr == null || attr.length !== value.length || attr.toLowerCase() !== value) && next(elem);
          };
        }
        return function(elem) {
          return adapter.getAttributeValue(elem, name) !== value && next(elem);
        };
      }
    };
  }
});

// node_modules/nth-check/lib/parse.js
var require_parse4 = __commonJS({
  "node_modules/nth-check/lib/parse.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.parse = void 0;
    var whitespace = /* @__PURE__ */ new Set([9, 10, 12, 13, 32]);
    var ZERO = "0".charCodeAt(0);
    var NINE = "9".charCodeAt(0);
    function parse(formula) {
      formula = formula.trim().toLowerCase();
      if (formula === "even") {
        return [2, 0];
      } else if (formula === "odd") {
        return [2, 1];
      }
      var idx = 0;
      var a = 0;
      var sign = readSign();
      var number = readNumber();
      if (idx < formula.length && formula.charAt(idx) === "n") {
        idx++;
        a = sign * (number !== null && number !== void 0 ? number : 1);
        skipWhitespace();
        if (idx < formula.length) {
          sign = readSign();
          skipWhitespace();
          number = readNumber();
        } else {
          sign = number = 0;
        }
      }
      if (number === null || idx < formula.length) {
        throw new Error("n-th rule couldn't be parsed ('".concat(formula, "')"));
      }
      return [a, sign * number];
      function readSign() {
        if (formula.charAt(idx) === "-") {
          idx++;
          return -1;
        }
        if (formula.charAt(idx) === "+") {
          idx++;
        }
        return 1;
      }
      function readNumber() {
        var start = idx;
        var value = 0;
        while (idx < formula.length && formula.charCodeAt(idx) >= ZERO && formula.charCodeAt(idx) <= NINE) {
          value = value * 10 + (formula.charCodeAt(idx) - ZERO);
          idx++;
        }
        return idx === start ? null : value;
      }
      function skipWhitespace() {
        while (idx < formula.length && whitespace.has(formula.charCodeAt(idx))) {
          idx++;
        }
      }
    }
    exports2.parse = parse;
  }
});

// node_modules/nth-check/lib/compile.js
var require_compile = __commonJS({
  "node_modules/nth-check/lib/compile.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.generate = exports2.compile = void 0;
    var boolbase_1 = __importDefault(require_boolbase());
    function compile(parsed) {
      var a = parsed[0];
      var b = parsed[1] - 1;
      if (b < 0 && a <= 0)
        return boolbase_1.default.falseFunc;
      if (a === -1)
        return function(index) {
          return index <= b;
        };
      if (a === 0)
        return function(index) {
          return index === b;
        };
      if (a === 1)
        return b < 0 ? boolbase_1.default.trueFunc : function(index) {
          return index >= b;
        };
      var absA = Math.abs(a);
      var bMod = (b % absA + absA) % absA;
      return a > 1 ? function(index) {
        return index >= b && index % absA === bMod;
      } : function(index) {
        return index <= b && index % absA === bMod;
      };
    }
    exports2.compile = compile;
    function generate(parsed) {
      var a = parsed[0];
      var b = parsed[1] - 1;
      var n = 0;
      if (a < 0) {
        var aPos_1 = -a;
        var minValue_1 = (b % aPos_1 + aPos_1) % aPos_1;
        return function() {
          var val = minValue_1 + aPos_1 * n++;
          return val > b ? null : val;
        };
      }
      if (a === 0)
        return b < 0 ? function() {
          return null;
        } : function() {
          return n++ === 0 ? b : null;
        };
      if (b < 0) {
        b += a * Math.ceil(-b / a);
      }
      return function() {
        return a * n++ + b;
      };
    }
    exports2.generate = generate;
  }
});

// node_modules/nth-check/lib/index.js
var require_lib7 = __commonJS({
  "node_modules/nth-check/lib/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.sequence = exports2.generate = exports2.compile = exports2.parse = void 0;
    var parse_js_1 = require_parse4();
    Object.defineProperty(exports2, "parse", { enumerable: true, get: function() {
      return parse_js_1.parse;
    } });
    var compile_js_1 = require_compile();
    Object.defineProperty(exports2, "compile", { enumerable: true, get: function() {
      return compile_js_1.compile;
    } });
    Object.defineProperty(exports2, "generate", { enumerable: true, get: function() {
      return compile_js_1.generate;
    } });
    function nthCheck(formula) {
      return (0, compile_js_1.compile)((0, parse_js_1.parse)(formula));
    }
    exports2.default = nthCheck;
    function sequence(formula) {
      return (0, compile_js_1.generate)((0, parse_js_1.parse)(formula));
    }
    exports2.sequence = sequence;
  }
});

// node_modules/css-select/lib/pseudo-selectors/filters.js
var require_filters = __commonJS({
  "node_modules/css-select/lib/pseudo-selectors/filters.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.filters = void 0;
    var nth_check_1 = __importDefault(require_lib7());
    var boolbase_1 = require_boolbase();
    function getChildFunc(next, adapter) {
      return function(elem) {
        var parent = adapter.getParent(elem);
        return parent != null && adapter.isTag(parent) && next(elem);
      };
    }
    exports2.filters = {
      contains: function(next, text, _a) {
        var adapter = _a.adapter;
        return function contains(elem) {
          return next(elem) && adapter.getText(elem).includes(text);
        };
      },
      icontains: function(next, text, _a) {
        var adapter = _a.adapter;
        var itext = text.toLowerCase();
        return function icontains(elem) {
          return next(elem) && adapter.getText(elem).toLowerCase().includes(itext);
        };
      },
      "nth-child": function(next, rule, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        var func = (0, nth_check_1.default)(rule);
        if (func === boolbase_1.falseFunc)
          return boolbase_1.falseFunc;
        if (func === boolbase_1.trueFunc)
          return getChildFunc(next, adapter);
        return function nthChild(elem) {
          var siblings = adapter.getSiblings(elem);
          var pos = 0;
          for (var i = 0; i < siblings.length; i++) {
            if (equals(elem, siblings[i]))
              break;
            if (adapter.isTag(siblings[i])) {
              pos++;
            }
          }
          return func(pos) && next(elem);
        };
      },
      "nth-last-child": function(next, rule, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        var func = (0, nth_check_1.default)(rule);
        if (func === boolbase_1.falseFunc)
          return boolbase_1.falseFunc;
        if (func === boolbase_1.trueFunc)
          return getChildFunc(next, adapter);
        return function nthLastChild(elem) {
          var siblings = adapter.getSiblings(elem);
          var pos = 0;
          for (var i = siblings.length - 1; i >= 0; i--) {
            if (equals(elem, siblings[i]))
              break;
            if (adapter.isTag(siblings[i])) {
              pos++;
            }
          }
          return func(pos) && next(elem);
        };
      },
      "nth-of-type": function(next, rule, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        var func = (0, nth_check_1.default)(rule);
        if (func === boolbase_1.falseFunc)
          return boolbase_1.falseFunc;
        if (func === boolbase_1.trueFunc)
          return getChildFunc(next, adapter);
        return function nthOfType(elem) {
          var siblings = adapter.getSiblings(elem);
          var pos = 0;
          for (var i = 0; i < siblings.length; i++) {
            var currentSibling = siblings[i];
            if (equals(elem, currentSibling))
              break;
            if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === adapter.getName(elem)) {
              pos++;
            }
          }
          return func(pos) && next(elem);
        };
      },
      "nth-last-of-type": function(next, rule, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        var func = (0, nth_check_1.default)(rule);
        if (func === boolbase_1.falseFunc)
          return boolbase_1.falseFunc;
        if (func === boolbase_1.trueFunc)
          return getChildFunc(next, adapter);
        return function nthLastOfType(elem) {
          var siblings = adapter.getSiblings(elem);
          var pos = 0;
          for (var i = siblings.length - 1; i >= 0; i--) {
            var currentSibling = siblings[i];
            if (equals(elem, currentSibling))
              break;
            if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === adapter.getName(elem)) {
              pos++;
            }
          }
          return func(pos) && next(elem);
        };
      },
      root: function(next, _rule, _a) {
        var adapter = _a.adapter;
        return function(elem) {
          var parent = adapter.getParent(elem);
          return (parent == null || !adapter.isTag(parent)) && next(elem);
        };
      },
      scope: function(next, rule, options, context) {
        var equals = options.equals;
        if (!context || context.length === 0) {
          return exports2.filters.root(next, rule, options);
        }
        if (context.length === 1) {
          return function(elem) {
            return equals(context[0], elem) && next(elem);
          };
        }
        return function(elem) {
          return context.includes(elem) && next(elem);
        };
      },
      hover: dynamicStatePseudo("isHovered"),
      visited: dynamicStatePseudo("isVisited"),
      active: dynamicStatePseudo("isActive")
    };
    function dynamicStatePseudo(name) {
      return function dynamicPseudo(next, _rule, _a) {
        var adapter = _a.adapter;
        var func = adapter[name];
        if (typeof func !== "function") {
          return boolbase_1.falseFunc;
        }
        return function active(elem) {
          return func(elem) && next(elem);
        };
      };
    }
  }
});

// node_modules/css-select/lib/pseudo-selectors/pseudos.js
var require_pseudos = __commonJS({
  "node_modules/css-select/lib/pseudo-selectors/pseudos.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.verifyPseudoArgs = exports2.pseudos = void 0;
    exports2.pseudos = {
      empty: function(elem, _a) {
        var adapter = _a.adapter;
        return !adapter.getChildren(elem).some(function(elem2) {
          return adapter.isTag(elem2) || adapter.getText(elem2) !== "";
        });
      },
      "first-child": function(elem, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        var firstChild = adapter.getSiblings(elem).find(function(elem2) {
          return adapter.isTag(elem2);
        });
        return firstChild != null && equals(elem, firstChild);
      },
      "last-child": function(elem, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        var siblings = adapter.getSiblings(elem);
        for (var i = siblings.length - 1; i >= 0; i--) {
          if (equals(elem, siblings[i]))
            return true;
          if (adapter.isTag(siblings[i]))
            break;
        }
        return false;
      },
      "first-of-type": function(elem, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        var siblings = adapter.getSiblings(elem);
        var elemName = adapter.getName(elem);
        for (var i = 0; i < siblings.length; i++) {
          var currentSibling = siblings[i];
          if (equals(elem, currentSibling))
            return true;
          if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === elemName) {
            break;
          }
        }
        return false;
      },
      "last-of-type": function(elem, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        var siblings = adapter.getSiblings(elem);
        var elemName = adapter.getName(elem);
        for (var i = siblings.length - 1; i >= 0; i--) {
          var currentSibling = siblings[i];
          if (equals(elem, currentSibling))
            return true;
          if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === elemName) {
            break;
          }
        }
        return false;
      },
      "only-of-type": function(elem, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        var elemName = adapter.getName(elem);
        return adapter.getSiblings(elem).every(function(sibling) {
          return equals(elem, sibling) || !adapter.isTag(sibling) || adapter.getName(sibling) !== elemName;
        });
      },
      "only-child": function(elem, _a) {
        var adapter = _a.adapter, equals = _a.equals;
        return adapter.getSiblings(elem).every(function(sibling) {
          return equals(elem, sibling) || !adapter.isTag(sibling);
        });
      }
    };
    function verifyPseudoArgs(func, name, subselect) {
      if (subselect === null) {
        if (func.length > 2) {
          throw new Error("pseudo-selector :".concat(name, " requires an argument"));
        }
      } else if (func.length === 2) {
        throw new Error("pseudo-selector :".concat(name, " doesn't have any arguments"));
      }
    }
    exports2.verifyPseudoArgs = verifyPseudoArgs;
  }
});

// node_modules/css-select/lib/pseudo-selectors/aliases.js
var require_aliases = __commonJS({
  "node_modules/css-select/lib/pseudo-selectors/aliases.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.aliases = void 0;
    exports2.aliases = {
      "any-link": ":is(a, area, link)[href]",
      link: ":any-link:not(:visited)",
      disabled: ":is(\n        :is(button, input, select, textarea, optgroup, option)[disabled],\n        optgroup[disabled] > option,\n        fieldset[disabled]:not(fieldset[disabled] legend:first-of-type *)\n    )",
      enabled: ":not(:disabled)",
      checked: ":is(:is(input[type=radio], input[type=checkbox])[checked], option:selected)",
      required: ":is(input, select, textarea)[required]",
      optional: ":is(input, select, textarea):not([required])",
      selected: "option:is([selected], select:not([multiple]):not(:has(> option[selected])) > :first-of-type)",
      checkbox: "[type=checkbox]",
      file: "[type=file]",
      password: "[type=password]",
      radio: "[type=radio]",
      reset: "[type=reset]",
      image: "[type=image]",
      submit: "[type=submit]",
      parent: ":not(:empty)",
      header: ":is(h1, h2, h3, h4, h5, h6)",
      button: ":is(button, input[type=button])",
      input: ":is(input, textarea, select, button)",
      text: "input:is(:not([type!='']), [type=text])"
    };
  }
});

// node_modules/css-select/lib/pseudo-selectors/subselects.js
var require_subselects = __commonJS({
  "node_modules/css-select/lib/pseudo-selectors/subselects.js"(exports2) {
    "use strict";
    var __spreadArray = exports2 && exports2.__spreadArray || function(to, from, pack) {
      if (pack || arguments.length === 2)
        for (var i = 0, l = from.length, ar; i < l; i++) {
          if (ar || !(i in from)) {
            if (!ar)
              ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
          }
        }
      return to.concat(ar || Array.prototype.slice.call(from));
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.subselects = exports2.getNextSiblings = exports2.ensureIsTag = exports2.PLACEHOLDER_ELEMENT = void 0;
    var boolbase_1 = require_boolbase();
    var procedure_1 = require_procedure();
    exports2.PLACEHOLDER_ELEMENT = {};
    function ensureIsTag(next, adapter) {
      if (next === boolbase_1.falseFunc)
        return boolbase_1.falseFunc;
      return function(elem) {
        return adapter.isTag(elem) && next(elem);
      };
    }
    exports2.ensureIsTag = ensureIsTag;
    function getNextSiblings(elem, adapter) {
      var siblings = adapter.getSiblings(elem);
      if (siblings.length <= 1)
        return [];
      var elemIndex = siblings.indexOf(elem);
      if (elemIndex < 0 || elemIndex === siblings.length - 1)
        return [];
      return siblings.slice(elemIndex + 1).filter(adapter.isTag);
    }
    exports2.getNextSiblings = getNextSiblings;
    var is = function(next, token, options, context, compileToken) {
      var opts = {
        xmlMode: !!options.xmlMode,
        adapter: options.adapter,
        equals: options.equals
      };
      var func = compileToken(token, opts, context);
      return function(elem) {
        return func(elem) && next(elem);
      };
    };
    exports2.subselects = {
      is,
      matches: is,
      where: is,
      not: function(next, token, options, context, compileToken) {
        var opts = {
          xmlMode: !!options.xmlMode,
          adapter: options.adapter,
          equals: options.equals
        };
        var func = compileToken(token, opts, context);
        if (func === boolbase_1.falseFunc)
          return next;
        if (func === boolbase_1.trueFunc)
          return boolbase_1.falseFunc;
        return function not(elem) {
          return !func(elem) && next(elem);
        };
      },
      has: function(next, subselect, options, _context, compileToken) {
        var adapter = options.adapter;
        var opts = {
          xmlMode: !!options.xmlMode,
          adapter,
          equals: options.equals
        };
        var context = subselect.some(function(s) {
          return s.some(procedure_1.isTraversal);
        }) ? [exports2.PLACEHOLDER_ELEMENT] : void 0;
        var compiled = compileToken(subselect, opts, context);
        if (compiled === boolbase_1.falseFunc)
          return boolbase_1.falseFunc;
        if (compiled === boolbase_1.trueFunc) {
          return function(elem) {
            return adapter.getChildren(elem).some(adapter.isTag) && next(elem);
          };
        }
        var hasElement = ensureIsTag(compiled, adapter);
        var _a = compiled.shouldTestNextSiblings, shouldTestNextSiblings = _a === void 0 ? false : _a;
        if (context) {
          return function(elem) {
            context[0] = elem;
            var childs = adapter.getChildren(elem);
            var nextElements = shouldTestNextSiblings ? __spreadArray(__spreadArray([], childs, true), getNextSiblings(elem, adapter), true) : childs;
            return next(elem) && adapter.existsOne(hasElement, nextElements);
          };
        }
        return function(elem) {
          return next(elem) && adapter.existsOne(hasElement, adapter.getChildren(elem));
        };
      }
    };
  }
});

// node_modules/css-select/lib/pseudo-selectors/index.js
var require_pseudo_selectors = __commonJS({
  "node_modules/css-select/lib/pseudo-selectors/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.compilePseudoSelector = exports2.aliases = exports2.pseudos = exports2.filters = void 0;
    var boolbase_1 = require_boolbase();
    var css_what_1 = require_commonjs();
    var filters_1 = require_filters();
    Object.defineProperty(exports2, "filters", { enumerable: true, get: function() {
      return filters_1.filters;
    } });
    var pseudos_1 = require_pseudos();
    Object.defineProperty(exports2, "pseudos", { enumerable: true, get: function() {
      return pseudos_1.pseudos;
    } });
    var aliases_1 = require_aliases();
    Object.defineProperty(exports2, "aliases", { enumerable: true, get: function() {
      return aliases_1.aliases;
    } });
    var subselects_1 = require_subselects();
    function compilePseudoSelector(next, selector, options, context, compileToken) {
      var name = selector.name, data = selector.data;
      if (Array.isArray(data)) {
        return subselects_1.subselects[name](next, data, options, context, compileToken);
      }
      if (name in aliases_1.aliases) {
        if (data != null) {
          throw new Error("Pseudo ".concat(name, " doesn't have any arguments"));
        }
        var alias = (0, css_what_1.parse)(aliases_1.aliases[name]);
        return subselects_1.subselects.is(next, alias, options, context, compileToken);
      }
      if (name in filters_1.filters) {
        return filters_1.filters[name](next, data, options, context);
      }
      if (name in pseudos_1.pseudos) {
        var pseudo_1 = pseudos_1.pseudos[name];
        (0, pseudos_1.verifyPseudoArgs)(pseudo_1, name, data);
        return pseudo_1 === boolbase_1.falseFunc ? boolbase_1.falseFunc : next === boolbase_1.trueFunc ? function(elem) {
          return pseudo_1(elem, options, data);
        } : function(elem) {
          return pseudo_1(elem, options, data) && next(elem);
        };
      }
      throw new Error("unmatched pseudo-class :".concat(name));
    }
    exports2.compilePseudoSelector = compilePseudoSelector;
  }
});

// node_modules/css-select/lib/general.js
var require_general = __commonJS({
  "node_modules/css-select/lib/general.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.compileGeneralSelector = void 0;
    var attributes_1 = require_attributes();
    var pseudo_selectors_1 = require_pseudo_selectors();
    var css_what_1 = require_commonjs();
    function compileGeneralSelector(next, selector, options, context, compileToken) {
      var adapter = options.adapter, equals = options.equals;
      switch (selector.type) {
        case css_what_1.SelectorType.PseudoElement: {
          throw new Error("Pseudo-elements are not supported by css-select");
        }
        case css_what_1.SelectorType.ColumnCombinator: {
          throw new Error("Column combinators are not yet supported by css-select");
        }
        case css_what_1.SelectorType.Attribute: {
          if (selector.namespace != null) {
            throw new Error("Namespaced attributes are not yet supported by css-select");
          }
          if (!options.xmlMode || options.lowerCaseAttributeNames) {
            selector.name = selector.name.toLowerCase();
          }
          return attributes_1.attributeRules[selector.action](next, selector, options);
        }
        case css_what_1.SelectorType.Pseudo: {
          return (0, pseudo_selectors_1.compilePseudoSelector)(next, selector, options, context, compileToken);
        }
        case css_what_1.SelectorType.Tag: {
          if (selector.namespace != null) {
            throw new Error("Namespaced tag names are not yet supported by css-select");
          }
          var name_1 = selector.name;
          if (!options.xmlMode || options.lowerCaseTags) {
            name_1 = name_1.toLowerCase();
          }
          return function tag(elem) {
            return adapter.getName(elem) === name_1 && next(elem);
          };
        }
        case css_what_1.SelectorType.Descendant: {
          if (options.cacheResults === false || typeof WeakSet === "undefined") {
            return function descendant(elem) {
              var current = elem;
              while (current = adapter.getParent(current)) {
                if (adapter.isTag(current) && next(current)) {
                  return true;
                }
              }
              return false;
            };
          }
          var isFalseCache_1 = /* @__PURE__ */ new WeakSet();
          return function cachedDescendant(elem) {
            var current = elem;
            while (current = adapter.getParent(current)) {
              if (!isFalseCache_1.has(current)) {
                if (adapter.isTag(current) && next(current)) {
                  return true;
                }
                isFalseCache_1.add(current);
              }
            }
            return false;
          };
        }
        case "_flexibleDescendant": {
          return function flexibleDescendant(elem) {
            var current = elem;
            do {
              if (adapter.isTag(current) && next(current))
                return true;
            } while (current = adapter.getParent(current));
            return false;
          };
        }
        case css_what_1.SelectorType.Parent: {
          return function parent(elem) {
            return adapter.getChildren(elem).some(function(elem2) {
              return adapter.isTag(elem2) && next(elem2);
            });
          };
        }
        case css_what_1.SelectorType.Child: {
          return function child(elem) {
            var parent = adapter.getParent(elem);
            return parent != null && adapter.isTag(parent) && next(parent);
          };
        }
        case css_what_1.SelectorType.Sibling: {
          return function sibling(elem) {
            var siblings = adapter.getSiblings(elem);
            for (var i = 0; i < siblings.length; i++) {
              var currentSibling = siblings[i];
              if (equals(elem, currentSibling))
                break;
              if (adapter.isTag(currentSibling) && next(currentSibling)) {
                return true;
              }
            }
            return false;
          };
        }
        case css_what_1.SelectorType.Adjacent: {
          if (adapter.prevElementSibling) {
            return function adjacent(elem) {
              var previous = adapter.prevElementSibling(elem);
              return previous != null && next(previous);
            };
          }
          return function adjacent(elem) {
            var siblings = adapter.getSiblings(elem);
            var lastElement;
            for (var i = 0; i < siblings.length; i++) {
              var currentSibling = siblings[i];
              if (equals(elem, currentSibling))
                break;
              if (adapter.isTag(currentSibling)) {
                lastElement = currentSibling;
              }
            }
            return !!lastElement && next(lastElement);
          };
        }
        case css_what_1.SelectorType.Universal: {
          if (selector.namespace != null && selector.namespace !== "*") {
            throw new Error("Namespaced universal selectors are not yet supported by css-select");
          }
          return next;
        }
      }
    }
    exports2.compileGeneralSelector = compileGeneralSelector;
  }
});

// node_modules/css-select/lib/compile.js
var require_compile2 = __commonJS({
  "node_modules/css-select/lib/compile.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.compileToken = exports2.compileUnsafe = exports2.compile = void 0;
    var css_what_1 = require_commonjs();
    var boolbase_1 = require_boolbase();
    var sort_1 = __importDefault(require_sort());
    var procedure_1 = require_procedure();
    var general_1 = require_general();
    var subselects_1 = require_subselects();
    function compile(selector, options, context) {
      var next = compileUnsafe(selector, options, context);
      return (0, subselects_1.ensureIsTag)(next, options.adapter);
    }
    exports2.compile = compile;
    function compileUnsafe(selector, options, context) {
      var token = typeof selector === "string" ? (0, css_what_1.parse)(selector) : selector;
      return compileToken(token, options, context);
    }
    exports2.compileUnsafe = compileUnsafe;
    function includesScopePseudo(t) {
      return t.type === "pseudo" && (t.name === "scope" || Array.isArray(t.data) && t.data.some(function(data) {
        return data.some(includesScopePseudo);
      }));
    }
    var DESCENDANT_TOKEN = { type: css_what_1.SelectorType.Descendant };
    var FLEXIBLE_DESCENDANT_TOKEN = {
      type: "_flexibleDescendant"
    };
    var SCOPE_TOKEN = {
      type: css_what_1.SelectorType.Pseudo,
      name: "scope",
      data: null
    };
    function absolutize(token, _a, context) {
      var adapter = _a.adapter;
      var hasContext = !!(context === null || context === void 0 ? void 0 : context.every(function(e) {
        var parent = adapter.isTag(e) && adapter.getParent(e);
        return e === subselects_1.PLACEHOLDER_ELEMENT || parent && adapter.isTag(parent);
      }));
      for (var _i = 0, token_1 = token; _i < token_1.length; _i++) {
        var t = token_1[_i];
        if (t.length > 0 && (0, procedure_1.isTraversal)(t[0]) && t[0].type !== "descendant") {
        } else if (hasContext && !t.some(includesScopePseudo)) {
          t.unshift(DESCENDANT_TOKEN);
        } else {
          continue;
        }
        t.unshift(SCOPE_TOKEN);
      }
    }
    function compileToken(token, options, context) {
      var _a;
      token = token.filter(function(t) {
        return t.length > 0;
      });
      token.forEach(sort_1.default);
      context = (_a = options.context) !== null && _a !== void 0 ? _a : context;
      var isArrayContext = Array.isArray(context);
      var finalContext = context && (Array.isArray(context) ? context : [context]);
      absolutize(token, options, finalContext);
      var shouldTestNextSiblings = false;
      var query = token.map(function(rules) {
        if (rules.length >= 2) {
          var first = rules[0], second = rules[1];
          if (first.type !== "pseudo" || first.name !== "scope") {
          } else if (isArrayContext && second.type === "descendant") {
            rules[1] = FLEXIBLE_DESCENDANT_TOKEN;
          } else if (second.type === "adjacent" || second.type === "sibling") {
            shouldTestNextSiblings = true;
          }
        }
        return compileRules(rules, options, finalContext);
      }).reduce(reduceRules, boolbase_1.falseFunc);
      query.shouldTestNextSiblings = shouldTestNextSiblings;
      return query;
    }
    exports2.compileToken = compileToken;
    function compileRules(rules, options, context) {
      var _a;
      return rules.reduce(function(previous, rule) {
        return previous === boolbase_1.falseFunc ? boolbase_1.falseFunc : (0, general_1.compileGeneralSelector)(previous, rule, options, context, compileToken);
      }, (_a = options.rootFunc) !== null && _a !== void 0 ? _a : boolbase_1.trueFunc);
    }
    function reduceRules(a, b) {
      if (b === boolbase_1.falseFunc || a === boolbase_1.trueFunc) {
        return a;
      }
      if (a === boolbase_1.falseFunc || b === boolbase_1.trueFunc) {
        return b;
      }
      return function combine(elem) {
        return a(elem) || b(elem);
      };
    }
  }
});

// node_modules/css-select/lib/index.js
var require_lib8 = __commonJS({
  "node_modules/css-select/lib/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0)
        k2 = k;
      o[k2] = m[k];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    } : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod)
          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
            __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.aliases = exports2.pseudos = exports2.filters = exports2.is = exports2.selectOne = exports2.selectAll = exports2.prepareContext = exports2._compileToken = exports2._compileUnsafe = exports2.compile = void 0;
    var DomUtils = __importStar(require_lib6());
    var boolbase_1 = require_boolbase();
    var compile_1 = require_compile2();
    var subselects_1 = require_subselects();
    var defaultEquals = function(a, b) {
      return a === b;
    };
    var defaultOptions = {
      adapter: DomUtils,
      equals: defaultEquals
    };
    function convertOptionFormats(options) {
      var _a, _b, _c, _d;
      var opts = options !== null && options !== void 0 ? options : defaultOptions;
      (_a = opts.adapter) !== null && _a !== void 0 ? _a : opts.adapter = DomUtils;
      (_b = opts.equals) !== null && _b !== void 0 ? _b : opts.equals = (_d = (_c = opts.adapter) === null || _c === void 0 ? void 0 : _c.equals) !== null && _d !== void 0 ? _d : defaultEquals;
      return opts;
    }
    function wrapCompile(func) {
      return function addAdapter(selector, options, context) {
        var opts = convertOptionFormats(options);
        return func(selector, opts, context);
      };
    }
    exports2.compile = wrapCompile(compile_1.compile);
    exports2._compileUnsafe = wrapCompile(compile_1.compileUnsafe);
    exports2._compileToken = wrapCompile(compile_1.compileToken);
    function getSelectorFunc(searchFunc) {
      return function select(query, elements, options) {
        var opts = convertOptionFormats(options);
        if (typeof query !== "function") {
          query = (0, compile_1.compileUnsafe)(query, opts, elements);
        }
        var filteredElements = prepareContext(elements, opts.adapter, query.shouldTestNextSiblings);
        return searchFunc(query, filteredElements, opts);
      };
    }
    function prepareContext(elems, adapter, shouldTestNextSiblings) {
      if (shouldTestNextSiblings === void 0) {
        shouldTestNextSiblings = false;
      }
      if (shouldTestNextSiblings) {
        elems = appendNextSiblings(elems, adapter);
      }
      return Array.isArray(elems) ? adapter.removeSubsets(elems) : adapter.getChildren(elems);
    }
    exports2.prepareContext = prepareContext;
    function appendNextSiblings(elem, adapter) {
      var elems = Array.isArray(elem) ? elem.slice(0) : [elem];
      var elemsLength = elems.length;
      for (var i = 0; i < elemsLength; i++) {
        var nextSiblings = (0, subselects_1.getNextSiblings)(elems[i], adapter);
        elems.push.apply(elems, nextSiblings);
      }
      return elems;
    }
    exports2.selectAll = getSelectorFunc(function(query, elems, options) {
      return query === boolbase_1.falseFunc || !elems || elems.length === 0 ? [] : options.adapter.findAll(query, elems);
    });
    exports2.selectOne = getSelectorFunc(function(query, elems, options) {
      return query === boolbase_1.falseFunc || !elems || elems.length === 0 ? null : options.adapter.findOne(query, elems);
    });
    function is(elem, query, options) {
      var opts = convertOptionFormats(options);
      return (typeof query === "function" ? query : (0, compile_1.compile)(query, opts))(elem);
    }
    exports2.is = is;
    exports2.default = exports2.selectAll;
    var pseudo_selectors_1 = require_pseudo_selectors();
    Object.defineProperty(exports2, "filters", { enumerable: true, get: function() {
      return pseudo_selectors_1.filters;
    } });
    Object.defineProperty(exports2, "pseudos", { enumerable: true, get: function() {
      return pseudo_selectors_1.pseudos;
    } });
    Object.defineProperty(exports2, "aliases", { enumerable: true, get: function() {
      return pseudo_selectors_1.aliases;
    } });
  }
});

// node_modules/svgo/lib/svgo/css-select-adapter.js
var require_css_select_adapter = __commonJS({
  "node_modules/svgo/lib/svgo/css-select-adapter.js"(exports2, module2) {
    "use strict";
    var isTag = (node) => {
      return node.type === "element";
    };
    var existsOne = (test, elems) => {
      return elems.some((elem) => {
        if (isTag(elem)) {
          return test(elem) || existsOne(test, getChildren(elem));
        } else {
          return false;
        }
      });
    };
    var getAttributeValue = (elem, name) => {
      return elem.attributes[name];
    };
    var getChildren = (node) => {
      return node.children || [];
    };
    var getName = (elemAst) => {
      return elemAst.name;
    };
    var getParent = (node) => {
      return node.parentNode || null;
    };
    var getSiblings = (elem) => {
      var parent = getParent(elem);
      return parent ? getChildren(parent) : [];
    };
    var getText = (node) => {
      if (node.children[0].type === "text" && node.children[0].type === "cdata") {
        return node.children[0].value;
      }
      return "";
    };
    var hasAttrib = (elem, name) => {
      return elem.attributes[name] !== void 0;
    };
    var removeSubsets = (nodes) => {
      let idx = nodes.length;
      let node;
      let ancestor;
      let replace;
      while (--idx > -1) {
        node = ancestor = nodes[idx];
        nodes[idx] = null;
        replace = true;
        while (ancestor) {
          if (nodes.includes(ancestor)) {
            replace = false;
            nodes.splice(idx, 1);
            break;
          }
          ancestor = getParent(ancestor);
        }
        if (replace) {
          nodes[idx] = node;
        }
      }
      return nodes;
    };
    var findAll = (test, elems) => {
      const result = [];
      for (const elem of elems) {
        if (isTag(elem)) {
          if (test(elem)) {
            result.push(elem);
          }
          result.push(...findAll(test, getChildren(elem)));
        }
      }
      return result;
    };
    var findOne = (test, elems) => {
      for (const elem of elems) {
        if (isTag(elem)) {
          if (test(elem)) {
            return elem;
          }
          const result = findOne(test, getChildren(elem));
          if (result) {
            return result;
          }
        }
      }
      return null;
    };
    var svgoCssSelectAdapter = {
      isTag,
      existsOne,
      getAttributeValue,
      getChildren,
      getName,
      getParent,
      getSiblings,
      getText,
      hasAttrib,
      removeSubsets,
      findAll,
      findOne
    };
    module2.exports = svgoCssSelectAdapter;
  }
});

// node_modules/svgo/lib/xast.js
var require_xast = __commonJS({
  "node_modules/svgo/lib/xast.js"(exports2) {
    "use strict";
    var { selectAll, selectOne, is } = require_lib8();
    var xastAdaptor = require_css_select_adapter();
    var cssSelectOptions = {
      xmlMode: true,
      adapter: xastAdaptor
    };
    var querySelectorAll = (node, selector) => {
      return selectAll(selector, node, cssSelectOptions);
    };
    exports2.querySelectorAll = querySelectorAll;
    var querySelector = (node, selector) => {
      return selectOne(selector, node, cssSelectOptions);
    };
    exports2.querySelector = querySelector;
    var matches = (node, selector) => {
      return is(node, selector, cssSelectOptions);
    };
    exports2.matches = matches;
    var closestByName = (node, name) => {
      let currentNode = node;
      while (currentNode) {
        if (currentNode.type === "element" && currentNode.name === name) {
          return currentNode;
        }
        currentNode = currentNode.parentNode;
      }
      return null;
    };
    exports2.closestByName = closestByName;
    var visitSkip = Symbol();
    exports2.visitSkip = visitSkip;
    var visit = (node, visitor, parentNode) => {
      const callbacks = visitor[node.type];
      if (callbacks && callbacks.enter) {
        const symbol = callbacks.enter(node, parentNode);
        if (symbol === visitSkip) {
          return;
        }
      }
      if (node.type === "root") {
        for (const child of node.children) {
          visit(child, visitor, node);
        }
      }
      if (node.type === "element") {
        if (parentNode.children.includes(node)) {
          for (const child of node.children) {
            visit(child, visitor, node);
          }
        }
      }
      if (callbacks && callbacks.exit) {
        callbacks.exit(node, parentNode);
      }
    };
    exports2.visit = visit;
    var detachNodeFromParent = (node, parentNode) => {
      parentNode.children = parentNode.children.filter((child) => child !== node);
    };
    exports2.detachNodeFromParent = detachNodeFromParent;
  }
});

// node_modules/svgo/lib/svgo/plugins.js
var require_plugins = __commonJS({
  "node_modules/svgo/lib/svgo/plugins.js"(exports2) {
    "use strict";
    var { visit } = require_xast();
    var invokePlugins = (ast, info, plugins, overrides, globalOverrides) => {
      for (const plugin of plugins) {
        const override = overrides == null ? null : overrides[plugin.name];
        if (override === false) {
          continue;
        }
        const params = { ...plugin.params, ...globalOverrides, ...override };
        if (plugin.type === "perItem") {
          ast = perItem(ast, info, plugin, params);
        }
        if (plugin.type === "perItemReverse") {
          ast = perItem(ast, info, plugin, params, true);
        }
        if (plugin.type === "full") {
          if (plugin.active) {
            ast = plugin.fn(ast, params, info);
          }
        }
        if (plugin.type === "visitor") {
          if (plugin.active) {
            const visitor = plugin.fn(ast, params, info);
            if (visitor != null) {
              visit(ast, visitor);
            }
          }
        }
      }
      return ast;
    };
    exports2.invokePlugins = invokePlugins;
    function perItem(data, info, plugin, params, reverse) {
      function monkeys(items) {
        items.children = items.children.filter(function(item) {
          if (reverse && item.children) {
            monkeys(item);
          }
          let kept = true;
          if (plugin.active) {
            kept = plugin.fn(item, params, info) !== false;
          }
          if (!reverse && item.children) {
            monkeys(item);
          }
          return kept;
        });
        return items;
      }
      return monkeys(data);
    }
    var createPreset = ({ name, plugins }) => {
      return {
        name,
        type: "full",
        fn: (ast, params, info) => {
          const { floatPrecision, overrides } = params;
          const globalOverrides = {};
          if (floatPrecision != null) {
            globalOverrides.floatPrecision = floatPrecision;
          }
          if (overrides) {
            for (const [pluginName, override] of Object.entries(overrides)) {
              if (override === true) {
                console.warn(`You are trying to enable ${pluginName} which is not part of preset.
Try to put it before or after preset, for example

plugins: [
  {
    name: 'preset-default',
  },
  'cleanupListOfValues'
]
`);
              }
            }
          }
          return invokePlugins(ast, info, plugins, overrides, globalOverrides);
        }
      };
    };
    exports2.createPreset = createPreset;
  }
});

// node_modules/svgo/plugins/removeDoctype.js
var require_removeDoctype = __commonJS({
  "node_modules/svgo/plugins/removeDoctype.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeDoctype";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "removes doctype declaration";
    exports2.fn = () => {
      return {
        doctype: {
          enter: (node, parentNode) => {
            detachNodeFromParent(node, parentNode);
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeXMLProcInst.js
var require_removeXMLProcInst = __commonJS({
  "node_modules/svgo/plugins/removeXMLProcInst.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeXMLProcInst";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "removes XML processing instructions";
    exports2.fn = () => {
      return {
        instruction: {
          enter: (node, parentNode) => {
            if (node.name === "xml") {
              detachNodeFromParent(node, parentNode);
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeComments.js
var require_removeComments = __commonJS({
  "node_modules/svgo/plugins/removeComments.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeComments";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "removes comments";
    exports2.fn = () => {
      return {
        comment: {
          enter: (node, parentNode) => {
            if (node.value.charAt(0) !== "!") {
              detachNodeFromParent(node, parentNode);
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeMetadata.js
var require_removeMetadata = __commonJS({
  "node_modules/svgo/plugins/removeMetadata.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeMetadata";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "removes <metadata>";
    exports2.fn = () => {
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "metadata") {
              detachNodeFromParent(node, parentNode);
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/_collections.js
var require_collections = __commonJS({
  "node_modules/svgo/plugins/_collections.js"(exports2) {
    "use strict";
    exports2.elemsGroups = {
      animation: [
        "animate",
        "animateColor",
        "animateMotion",
        "animateTransform",
        "set"
      ],
      descriptive: ["desc", "metadata", "title"],
      shape: ["circle", "ellipse", "line", "path", "polygon", "polyline", "rect"],
      structural: ["defs", "g", "svg", "symbol", "use"],
      paintServer: [
        "solidColor",
        "linearGradient",
        "radialGradient",
        "meshGradient",
        "pattern",
        "hatch"
      ],
      nonRendering: [
        "linearGradient",
        "radialGradient",
        "pattern",
        "clipPath",
        "mask",
        "marker",
        "symbol",
        "filter",
        "solidColor"
      ],
      container: [
        "a",
        "defs",
        "g",
        "marker",
        "mask",
        "missing-glyph",
        "pattern",
        "svg",
        "switch",
        "symbol",
        "foreignObject"
      ],
      textContent: [
        "altGlyph",
        "altGlyphDef",
        "altGlyphItem",
        "glyph",
        "glyphRef",
        "textPath",
        "text",
        "tref",
        "tspan"
      ],
      textContentChild: ["altGlyph", "textPath", "tref", "tspan"],
      lightSource: [
        "feDiffuseLighting",
        "feSpecularLighting",
        "feDistantLight",
        "fePointLight",
        "feSpotLight"
      ],
      filterPrimitive: [
        "feBlend",
        "feColorMatrix",
        "feComponentTransfer",
        "feComposite",
        "feConvolveMatrix",
        "feDiffuseLighting",
        "feDisplacementMap",
        "feDropShadow",
        "feFlood",
        "feFuncA",
        "feFuncB",
        "feFuncG",
        "feFuncR",
        "feGaussianBlur",
        "feImage",
        "feMerge",
        "feMergeNode",
        "feMorphology",
        "feOffset",
        "feSpecularLighting",
        "feTile",
        "feTurbulence"
      ]
    };
    exports2.textElems = exports2.elemsGroups.textContent.concat("title");
    exports2.pathElems = ["path", "glyph", "missing-glyph"];
    exports2.attrsGroups = {
      animationAddition: ["additive", "accumulate"],
      animationAttributeTarget: ["attributeType", "attributeName"],
      animationEvent: ["onbegin", "onend", "onrepeat", "onload"],
      animationTiming: [
        "begin",
        "dur",
        "end",
        "min",
        "max",
        "restart",
        "repeatCount",
        "repeatDur",
        "fill"
      ],
      animationValue: [
        "calcMode",
        "values",
        "keyTimes",
        "keySplines",
        "from",
        "to",
        "by"
      ],
      conditionalProcessing: [
        "requiredFeatures",
        "requiredExtensions",
        "systemLanguage"
      ],
      core: ["id", "tabindex", "xml:base", "xml:lang", "xml:space"],
      graphicalEvent: [
        "onfocusin",
        "onfocusout",
        "onactivate",
        "onclick",
        "onmousedown",
        "onmouseup",
        "onmouseover",
        "onmousemove",
        "onmouseout",
        "onload"
      ],
      presentation: [
        "alignment-baseline",
        "baseline-shift",
        "clip",
        "clip-path",
        "clip-rule",
        "color",
        "color-interpolation",
        "color-interpolation-filters",
        "color-profile",
        "color-rendering",
        "cursor",
        "direction",
        "display",
        "dominant-baseline",
        "enable-background",
        "fill",
        "fill-opacity",
        "fill-rule",
        "filter",
        "flood-color",
        "flood-opacity",
        "font-family",
        "font-size",
        "font-size-adjust",
        "font-stretch",
        "font-style",
        "font-variant",
        "font-weight",
        "glyph-orientation-horizontal",
        "glyph-orientation-vertical",
        "image-rendering",
        "letter-spacing",
        "lighting-color",
        "marker-end",
        "marker-mid",
        "marker-start",
        "mask",
        "opacity",
        "overflow",
        "paint-order",
        "pointer-events",
        "shape-rendering",
        "stop-color",
        "stop-opacity",
        "stroke",
        "stroke-dasharray",
        "stroke-dashoffset",
        "stroke-linecap",
        "stroke-linejoin",
        "stroke-miterlimit",
        "stroke-opacity",
        "stroke-width",
        "text-anchor",
        "text-decoration",
        "text-overflow",
        "text-rendering",
        "transform",
        "transform-origin",
        "unicode-bidi",
        "vector-effect",
        "visibility",
        "word-spacing",
        "writing-mode"
      ],
      xlink: [
        "xlink:href",
        "xlink:show",
        "xlink:actuate",
        "xlink:type",
        "xlink:role",
        "xlink:arcrole",
        "xlink:title"
      ],
      documentEvent: [
        "onunload",
        "onabort",
        "onerror",
        "onresize",
        "onscroll",
        "onzoom"
      ],
      filterPrimitive: ["x", "y", "width", "height", "result"],
      transferFunction: [
        "type",
        "tableValues",
        "slope",
        "intercept",
        "amplitude",
        "exponent",
        "offset"
      ]
    };
    exports2.attrsGroupsDefaults = {
      core: { "xml:space": "default" },
      presentation: {
        clip: "auto",
        "clip-path": "none",
        "clip-rule": "nonzero",
        mask: "none",
        opacity: "1",
        "stop-color": "#000",
        "stop-opacity": "1",
        "fill-opacity": "1",
        "fill-rule": "nonzero",
        fill: "#000",
        stroke: "none",
        "stroke-width": "1",
        "stroke-linecap": "butt",
        "stroke-linejoin": "miter",
        "stroke-miterlimit": "4",
        "stroke-dasharray": "none",
        "stroke-dashoffset": "0",
        "stroke-opacity": "1",
        "paint-order": "normal",
        "vector-effect": "none",
        display: "inline",
        visibility: "visible",
        "marker-start": "none",
        "marker-mid": "none",
        "marker-end": "none",
        "color-interpolation": "sRGB",
        "color-interpolation-filters": "linearRGB",
        "color-rendering": "auto",
        "shape-rendering": "auto",
        "text-rendering": "auto",
        "image-rendering": "auto",
        "font-style": "normal",
        "font-variant": "normal",
        "font-weight": "normal",
        "font-stretch": "normal",
        "font-size": "medium",
        "font-size-adjust": "none",
        kerning: "auto",
        "letter-spacing": "normal",
        "word-spacing": "normal",
        "text-decoration": "none",
        "text-anchor": "start",
        "text-overflow": "clip",
        "writing-mode": "lr-tb",
        "glyph-orientation-vertical": "auto",
        "glyph-orientation-horizontal": "0deg",
        direction: "ltr",
        "unicode-bidi": "normal",
        "dominant-baseline": "auto",
        "alignment-baseline": "baseline",
        "baseline-shift": "baseline"
      },
      transferFunction: {
        slope: "1",
        intercept: "0",
        amplitude: "1",
        exponent: "1",
        offset: "0"
      }
    };
    exports2.elems = {
      a: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation",
          "xlink"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "target"
        ],
        defaults: {
          target: "_self"
        },
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view",
          "tspan"
        ]
      },
      altGlyph: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation",
          "xlink"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "x",
          "y",
          "dx",
          "dy",
          "glyphRef",
          "format",
          "rotate"
        ]
      },
      altGlyphDef: {
        attrsGroups: ["core"],
        content: ["glyphRef"]
      },
      altGlyphItem: {
        attrsGroups: ["core"],
        content: ["glyphRef", "altGlyphItem"]
      },
      animate: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "animationAddition",
          "animationAttributeTarget",
          "animationEvent",
          "animationTiming",
          "animationValue",
          "presentation",
          "xlink"
        ],
        attrs: ["externalResourcesRequired"],
        contentGroups: ["descriptive"]
      },
      animateColor: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "animationEvent",
          "xlink",
          "animationAttributeTarget",
          "animationTiming",
          "animationValue",
          "animationAddition",
          "presentation"
        ],
        attrs: ["externalResourcesRequired"],
        contentGroups: ["descriptive"]
      },
      animateMotion: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "animationEvent",
          "xlink",
          "animationTiming",
          "animationValue",
          "animationAddition"
        ],
        attrs: [
          "externalResourcesRequired",
          "path",
          "keyPoints",
          "rotate",
          "origin"
        ],
        defaults: {
          rotate: "0"
        },
        contentGroups: ["descriptive"],
        content: ["mpath"]
      },
      animateTransform: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "animationEvent",
          "xlink",
          "animationAttributeTarget",
          "animationTiming",
          "animationValue",
          "animationAddition"
        ],
        attrs: ["externalResourcesRequired", "type"],
        contentGroups: ["descriptive"]
      },
      circle: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "cx",
          "cy",
          "r"
        ],
        defaults: {
          cx: "0",
          cy: "0"
        },
        contentGroups: ["animation", "descriptive"]
      },
      clipPath: {
        attrsGroups: ["conditionalProcessing", "core", "presentation"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "clipPathUnits"
        ],
        defaults: {
          clipPathUnits: "userSpaceOnUse"
        },
        contentGroups: ["animation", "descriptive", "shape"],
        content: ["text", "use"]
      },
      "color-profile": {
        attrsGroups: ["core", "xlink"],
        attrs: ["local", "name", "rendering-intent"],
        defaults: {
          name: "sRGB",
          "rendering-intent": "auto"
        },
        contentGroups: ["descriptive"]
      },
      cursor: {
        attrsGroups: ["core", "conditionalProcessing", "xlink"],
        attrs: ["externalResourcesRequired", "x", "y"],
        defaults: {
          x: "0",
          y: "0"
        },
        contentGroups: ["descriptive"]
      },
      defs: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: ["class", "style", "externalResourcesRequired", "transform"],
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      desc: {
        attrsGroups: ["core"],
        attrs: ["class", "style"]
      },
      ellipse: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "cx",
          "cy",
          "rx",
          "ry"
        ],
        defaults: {
          cx: "0",
          cy: "0"
        },
        contentGroups: ["animation", "descriptive"]
      },
      feBlend: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: [
          "class",
          "style",
          "in",
          "in2",
          "mode"
        ],
        defaults: {
          mode: "normal"
        },
        content: ["animate", "set"]
      },
      feColorMatrix: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: ["class", "style", "in", "type", "values"],
        defaults: {
          type: "matrix"
        },
        content: ["animate", "set"]
      },
      feComponentTransfer: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: ["class", "style", "in"],
        content: ["feFuncA", "feFuncB", "feFuncG", "feFuncR"]
      },
      feComposite: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: ["class", "style", "in", "in2", "operator", "k1", "k2", "k3", "k4"],
        defaults: {
          operator: "over",
          k1: "0",
          k2: "0",
          k3: "0",
          k4: "0"
        },
        content: ["animate", "set"]
      },
      feConvolveMatrix: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: [
          "class",
          "style",
          "in",
          "order",
          "kernelMatrix",
          "divisor",
          "bias",
          "targetX",
          "targetY",
          "edgeMode",
          "kernelUnitLength",
          "preserveAlpha"
        ],
        defaults: {
          order: "3",
          bias: "0",
          edgeMode: "duplicate",
          preserveAlpha: "false"
        },
        content: ["animate", "set"]
      },
      feDiffuseLighting: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: [
          "class",
          "style",
          "in",
          "surfaceScale",
          "diffuseConstant",
          "kernelUnitLength"
        ],
        defaults: {
          surfaceScale: "1",
          diffuseConstant: "1"
        },
        contentGroups: ["descriptive"],
        content: [
          "feDistantLight",
          "fePointLight",
          "feSpotLight"
        ]
      },
      feDisplacementMap: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: [
          "class",
          "style",
          "in",
          "in2",
          "scale",
          "xChannelSelector",
          "yChannelSelector"
        ],
        defaults: {
          scale: "0",
          xChannelSelector: "A",
          yChannelSelector: "A"
        },
        content: ["animate", "set"]
      },
      feDistantLight: {
        attrsGroups: ["core"],
        attrs: ["azimuth", "elevation"],
        defaults: {
          azimuth: "0",
          elevation: "0"
        },
        content: ["animate", "set"]
      },
      feFlood: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: ["class", "style"],
        content: ["animate", "animateColor", "set"]
      },
      feFuncA: {
        attrsGroups: ["core", "transferFunction"],
        content: ["set", "animate"]
      },
      feFuncB: {
        attrsGroups: ["core", "transferFunction"],
        content: ["set", "animate"]
      },
      feFuncG: {
        attrsGroups: ["core", "transferFunction"],
        content: ["set", "animate"]
      },
      feFuncR: {
        attrsGroups: ["core", "transferFunction"],
        content: ["set", "animate"]
      },
      feGaussianBlur: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: ["class", "style", "in", "stdDeviation"],
        defaults: {
          stdDeviation: "0"
        },
        content: ["set", "animate"]
      },
      feImage: {
        attrsGroups: ["core", "presentation", "filterPrimitive", "xlink"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "preserveAspectRatio",
          "href",
          "xlink:href"
        ],
        defaults: {
          preserveAspectRatio: "xMidYMid meet"
        },
        content: ["animate", "animateTransform", "set"]
      },
      feMerge: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: ["class", "style"],
        content: ["feMergeNode"]
      },
      feMergeNode: {
        attrsGroups: ["core"],
        attrs: ["in"],
        content: ["animate", "set"]
      },
      feMorphology: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: ["class", "style", "in", "operator", "radius"],
        defaults: {
          operator: "erode",
          radius: "0"
        },
        content: ["animate", "set"]
      },
      feOffset: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: ["class", "style", "in", "dx", "dy"],
        defaults: {
          dx: "0",
          dy: "0"
        },
        content: ["animate", "set"]
      },
      fePointLight: {
        attrsGroups: ["core"],
        attrs: ["x", "y", "z"],
        defaults: {
          x: "0",
          y: "0",
          z: "0"
        },
        content: ["animate", "set"]
      },
      feSpecularLighting: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: [
          "class",
          "style",
          "in",
          "surfaceScale",
          "specularConstant",
          "specularExponent",
          "kernelUnitLength"
        ],
        defaults: {
          surfaceScale: "1",
          specularConstant: "1",
          specularExponent: "1"
        },
        contentGroups: [
          "descriptive",
          "lightSource"
        ]
      },
      feSpotLight: {
        attrsGroups: ["core"],
        attrs: [
          "x",
          "y",
          "z",
          "pointsAtX",
          "pointsAtY",
          "pointsAtZ",
          "specularExponent",
          "limitingConeAngle"
        ],
        defaults: {
          x: "0",
          y: "0",
          z: "0",
          pointsAtX: "0",
          pointsAtY: "0",
          pointsAtZ: "0",
          specularExponent: "1"
        },
        content: ["animate", "set"]
      },
      feTile: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: ["class", "style", "in"],
        content: ["animate", "set"]
      },
      feTurbulence: {
        attrsGroups: ["core", "presentation", "filterPrimitive"],
        attrs: [
          "class",
          "style",
          "baseFrequency",
          "numOctaves",
          "seed",
          "stitchTiles",
          "type"
        ],
        defaults: {
          baseFrequency: "0",
          numOctaves: "1",
          seed: "0",
          stitchTiles: "noStitch",
          type: "turbulence"
        },
        content: ["animate", "set"]
      },
      filter: {
        attrsGroups: ["core", "presentation", "xlink"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "x",
          "y",
          "width",
          "height",
          "filterRes",
          "filterUnits",
          "primitiveUnits",
          "href",
          "xlink:href"
        ],
        defaults: {
          primitiveUnits: "userSpaceOnUse",
          x: "-10%",
          y: "-10%",
          width: "120%",
          height: "120%"
        },
        contentGroups: ["descriptive", "filterPrimitive"],
        content: ["animate", "set"]
      },
      font: {
        attrsGroups: ["core", "presentation"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "horiz-origin-x",
          "horiz-origin-y",
          "horiz-adv-x",
          "vert-origin-x",
          "vert-origin-y",
          "vert-adv-y"
        ],
        defaults: {
          "horiz-origin-x": "0",
          "horiz-origin-y": "0"
        },
        contentGroups: ["descriptive"],
        content: ["font-face", "glyph", "hkern", "missing-glyph", "vkern"]
      },
      "font-face": {
        attrsGroups: ["core"],
        attrs: [
          "font-family",
          "font-style",
          "font-variant",
          "font-weight",
          "font-stretch",
          "font-size",
          "unicode-range",
          "units-per-em",
          "panose-1",
          "stemv",
          "stemh",
          "slope",
          "cap-height",
          "x-height",
          "accent-height",
          "ascent",
          "descent",
          "widths",
          "bbox",
          "ideographic",
          "alphabetic",
          "mathematical",
          "hanging",
          "v-ideographic",
          "v-alphabetic",
          "v-mathematical",
          "v-hanging",
          "underline-position",
          "underline-thickness",
          "strikethrough-position",
          "strikethrough-thickness",
          "overline-position",
          "overline-thickness"
        ],
        defaults: {
          "font-style": "all",
          "font-variant": "normal",
          "font-weight": "all",
          "font-stretch": "normal",
          "unicode-range": "U+0-10FFFF",
          "units-per-em": "1000",
          "panose-1": "0 0 0 0 0 0 0 0 0 0",
          slope: "0"
        },
        contentGroups: ["descriptive"],
        content: [
          "font-face-src"
        ]
      },
      "font-face-format": {
        attrsGroups: ["core"],
        attrs: ["string"]
      },
      "font-face-name": {
        attrsGroups: ["core"],
        attrs: ["name"]
      },
      "font-face-src": {
        attrsGroups: ["core"],
        content: ["font-face-name", "font-face-uri"]
      },
      "font-face-uri": {
        attrsGroups: ["core", "xlink"],
        attrs: ["href", "xlink:href"],
        content: ["font-face-format"]
      },
      foreignObject: {
        attrsGroups: [
          "core",
          "conditionalProcessing",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "x",
          "y",
          "width",
          "height"
        ],
        defaults: {
          x: "0",
          y: "0"
        }
      },
      g: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: ["class", "style", "externalResourcesRequired", "transform"],
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      glyph: {
        attrsGroups: ["core", "presentation"],
        attrs: [
          "class",
          "style",
          "d",
          "horiz-adv-x",
          "vert-origin-x",
          "vert-origin-y",
          "vert-adv-y",
          "unicode",
          "glyph-name",
          "orientation",
          "arabic-form",
          "lang"
        ],
        defaults: {
          "arabic-form": "initial"
        },
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      glyphRef: {
        attrsGroups: ["core", "presentation"],
        attrs: [
          "class",
          "style",
          "d",
          "horiz-adv-x",
          "vert-origin-x",
          "vert-origin-y",
          "vert-adv-y"
        ],
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      hatch: {
        attrsGroups: ["core", "presentation", "xlink"],
        attrs: [
          "class",
          "style",
          "x",
          "y",
          "pitch",
          "rotate",
          "hatchUnits",
          "hatchContentUnits",
          "transform"
        ],
        defaults: {
          hatchUnits: "objectBoundingBox",
          hatchContentUnits: "userSpaceOnUse",
          x: "0",
          y: "0",
          pitch: "0",
          rotate: "0"
        },
        contentGroups: ["animation", "descriptive"],
        content: ["hatchPath"]
      },
      hatchPath: {
        attrsGroups: ["core", "presentation", "xlink"],
        attrs: ["class", "style", "d", "offset"],
        defaults: {
          offset: "0"
        },
        contentGroups: ["animation", "descriptive"]
      },
      hkern: {
        attrsGroups: ["core"],
        attrs: ["u1", "g1", "u2", "g2", "k"]
      },
      image: {
        attrsGroups: [
          "core",
          "conditionalProcessing",
          "graphicalEvent",
          "xlink",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "preserveAspectRatio",
          "transform",
          "x",
          "y",
          "width",
          "height",
          "href",
          "xlink:href"
        ],
        defaults: {
          x: "0",
          y: "0",
          preserveAspectRatio: "xMidYMid meet"
        },
        contentGroups: ["animation", "descriptive"]
      },
      line: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "x1",
          "y1",
          "x2",
          "y2"
        ],
        defaults: {
          x1: "0",
          y1: "0",
          x2: "0",
          y2: "0"
        },
        contentGroups: ["animation", "descriptive"]
      },
      linearGradient: {
        attrsGroups: ["core", "presentation", "xlink"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "x1",
          "y1",
          "x2",
          "y2",
          "gradientUnits",
          "gradientTransform",
          "spreadMethod",
          "href",
          "xlink:href"
        ],
        defaults: {
          x1: "0",
          y1: "0",
          x2: "100%",
          y2: "0",
          spreadMethod: "pad"
        },
        contentGroups: ["descriptive"],
        content: ["animate", "animateTransform", "set", "stop"]
      },
      marker: {
        attrsGroups: ["core", "presentation"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "viewBox",
          "preserveAspectRatio",
          "refX",
          "refY",
          "markerUnits",
          "markerWidth",
          "markerHeight",
          "orient"
        ],
        defaults: {
          markerUnits: "strokeWidth",
          refX: "0",
          refY: "0",
          markerWidth: "3",
          markerHeight: "3"
        },
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      mask: {
        attrsGroups: ["conditionalProcessing", "core", "presentation"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "x",
          "y",
          "width",
          "height",
          "mask-type",
          "maskUnits",
          "maskContentUnits"
        ],
        defaults: {
          maskUnits: "objectBoundingBox",
          maskContentUnits: "userSpaceOnUse",
          x: "-10%",
          y: "-10%",
          width: "120%",
          height: "120%"
        },
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      metadata: {
        attrsGroups: ["core"]
      },
      "missing-glyph": {
        attrsGroups: ["core", "presentation"],
        attrs: [
          "class",
          "style",
          "d",
          "horiz-adv-x",
          "vert-origin-x",
          "vert-origin-y",
          "vert-adv-y"
        ],
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      mpath: {
        attrsGroups: ["core", "xlink"],
        attrs: ["externalResourcesRequired", "href", "xlink:href"],
        contentGroups: ["descriptive"]
      },
      path: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "d",
          "pathLength"
        ],
        contentGroups: ["animation", "descriptive"]
      },
      pattern: {
        attrsGroups: ["conditionalProcessing", "core", "presentation", "xlink"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "viewBox",
          "preserveAspectRatio",
          "x",
          "y",
          "width",
          "height",
          "patternUnits",
          "patternContentUnits",
          "patternTransform",
          "href",
          "xlink:href"
        ],
        defaults: {
          patternUnits: "objectBoundingBox",
          patternContentUnits: "userSpaceOnUse",
          x: "0",
          y: "0",
          width: "0",
          height: "0",
          preserveAspectRatio: "xMidYMid meet"
        },
        contentGroups: [
          "animation",
          "descriptive",
          "paintServer",
          "shape",
          "structural"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      polygon: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "points"
        ],
        contentGroups: ["animation", "descriptive"]
      },
      polyline: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "points"
        ],
        contentGroups: ["animation", "descriptive"]
      },
      radialGradient: {
        attrsGroups: ["core", "presentation", "xlink"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "cx",
          "cy",
          "r",
          "fx",
          "fy",
          "fr",
          "gradientUnits",
          "gradientTransform",
          "spreadMethod",
          "href",
          "xlink:href"
        ],
        defaults: {
          gradientUnits: "objectBoundingBox",
          cx: "50%",
          cy: "50%",
          r: "50%"
        },
        contentGroups: ["descriptive"],
        content: ["animate", "animateTransform", "set", "stop"]
      },
      meshGradient: {
        attrsGroups: ["core", "presentation", "xlink"],
        attrs: ["class", "style", "x", "y", "gradientUnits", "transform"],
        contentGroups: ["descriptive", "paintServer", "animation"],
        content: ["meshRow"]
      },
      meshRow: {
        attrsGroups: ["core", "presentation"],
        attrs: ["class", "style"],
        contentGroups: ["descriptive"],
        content: ["meshPatch"]
      },
      meshPatch: {
        attrsGroups: ["core", "presentation"],
        attrs: ["class", "style"],
        contentGroups: ["descriptive"],
        content: ["stop"]
      },
      rect: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "x",
          "y",
          "width",
          "height",
          "rx",
          "ry"
        ],
        defaults: {
          x: "0",
          y: "0"
        },
        contentGroups: ["animation", "descriptive"]
      },
      script: {
        attrsGroups: ["core", "xlink"],
        attrs: ["externalResourcesRequired", "type", "href", "xlink:href"]
      },
      set: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "animation",
          "xlink",
          "animationAttributeTarget",
          "animationTiming"
        ],
        attrs: ["externalResourcesRequired", "to"],
        contentGroups: ["descriptive"]
      },
      solidColor: {
        attrsGroups: ["core", "presentation"],
        attrs: ["class", "style"],
        contentGroups: ["paintServer"]
      },
      stop: {
        attrsGroups: ["core", "presentation"],
        attrs: ["class", "style", "offset", "path"],
        content: ["animate", "animateColor", "set"]
      },
      style: {
        attrsGroups: ["core"],
        attrs: ["type", "media", "title"],
        defaults: {
          type: "text/css"
        }
      },
      svg: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "documentEvent",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "x",
          "y",
          "width",
          "height",
          "viewBox",
          "preserveAspectRatio",
          "zoomAndPan",
          "version",
          "baseProfile",
          "contentScriptType",
          "contentStyleType"
        ],
        defaults: {
          x: "0",
          y: "0",
          width: "100%",
          height: "100%",
          preserveAspectRatio: "xMidYMid meet",
          zoomAndPan: "magnify",
          version: "1.1",
          baseProfile: "none",
          contentScriptType: "application/ecmascript",
          contentStyleType: "text/css"
        },
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      switch: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: ["class", "style", "externalResourcesRequired", "transform"],
        contentGroups: ["animation", "descriptive", "shape"],
        content: [
          "a",
          "foreignObject",
          "g",
          "image",
          "svg",
          "switch",
          "text",
          "use"
        ]
      },
      symbol: {
        attrsGroups: ["core", "graphicalEvent", "presentation"],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "preserveAspectRatio",
          "viewBox",
          "refX",
          "refY"
        ],
        defaults: {
          refX: "0",
          refY: "0"
        },
        contentGroups: [
          "animation",
          "descriptive",
          "shape",
          "structural",
          "paintServer"
        ],
        content: [
          "a",
          "altGlyphDef",
          "clipPath",
          "color-profile",
          "cursor",
          "filter",
          "font",
          "font-face",
          "foreignObject",
          "image",
          "marker",
          "mask",
          "pattern",
          "script",
          "style",
          "switch",
          "text",
          "view"
        ]
      },
      text: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "lengthAdjust",
          "x",
          "y",
          "dx",
          "dy",
          "rotate",
          "textLength"
        ],
        defaults: {
          x: "0",
          y: "0",
          lengthAdjust: "spacing"
        },
        contentGroups: ["animation", "descriptive", "textContentChild"],
        content: ["a"]
      },
      textPath: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation",
          "xlink"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "href",
          "xlink:href",
          "startOffset",
          "method",
          "spacing",
          "d"
        ],
        defaults: {
          startOffset: "0",
          method: "align",
          spacing: "exact"
        },
        contentGroups: ["descriptive"],
        content: [
          "a",
          "altGlyph",
          "animate",
          "animateColor",
          "set",
          "tref",
          "tspan"
        ]
      },
      title: {
        attrsGroups: ["core"],
        attrs: ["class", "style"]
      },
      tref: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation",
          "xlink"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "href",
          "xlink:href"
        ],
        contentGroups: ["descriptive"],
        content: ["animate", "animateColor", "set"]
      },
      tspan: {
        attrsGroups: [
          "conditionalProcessing",
          "core",
          "graphicalEvent",
          "presentation"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "x",
          "y",
          "dx",
          "dy",
          "rotate",
          "textLength",
          "lengthAdjust"
        ],
        contentGroups: ["descriptive"],
        content: [
          "a",
          "altGlyph",
          "animate",
          "animateColor",
          "set",
          "tref",
          "tspan"
        ]
      },
      use: {
        attrsGroups: [
          "core",
          "conditionalProcessing",
          "graphicalEvent",
          "presentation",
          "xlink"
        ],
        attrs: [
          "class",
          "style",
          "externalResourcesRequired",
          "transform",
          "x",
          "y",
          "width",
          "height",
          "href",
          "xlink:href"
        ],
        defaults: {
          x: "0",
          y: "0"
        },
        contentGroups: ["animation", "descriptive"]
      },
      view: {
        attrsGroups: ["core"],
        attrs: [
          "externalResourcesRequired",
          "viewBox",
          "preserveAspectRatio",
          "zoomAndPan",
          "viewTarget"
        ],
        contentGroups: ["descriptive"]
      },
      vkern: {
        attrsGroups: ["core"],
        attrs: ["u1", "g1", "u2", "g2", "k"]
      }
    };
    exports2.editorNamespaces = [
      "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd",
      "http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd",
      "http://www.inkscape.org/namespaces/inkscape",
      "http://www.bohemiancoding.com/sketch/ns",
      "http://ns.adobe.com/AdobeIllustrator/10.0/",
      "http://ns.adobe.com/Graphs/1.0/",
      "http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/",
      "http://ns.adobe.com/Variables/1.0/",
      "http://ns.adobe.com/SaveForWeb/1.0/",
      "http://ns.adobe.com/Extensibility/1.0/",
      "http://ns.adobe.com/Flows/1.0/",
      "http://ns.adobe.com/ImageReplacement/1.0/",
      "http://ns.adobe.com/GenericCustomNamespace/1.0/",
      "http://ns.adobe.com/XPath/1.0/",
      "http://schemas.microsoft.com/visio/2003/SVGExtensions/",
      "http://taptrix.com/vectorillustrator/svg_extensions",
      "http://www.figma.com/figma/ns",
      "http://purl.org/dc/elements/1.1/",
      "http://creativecommons.org/ns#",
      "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
      "http://www.serif.com/",
      "http://www.vector.evaxdesign.sk"
    ];
    exports2.referencesProps = [
      "clip-path",
      "color-profile",
      "fill",
      "filter",
      "marker-start",
      "marker-mid",
      "marker-end",
      "mask",
      "stroke",
      "style"
    ];
    exports2.inheritableAttrs = [
      "clip-rule",
      "color",
      "color-interpolation",
      "color-interpolation-filters",
      "color-profile",
      "color-rendering",
      "cursor",
      "direction",
      "dominant-baseline",
      "fill",
      "fill-opacity",
      "fill-rule",
      "font",
      "font-family",
      "font-size",
      "font-size-adjust",
      "font-stretch",
      "font-style",
      "font-variant",
      "font-weight",
      "glyph-orientation-horizontal",
      "glyph-orientation-vertical",
      "image-rendering",
      "letter-spacing",
      "marker",
      "marker-end",
      "marker-mid",
      "marker-start",
      "paint-order",
      "pointer-events",
      "shape-rendering",
      "stroke",
      "stroke-dasharray",
      "stroke-dashoffset",
      "stroke-linecap",
      "stroke-linejoin",
      "stroke-miterlimit",
      "stroke-opacity",
      "stroke-width",
      "text-anchor",
      "text-rendering",
      "transform",
      "visibility",
      "word-spacing",
      "writing-mode"
    ];
    exports2.presentationNonInheritableGroupAttrs = [
      "display",
      "clip-path",
      "filter",
      "mask",
      "opacity",
      "text-decoration",
      "transform",
      "unicode-bidi"
    ];
    exports2.colorsNames = {
      aliceblue: "#f0f8ff",
      antiquewhite: "#faebd7",
      aqua: "#0ff",
      aquamarine: "#7fffd4",
      azure: "#f0ffff",
      beige: "#f5f5dc",
      bisque: "#ffe4c4",
      black: "#000",
      blanchedalmond: "#ffebcd",
      blue: "#00f",
      blueviolet: "#8a2be2",
      brown: "#a52a2a",
      burlywood: "#deb887",
      cadetblue: "#5f9ea0",
      chartreuse: "#7fff00",
      chocolate: "#d2691e",
      coral: "#ff7f50",
      cornflowerblue: "#6495ed",
      cornsilk: "#fff8dc",
      crimson: "#dc143c",
      cyan: "#0ff",
      darkblue: "#00008b",
      darkcyan: "#008b8b",
      darkgoldenrod: "#b8860b",
      darkgray: "#a9a9a9",
      darkgreen: "#006400",
      darkgrey: "#a9a9a9",
      darkkhaki: "#bdb76b",
      darkmagenta: "#8b008b",
      darkolivegreen: "#556b2f",
      darkorange: "#ff8c00",
      darkorchid: "#9932cc",
      darkred: "#8b0000",
      darksalmon: "#e9967a",
      darkseagreen: "#8fbc8f",
      darkslateblue: "#483d8b",
      darkslategray: "#2f4f4f",
      darkslategrey: "#2f4f4f",
      darkturquoise: "#00ced1",
      darkviolet: "#9400d3",
      deeppink: "#ff1493",
      deepskyblue: "#00bfff",
      dimgray: "#696969",
      dimgrey: "#696969",
      dodgerblue: "#1e90ff",
      firebrick: "#b22222",
      floralwhite: "#fffaf0",
      forestgreen: "#228b22",
      fuchsia: "#f0f",
      gainsboro: "#dcdcdc",
      ghostwhite: "#f8f8ff",
      gold: "#ffd700",
      goldenrod: "#daa520",
      gray: "#808080",
      green: "#008000",
      greenyellow: "#adff2f",
      grey: "#808080",
      honeydew: "#f0fff0",
      hotpink: "#ff69b4",
      indianred: "#cd5c5c",
      indigo: "#4b0082",
      ivory: "#fffff0",
      khaki: "#f0e68c",
      lavender: "#e6e6fa",
      lavenderblush: "#fff0f5",
      lawngreen: "#7cfc00",
      lemonchiffon: "#fffacd",
      lightblue: "#add8e6",
      lightcoral: "#f08080",
      lightcyan: "#e0ffff",
      lightgoldenrodyellow: "#fafad2",
      lightgray: "#d3d3d3",
      lightgreen: "#90ee90",
      lightgrey: "#d3d3d3",
      lightpink: "#ffb6c1",
      lightsalmon: "#ffa07a",
      lightseagreen: "#20b2aa",
      lightskyblue: "#87cefa",
      lightslategray: "#789",
      lightslategrey: "#789",
      lightsteelblue: "#b0c4de",
      lightyellow: "#ffffe0",
      lime: "#0f0",
      limegreen: "#32cd32",
      linen: "#faf0e6",
      magenta: "#f0f",
      maroon: "#800000",
      mediumaquamarine: "#66cdaa",
      mediumblue: "#0000cd",
      mediumorchid: "#ba55d3",
      mediumpurple: "#9370db",
      mediumseagreen: "#3cb371",
      mediumslateblue: "#7b68ee",
      mediumspringgreen: "#00fa9a",
      mediumturquoise: "#48d1cc",
      mediumvioletred: "#c71585",
      midnightblue: "#191970",
      mintcream: "#f5fffa",
      mistyrose: "#ffe4e1",
      moccasin: "#ffe4b5",
      navajowhite: "#ffdead",
      navy: "#000080",
      oldlace: "#fdf5e6",
      olive: "#808000",
      olivedrab: "#6b8e23",
      orange: "#ffa500",
      orangered: "#ff4500",
      orchid: "#da70d6",
      palegoldenrod: "#eee8aa",
      palegreen: "#98fb98",
      paleturquoise: "#afeeee",
      palevioletred: "#db7093",
      papayawhip: "#ffefd5",
      peachpuff: "#ffdab9",
      peru: "#cd853f",
      pink: "#ffc0cb",
      plum: "#dda0dd",
      powderblue: "#b0e0e6",
      purple: "#800080",
      rebeccapurple: "#639",
      red: "#f00",
      rosybrown: "#bc8f8f",
      royalblue: "#4169e1",
      saddlebrown: "#8b4513",
      salmon: "#fa8072",
      sandybrown: "#f4a460",
      seagreen: "#2e8b57",
      seashell: "#fff5ee",
      sienna: "#a0522d",
      silver: "#c0c0c0",
      skyblue: "#87ceeb",
      slateblue: "#6a5acd",
      slategray: "#708090",
      slategrey: "#708090",
      snow: "#fffafa",
      springgreen: "#00ff7f",
      steelblue: "#4682b4",
      tan: "#d2b48c",
      teal: "#008080",
      thistle: "#d8bfd8",
      tomato: "#ff6347",
      turquoise: "#40e0d0",
      violet: "#ee82ee",
      wheat: "#f5deb3",
      white: "#fff",
      whitesmoke: "#f5f5f5",
      yellow: "#ff0",
      yellowgreen: "#9acd32"
    };
    exports2.colorsShortNames = {
      "#f0ffff": "azure",
      "#f5f5dc": "beige",
      "#ffe4c4": "bisque",
      "#a52a2a": "brown",
      "#ff7f50": "coral",
      "#ffd700": "gold",
      "#808080": "gray",
      "#008000": "green",
      "#4b0082": "indigo",
      "#fffff0": "ivory",
      "#f0e68c": "khaki",
      "#faf0e6": "linen",
      "#800000": "maroon",
      "#000080": "navy",
      "#808000": "olive",
      "#ffa500": "orange",
      "#da70d6": "orchid",
      "#cd853f": "peru",
      "#ffc0cb": "pink",
      "#dda0dd": "plum",
      "#800080": "purple",
      "#f00": "red",
      "#ff0000": "red",
      "#fa8072": "salmon",
      "#a0522d": "sienna",
      "#c0c0c0": "silver",
      "#fffafa": "snow",
      "#d2b48c": "tan",
      "#008080": "teal",
      "#ff6347": "tomato",
      "#ee82ee": "violet",
      "#f5deb3": "wheat"
    };
    exports2.colorsProps = [
      "color",
      "fill",
      "stroke",
      "stop-color",
      "flood-color",
      "lighting-color"
    ];
  }
});

// node_modules/svgo/plugins/removeEditorsNSData.js
var require_removeEditorsNSData = __commonJS({
  "node_modules/svgo/plugins/removeEditorsNSData.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    var { editorNamespaces } = require_collections();
    exports2.type = "visitor";
    exports2.name = "removeEditorsNSData";
    exports2.active = true;
    exports2.description = "removes editors namespaces, elements and attributes";
    exports2.fn = (_root, params) => {
      let namespaces = editorNamespaces;
      if (Array.isArray(params.additionalNamespaces)) {
        namespaces = [...editorNamespaces, ...params.additionalNamespaces];
      }
      const prefixes = [];
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "svg") {
              for (const [name, value] of Object.entries(node.attributes)) {
                if (name.startsWith("xmlns:") && namespaces.includes(value)) {
                  prefixes.push(name.slice("xmlns:".length));
                  delete node.attributes[name];
                }
              }
            }
            for (const name of Object.keys(node.attributes)) {
              if (name.includes(":")) {
                const [prefix] = name.split(":");
                if (prefixes.includes(prefix)) {
                  delete node.attributes[name];
                }
              }
            }
            if (node.name.includes(":")) {
              const [prefix] = node.name.split(":");
              if (prefixes.includes(prefix)) {
                detachNodeFromParent(node, parentNode);
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/cleanupAttrs.js
var require_cleanupAttrs = __commonJS({
  "node_modules/svgo/plugins/cleanupAttrs.js"(exports2) {
    "use strict";
    exports2.name = "cleanupAttrs";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "cleanups attributes from newlines, trailing and repeating spaces";
    var regNewlinesNeedSpace = /(\S)\r?\n(\S)/g;
    var regNewlines = /\r?\n/g;
    var regSpaces = /\s{2,}/g;
    exports2.fn = (root, params) => {
      const { newlines = true, trim = true, spaces = true } = params;
      return {
        element: {
          enter: (node) => {
            for (const name of Object.keys(node.attributes)) {
              if (newlines) {
                node.attributes[name] = node.attributes[name].replace(regNewlinesNeedSpace, (match, p1, p2) => p1 + " " + p2);
                node.attributes[name] = node.attributes[name].replace(regNewlines, "");
              }
              if (trim) {
                node.attributes[name] = node.attributes[name].trim();
              }
              if (spaces) {
                node.attributes[name] = node.attributes[name].replace(regSpaces, " ");
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/lib/svgo/css-class-list.js
var require_css_class_list = __commonJS({
  "node_modules/svgo/lib/svgo/css-class-list.js"(exports2, module2) {
    "use strict";
    var CSSClassList = function(node) {
      this.parentNode = node;
      this.classNames = /* @__PURE__ */ new Set();
      const value = node.attributes.class;
      if (value != null) {
        this.addClassValueHandler();
        this.setClassValue(value);
      }
    };
    CSSClassList.prototype.addClassValueHandler = function() {
      Object.defineProperty(this.parentNode.attributes, "class", {
        get: this.getClassValue.bind(this),
        set: this.setClassValue.bind(this),
        enumerable: true,
        configurable: true
      });
    };
    CSSClassList.prototype.getClassValue = function() {
      var arrClassNames = Array.from(this.classNames);
      return arrClassNames.join(" ");
    };
    CSSClassList.prototype.setClassValue = function(newValue) {
      if (typeof newValue === "undefined") {
        this.classNames.clear();
        return;
      }
      var arrClassNames = newValue.split(" ");
      this.classNames = new Set(arrClassNames);
    };
    CSSClassList.prototype.add = function() {
      this.addClassValueHandler();
      Object.values(arguments).forEach(this._addSingle.bind(this));
    };
    CSSClassList.prototype._addSingle = function(className) {
      this.classNames.add(className);
    };
    CSSClassList.prototype.remove = function() {
      this.addClassValueHandler();
      Object.values(arguments).forEach(this._removeSingle.bind(this));
    };
    CSSClassList.prototype._removeSingle = function(className) {
      this.classNames.delete(className);
    };
    CSSClassList.prototype.item = function(index) {
      var arrClassNames = Array.from(this.classNames);
      return arrClassNames[index];
    };
    CSSClassList.prototype.toggle = function(className, force) {
      if (this.contains(className) || force === false) {
        this.classNames.delete(className);
      }
      this.classNames.add(className);
    };
    CSSClassList.prototype.contains = function(className) {
      return this.classNames.has(className);
    };
    module2.exports = CSSClassList;
  }
});

// node_modules/css-tree/lib/common/List.js
var require_List = __commonJS({
  "node_modules/css-tree/lib/common/List.js"(exports2, module2) {
    function createItem(data) {
      return {
        prev: null,
        next: null,
        data
      };
    }
    function allocateCursor(node, prev, next) {
      var cursor;
      if (cursors !== null) {
        cursor = cursors;
        cursors = cursors.cursor;
        cursor.prev = prev;
        cursor.next = next;
        cursor.cursor = node.cursor;
      } else {
        cursor = {
          prev,
          next,
          cursor: node.cursor
        };
      }
      node.cursor = cursor;
      return cursor;
    }
    function releaseCursor(node) {
      var cursor = node.cursor;
      node.cursor = cursor.cursor;
      cursor.prev = null;
      cursor.next = null;
      cursor.cursor = cursors;
      cursors = cursor;
    }
    var cursors = null;
    var List = function() {
      this.cursor = null;
      this.head = null;
      this.tail = null;
    };
    List.createItem = createItem;
    List.prototype.createItem = createItem;
    List.prototype.updateCursors = function(prevOld, prevNew, nextOld, nextNew) {
      var cursor = this.cursor;
      while (cursor !== null) {
        if (cursor.prev === prevOld) {
          cursor.prev = prevNew;
        }
        if (cursor.next === nextOld) {
          cursor.next = nextNew;
        }
        cursor = cursor.cursor;
      }
    };
    List.prototype.getSize = function() {
      var size = 0;
      var cursor = this.head;
      while (cursor) {
        size++;
        cursor = cursor.next;
      }
      return size;
    };
    List.prototype.fromArray = function(array) {
      var cursor = null;
      this.head = null;
      for (var i = 0; i < array.length; i++) {
        var item = createItem(array[i]);
        if (cursor !== null) {
          cursor.next = item;
        } else {
          this.head = item;
        }
        item.prev = cursor;
        cursor = item;
      }
      this.tail = cursor;
      return this;
    };
    List.prototype.toArray = function() {
      var cursor = this.head;
      var result = [];
      while (cursor) {
        result.push(cursor.data);
        cursor = cursor.next;
      }
      return result;
    };
    List.prototype.toJSON = List.prototype.toArray;
    List.prototype.isEmpty = function() {
      return this.head === null;
    };
    List.prototype.first = function() {
      return this.head && this.head.data;
    };
    List.prototype.last = function() {
      return this.tail && this.tail.data;
    };
    List.prototype.each = function(fn, context) {
      var item;
      if (context === void 0) {
        context = this;
      }
      var cursor = allocateCursor(this, null, this.head);
      while (cursor.next !== null) {
        item = cursor.next;
        cursor.next = item.next;
        fn.call(context, item.data, item, this);
      }
      releaseCursor(this);
    };
    List.prototype.forEach = List.prototype.each;
    List.prototype.eachRight = function(fn, context) {
      var item;
      if (context === void 0) {
        context = this;
      }
      var cursor = allocateCursor(this, this.tail, null);
      while (cursor.prev !== null) {
        item = cursor.prev;
        cursor.prev = item.prev;
        fn.call(context, item.data, item, this);
      }
      releaseCursor(this);
    };
    List.prototype.forEachRight = List.prototype.eachRight;
    List.prototype.reduce = function(fn, initialValue, context) {
      var item;
      if (context === void 0) {
        context = this;
      }
      var cursor = allocateCursor(this, null, this.head);
      var acc = initialValue;
      while (cursor.next !== null) {
        item = cursor.next;
        cursor.next = item.next;
        acc = fn.call(context, acc, item.data, item, this);
      }
      releaseCursor(this);
      return acc;
    };
    List.prototype.reduceRight = function(fn, initialValue, context) {
      var item;
      if (context === void 0) {
        context = this;
      }
      var cursor = allocateCursor(this, this.tail, null);
      var acc = initialValue;
      while (cursor.prev !== null) {
        item = cursor.prev;
        cursor.prev = item.prev;
        acc = fn.call(context, acc, item.data, item, this);
      }
      releaseCursor(this);
      return acc;
    };
    List.prototype.nextUntil = function(start, fn, context) {
      if (start === null) {
        return;
      }
      var item;
      if (context === void 0) {
        context = this;
      }
      var cursor = allocateCursor(this, null, start);
      while (cursor.next !== null) {
        item = cursor.next;
        cursor.next = item.next;
        if (fn.call(context, item.data, item, this)) {
          break;
        }
      }
      releaseCursor(this);
    };
    List.prototype.prevUntil = function(start, fn, context) {
      if (start === null) {
        return;
      }
      var item;
      if (context === void 0) {
        context = this;
      }
      var cursor = allocateCursor(this, start, null);
      while (cursor.prev !== null) {
        item = cursor.prev;
        cursor.prev = item.prev;
        if (fn.call(context, item.data, item, this)) {
          break;
        }
      }
      releaseCursor(this);
    };
    List.prototype.some = function(fn, context) {
      var cursor = this.head;
      if (context === void 0) {
        context = this;
      }
      while (cursor !== null) {
        if (fn.call(context, cursor.data, cursor, this)) {
          return true;
        }
        cursor = cursor.next;
      }
      return false;
    };
    List.prototype.map = function(fn, context) {
      var result = new List();
      var cursor = this.head;
      if (context === void 0) {
        context = this;
      }
      while (cursor !== null) {
        result.appendData(fn.call(context, cursor.data, cursor, this));
        cursor = cursor.next;
      }
      return result;
    };
    List.prototype.filter = function(fn, context) {
      var result = new List();
      var cursor = this.head;
      if (context === void 0) {
        context = this;
      }
      while (cursor !== null) {
        if (fn.call(context, cursor.data, cursor, this)) {
          result.appendData(cursor.data);
        }
        cursor = cursor.next;
      }
      return result;
    };
    List.prototype.clear = function() {
      this.head = null;
      this.tail = null;
    };
    List.prototype.copy = function() {
      var result = new List();
      var cursor = this.head;
      while (cursor !== null) {
        result.insert(createItem(cursor.data));
        cursor = cursor.next;
      }
      return result;
    };
    List.prototype.prepend = function(item) {
      this.updateCursors(null, item, this.head, item);
      if (this.head !== null) {
        this.head.prev = item;
        item.next = this.head;
      } else {
        this.tail = item;
      }
      this.head = item;
      return this;
    };
    List.prototype.prependData = function(data) {
      return this.prepend(createItem(data));
    };
    List.prototype.append = function(item) {
      return this.insert(item);
    };
    List.prototype.appendData = function(data) {
      return this.insert(createItem(data));
    };
    List.prototype.insert = function(item, before) {
      if (before !== void 0 && before !== null) {
        this.updateCursors(before.prev, item, before, item);
        if (before.prev === null) {
          if (this.head !== before) {
            throw new Error("before doesn't belong to list");
          }
          this.head = item;
          before.prev = item;
          item.next = before;
          this.updateCursors(null, item);
        } else {
          before.prev.next = item;
          item.prev = before.prev;
          before.prev = item;
          item.next = before;
        }
      } else {
        this.updateCursors(this.tail, item, null, item);
        if (this.tail !== null) {
          this.tail.next = item;
          item.prev = this.tail;
        } else {
          this.head = item;
        }
        this.tail = item;
      }
      return this;
    };
    List.prototype.insertData = function(data, before) {
      return this.insert(createItem(data), before);
    };
    List.prototype.remove = function(item) {
      this.updateCursors(item, item.prev, item, item.next);
      if (item.prev !== null) {
        item.prev.next = item.next;
      } else {
        if (this.head !== item) {
          throw new Error("item doesn't belong to list");
        }
        this.head = item.next;
      }
      if (item.next !== null) {
        item.next.prev = item.prev;
      } else {
        if (this.tail !== item) {
          throw new Error("item doesn't belong to list");
        }
        this.tail = item.prev;
      }
      item.prev = null;
      item.next = null;
      return item;
    };
    List.prototype.push = function(data) {
      this.insert(createItem(data));
    };
    List.prototype.pop = function() {
      if (this.tail !== null) {
        return this.remove(this.tail);
      }
    };
    List.prototype.unshift = function(data) {
      this.prepend(createItem(data));
    };
    List.prototype.shift = function() {
      if (this.head !== null) {
        return this.remove(this.head);
      }
    };
    List.prototype.prependList = function(list) {
      return this.insertList(list, this.head);
    };
    List.prototype.appendList = function(list) {
      return this.insertList(list);
    };
    List.prototype.insertList = function(list, before) {
      if (list.head === null) {
        return this;
      }
      if (before !== void 0 && before !== null) {
        this.updateCursors(before.prev, list.tail, before, list.head);
        if (before.prev !== null) {
          before.prev.next = list.head;
          list.head.prev = before.prev;
        } else {
          this.head = list.head;
        }
        before.prev = list.tail;
        list.tail.next = before;
      } else {
        this.updateCursors(this.tail, list.tail, null, list.head);
        if (this.tail !== null) {
          this.tail.next = list.head;
          list.head.prev = this.tail;
        } else {
          this.head = list.head;
        }
        this.tail = list.tail;
      }
      list.head = null;
      list.tail = null;
      return this;
    };
    List.prototype.replace = function(oldItem, newItemOrList) {
      if ("head" in newItemOrList) {
        this.insertList(newItemOrList, oldItem);
      } else {
        this.insert(newItemOrList, oldItem);
      }
      this.remove(oldItem);
    };
    module2.exports = List;
  }
});

// node_modules/css-tree/lib/utils/createCustomError.js
var require_createCustomError = __commonJS({
  "node_modules/css-tree/lib/utils/createCustomError.js"(exports2, module2) {
    module2.exports = function createCustomError(name, message) {
      var error = Object.create(SyntaxError.prototype);
      var errorStack = new Error();
      error.name = name;
      error.message = message;
      Object.defineProperty(error, "stack", {
        get: function() {
          return (errorStack.stack || "").replace(/^(.+\n){1,3}/, name + ": " + message + "\n");
        }
      });
      return error;
    };
  }
});

// node_modules/css-tree/lib/common/SyntaxError.js
var require_SyntaxError = __commonJS({
  "node_modules/css-tree/lib/common/SyntaxError.js"(exports2, module2) {
    var createCustomError = require_createCustomError();
    var MAX_LINE_LENGTH = 100;
    var OFFSET_CORRECTION = 60;
    var TAB_REPLACEMENT = "    ";
    function sourceFragment(error, extraLines) {
      function processLines(start, end) {
        return lines.slice(start, end).map(function(line2, idx) {
          var num = String(start + idx + 1);
          while (num.length < maxNumLength) {
            num = " " + num;
          }
          return num + " |" + line2;
        }).join("\n");
      }
      var lines = error.source.split(/\r\n?|\n|\f/);
      var line = error.line;
      var column = error.column;
      var startLine = Math.max(1, line - extraLines) - 1;
      var endLine = Math.min(line + extraLines, lines.length + 1);
      var maxNumLength = Math.max(4, String(endLine).length) + 1;
      var cutLeft = 0;
      column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\t/g) || []).length;
      if (column > MAX_LINE_LENGTH) {
        cutLeft = column - OFFSET_CORRECTION + 3;
        column = OFFSET_CORRECTION - 2;
      }
      for (var i = startLine; i <= endLine; i++) {
        if (i >= 0 && i < lines.length) {
          lines[i] = lines[i].replace(/\t/g, TAB_REPLACEMENT);
          lines[i] = (cutLeft > 0 && lines[i].length > cutLeft ? "\u2026" : "") + lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) + (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? "\u2026" : "");
        }
      }
      return [
        processLines(startLine, line),
        new Array(column + maxNumLength + 2).join("-") + "^",
        processLines(line, endLine)
      ].filter(Boolean).join("\n");
    }
    var SyntaxError2 = function(message, source, offset, line, column) {
      var error = createCustomError("SyntaxError", message);
      error.source = source;
      error.offset = offset;
      error.line = line;
      error.column = column;
      error.sourceFragment = function(extraLines) {
        return sourceFragment(error, isNaN(extraLines) ? 0 : extraLines);
      };
      Object.defineProperty(error, "formattedMessage", {
        get: function() {
          return "Parse error: " + error.message + "\n" + sourceFragment(error, 2);
        }
      });
      error.parseError = {
        offset,
        line,
        column
      };
      return error;
    };
    module2.exports = SyntaxError2;
  }
});

// node_modules/css-tree/lib/tokenizer/const.js
var require_const2 = __commonJS({
  "node_modules/css-tree/lib/tokenizer/const.js"(exports2, module2) {
    var TYPE = {
      EOF: 0,
      Ident: 1,
      Function: 2,
      AtKeyword: 3,
      Hash: 4,
      String: 5,
      BadString: 6,
      Url: 7,
      BadUrl: 8,
      Delim: 9,
      Number: 10,
      Percentage: 11,
      Dimension: 12,
      WhiteSpace: 13,
      CDO: 14,
      CDC: 15,
      Colon: 16,
      Semicolon: 17,
      Comma: 18,
      LeftSquareBracket: 19,
      RightSquareBracket: 20,
      LeftParenthesis: 21,
      RightParenthesis: 22,
      LeftCurlyBracket: 23,
      RightCurlyBracket: 24,
      Comment: 25
    };
    var NAME = Object.keys(TYPE).reduce(function(result, key) {
      result[TYPE[key]] = key;
      return result;
    }, {});
    module2.exports = {
      TYPE,
      NAME
    };
  }
});

// node_modules/css-tree/lib/tokenizer/char-code-definitions.js
var require_char_code_definitions = __commonJS({
  "node_modules/css-tree/lib/tokenizer/char-code-definitions.js"(exports2, module2) {
    var EOF = 0;
    function isDigit(code) {
      return code >= 48 && code <= 57;
    }
    function isHexDigit(code) {
      return isDigit(code) || code >= 65 && code <= 70 || code >= 97 && code <= 102;
    }
    function isUppercaseLetter(code) {
      return code >= 65 && code <= 90;
    }
    function isLowercaseLetter(code) {
      return code >= 97 && code <= 122;
    }
    function isLetter(code) {
      return isUppercaseLetter(code) || isLowercaseLetter(code);
    }
    function isNonAscii(code) {
      return code >= 128;
    }
    function isNameStart(code) {
      return isLetter(code) || isNonAscii(code) || code === 95;
    }
    function isName(code) {
      return isNameStart(code) || isDigit(code) || code === 45;
    }
    function isNonPrintable(code) {
      return code >= 0 && code <= 8 || code === 11 || code >= 14 && code <= 31 || code === 127;
    }
    function isNewline(code) {
      return code === 10 || code === 13 || code === 12;
    }
    function isWhiteSpace(code) {
      return isNewline(code) || code === 32 || code === 9;
    }
    function isValidEscape(first, second) {
      if (first !== 92) {
        return false;
      }
      if (isNewline(second) || second === EOF) {
        return false;
      }
      return true;
    }
    function isIdentifierStart(first, second, third) {
      if (first === 45) {
        return isNameStart(second) || second === 45 || isValidEscape(second, third);
      }
      if (isNameStart(first)) {
        return true;
      }
      if (first === 92) {
        return isValidEscape(first, second);
      }
      return false;
    }
    function isNumberStart(first, second, third) {
      if (first === 43 || first === 45) {
        if (isDigit(second)) {
          return 2;
        }
        return second === 46 && isDigit(third) ? 3 : 0;
      }
      if (first === 46) {
        return isDigit(second) ? 2 : 0;
      }
      if (isDigit(first)) {
        return 1;
      }
      return 0;
    }
    function isBOM(code) {
      if (code === 65279) {
        return 1;
      }
      if (code === 65534) {
        return 1;
      }
      return 0;
    }
    var CATEGORY = new Array(128);
    charCodeCategory.Eof = 128;
    charCodeCategory.WhiteSpace = 130;
    charCodeCategory.Digit = 131;
    charCodeCategory.NameStart = 132;
    charCodeCategory.NonPrintable = 133;
    for (i = 0; i < CATEGORY.length; i++) {
      switch (true) {
        case isWhiteSpace(i):
          CATEGORY[i] = charCodeCategory.WhiteSpace;
          break;
        case isDigit(i):
          CATEGORY[i] = charCodeCategory.Digit;
          break;
        case isNameStart(i):
          CATEGORY[i] = charCodeCategory.NameStart;
          break;
        case isNonPrintable(i):
          CATEGORY[i] = charCodeCategory.NonPrintable;
          break;
        default:
          CATEGORY[i] = i || charCodeCategory.Eof;
      }
    }
    var i;
    function charCodeCategory(code) {
      return code < 128 ? CATEGORY[code] : charCodeCategory.NameStart;
    }
    module2.exports = {
      isDigit,
      isHexDigit,
      isUppercaseLetter,
      isLowercaseLetter,
      isLetter,
      isNonAscii,
      isNameStart,
      isName,
      isNonPrintable,
      isNewline,
      isWhiteSpace,
      isValidEscape,
      isIdentifierStart,
      isNumberStart,
      isBOM,
      charCodeCategory
    };
  }
});

// node_modules/css-tree/lib/tokenizer/utils.js
var require_utils3 = __commonJS({
  "node_modules/css-tree/lib/tokenizer/utils.js"(exports2, module2) {
    var charCodeDef = require_char_code_definitions();
    var isDigit = charCodeDef.isDigit;
    var isHexDigit = charCodeDef.isHexDigit;
    var isUppercaseLetter = charCodeDef.isUppercaseLetter;
    var isName = charCodeDef.isName;
    var isWhiteSpace = charCodeDef.isWhiteSpace;
    var isValidEscape = charCodeDef.isValidEscape;
    function getCharCode(source, offset) {
      return offset < source.length ? source.charCodeAt(offset) : 0;
    }
    function getNewlineLength(source, offset, code) {
      if (code === 13 && getCharCode(source, offset + 1) === 10) {
        return 2;
      }
      return 1;
    }
    function cmpChar(testStr, offset, referenceCode) {
      var code = testStr.charCodeAt(offset);
      if (isUppercaseLetter(code)) {
        code = code | 32;
      }
      return code === referenceCode;
    }
    function cmpStr(testStr, start, end, referenceStr) {
      if (end - start !== referenceStr.length) {
        return false;
      }
      if (start < 0 || end > testStr.length) {
        return false;
      }
      for (var i = start; i < end; i++) {
        var testCode = testStr.charCodeAt(i);
        var referenceCode = referenceStr.charCodeAt(i - start);
        if (isUppercaseLetter(testCode)) {
          testCode = testCode | 32;
        }
        if (testCode !== referenceCode) {
          return false;
        }
      }
      return true;
    }
    function findWhiteSpaceStart(source, offset) {
      for (; offset >= 0; offset--) {
        if (!isWhiteSpace(source.charCodeAt(offset))) {
          break;
        }
      }
      return offset + 1;
    }
    function findWhiteSpaceEnd(source, offset) {
      for (; offset < source.length; offset++) {
        if (!isWhiteSpace(source.charCodeAt(offset))) {
          break;
        }
      }
      return offset;
    }
    function findDecimalNumberEnd(source, offset) {
      for (; offset < source.length; offset++) {
        if (!isDigit(source.charCodeAt(offset))) {
          break;
        }
      }
      return offset;
    }
    function consumeEscaped(source, offset) {
      offset += 2;
      if (isHexDigit(getCharCode(source, offset - 1))) {
        for (var maxOffset = Math.min(source.length, offset + 5); offset < maxOffset; offset++) {
          if (!isHexDigit(getCharCode(source, offset))) {
            break;
          }
        }
        var code = getCharCode(source, offset);
        if (isWhiteSpace(code)) {
          offset += getNewlineLength(source, offset, code);
        }
      }
      return offset;
    }
    function consumeName(source, offset) {
      for (; offset < source.length; offset++) {
        var code = source.charCodeAt(offset);
        if (isName(code)) {
          continue;
        }
        if (isValidEscape(code, getCharCode(source, offset + 1))) {
          offset = consumeEscaped(source, offset) - 1;
          continue;
        }
        break;
      }
      return offset;
    }
    function consumeNumber(source, offset) {
      var code = source.charCodeAt(offset);
      if (code === 43 || code === 45) {
        code = source.charCodeAt(offset += 1);
      }
      if (isDigit(code)) {
        offset = findDecimalNumberEnd(source, offset + 1);
        code = source.charCodeAt(offset);
      }
      if (code === 46 && isDigit(source.charCodeAt(offset + 1))) {
        code = source.charCodeAt(offset += 2);
        offset = findDecimalNumberEnd(source, offset);
      }
      if (cmpChar(source, offset, 101)) {
        var sign = 0;
        code = source.charCodeAt(offset + 1);
        if (code === 45 || code === 43) {
          sign = 1;
          code = source.charCodeAt(offset + 2);
        }
        if (isDigit(code)) {
          offset = findDecimalNumberEnd(source, offset + 1 + sign + 1);
        }
      }
      return offset;
    }
    function consumeBadUrlRemnants(source, offset) {
      for (; offset < source.length; offset++) {
        var code = source.charCodeAt(offset);
        if (code === 41) {
          offset++;
          break;
        }
        if (isValidEscape(code, getCharCode(source, offset + 1))) {
          offset = consumeEscaped(source, offset);
        }
      }
      return offset;
    }
    module2.exports = {
      consumeEscaped,
      consumeName,
      consumeNumber,
      consumeBadUrlRemnants,
      cmpChar,
      cmpStr,
      getNewlineLength,
      findWhiteSpaceStart,
      findWhiteSpaceEnd
    };
  }
});

// node_modules/css-tree/lib/common/TokenStream.js
var require_TokenStream = __commonJS({
  "node_modules/css-tree/lib/common/TokenStream.js"(exports2, module2) {
    var constants = require_const2();
    var TYPE = constants.TYPE;
    var NAME = constants.NAME;
    var utils = require_utils3();
    var cmpStr = utils.cmpStr;
    var EOF = TYPE.EOF;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    var OFFSET_MASK = 16777215;
    var TYPE_SHIFT = 24;
    var TokenStream = function() {
      this.offsetAndType = null;
      this.balance = null;
      this.reset();
    };
    TokenStream.prototype = {
      reset: function() {
        this.eof = false;
        this.tokenIndex = -1;
        this.tokenType = 0;
        this.tokenStart = this.firstCharOffset;
        this.tokenEnd = this.firstCharOffset;
      },
      lookupType: function(offset) {
        offset += this.tokenIndex;
        if (offset < this.tokenCount) {
          return this.offsetAndType[offset] >> TYPE_SHIFT;
        }
        return EOF;
      },
      lookupOffset: function(offset) {
        offset += this.tokenIndex;
        if (offset < this.tokenCount) {
          return this.offsetAndType[offset - 1] & OFFSET_MASK;
        }
        return this.source.length;
      },
      lookupValue: function(offset, referenceStr) {
        offset += this.tokenIndex;
        if (offset < this.tokenCount) {
          return cmpStr(this.source, this.offsetAndType[offset - 1] & OFFSET_MASK, this.offsetAndType[offset] & OFFSET_MASK, referenceStr);
        }
        return false;
      },
      getTokenStart: function(tokenIndex) {
        if (tokenIndex === this.tokenIndex) {
          return this.tokenStart;
        }
        if (tokenIndex > 0) {
          return tokenIndex < this.tokenCount ? this.offsetAndType[tokenIndex - 1] & OFFSET_MASK : this.offsetAndType[this.tokenCount] & OFFSET_MASK;
        }
        return this.firstCharOffset;
      },
      getRawLength: function(startToken, mode) {
        var cursor = startToken;
        var balanceEnd;
        var offset = this.offsetAndType[Math.max(cursor - 1, 0)] & OFFSET_MASK;
        var type;
        loop:
          for (; cursor < this.tokenCount; cursor++) {
            balanceEnd = this.balance[cursor];
            if (balanceEnd < startToken) {
              break loop;
            }
            type = this.offsetAndType[cursor] >> TYPE_SHIFT;
            switch (mode(type, this.source, offset)) {
              case 1:
                break loop;
              case 2:
                cursor++;
                break loop;
              default:
                if (this.balance[balanceEnd] === cursor) {
                  cursor = balanceEnd;
                }
                offset = this.offsetAndType[cursor] & OFFSET_MASK;
            }
          }
        return cursor - this.tokenIndex;
      },
      isBalanceEdge: function(pos) {
        return this.balance[this.tokenIndex] < pos;
      },
      isDelim: function(code, offset) {
        if (offset) {
          return this.lookupType(offset) === TYPE.Delim && this.source.charCodeAt(this.lookupOffset(offset)) === code;
        }
        return this.tokenType === TYPE.Delim && this.source.charCodeAt(this.tokenStart) === code;
      },
      getTokenValue: function() {
        return this.source.substring(this.tokenStart, this.tokenEnd);
      },
      getTokenLength: function() {
        return this.tokenEnd - this.tokenStart;
      },
      substrToCursor: function(start) {
        return this.source.substring(start, this.tokenStart);
      },
      skipWS: function() {
        for (var i = this.tokenIndex, skipTokenCount = 0; i < this.tokenCount; i++, skipTokenCount++) {
          if (this.offsetAndType[i] >> TYPE_SHIFT !== WHITESPACE) {
            break;
          }
        }
        if (skipTokenCount > 0) {
          this.skip(skipTokenCount);
        }
      },
      skipSC: function() {
        while (this.tokenType === WHITESPACE || this.tokenType === COMMENT) {
          this.next();
        }
      },
      skip: function(tokenCount) {
        var next = this.tokenIndex + tokenCount;
        if (next < this.tokenCount) {
          this.tokenIndex = next;
          this.tokenStart = this.offsetAndType[next - 1] & OFFSET_MASK;
          next = this.offsetAndType[next];
          this.tokenType = next >> TYPE_SHIFT;
          this.tokenEnd = next & OFFSET_MASK;
        } else {
          this.tokenIndex = this.tokenCount;
          this.next();
        }
      },
      next: function() {
        var next = this.tokenIndex + 1;
        if (next < this.tokenCount) {
          this.tokenIndex = next;
          this.tokenStart = this.tokenEnd;
          next = this.offsetAndType[next];
          this.tokenType = next >> TYPE_SHIFT;
          this.tokenEnd = next & OFFSET_MASK;
        } else {
          this.tokenIndex = this.tokenCount;
          this.eof = true;
          this.tokenType = EOF;
          this.tokenStart = this.tokenEnd = this.source.length;
        }
      },
      forEachToken(fn) {
        for (var i = 0, offset = this.firstCharOffset; i < this.tokenCount; i++) {
          var start = offset;
          var item = this.offsetAndType[i];
          var end = item & OFFSET_MASK;
          var type = item >> TYPE_SHIFT;
          offset = end;
          fn(type, start, end, i);
        }
      },
      dump() {
        var tokens = new Array(this.tokenCount);
        this.forEachToken((type, start, end, index) => {
          tokens[index] = {
            idx: index,
            type: NAME[type],
            chunk: this.source.substring(start, end),
            balance: this.balance[index]
          };
        });
        return tokens;
      }
    };
    module2.exports = TokenStream;
  }
});

// node_modules/css-tree/lib/definition-syntax/generate.js
var require_generate = __commonJS({
  "node_modules/css-tree/lib/definition-syntax/generate.js"(exports2, module2) {
    function noop(value) {
      return value;
    }
    function generateMultiplier(multiplier) {
      if (multiplier.min === 0 && multiplier.max === 0) {
        return "*";
      }
      if (multiplier.min === 0 && multiplier.max === 1) {
        return "?";
      }
      if (multiplier.min === 1 && multiplier.max === 0) {
        return multiplier.comma ? "#" : "+";
      }
      if (multiplier.min === 1 && multiplier.max === 1) {
        return "";
      }
      return (multiplier.comma ? "#" : "") + (multiplier.min === multiplier.max ? "{" + multiplier.min + "}" : "{" + multiplier.min + "," + (multiplier.max !== 0 ? multiplier.max : "") + "}");
    }
    function generateTypeOpts(node) {
      switch (node.type) {
        case "Range":
          return " [" + (node.min === null ? "-\u221E" : node.min) + "," + (node.max === null ? "\u221E" : node.max) + "]";
        default:
          throw new Error("Unknown node type `" + node.type + "`");
      }
    }
    function generateSequence(node, decorate, forceBraces, compact) {
      var combinator = node.combinator === " " || compact ? node.combinator : " " + node.combinator + " ";
      var result = node.terms.map(function(term) {
        return generate(term, decorate, forceBraces, compact);
      }).join(combinator);
      if (node.explicit || forceBraces) {
        result = (compact || result[0] === "," ? "[" : "[ ") + result + (compact ? "]" : " ]");
      }
      return result;
    }
    function generate(node, decorate, forceBraces, compact) {
      var result;
      switch (node.type) {
        case "Group":
          result = generateSequence(node, decorate, forceBraces, compact) + (node.disallowEmpty ? "!" : "");
          break;
        case "Multiplier":
          return generate(node.term, decorate, forceBraces, compact) + decorate(generateMultiplier(node), node);
        case "Type":
          result = "<" + node.name + (node.opts ? decorate(generateTypeOpts(node.opts), node.opts) : "") + ">";
          break;
        case "Property":
          result = "<'" + node.name + "'>";
          break;
        case "Keyword":
          result = node.name;
          break;
        case "AtKeyword":
          result = "@" + node.name;
          break;
        case "Function":
          result = node.name + "(";
          break;
        case "String":
        case "Token":
          result = node.value;
          break;
        case "Comma":
          result = ",";
          break;
        default:
          throw new Error("Unknown node type `" + node.type + "`");
      }
      return decorate(result, node);
    }
    module2.exports = function(node, options) {
      var decorate = noop;
      var forceBraces = false;
      var compact = false;
      if (typeof options === "function") {
        decorate = options;
      } else if (options) {
        forceBraces = Boolean(options.forceBraces);
        compact = Boolean(options.compact);
        if (typeof options.decorate === "function") {
          decorate = options.decorate;
        }
      }
      return generate(node, decorate, forceBraces, compact);
    };
  }
});

// node_modules/css-tree/lib/lexer/error.js
var require_error2 = __commonJS({
  "node_modules/css-tree/lib/lexer/error.js"(exports2, module2) {
    var createCustomError = require_createCustomError();
    var generate = require_generate();
    var defaultLoc = { offset: 0, line: 1, column: 1 };
    function locateMismatch(matchResult, node) {
      const tokens = matchResult.tokens;
      const longestMatch = matchResult.longestMatch;
      const mismatchNode = longestMatch < tokens.length ? tokens[longestMatch].node || null : null;
      const badNode = mismatchNode !== node ? mismatchNode : null;
      let mismatchOffset = 0;
      let mismatchLength = 0;
      let entries = 0;
      let css = "";
      let start;
      let end;
      for (let i = 0; i < tokens.length; i++) {
        const token = tokens[i].value;
        if (i === longestMatch) {
          mismatchLength = token.length;
          mismatchOffset = css.length;
        }
        if (badNode !== null && tokens[i].node === badNode) {
          if (i <= longestMatch) {
            entries++;
          } else {
            entries = 0;
          }
        }
        css += token;
      }
      if (longestMatch === tokens.length || entries > 1) {
        start = fromLoc(badNode || node, "end") || buildLoc(defaultLoc, css);
        end = buildLoc(start);
      } else {
        start = fromLoc(badNode, "start") || buildLoc(fromLoc(node, "start") || defaultLoc, css.slice(0, mismatchOffset));
        end = fromLoc(badNode, "end") || buildLoc(start, css.substr(mismatchOffset, mismatchLength));
      }
      return {
        css,
        mismatchOffset,
        mismatchLength,
        start,
        end
      };
    }
    function fromLoc(node, point) {
      const value = node && node.loc && node.loc[point];
      if (value) {
        return "line" in value ? buildLoc(value) : value;
      }
      return null;
    }
    function buildLoc({ offset, line, column }, extra) {
      const loc = {
        offset,
        line,
        column
      };
      if (extra) {
        const lines = extra.split(/\n|\r\n?|\f/);
        loc.offset += extra.length;
        loc.line += lines.length - 1;
        loc.column = lines.length === 1 ? loc.column + extra.length : lines.pop().length + 1;
      }
      return loc;
    }
    var SyntaxReferenceError = function(type, referenceName) {
      const error = createCustomError("SyntaxReferenceError", type + (referenceName ? " `" + referenceName + "`" : ""));
      error.reference = referenceName;
      return error;
    };
    var SyntaxMatchError = function(message, syntax, node, matchResult) {
      const error = createCustomError("SyntaxMatchError", message);
      const {
        css,
        mismatchOffset,
        mismatchLength,
        start,
        end
      } = locateMismatch(matchResult, node);
      error.rawMessage = message;
      error.syntax = syntax ? generate(syntax) : "<generic>";
      error.css = css;
      error.mismatchOffset = mismatchOffset;
      error.mismatchLength = mismatchLength;
      error.message = message + "\n  syntax: " + error.syntax + "\n   value: " + (css || "<empty string>") + "\n  --------" + new Array(error.mismatchOffset + 1).join("-") + "^";
      Object.assign(error, start);
      error.loc = {
        source: node && node.loc && node.loc.source || "<unknown>",
        start,
        end
      };
      return error;
    };
    module2.exports = {
      SyntaxReferenceError,
      SyntaxMatchError
    };
  }
});

// node_modules/css-tree/lib/utils/names.js
var require_names2 = __commonJS({
  "node_modules/css-tree/lib/utils/names.js"(exports2, module2) {
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    var keywords = /* @__PURE__ */ Object.create(null);
    var properties = /* @__PURE__ */ Object.create(null);
    var HYPHENMINUS = 45;
    function isCustomProperty(str, offset) {
      offset = offset || 0;
      return str.length - offset >= 2 && str.charCodeAt(offset) === HYPHENMINUS && str.charCodeAt(offset + 1) === HYPHENMINUS;
    }
    function getVendorPrefix(str, offset) {
      offset = offset || 0;
      if (str.length - offset >= 3) {
        if (str.charCodeAt(offset) === HYPHENMINUS && str.charCodeAt(offset + 1) !== HYPHENMINUS) {
          var secondDashIndex = str.indexOf("-", offset + 2);
          if (secondDashIndex !== -1) {
            return str.substring(offset, secondDashIndex + 1);
          }
        }
      }
      return "";
    }
    function getKeywordDescriptor(keyword) {
      if (hasOwnProperty2.call(keywords, keyword)) {
        return keywords[keyword];
      }
      var name = keyword.toLowerCase();
      if (hasOwnProperty2.call(keywords, name)) {
        return keywords[keyword] = keywords[name];
      }
      var custom = isCustomProperty(name, 0);
      var vendor = !custom ? getVendorPrefix(name, 0) : "";
      return keywords[keyword] = Object.freeze({
        basename: name.substr(vendor.length),
        name,
        vendor,
        prefix: vendor,
        custom
      });
    }
    function getPropertyDescriptor(property) {
      if (hasOwnProperty2.call(properties, property)) {
        return properties[property];
      }
      var name = property;
      var hack = property[0];
      if (hack === "/") {
        hack = property[1] === "/" ? "//" : "/";
      } else if (hack !== "_" && hack !== "*" && hack !== "$" && hack !== "#" && hack !== "+" && hack !== "&") {
        hack = "";
      }
      var custom = isCustomProperty(name, hack.length);
      if (!custom) {
        name = name.toLowerCase();
        if (hasOwnProperty2.call(properties, name)) {
          return properties[property] = properties[name];
        }
      }
      var vendor = !custom ? getVendorPrefix(name, hack.length) : "";
      var prefix = name.substr(0, hack.length + vendor.length);
      return properties[property] = Object.freeze({
        basename: name.substr(prefix.length),
        name: name.substr(hack.length),
        hack,
        vendor,
        prefix,
        custom
      });
    }
    module2.exports = {
      keyword: getKeywordDescriptor,
      property: getPropertyDescriptor,
      isCustomProperty,
      vendorPrefix: getVendorPrefix
    };
  }
});

// node_modules/css-tree/lib/common/adopt-buffer.js
var require_adopt_buffer = __commonJS({
  "node_modules/css-tree/lib/common/adopt-buffer.js"(exports2, module2) {
    var MIN_SIZE = 16 * 1024;
    var SafeUint32Array = typeof Uint32Array !== "undefined" ? Uint32Array : Array;
    module2.exports = function adoptBuffer(buffer, size) {
      if (buffer === null || buffer.length < size) {
        return new SafeUint32Array(Math.max(size + 1024, MIN_SIZE));
      }
      return buffer;
    };
  }
});

// node_modules/css-tree/lib/tokenizer/index.js
var require_tokenizer = __commonJS({
  "node_modules/css-tree/lib/tokenizer/index.js"(exports2, module2) {
    var TokenStream = require_TokenStream();
    var adoptBuffer = require_adopt_buffer();
    var constants = require_const2();
    var TYPE = constants.TYPE;
    var charCodeDefinitions = require_char_code_definitions();
    var isNewline = charCodeDefinitions.isNewline;
    var isName = charCodeDefinitions.isName;
    var isValidEscape = charCodeDefinitions.isValidEscape;
    var isNumberStart = charCodeDefinitions.isNumberStart;
    var isIdentifierStart = charCodeDefinitions.isIdentifierStart;
    var charCodeCategory = charCodeDefinitions.charCodeCategory;
    var isBOM = charCodeDefinitions.isBOM;
    var utils = require_utils3();
    var cmpStr = utils.cmpStr;
    var getNewlineLength = utils.getNewlineLength;
    var findWhiteSpaceEnd = utils.findWhiteSpaceEnd;
    var consumeEscaped = utils.consumeEscaped;
    var consumeName = utils.consumeName;
    var consumeNumber = utils.consumeNumber;
    var consumeBadUrlRemnants = utils.consumeBadUrlRemnants;
    var OFFSET_MASK = 16777215;
    var TYPE_SHIFT = 24;
    function tokenize(source, stream) {
      function getCharCode(offset2) {
        return offset2 < sourceLength ? source.charCodeAt(offset2) : 0;
      }
      function consumeNumericToken() {
        offset = consumeNumber(source, offset);
        if (isIdentifierStart(getCharCode(offset), getCharCode(offset + 1), getCharCode(offset + 2))) {
          type = TYPE.Dimension;
          offset = consumeName(source, offset);
          return;
        }
        if (getCharCode(offset) === 37) {
          type = TYPE.Percentage;
          offset++;
          return;
        }
        type = TYPE.Number;
      }
      function consumeIdentLikeToken() {
        const nameStartOffset = offset;
        offset = consumeName(source, offset);
        if (cmpStr(source, nameStartOffset, offset, "url") && getCharCode(offset) === 40) {
          offset = findWhiteSpaceEnd(source, offset + 1);
          if (getCharCode(offset) === 34 || getCharCode(offset) === 39) {
            type = TYPE.Function;
            offset = nameStartOffset + 4;
            return;
          }
          consumeUrlToken();
          return;
        }
        if (getCharCode(offset) === 40) {
          type = TYPE.Function;
          offset++;
          return;
        }
        type = TYPE.Ident;
      }
      function consumeStringToken(endingCodePoint) {
        if (!endingCodePoint) {
          endingCodePoint = getCharCode(offset++);
        }
        type = TYPE.String;
        for (; offset < source.length; offset++) {
          var code2 = source.charCodeAt(offset);
          switch (charCodeCategory(code2)) {
            case endingCodePoint:
              offset++;
              return;
            case charCodeCategory.Eof:
              return;
            case charCodeCategory.WhiteSpace:
              if (isNewline(code2)) {
                offset += getNewlineLength(source, offset, code2);
                type = TYPE.BadString;
                return;
              }
              break;
            case 92:
              if (offset === source.length - 1) {
                break;
              }
              var nextCode = getCharCode(offset + 1);
              if (isNewline(nextCode)) {
                offset += getNewlineLength(source, offset + 1, nextCode);
              } else if (isValidEscape(code2, nextCode)) {
                offset = consumeEscaped(source, offset) - 1;
              }
              break;
          }
        }
      }
      function consumeUrlToken() {
        type = TYPE.Url;
        offset = findWhiteSpaceEnd(source, offset);
        for (; offset < source.length; offset++) {
          var code2 = source.charCodeAt(offset);
          switch (charCodeCategory(code2)) {
            case 41:
              offset++;
              return;
            case charCodeCategory.Eof:
              return;
            case charCodeCategory.WhiteSpace:
              offset = findWhiteSpaceEnd(source, offset);
              if (getCharCode(offset) === 41 || offset >= source.length) {
                if (offset < source.length) {
                  offset++;
                }
                return;
              }
              offset = consumeBadUrlRemnants(source, offset);
              type = TYPE.BadUrl;
              return;
            case 34:
            case 39:
            case 40:
            case charCodeCategory.NonPrintable:
              offset = consumeBadUrlRemnants(source, offset);
              type = TYPE.BadUrl;
              return;
            case 92:
              if (isValidEscape(code2, getCharCode(offset + 1))) {
                offset = consumeEscaped(source, offset) - 1;
                break;
              }
              offset = consumeBadUrlRemnants(source, offset);
              type = TYPE.BadUrl;
              return;
          }
        }
      }
      if (!stream) {
        stream = new TokenStream();
      }
      source = String(source || "");
      var sourceLength = source.length;
      var offsetAndType = adoptBuffer(stream.offsetAndType, sourceLength + 1);
      var balance = adoptBuffer(stream.balance, sourceLength + 1);
      var tokenCount = 0;
      var start = isBOM(getCharCode(0));
      var offset = start;
      var balanceCloseType = 0;
      var balanceStart = 0;
      var balancePrev = 0;
      while (offset < sourceLength) {
        var code = source.charCodeAt(offset);
        var type = 0;
        balance[tokenCount] = sourceLength;
        switch (charCodeCategory(code)) {
          case charCodeCategory.WhiteSpace:
            type = TYPE.WhiteSpace;
            offset = findWhiteSpaceEnd(source, offset + 1);
            break;
          case 34:
            consumeStringToken();
            break;
          case 35:
            if (isName(getCharCode(offset + 1)) || isValidEscape(getCharCode(offset + 1), getCharCode(offset + 2))) {
              type = TYPE.Hash;
              offset = consumeName(source, offset + 1);
            } else {
              type = TYPE.Delim;
              offset++;
            }
            break;
          case 39:
            consumeStringToken();
            break;
          case 40:
            type = TYPE.LeftParenthesis;
            offset++;
            break;
          case 41:
            type = TYPE.RightParenthesis;
            offset++;
            break;
          case 43:
            if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
              consumeNumericToken();
            } else {
              type = TYPE.Delim;
              offset++;
            }
            break;
          case 44:
            type = TYPE.Comma;
            offset++;
            break;
          case 45:
            if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
              consumeNumericToken();
            } else {
              if (getCharCode(offset + 1) === 45 && getCharCode(offset + 2) === 62) {
                type = TYPE.CDC;
                offset = offset + 3;
              } else {
                if (isIdentifierStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
                  consumeIdentLikeToken();
                } else {
                  type = TYPE.Delim;
                  offset++;
                }
              }
            }
            break;
          case 46:
            if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
              consumeNumericToken();
            } else {
              type = TYPE.Delim;
              offset++;
            }
            break;
          case 47:
            if (getCharCode(offset + 1) === 42) {
              type = TYPE.Comment;
              offset = source.indexOf("*/", offset + 2) + 2;
              if (offset === 1) {
                offset = source.length;
              }
            } else {
              type = TYPE.Delim;
              offset++;
            }
            break;
          case 58:
            type = TYPE.Colon;
            offset++;
            break;
          case 59:
            type = TYPE.Semicolon;
            offset++;
            break;
          case 60:
            if (getCharCode(offset + 1) === 33 && getCharCode(offset + 2) === 45 && getCharCode(offset + 3) === 45) {
              type = TYPE.CDO;
              offset = offset + 4;
            } else {
              type = TYPE.Delim;
              offset++;
            }
            break;
          case 64:
            if (isIdentifierStart(getCharCode(offset + 1), getCharCode(offset + 2), getCharCode(offset + 3))) {
              type = TYPE.AtKeyword;
              offset = consumeName(source, offset + 1);
            } else {
              type = TYPE.Delim;
              offset++;
            }
            break;
          case 91:
            type = TYPE.LeftSquareBracket;
            offset++;
            break;
          case 92:
            if (isValidEscape(code, getCharCode(offset + 1))) {
              consumeIdentLikeToken();
            } else {
              type = TYPE.Delim;
              offset++;
            }
            break;
          case 93:
            type = TYPE.RightSquareBracket;
            offset++;
            break;
          case 123:
            type = TYPE.LeftCurlyBracket;
            offset++;
            break;
          case 125:
            type = TYPE.RightCurlyBracket;
            offset++;
            break;
          case charCodeCategory.Digit:
            consumeNumericToken();
            break;
          case charCodeCategory.NameStart:
            consumeIdentLikeToken();
            break;
          case charCodeCategory.Eof:
            break;
          default:
            type = TYPE.Delim;
            offset++;
        }
        switch (type) {
          case balanceCloseType:
            balancePrev = balanceStart & OFFSET_MASK;
            balanceStart = balance[balancePrev];
            balanceCloseType = balanceStart >> TYPE_SHIFT;
            balance[tokenCount] = balancePrev;
            balance[balancePrev++] = tokenCount;
            for (; balancePrev < tokenCount; balancePrev++) {
              if (balance[balancePrev] === sourceLength) {
                balance[balancePrev] = tokenCount;
              }
            }
            break;
          case TYPE.LeftParenthesis:
          case TYPE.Function:
            balance[tokenCount] = balanceStart;
            balanceCloseType = TYPE.RightParenthesis;
            balanceStart = balanceCloseType << TYPE_SHIFT | tokenCount;
            break;
          case TYPE.LeftSquareBracket:
            balance[tokenCount] = balanceStart;
            balanceCloseType = TYPE.RightSquareBracket;
            balanceStart = balanceCloseType << TYPE_SHIFT | tokenCount;
            break;
          case TYPE.LeftCurlyBracket:
            balance[tokenCount] = balanceStart;
            balanceCloseType = TYPE.RightCurlyBracket;
            balanceStart = balanceCloseType << TYPE_SHIFT | tokenCount;
            break;
        }
        offsetAndType[tokenCount++] = type << TYPE_SHIFT | offset;
      }
      offsetAndType[tokenCount] = TYPE.EOF << TYPE_SHIFT | offset;
      balance[tokenCount] = sourceLength;
      balance[sourceLength] = sourceLength;
      while (balanceStart !== 0) {
        balancePrev = balanceStart & OFFSET_MASK;
        balanceStart = balance[balancePrev];
        balance[balancePrev] = sourceLength;
      }
      stream.source = source;
      stream.firstCharOffset = start;
      stream.offsetAndType = offsetAndType;
      stream.tokenCount = tokenCount;
      stream.balance = balance;
      stream.reset();
      stream.next();
      return stream;
    }
    Object.keys(constants).forEach(function(key) {
      tokenize[key] = constants[key];
    });
    Object.keys(charCodeDefinitions).forEach(function(key) {
      tokenize[key] = charCodeDefinitions[key];
    });
    Object.keys(utils).forEach(function(key) {
      tokenize[key] = utils[key];
    });
    module2.exports = tokenize;
  }
});

// node_modules/css-tree/lib/lexer/generic-an-plus-b.js
var require_generic_an_plus_b = __commonJS({
  "node_modules/css-tree/lib/lexer/generic-an-plus-b.js"(exports2, module2) {
    var isDigit = require_tokenizer().isDigit;
    var cmpChar = require_tokenizer().cmpChar;
    var TYPE = require_tokenizer().TYPE;
    var DELIM = TYPE.Delim;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    var IDENT = TYPE.Ident;
    var NUMBER = TYPE.Number;
    var DIMENSION = TYPE.Dimension;
    var PLUSSIGN = 43;
    var HYPHENMINUS = 45;
    var N = 110;
    var DISALLOW_SIGN = true;
    var ALLOW_SIGN = false;
    function isDelim(token, code) {
      return token !== null && token.type === DELIM && token.value.charCodeAt(0) === code;
    }
    function skipSC(token, offset, getNextToken) {
      while (token !== null && (token.type === WHITESPACE || token.type === COMMENT)) {
        token = getNextToken(++offset);
      }
      return offset;
    }
    function checkInteger(token, valueOffset, disallowSign, offset) {
      if (!token) {
        return 0;
      }
      var code = token.value.charCodeAt(valueOffset);
      if (code === PLUSSIGN || code === HYPHENMINUS) {
        if (disallowSign) {
          return 0;
        }
        valueOffset++;
      }
      for (; valueOffset < token.value.length; valueOffset++) {
        if (!isDigit(token.value.charCodeAt(valueOffset))) {
          return 0;
        }
      }
      return offset + 1;
    }
    function consumeB(token, offset_, getNextToken) {
      var sign = false;
      var offset = skipSC(token, offset_, getNextToken);
      token = getNextToken(offset);
      if (token === null) {
        return offset_;
      }
      if (token.type !== NUMBER) {
        if (isDelim(token, PLUSSIGN) || isDelim(token, HYPHENMINUS)) {
          sign = true;
          offset = skipSC(getNextToken(++offset), offset, getNextToken);
          token = getNextToken(offset);
          if (token === null && token.type !== NUMBER) {
            return 0;
          }
        } else {
          return offset_;
        }
      }
      if (!sign) {
        var code = token.value.charCodeAt(0);
        if (code !== PLUSSIGN && code !== HYPHENMINUS) {
          return 0;
        }
      }
      return checkInteger(token, sign ? 0 : 1, sign, offset);
    }
    module2.exports = function anPlusB(token, getNextToken) {
      var offset = 0;
      if (!token) {
        return 0;
      }
      if (token.type === NUMBER) {
        return checkInteger(token, 0, ALLOW_SIGN, offset);
      } else if (token.type === IDENT && token.value.charCodeAt(0) === HYPHENMINUS) {
        if (!cmpChar(token.value, 1, N)) {
          return 0;
        }
        switch (token.value.length) {
          case 2:
            return consumeB(getNextToken(++offset), offset, getNextToken);
          case 3:
            if (token.value.charCodeAt(2) !== HYPHENMINUS) {
              return 0;
            }
            offset = skipSC(getNextToken(++offset), offset, getNextToken);
            token = getNextToken(offset);
            return checkInteger(token, 0, DISALLOW_SIGN, offset);
          default:
            if (token.value.charCodeAt(2) !== HYPHENMINUS) {
              return 0;
            }
            return checkInteger(token, 3, DISALLOW_SIGN, offset);
        }
      } else if (token.type === IDENT || isDelim(token, PLUSSIGN) && getNextToken(offset + 1).type === IDENT) {
        if (token.type !== IDENT) {
          token = getNextToken(++offset);
        }
        if (token === null || !cmpChar(token.value, 0, N)) {
          return 0;
        }
        switch (token.value.length) {
          case 1:
            return consumeB(getNextToken(++offset), offset, getNextToken);
          case 2:
            if (token.value.charCodeAt(1) !== HYPHENMINUS) {
              return 0;
            }
            offset = skipSC(getNextToken(++offset), offset, getNextToken);
            token = getNextToken(offset);
            return checkInteger(token, 0, DISALLOW_SIGN, offset);
          default:
            if (token.value.charCodeAt(1) !== HYPHENMINUS) {
              return 0;
            }
            return checkInteger(token, 2, DISALLOW_SIGN, offset);
        }
      } else if (token.type === DIMENSION) {
        var code = token.value.charCodeAt(0);
        var sign = code === PLUSSIGN || code === HYPHENMINUS ? 1 : 0;
        for (var i = sign; i < token.value.length; i++) {
          if (!isDigit(token.value.charCodeAt(i))) {
            break;
          }
        }
        if (i === sign) {
          return 0;
        }
        if (!cmpChar(token.value, i, N)) {
          return 0;
        }
        if (i + 1 === token.value.length) {
          return consumeB(getNextToken(++offset), offset, getNextToken);
        } else {
          if (token.value.charCodeAt(i + 1) !== HYPHENMINUS) {
            return 0;
          }
          if (i + 2 === token.value.length) {
            offset = skipSC(getNextToken(++offset), offset, getNextToken);
            token = getNextToken(offset);
            return checkInteger(token, 0, DISALLOW_SIGN, offset);
          } else {
            return checkInteger(token, i + 2, DISALLOW_SIGN, offset);
          }
        }
      }
      return 0;
    };
  }
});

// node_modules/css-tree/lib/lexer/generic-urange.js
var require_generic_urange = __commonJS({
  "node_modules/css-tree/lib/lexer/generic-urange.js"(exports2, module2) {
    var isHexDigit = require_tokenizer().isHexDigit;
    var cmpChar = require_tokenizer().cmpChar;
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    var DELIM = TYPE.Delim;
    var NUMBER = TYPE.Number;
    var DIMENSION = TYPE.Dimension;
    var PLUSSIGN = 43;
    var HYPHENMINUS = 45;
    var QUESTIONMARK = 63;
    var U = 117;
    function isDelim(token, code) {
      return token !== null && token.type === DELIM && token.value.charCodeAt(0) === code;
    }
    function startsWith(token, code) {
      return token.value.charCodeAt(0) === code;
    }
    function hexSequence(token, offset, allowDash) {
      for (var pos = offset, hexlen = 0; pos < token.value.length; pos++) {
        var code = token.value.charCodeAt(pos);
        if (code === HYPHENMINUS && allowDash && hexlen !== 0) {
          if (hexSequence(token, offset + hexlen + 1, false) > 0) {
            return 6;
          }
          return 0;
        }
        if (!isHexDigit(code)) {
          return 0;
        }
        if (++hexlen > 6) {
          return 0;
        }
        ;
      }
      return hexlen;
    }
    function withQuestionMarkSequence(consumed, length, getNextToken) {
      if (!consumed) {
        return 0;
      }
      while (isDelim(getNextToken(length), QUESTIONMARK)) {
        if (++consumed > 6) {
          return 0;
        }
        length++;
      }
      return length;
    }
    module2.exports = function urange(token, getNextToken) {
      var length = 0;
      if (token === null || token.type !== IDENT || !cmpChar(token.value, 0, U)) {
        return 0;
      }
      token = getNextToken(++length);
      if (token === null) {
        return 0;
      }
      if (isDelim(token, PLUSSIGN)) {
        token = getNextToken(++length);
        if (token === null) {
          return 0;
        }
        if (token.type === IDENT) {
          return withQuestionMarkSequence(hexSequence(token, 0, true), ++length, getNextToken);
        }
        if (isDelim(token, QUESTIONMARK)) {
          return withQuestionMarkSequence(1, ++length, getNextToken);
        }
        return 0;
      }
      if (token.type === NUMBER) {
        if (!startsWith(token, PLUSSIGN)) {
          return 0;
        }
        var consumedHexLength = hexSequence(token, 1, true);
        if (consumedHexLength === 0) {
          return 0;
        }
        token = getNextToken(++length);
        if (token === null) {
          return length;
        }
        if (token.type === DIMENSION || token.type === NUMBER) {
          if (!startsWith(token, HYPHENMINUS) || !hexSequence(token, 1, false)) {
            return 0;
          }
          return length + 1;
        }
        return withQuestionMarkSequence(consumedHexLength, length, getNextToken);
      }
      if (token.type === DIMENSION) {
        if (!startsWith(token, PLUSSIGN)) {
          return 0;
        }
        return withQuestionMarkSequence(hexSequence(token, 1, true), ++length, getNextToken);
      }
      return 0;
    };
  }
});

// node_modules/css-tree/lib/lexer/generic.js
var require_generic = __commonJS({
  "node_modules/css-tree/lib/lexer/generic.js"(exports2, module2) {
    var tokenizer = require_tokenizer();
    var isIdentifierStart = tokenizer.isIdentifierStart;
    var isHexDigit = tokenizer.isHexDigit;
    var isDigit = tokenizer.isDigit;
    var cmpStr = tokenizer.cmpStr;
    var consumeNumber = tokenizer.consumeNumber;
    var TYPE = tokenizer.TYPE;
    var anPlusB = require_generic_an_plus_b();
    var urange = require_generic_urange();
    var cssWideKeywords = ["unset", "initial", "inherit"];
    var calcFunctionNames = ["calc(", "-moz-calc(", "-webkit-calc("];
    var LENGTH = {
      "px": true,
      "mm": true,
      "cm": true,
      "in": true,
      "pt": true,
      "pc": true,
      "q": true,
      "em": true,
      "ex": true,
      "ch": true,
      "rem": true,
      "vh": true,
      "vw": true,
      "vmin": true,
      "vmax": true,
      "vm": true
    };
    var ANGLE = {
      "deg": true,
      "grad": true,
      "rad": true,
      "turn": true
    };
    var TIME = {
      "s": true,
      "ms": true
    };
    var FREQUENCY = {
      "hz": true,
      "khz": true
    };
    var RESOLUTION = {
      "dpi": true,
      "dpcm": true,
      "dppx": true,
      "x": true
    };
    var FLEX = {
      "fr": true
    };
    var DECIBEL = {
      "db": true
    };
    var SEMITONES = {
      "st": true
    };
    function charCode(str, index) {
      return index < str.length ? str.charCodeAt(index) : 0;
    }
    function eqStr(actual, expected) {
      return cmpStr(actual, 0, actual.length, expected);
    }
    function eqStrAny(actual, expected) {
      for (var i = 0; i < expected.length; i++) {
        if (eqStr(actual, expected[i])) {
          return true;
        }
      }
      return false;
    }
    function isPostfixIeHack(str, offset) {
      if (offset !== str.length - 2) {
        return false;
      }
      return str.charCodeAt(offset) === 92 && isDigit(str.charCodeAt(offset + 1));
    }
    function outOfRange(opts, value, numEnd) {
      if (opts && opts.type === "Range") {
        var num = Number(numEnd !== void 0 && numEnd !== value.length ? value.substr(0, numEnd) : value);
        if (isNaN(num)) {
          return true;
        }
        if (opts.min !== null && num < opts.min) {
          return true;
        }
        if (opts.max !== null && num > opts.max) {
          return true;
        }
      }
      return false;
    }
    function consumeFunction(token, getNextToken) {
      var startIdx = token.index;
      var length = 0;
      do {
        length++;
        if (token.balance <= startIdx) {
          break;
        }
      } while (token = getNextToken(length));
      return length;
    }
    function calc(next) {
      return function(token, getNextToken, opts) {
        if (token === null) {
          return 0;
        }
        if (token.type === TYPE.Function && eqStrAny(token.value, calcFunctionNames)) {
          return consumeFunction(token, getNextToken);
        }
        return next(token, getNextToken, opts);
      };
    }
    function tokenType(expectedTokenType) {
      return function(token) {
        if (token === null || token.type !== expectedTokenType) {
          return 0;
        }
        return 1;
      };
    }
    function func(name) {
      name = name + "(";
      return function(token, getNextToken) {
        if (token !== null && eqStr(token.value, name)) {
          return consumeFunction(token, getNextToken);
        }
        return 0;
      };
    }
    function customIdent(token) {
      if (token === null || token.type !== TYPE.Ident) {
        return 0;
      }
      var name = token.value.toLowerCase();
      if (eqStrAny(name, cssWideKeywords)) {
        return 0;
      }
      if (eqStr(name, "default")) {
        return 0;
      }
      return 1;
    }
    function customPropertyName(token) {
      if (token === null || token.type !== TYPE.Ident) {
        return 0;
      }
      if (charCode(token.value, 0) !== 45 || charCode(token.value, 1) !== 45) {
        return 0;
      }
      return 1;
    }
    function hexColor(token) {
      if (token === null || token.type !== TYPE.Hash) {
        return 0;
      }
      var length = token.value.length;
      if (length !== 4 && length !== 5 && length !== 7 && length !== 9) {
        return 0;
      }
      for (var i = 1; i < length; i++) {
        if (!isHexDigit(token.value.charCodeAt(i))) {
          return 0;
        }
      }
      return 1;
    }
    function idSelector(token) {
      if (token === null || token.type !== TYPE.Hash) {
        return 0;
      }
      if (!isIdentifierStart(charCode(token.value, 1), charCode(token.value, 2), charCode(token.value, 3))) {
        return 0;
      }
      return 1;
    }
    function declarationValue(token, getNextToken) {
      if (!token) {
        return 0;
      }
      var length = 0;
      var level = 0;
      var startIdx = token.index;
      scan:
        do {
          switch (token.type) {
            case TYPE.BadString:
            case TYPE.BadUrl:
              break scan;
            case TYPE.RightCurlyBracket:
            case TYPE.RightParenthesis:
            case TYPE.RightSquareBracket:
              if (token.balance > token.index || token.balance < startIdx) {
                break scan;
              }
              level--;
              break;
            case TYPE.Semicolon:
              if (level === 0) {
                break scan;
              }
              break;
            case TYPE.Delim:
              if (token.value === "!" && level === 0) {
                break scan;
              }
              break;
            case TYPE.Function:
            case TYPE.LeftParenthesis:
            case TYPE.LeftSquareBracket:
            case TYPE.LeftCurlyBracket:
              level++;
              break;
          }
          length++;
          if (token.balance <= startIdx) {
            break;
          }
        } while (token = getNextToken(length));
      return length;
    }
    function anyValue(token, getNextToken) {
      if (!token) {
        return 0;
      }
      var startIdx = token.index;
      var length = 0;
      scan:
        do {
          switch (token.type) {
            case TYPE.BadString:
            case TYPE.BadUrl:
              break scan;
            case TYPE.RightCurlyBracket:
            case TYPE.RightParenthesis:
            case TYPE.RightSquareBracket:
              if (token.balance > token.index || token.balance < startIdx) {
                break scan;
              }
              break;
          }
          length++;
          if (token.balance <= startIdx) {
            break;
          }
        } while (token = getNextToken(length));
      return length;
    }
    function dimension(type) {
      return function(token, getNextToken, opts) {
        if (token === null || token.type !== TYPE.Dimension) {
          return 0;
        }
        var numberEnd = consumeNumber(token.value, 0);
        if (type !== null) {
          var reverseSolidusOffset = token.value.indexOf("\\", numberEnd);
          var unit = reverseSolidusOffset === -1 || !isPostfixIeHack(token.value, reverseSolidusOffset) ? token.value.substr(numberEnd) : token.value.substring(numberEnd, reverseSolidusOffset);
          if (type.hasOwnProperty(unit.toLowerCase()) === false) {
            return 0;
          }
        }
        if (outOfRange(opts, token.value, numberEnd)) {
          return 0;
        }
        return 1;
      };
    }
    function percentage(token, getNextToken, opts) {
      if (token === null || token.type !== TYPE.Percentage) {
        return 0;
      }
      if (outOfRange(opts, token.value, token.value.length - 1)) {
        return 0;
      }
      return 1;
    }
    function zero(next) {
      if (typeof next !== "function") {
        next = function() {
          return 0;
        };
      }
      return function(token, getNextToken, opts) {
        if (token !== null && token.type === TYPE.Number) {
          if (Number(token.value) === 0) {
            return 1;
          }
        }
        return next(token, getNextToken, opts);
      };
    }
    function number(token, getNextToken, opts) {
      if (token === null) {
        return 0;
      }
      var numberEnd = consumeNumber(token.value, 0);
      var isNumber = numberEnd === token.value.length;
      if (!isNumber && !isPostfixIeHack(token.value, numberEnd)) {
        return 0;
      }
      if (outOfRange(opts, token.value, numberEnd)) {
        return 0;
      }
      return 1;
    }
    function integer(token, getNextToken, opts) {
      if (token === null || token.type !== TYPE.Number) {
        return 0;
      }
      var i = token.value.charCodeAt(0) === 43 || token.value.charCodeAt(0) === 45 ? 1 : 0;
      for (; i < token.value.length; i++) {
        if (!isDigit(token.value.charCodeAt(i))) {
          return 0;
        }
      }
      if (outOfRange(opts, token.value, i)) {
        return 0;
      }
      return 1;
    }
    module2.exports = {
      "ident-token": tokenType(TYPE.Ident),
      "function-token": tokenType(TYPE.Function),
      "at-keyword-token": tokenType(TYPE.AtKeyword),
      "hash-token": tokenType(TYPE.Hash),
      "string-token": tokenType(TYPE.String),
      "bad-string-token": tokenType(TYPE.BadString),
      "url-token": tokenType(TYPE.Url),
      "bad-url-token": tokenType(TYPE.BadUrl),
      "delim-token": tokenType(TYPE.Delim),
      "number-token": tokenType(TYPE.Number),
      "percentage-token": tokenType(TYPE.Percentage),
      "dimension-token": tokenType(TYPE.Dimension),
      "whitespace-token": tokenType(TYPE.WhiteSpace),
      "CDO-token": tokenType(TYPE.CDO),
      "CDC-token": tokenType(TYPE.CDC),
      "colon-token": tokenType(TYPE.Colon),
      "semicolon-token": tokenType(TYPE.Semicolon),
      "comma-token": tokenType(TYPE.Comma),
      "[-token": tokenType(TYPE.LeftSquareBracket),
      "]-token": tokenType(TYPE.RightSquareBracket),
      "(-token": tokenType(TYPE.LeftParenthesis),
      ")-token": tokenType(TYPE.RightParenthesis),
      "{-token": tokenType(TYPE.LeftCurlyBracket),
      "}-token": tokenType(TYPE.RightCurlyBracket),
      "string": tokenType(TYPE.String),
      "ident": tokenType(TYPE.Ident),
      "custom-ident": customIdent,
      "custom-property-name": customPropertyName,
      "hex-color": hexColor,
      "id-selector": idSelector,
      "an-plus-b": anPlusB,
      "urange": urange,
      "declaration-value": declarationValue,
      "any-value": anyValue,
      "dimension": calc(dimension(null)),
      "angle": calc(dimension(ANGLE)),
      "decibel": calc(dimension(DECIBEL)),
      "frequency": calc(dimension(FREQUENCY)),
      "flex": calc(dimension(FLEX)),
      "length": calc(zero(dimension(LENGTH))),
      "resolution": calc(dimension(RESOLUTION)),
      "semitones": calc(dimension(SEMITONES)),
      "time": calc(dimension(TIME)),
      "percentage": calc(percentage),
      "zero": zero(),
      "number": calc(number),
      "integer": calc(integer),
      "-ms-legacy-expression": func("expression")
    };
  }
});

// node_modules/css-tree/lib/definition-syntax/SyntaxError.js
var require_SyntaxError2 = __commonJS({
  "node_modules/css-tree/lib/definition-syntax/SyntaxError.js"(exports2, module2) {
    var createCustomError = require_createCustomError();
    module2.exports = function SyntaxError2(message, input, offset) {
      var error = createCustomError("SyntaxError", message);
      error.input = input;
      error.offset = offset;
      error.rawMessage = message;
      error.message = error.rawMessage + "\n  " + error.input + "\n--" + new Array((error.offset || error.input.length) + 1).join("-") + "^";
      return error;
    };
  }
});

// node_modules/css-tree/lib/definition-syntax/tokenizer.js
var require_tokenizer2 = __commonJS({
  "node_modules/css-tree/lib/definition-syntax/tokenizer.js"(exports2, module2) {
    var SyntaxError2 = require_SyntaxError2();
    var TAB = 9;
    var N = 10;
    var F = 12;
    var R = 13;
    var SPACE = 32;
    var Tokenizer = function(str) {
      this.str = str;
      this.pos = 0;
    };
    Tokenizer.prototype = {
      charCodeAt: function(pos) {
        return pos < this.str.length ? this.str.charCodeAt(pos) : 0;
      },
      charCode: function() {
        return this.charCodeAt(this.pos);
      },
      nextCharCode: function() {
        return this.charCodeAt(this.pos + 1);
      },
      nextNonWsCode: function(pos) {
        return this.charCodeAt(this.findWsEnd(pos));
      },
      findWsEnd: function(pos) {
        for (; pos < this.str.length; pos++) {
          var code = this.str.charCodeAt(pos);
          if (code !== R && code !== N && code !== F && code !== SPACE && code !== TAB) {
            break;
          }
        }
        return pos;
      },
      substringToPos: function(end) {
        return this.str.substring(this.pos, this.pos = end);
      },
      eat: function(code) {
        if (this.charCode() !== code) {
          this.error("Expect `" + String.fromCharCode(code) + "`");
        }
        this.pos++;
      },
      peek: function() {
        return this.pos < this.str.length ? this.str.charAt(this.pos++) : "";
      },
      error: function(message) {
        throw new SyntaxError2(message, this.str, this.pos);
      }
    };
    module2.exports = Tokenizer;
  }
});

// node_modules/css-tree/lib/definition-syntax/parse.js
var require_parse5 = __commonJS({
  "node_modules/css-tree/lib/definition-syntax/parse.js"(exports2, module2) {
    var Tokenizer = require_tokenizer2();
    var TAB = 9;
    var N = 10;
    var F = 12;
    var R = 13;
    var SPACE = 32;
    var EXCLAMATIONMARK = 33;
    var NUMBERSIGN = 35;
    var AMPERSAND = 38;
    var APOSTROPHE = 39;
    var LEFTPARENTHESIS = 40;
    var RIGHTPARENTHESIS = 41;
    var ASTERISK = 42;
    var PLUSSIGN = 43;
    var COMMA = 44;
    var HYPERMINUS = 45;
    var LESSTHANSIGN = 60;
    var GREATERTHANSIGN = 62;
    var QUESTIONMARK = 63;
    var COMMERCIALAT = 64;
    var LEFTSQUAREBRACKET = 91;
    var RIGHTSQUAREBRACKET = 93;
    var LEFTCURLYBRACKET = 123;
    var VERTICALLINE = 124;
    var RIGHTCURLYBRACKET = 125;
    var INFINITY = 8734;
    var NAME_CHAR = createCharMap(function(ch) {
      return /[a-zA-Z0-9\-]/.test(ch);
    });
    var COMBINATOR_PRECEDENCE = {
      " ": 1,
      "&&": 2,
      "||": 3,
      "|": 4
    };
    function createCharMap(fn) {
      var array = typeof Uint32Array === "function" ? new Uint32Array(128) : new Array(128);
      for (var i = 0; i < 128; i++) {
        array[i] = fn(String.fromCharCode(i)) ? 1 : 0;
      }
      return array;
    }
    function scanSpaces(tokenizer) {
      return tokenizer.substringToPos(tokenizer.findWsEnd(tokenizer.pos));
    }
    function scanWord(tokenizer) {
      var end = tokenizer.pos;
      for (; end < tokenizer.str.length; end++) {
        var code = tokenizer.str.charCodeAt(end);
        if (code >= 128 || NAME_CHAR[code] === 0) {
          break;
        }
      }
      if (tokenizer.pos === end) {
        tokenizer.error("Expect a keyword");
      }
      return tokenizer.substringToPos(end);
    }
    function scanNumber(tokenizer) {
      var end = tokenizer.pos;
      for (; end < tokenizer.str.length; end++) {
        var code = tokenizer.str.charCodeAt(end);
        if (code < 48 || code > 57) {
          break;
        }
      }
      if (tokenizer.pos === end) {
        tokenizer.error("Expect a number");
      }
      return tokenizer.substringToPos(end);
    }
    function scanString(tokenizer) {
      var end = tokenizer.str.indexOf("'", tokenizer.pos + 1);
      if (end === -1) {
        tokenizer.pos = tokenizer.str.length;
        tokenizer.error("Expect an apostrophe");
      }
      return tokenizer.substringToPos(end + 1);
    }
    function readMultiplierRange(tokenizer) {
      var min = null;
      var max = null;
      tokenizer.eat(LEFTCURLYBRACKET);
      min = scanNumber(tokenizer);
      if (tokenizer.charCode() === COMMA) {
        tokenizer.pos++;
        if (tokenizer.charCode() !== RIGHTCURLYBRACKET) {
          max = scanNumber(tokenizer);
        }
      } else {
        max = min;
      }
      tokenizer.eat(RIGHTCURLYBRACKET);
      return {
        min: Number(min),
        max: max ? Number(max) : 0
      };
    }
    function readMultiplier(tokenizer) {
      var range = null;
      var comma = false;
      switch (tokenizer.charCode()) {
        case ASTERISK:
          tokenizer.pos++;
          range = {
            min: 0,
            max: 0
          };
          break;
        case PLUSSIGN:
          tokenizer.pos++;
          range = {
            min: 1,
            max: 0
          };
          break;
        case QUESTIONMARK:
          tokenizer.pos++;
          range = {
            min: 0,
            max: 1
          };
          break;
        case NUMBERSIGN:
          tokenizer.pos++;
          comma = true;
          if (tokenizer.charCode() === LEFTCURLYBRACKET) {
            range = readMultiplierRange(tokenizer);
          } else {
            range = {
              min: 1,
              max: 0
            };
          }
          break;
        case LEFTCURLYBRACKET:
          range = readMultiplierRange(tokenizer);
          break;
        default:
          return null;
      }
      return {
        type: "Multiplier",
        comma,
        min: range.min,
        max: range.max,
        term: null
      };
    }
    function maybeMultiplied(tokenizer, node) {
      var multiplier = readMultiplier(tokenizer);
      if (multiplier !== null) {
        multiplier.term = node;
        return multiplier;
      }
      return node;
    }
    function maybeToken(tokenizer) {
      var ch = tokenizer.peek();
      if (ch === "") {
        return null;
      }
      return {
        type: "Token",
        value: ch
      };
    }
    function readProperty(tokenizer) {
      var name;
      tokenizer.eat(LESSTHANSIGN);
      tokenizer.eat(APOSTROPHE);
      name = scanWord(tokenizer);
      tokenizer.eat(APOSTROPHE);
      tokenizer.eat(GREATERTHANSIGN);
      return maybeMultiplied(tokenizer, {
        type: "Property",
        name
      });
    }
    function readTypeRange(tokenizer) {
      var min = null;
      var max = null;
      var sign = 1;
      tokenizer.eat(LEFTSQUAREBRACKET);
      if (tokenizer.charCode() === HYPERMINUS) {
        tokenizer.peek();
        sign = -1;
      }
      if (sign == -1 && tokenizer.charCode() === INFINITY) {
        tokenizer.peek();
      } else {
        min = sign * Number(scanNumber(tokenizer));
      }
      scanSpaces(tokenizer);
      tokenizer.eat(COMMA);
      scanSpaces(tokenizer);
      if (tokenizer.charCode() === INFINITY) {
        tokenizer.peek();
      } else {
        sign = 1;
        if (tokenizer.charCode() === HYPERMINUS) {
          tokenizer.peek();
          sign = -1;
        }
        max = sign * Number(scanNumber(tokenizer));
      }
      tokenizer.eat(RIGHTSQUAREBRACKET);
      if (min === null && max === null) {
        return null;
      }
      return {
        type: "Range",
        min,
        max
      };
    }
    function readType(tokenizer) {
      var name;
      var opts = null;
      tokenizer.eat(LESSTHANSIGN);
      name = scanWord(tokenizer);
      if (tokenizer.charCode() === LEFTPARENTHESIS && tokenizer.nextCharCode() === RIGHTPARENTHESIS) {
        tokenizer.pos += 2;
        name += "()";
      }
      if (tokenizer.charCodeAt(tokenizer.findWsEnd(tokenizer.pos)) === LEFTSQUAREBRACKET) {
        scanSpaces(tokenizer);
        opts = readTypeRange(tokenizer);
      }
      tokenizer.eat(GREATERTHANSIGN);
      return maybeMultiplied(tokenizer, {
        type: "Type",
        name,
        opts
      });
    }
    function readKeywordOrFunction(tokenizer) {
      var name;
      name = scanWord(tokenizer);
      if (tokenizer.charCode() === LEFTPARENTHESIS) {
        tokenizer.pos++;
        return {
          type: "Function",
          name
        };
      }
      return maybeMultiplied(tokenizer, {
        type: "Keyword",
        name
      });
    }
    function regroupTerms(terms, combinators) {
      function createGroup(terms2, combinator2) {
        return {
          type: "Group",
          terms: terms2,
          combinator: combinator2,
          disallowEmpty: false,
          explicit: false
        };
      }
      combinators = Object.keys(combinators).sort(function(a, b) {
        return COMBINATOR_PRECEDENCE[a] - COMBINATOR_PRECEDENCE[b];
      });
      while (combinators.length > 0) {
        var combinator = combinators.shift();
        for (var i = 0, subgroupStart = 0; i < terms.length; i++) {
          var term = terms[i];
          if (term.type === "Combinator") {
            if (term.value === combinator) {
              if (subgroupStart === -1) {
                subgroupStart = i - 1;
              }
              terms.splice(i, 1);
              i--;
            } else {
              if (subgroupStart !== -1 && i - subgroupStart > 1) {
                terms.splice(subgroupStart, i - subgroupStart, createGroup(terms.slice(subgroupStart, i), combinator));
                i = subgroupStart + 1;
              }
              subgroupStart = -1;
            }
          }
        }
        if (subgroupStart !== -1 && combinators.length) {
          terms.splice(subgroupStart, i - subgroupStart, createGroup(terms.slice(subgroupStart, i), combinator));
        }
      }
      return combinator;
    }
    function readImplicitGroup(tokenizer) {
      var terms = [];
      var combinators = {};
      var token;
      var prevToken = null;
      var prevTokenPos = tokenizer.pos;
      while (token = peek(tokenizer)) {
        if (token.type !== "Spaces") {
          if (token.type === "Combinator") {
            if (prevToken === null || prevToken.type === "Combinator") {
              tokenizer.pos = prevTokenPos;
              tokenizer.error("Unexpected combinator");
            }
            combinators[token.value] = true;
          } else if (prevToken !== null && prevToken.type !== "Combinator") {
            combinators[" "] = true;
            terms.push({
              type: "Combinator",
              value: " "
            });
          }
          terms.push(token);
          prevToken = token;
          prevTokenPos = tokenizer.pos;
        }
      }
      if (prevToken !== null && prevToken.type === "Combinator") {
        tokenizer.pos -= prevTokenPos;
        tokenizer.error("Unexpected combinator");
      }
      return {
        type: "Group",
        terms,
        combinator: regroupTerms(terms, combinators) || " ",
        disallowEmpty: false,
        explicit: false
      };
    }
    function readGroup(tokenizer) {
      var result;
      tokenizer.eat(LEFTSQUAREBRACKET);
      result = readImplicitGroup(tokenizer);
      tokenizer.eat(RIGHTSQUAREBRACKET);
      result.explicit = true;
      if (tokenizer.charCode() === EXCLAMATIONMARK) {
        tokenizer.pos++;
        result.disallowEmpty = true;
      }
      return result;
    }
    function peek(tokenizer) {
      var code = tokenizer.charCode();
      if (code < 128 && NAME_CHAR[code] === 1) {
        return readKeywordOrFunction(tokenizer);
      }
      switch (code) {
        case RIGHTSQUAREBRACKET:
          break;
        case LEFTSQUAREBRACKET:
          return maybeMultiplied(tokenizer, readGroup(tokenizer));
        case LESSTHANSIGN:
          return tokenizer.nextCharCode() === APOSTROPHE ? readProperty(tokenizer) : readType(tokenizer);
        case VERTICALLINE:
          return {
            type: "Combinator",
            value: tokenizer.substringToPos(tokenizer.nextCharCode() === VERTICALLINE ? tokenizer.pos + 2 : tokenizer.pos + 1)
          };
        case AMPERSAND:
          tokenizer.pos++;
          tokenizer.eat(AMPERSAND);
          return {
            type: "Combinator",
            value: "&&"
          };
        case COMMA:
          tokenizer.pos++;
          return {
            type: "Comma"
          };
        case APOSTROPHE:
          return maybeMultiplied(tokenizer, {
            type: "String",
            value: scanString(tokenizer)
          });
        case SPACE:
        case TAB:
        case N:
        case R:
        case F:
          return {
            type: "Spaces",
            value: scanSpaces(tokenizer)
          };
        case COMMERCIALAT:
          code = tokenizer.nextCharCode();
          if (code < 128 && NAME_CHAR[code] === 1) {
            tokenizer.pos++;
            return {
              type: "AtKeyword",
              name: scanWord(tokenizer)
            };
          }
          return maybeToken(tokenizer);
        case ASTERISK:
        case PLUSSIGN:
        case QUESTIONMARK:
        case NUMBERSIGN:
        case EXCLAMATIONMARK:
          break;
        case LEFTCURLYBRACKET:
          code = tokenizer.nextCharCode();
          if (code < 48 || code > 57) {
            return maybeToken(tokenizer);
          }
          break;
        default:
          return maybeToken(tokenizer);
      }
    }
    function parse(source) {
      var tokenizer = new Tokenizer(source);
      var result = readImplicitGroup(tokenizer);
      if (tokenizer.pos !== source.length) {
        tokenizer.error("Unexpected input");
      }
      if (result.terms.length === 1 && result.terms[0].type === "Group") {
        result = result.terms[0];
      }
      return result;
    }
    parse("[a&&<b>#|<'c'>*||e() f{2} /,(% g#{1,2} h{2,})]!");
    module2.exports = parse;
  }
});

// node_modules/css-tree/lib/definition-syntax/walk.js
var require_walk2 = __commonJS({
  "node_modules/css-tree/lib/definition-syntax/walk.js"(exports2, module2) {
    var noop = function() {
    };
    function ensureFunction(value) {
      return typeof value === "function" ? value : noop;
    }
    module2.exports = function(node, options, context) {
      function walk(node2) {
        enter.call(context, node2);
        switch (node2.type) {
          case "Group":
            node2.terms.forEach(walk);
            break;
          case "Multiplier":
            walk(node2.term);
            break;
          case "Type":
          case "Property":
          case "Keyword":
          case "AtKeyword":
          case "Function":
          case "String":
          case "Token":
          case "Comma":
            break;
          default:
            throw new Error("Unknown type: " + node2.type);
        }
        leave.call(context, node2);
      }
      var enter = noop;
      var leave = noop;
      if (typeof options === "function") {
        enter = options;
      } else if (options) {
        enter = ensureFunction(options.enter);
        leave = ensureFunction(options.leave);
      }
      if (enter === noop && leave === noop) {
        throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function");
      }
      walk(node, context);
    };
  }
});

// node_modules/css-tree/lib/lexer/prepare-tokens.js
var require_prepare_tokens = __commonJS({
  "node_modules/css-tree/lib/lexer/prepare-tokens.js"(exports2, module2) {
    var tokenize = require_tokenizer();
    var TokenStream = require_TokenStream();
    var tokenStream = new TokenStream();
    var astToTokens = {
      decorator: function(handlers) {
        var curNode = null;
        var prev = { len: 0, node: null };
        var nodes = [prev];
        var buffer = "";
        return {
          children: handlers.children,
          node: function(node) {
            var tmp = curNode;
            curNode = node;
            handlers.node.call(this, node);
            curNode = tmp;
          },
          chunk: function(chunk) {
            buffer += chunk;
            if (prev.node !== curNode) {
              nodes.push({
                len: chunk.length,
                node: curNode
              });
            } else {
              prev.len += chunk.length;
            }
          },
          result: function() {
            return prepareTokens(buffer, nodes);
          }
        };
      }
    };
    function prepareTokens(str, nodes) {
      var tokens = [];
      var nodesOffset = 0;
      var nodesIndex = 0;
      var currentNode = nodes ? nodes[nodesIndex].node : null;
      tokenize(str, tokenStream);
      while (!tokenStream.eof) {
        if (nodes) {
          while (nodesIndex < nodes.length && nodesOffset + nodes[nodesIndex].len <= tokenStream.tokenStart) {
            nodesOffset += nodes[nodesIndex++].len;
            currentNode = nodes[nodesIndex].node;
          }
        }
        tokens.push({
          type: tokenStream.tokenType,
          value: tokenStream.getTokenValue(),
          index: tokenStream.tokenIndex,
          balance: tokenStream.balance[tokenStream.tokenIndex],
          node: currentNode
        });
        tokenStream.next();
      }
      return tokens;
    }
    module2.exports = function(value, syntax) {
      if (typeof value === "string") {
        return prepareTokens(value, null);
      }
      return syntax.generate(value, astToTokens);
    };
  }
});

// node_modules/css-tree/lib/lexer/match-graph.js
var require_match_graph = __commonJS({
  "node_modules/css-tree/lib/lexer/match-graph.js"(exports2, module2) {
    var parse = require_parse5();
    var MATCH = { type: "Match" };
    var MISMATCH = { type: "Mismatch" };
    var DISALLOW_EMPTY = { type: "DisallowEmpty" };
    var LEFTPARENTHESIS = 40;
    var RIGHTPARENTHESIS = 41;
    function createCondition(match, thenBranch, elseBranch) {
      if (thenBranch === MATCH && elseBranch === MISMATCH) {
        return match;
      }
      if (match === MATCH && thenBranch === MATCH && elseBranch === MATCH) {
        return match;
      }
      if (match.type === "If" && match.else === MISMATCH && thenBranch === MATCH) {
        thenBranch = match.then;
        match = match.match;
      }
      return {
        type: "If",
        match,
        then: thenBranch,
        else: elseBranch
      };
    }
    function isFunctionType(name) {
      return name.length > 2 && name.charCodeAt(name.length - 2) === LEFTPARENTHESIS && name.charCodeAt(name.length - 1) === RIGHTPARENTHESIS;
    }
    function isEnumCapatible(term) {
      return term.type === "Keyword" || term.type === "AtKeyword" || term.type === "Function" || term.type === "Type" && isFunctionType(term.name);
    }
    function buildGroupMatchGraph(combinator, terms, atLeastOneTermMatched) {
      switch (combinator) {
        case " ":
          var result = MATCH;
          for (var i = terms.length - 1; i >= 0; i--) {
            var term = terms[i];
            result = createCondition(term, result, MISMATCH);
          }
          ;
          return result;
        case "|":
          var result = MISMATCH;
          var map = null;
          for (var i = terms.length - 1; i >= 0; i--) {
            var term = terms[i];
            if (isEnumCapatible(term)) {
              if (map === null && i > 0 && isEnumCapatible(terms[i - 1])) {
                map = /* @__PURE__ */ Object.create(null);
                result = createCondition({
                  type: "Enum",
                  map
                }, MATCH, result);
              }
              if (map !== null) {
                var key = (isFunctionType(term.name) ? term.name.slice(0, -1) : term.name).toLowerCase();
                if (key in map === false) {
                  map[key] = term;
                  continue;
                }
              }
            }
            map = null;
            result = createCondition(term, MATCH, result);
          }
          ;
          return result;
        case "&&":
          if (terms.length > 5) {
            return {
              type: "MatchOnce",
              terms,
              all: true
            };
          }
          var result = MISMATCH;
          for (var i = terms.length - 1; i >= 0; i--) {
            var term = terms[i];
            var thenClause;
            if (terms.length > 1) {
              thenClause = buildGroupMatchGraph(combinator, terms.filter(function(newGroupTerm) {
                return newGroupTerm !== term;
              }), false);
            } else {
              thenClause = MATCH;
            }
            result = createCondition(term, thenClause, result);
          }
          ;
          return result;
        case "||":
          if (terms.length > 5) {
            return {
              type: "MatchOnce",
              terms,
              all: false
            };
          }
          var result = atLeastOneTermMatched ? MATCH : MISMATCH;
          for (var i = terms.length - 1; i >= 0; i--) {
            var term = terms[i];
            var thenClause;
            if (terms.length > 1) {
              thenClause = buildGroupMatchGraph(combinator, terms.filter(function(newGroupTerm) {
                return newGroupTerm !== term;
              }), true);
            } else {
              thenClause = MATCH;
            }
            result = createCondition(term, thenClause, result);
          }
          ;
          return result;
      }
    }
    function buildMultiplierMatchGraph(node) {
      var result = MATCH;
      var matchTerm = buildMatchGraph(node.term);
      if (node.max === 0) {
        matchTerm = createCondition(matchTerm, DISALLOW_EMPTY, MISMATCH);
        result = createCondition(matchTerm, null, MISMATCH);
        result.then = createCondition(MATCH, MATCH, result);
        if (node.comma) {
          result.then.else = createCondition({ type: "Comma", syntax: node }, result, MISMATCH);
        }
      } else {
        for (var i = node.min || 1; i <= node.max; i++) {
          if (node.comma && result !== MATCH) {
            result = createCondition({ type: "Comma", syntax: node }, result, MISMATCH);
          }
          result = createCondition(matchTerm, createCondition(MATCH, MATCH, result), MISMATCH);
        }
      }
      if (node.min === 0) {
        result = createCondition(MATCH, MATCH, result);
      } else {
        for (var i = 0; i < node.min - 1; i++) {
          if (node.comma && result !== MATCH) {
            result = createCondition({ type: "Comma", syntax: node }, result, MISMATCH);
          }
          result = createCondition(matchTerm, result, MISMATCH);
        }
      }
      return result;
    }
    function buildMatchGraph(node) {
      if (typeof node === "function") {
        return {
          type: "Generic",
          fn: node
        };
      }
      switch (node.type) {
        case "Group":
          var result = buildGroupMatchGraph(node.combinator, node.terms.map(buildMatchGraph), false);
          if (node.disallowEmpty) {
            result = createCondition(result, DISALLOW_EMPTY, MISMATCH);
          }
          return result;
        case "Multiplier":
          return buildMultiplierMatchGraph(node);
        case "Type":
        case "Property":
          return {
            type: node.type,
            name: node.name,
            syntax: node
          };
        case "Keyword":
          return {
            type: node.type,
            name: node.name.toLowerCase(),
            syntax: node
          };
        case "AtKeyword":
          return {
            type: node.type,
            name: "@" + node.name.toLowerCase(),
            syntax: node
          };
        case "Function":
          return {
            type: node.type,
            name: node.name.toLowerCase() + "(",
            syntax: node
          };
        case "String":
          if (node.value.length === 3) {
            return {
              type: "Token",
              value: node.value.charAt(1),
              syntax: node
            };
          }
          return {
            type: node.type,
            value: node.value.substr(1, node.value.length - 2).replace(/\\'/g, "'"),
            syntax: node
          };
        case "Token":
          return {
            type: node.type,
            value: node.value,
            syntax: node
          };
        case "Comma":
          return {
            type: node.type,
            syntax: node
          };
        default:
          throw new Error("Unknown node type:", node.type);
      }
    }
    module2.exports = {
      MATCH,
      MISMATCH,
      DISALLOW_EMPTY,
      buildMatchGraph: function(syntaxTree, ref) {
        if (typeof syntaxTree === "string") {
          syntaxTree = parse(syntaxTree);
        }
        return {
          type: "MatchGraph",
          match: buildMatchGraph(syntaxTree),
          syntax: ref || null,
          source: syntaxTree
        };
      }
    };
  }
});

// node_modules/css-tree/lib/lexer/match.js
var require_match = __commonJS({
  "node_modules/css-tree/lib/lexer/match.js"(exports2, module2) {
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    var matchGraph = require_match_graph();
    var MATCH = matchGraph.MATCH;
    var MISMATCH = matchGraph.MISMATCH;
    var DISALLOW_EMPTY = matchGraph.DISALLOW_EMPTY;
    var TYPE = require_const2().TYPE;
    var STUB = 0;
    var TOKEN = 1;
    var OPEN_SYNTAX = 2;
    var CLOSE_SYNTAX = 3;
    var EXIT_REASON_MATCH = "Match";
    var EXIT_REASON_MISMATCH = "Mismatch";
    var EXIT_REASON_ITERATION_LIMIT = "Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)";
    var ITERATION_LIMIT = 15e3;
    var totalIterationCount = 0;
    function reverseList(list) {
      var prev = null;
      var next = null;
      var item = list;
      while (item !== null) {
        next = item.prev;
        item.prev = prev;
        prev = item;
        item = next;
      }
      return prev;
    }
    function areStringsEqualCaseInsensitive(testStr, referenceStr) {
      if (testStr.length !== referenceStr.length) {
        return false;
      }
      for (var i = 0; i < testStr.length; i++) {
        var testCode = testStr.charCodeAt(i);
        var referenceCode = referenceStr.charCodeAt(i);
        if (testCode >= 65 && testCode <= 90) {
          testCode = testCode | 32;
        }
        if (testCode !== referenceCode) {
          return false;
        }
      }
      return true;
    }
    function isContextEdgeDelim(token) {
      if (token.type !== TYPE.Delim) {
        return false;
      }
      return token.value !== "?";
    }
    function isCommaContextStart(token) {
      if (token === null) {
        return true;
      }
      return token.type === TYPE.Comma || token.type === TYPE.Function || token.type === TYPE.LeftParenthesis || token.type === TYPE.LeftSquareBracket || token.type === TYPE.LeftCurlyBracket || isContextEdgeDelim(token);
    }
    function isCommaContextEnd(token) {
      if (token === null) {
        return true;
      }
      return token.type === TYPE.RightParenthesis || token.type === TYPE.RightSquareBracket || token.type === TYPE.RightCurlyBracket || token.type === TYPE.Delim;
    }
    function internalMatch(tokens, state, syntaxes) {
      function moveToNextToken() {
        do {
          tokenIndex++;
          token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;
        } while (token !== null && (token.type === TYPE.WhiteSpace || token.type === TYPE.Comment));
      }
      function getNextToken(offset) {
        var nextIndex = tokenIndex + offset;
        return nextIndex < tokens.length ? tokens[nextIndex] : null;
      }
      function stateSnapshotFromSyntax(nextState, prev) {
        return {
          nextState,
          matchStack,
          syntaxStack,
          thenStack,
          tokenIndex,
          prev
        };
      }
      function pushThenStack(nextState) {
        thenStack = {
          nextState,
          matchStack,
          syntaxStack,
          prev: thenStack
        };
      }
      function pushElseStack(nextState) {
        elseStack = stateSnapshotFromSyntax(nextState, elseStack);
      }
      function addTokenToMatch() {
        matchStack = {
          type: TOKEN,
          syntax: state.syntax,
          token,
          prev: matchStack
        };
        moveToNextToken();
        syntaxStash = null;
        if (tokenIndex > longestMatch) {
          longestMatch = tokenIndex;
        }
      }
      function openSyntax() {
        syntaxStack = {
          syntax: state.syntax,
          opts: state.syntax.opts || syntaxStack !== null && syntaxStack.opts || null,
          prev: syntaxStack
        };
        matchStack = {
          type: OPEN_SYNTAX,
          syntax: state.syntax,
          token: matchStack.token,
          prev: matchStack
        };
      }
      function closeSyntax() {
        if (matchStack.type === OPEN_SYNTAX) {
          matchStack = matchStack.prev;
        } else {
          matchStack = {
            type: CLOSE_SYNTAX,
            syntax: syntaxStack.syntax,
            token: matchStack.token,
            prev: matchStack
          };
        }
        syntaxStack = syntaxStack.prev;
      }
      var syntaxStack = null;
      var thenStack = null;
      var elseStack = null;
      var syntaxStash = null;
      var iterationCount = 0;
      var exitReason = null;
      var token = null;
      var tokenIndex = -1;
      var longestMatch = 0;
      var matchStack = {
        type: STUB,
        syntax: null,
        token: null,
        prev: null
      };
      moveToNextToken();
      while (exitReason === null && ++iterationCount < ITERATION_LIMIT) {
        switch (state.type) {
          case "Match":
            if (thenStack === null) {
              if (token !== null) {
                if (tokenIndex !== tokens.length - 1 || token.value !== "\\0" && token.value !== "\\9") {
                  state = MISMATCH;
                  break;
                }
              }
              exitReason = EXIT_REASON_MATCH;
              break;
            }
            state = thenStack.nextState;
            if (state === DISALLOW_EMPTY) {
              if (thenStack.matchStack === matchStack) {
                state = MISMATCH;
                break;
              } else {
                state = MATCH;
              }
            }
            while (thenStack.syntaxStack !== syntaxStack) {
              closeSyntax();
            }
            thenStack = thenStack.prev;
            break;
          case "Mismatch":
            if (syntaxStash !== null && syntaxStash !== false) {
              if (elseStack === null || tokenIndex > elseStack.tokenIndex) {
                elseStack = syntaxStash;
                syntaxStash = false;
              }
            } else if (elseStack === null) {
              exitReason = EXIT_REASON_MISMATCH;
              break;
            }
            state = elseStack.nextState;
            thenStack = elseStack.thenStack;
            syntaxStack = elseStack.syntaxStack;
            matchStack = elseStack.matchStack;
            tokenIndex = elseStack.tokenIndex;
            token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;
            elseStack = elseStack.prev;
            break;
          case "MatchGraph":
            state = state.match;
            break;
          case "If":
            if (state.else !== MISMATCH) {
              pushElseStack(state.else);
            }
            if (state.then !== MATCH) {
              pushThenStack(state.then);
            }
            state = state.match;
            break;
          case "MatchOnce":
            state = {
              type: "MatchOnceBuffer",
              syntax: state,
              index: 0,
              mask: 0
            };
            break;
          case "MatchOnceBuffer":
            var terms = state.syntax.terms;
            if (state.index === terms.length) {
              if (state.mask === 0 || state.syntax.all) {
                state = MISMATCH;
                break;
              }
              state = MATCH;
              break;
            }
            if (state.mask === (1 << terms.length) - 1) {
              state = MATCH;
              break;
            }
            for (; state.index < terms.length; state.index++) {
              var matchFlag = 1 << state.index;
              if ((state.mask & matchFlag) === 0) {
                pushElseStack(state);
                pushThenStack({
                  type: "AddMatchOnce",
                  syntax: state.syntax,
                  mask: state.mask | matchFlag
                });
                state = terms[state.index++];
                break;
              }
            }
            break;
          case "AddMatchOnce":
            state = {
              type: "MatchOnceBuffer",
              syntax: state.syntax,
              index: 0,
              mask: state.mask
            };
            break;
          case "Enum":
            if (token !== null) {
              var name = token.value.toLowerCase();
              if (name.indexOf("\\") !== -1) {
                name = name.replace(/\\[09].*$/, "");
              }
              if (hasOwnProperty2.call(state.map, name)) {
                state = state.map[name];
                break;
              }
            }
            state = MISMATCH;
            break;
          case "Generic":
            var opts = syntaxStack !== null ? syntaxStack.opts : null;
            var lastTokenIndex = tokenIndex + Math.floor(state.fn(token, getNextToken, opts));
            if (!isNaN(lastTokenIndex) && lastTokenIndex > tokenIndex) {
              while (tokenIndex < lastTokenIndex) {
                addTokenToMatch();
              }
              state = MATCH;
            } else {
              state = MISMATCH;
            }
            break;
          case "Type":
          case "Property":
            var syntaxDict = state.type === "Type" ? "types" : "properties";
            var dictSyntax = hasOwnProperty2.call(syntaxes, syntaxDict) ? syntaxes[syntaxDict][state.name] : null;
            if (!dictSyntax || !dictSyntax.match) {
              throw new Error("Bad syntax reference: " + (state.type === "Type" ? "<" + state.name + ">" : "<'" + state.name + "'>"));
            }
            if (syntaxStash !== false && token !== null && state.type === "Type") {
              var lowPriorityMatching = state.name === "custom-ident" && token.type === TYPE.Ident || state.name === "length" && token.value === "0";
              if (lowPriorityMatching) {
                if (syntaxStash === null) {
                  syntaxStash = stateSnapshotFromSyntax(state, elseStack);
                }
                state = MISMATCH;
                break;
              }
            }
            openSyntax();
            state = dictSyntax.match;
            break;
          case "Keyword":
            var name = state.name;
            if (token !== null) {
              var keywordName = token.value;
              if (keywordName.indexOf("\\") !== -1) {
                keywordName = keywordName.replace(/\\[09].*$/, "");
              }
              if (areStringsEqualCaseInsensitive(keywordName, name)) {
                addTokenToMatch();
                state = MATCH;
                break;
              }
            }
            state = MISMATCH;
            break;
          case "AtKeyword":
          case "Function":
            if (token !== null && areStringsEqualCaseInsensitive(token.value, state.name)) {
              addTokenToMatch();
              state = MATCH;
              break;
            }
            state = MISMATCH;
            break;
          case "Token":
            if (token !== null && token.value === state.value) {
              addTokenToMatch();
              state = MATCH;
              break;
            }
            state = MISMATCH;
            break;
          case "Comma":
            if (token !== null && token.type === TYPE.Comma) {
              if (isCommaContextStart(matchStack.token)) {
                state = MISMATCH;
              } else {
                addTokenToMatch();
                state = isCommaContextEnd(token) ? MISMATCH : MATCH;
              }
            } else {
              state = isCommaContextStart(matchStack.token) || isCommaContextEnd(token) ? MATCH : MISMATCH;
            }
            break;
          case "String":
            var string = "";
            for (var lastTokenIndex = tokenIndex; lastTokenIndex < tokens.length && string.length < state.value.length; lastTokenIndex++) {
              string += tokens[lastTokenIndex].value;
            }
            if (areStringsEqualCaseInsensitive(string, state.value)) {
              while (tokenIndex < lastTokenIndex) {
                addTokenToMatch();
              }
              state = MATCH;
            } else {
              state = MISMATCH;
            }
            break;
          default:
            throw new Error("Unknown node type: " + state.type);
        }
      }
      totalIterationCount += iterationCount;
      switch (exitReason) {
        case null:
          console.warn("[csstree-match] BREAK after " + ITERATION_LIMIT + " iterations");
          exitReason = EXIT_REASON_ITERATION_LIMIT;
          matchStack = null;
          break;
        case EXIT_REASON_MATCH:
          while (syntaxStack !== null) {
            closeSyntax();
          }
          break;
        default:
          matchStack = null;
      }
      return {
        tokens,
        reason: exitReason,
        iterations: iterationCount,
        match: matchStack,
        longestMatch
      };
    }
    function matchAsList(tokens, matchGraph2, syntaxes) {
      var matchResult = internalMatch(tokens, matchGraph2, syntaxes || {});
      if (matchResult.match !== null) {
        var item = reverseList(matchResult.match).prev;
        matchResult.match = [];
        while (item !== null) {
          switch (item.type) {
            case STUB:
              break;
            case OPEN_SYNTAX:
            case CLOSE_SYNTAX:
              matchResult.match.push({
                type: item.type,
                syntax: item.syntax
              });
              break;
            default:
              matchResult.match.push({
                token: item.token.value,
                node: item.token.node
              });
              break;
          }
          item = item.prev;
        }
      }
      return matchResult;
    }
    function matchAsTree(tokens, matchGraph2, syntaxes) {
      var matchResult = internalMatch(tokens, matchGraph2, syntaxes || {});
      if (matchResult.match === null) {
        return matchResult;
      }
      var item = matchResult.match;
      var host = matchResult.match = {
        syntax: matchGraph2.syntax || null,
        match: []
      };
      var hostStack = [host];
      item = reverseList(item).prev;
      while (item !== null) {
        switch (item.type) {
          case OPEN_SYNTAX:
            host.match.push(host = {
              syntax: item.syntax,
              match: []
            });
            hostStack.push(host);
            break;
          case CLOSE_SYNTAX:
            hostStack.pop();
            host = hostStack[hostStack.length - 1];
            break;
          default:
            host.match.push({
              syntax: item.syntax || null,
              token: item.token.value,
              node: item.token.node
            });
        }
        item = item.prev;
      }
      return matchResult;
    }
    module2.exports = {
      matchAsList,
      matchAsTree,
      getTotalIterationCount: function() {
        return totalIterationCount;
      }
    };
  }
});

// node_modules/css-tree/lib/lexer/trace.js
var require_trace = __commonJS({
  "node_modules/css-tree/lib/lexer/trace.js"(exports2, module2) {
    function getTrace(node) {
      function shouldPutToTrace(syntax) {
        if (syntax === null) {
          return false;
        }
        return syntax.type === "Type" || syntax.type === "Property" || syntax.type === "Keyword";
      }
      function hasMatch(matchNode) {
        if (Array.isArray(matchNode.match)) {
          for (var i = 0; i < matchNode.match.length; i++) {
            if (hasMatch(matchNode.match[i])) {
              if (shouldPutToTrace(matchNode.syntax)) {
                result.unshift(matchNode.syntax);
              }
              return true;
            }
          }
        } else if (matchNode.node === node) {
          result = shouldPutToTrace(matchNode.syntax) ? [matchNode.syntax] : [];
          return true;
        }
        return false;
      }
      var result = null;
      if (this.matched !== null) {
        hasMatch(this.matched);
      }
      return result;
    }
    function testNode(match, node, fn) {
      var trace = getTrace.call(match, node);
      if (trace === null) {
        return false;
      }
      return trace.some(fn);
    }
    function isType(node, type) {
      return testNode(this, node, function(matchNode) {
        return matchNode.type === "Type" && matchNode.name === type;
      });
    }
    function isProperty(node, property) {
      return testNode(this, node, function(matchNode) {
        return matchNode.type === "Property" && matchNode.name === property;
      });
    }
    function isKeyword(node) {
      return testNode(this, node, function(matchNode) {
        return matchNode.type === "Keyword";
      });
    }
    module2.exports = {
      getTrace,
      isType,
      isProperty,
      isKeyword
    };
  }
});

// node_modules/css-tree/lib/lexer/search.js
var require_search = __commonJS({
  "node_modules/css-tree/lib/lexer/search.js"(exports2, module2) {
    var List = require_List();
    function getFirstMatchNode(matchNode) {
      if ("node" in matchNode) {
        return matchNode.node;
      }
      return getFirstMatchNode(matchNode.match[0]);
    }
    function getLastMatchNode(matchNode) {
      if ("node" in matchNode) {
        return matchNode.node;
      }
      return getLastMatchNode(matchNode.match[matchNode.match.length - 1]);
    }
    function matchFragments(lexer, ast, match, type, name) {
      function findFragments(matchNode) {
        if (matchNode.syntax !== null && matchNode.syntax.type === type && matchNode.syntax.name === name) {
          var start = getFirstMatchNode(matchNode);
          var end = getLastMatchNode(matchNode);
          lexer.syntax.walk(ast, function(node, item, list) {
            if (node === start) {
              var nodes = new List();
              do {
                nodes.appendData(item.data);
                if (item.data === end) {
                  break;
                }
                item = item.next;
              } while (item !== null);
              fragments.push({
                parent: list,
                nodes
              });
            }
          });
        }
        if (Array.isArray(matchNode.match)) {
          matchNode.match.forEach(findFragments);
        }
      }
      var fragments = [];
      if (match.matched !== null) {
        findFragments(match.matched);
      }
      return fragments;
    }
    module2.exports = {
      matchFragments
    };
  }
});

// node_modules/css-tree/lib/lexer/structure.js
var require_structure = __commonJS({
  "node_modules/css-tree/lib/lexer/structure.js"(exports2, module2) {
    var List = require_List();
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    function isValidNumber(value) {
      return typeof value === "number" && isFinite(value) && Math.floor(value) === value && value >= 0;
    }
    function isValidLocation(loc) {
      return Boolean(loc) && isValidNumber(loc.offset) && isValidNumber(loc.line) && isValidNumber(loc.column);
    }
    function createNodeStructureChecker(type, fields) {
      return function checkNode(node, warn) {
        if (!node || node.constructor !== Object) {
          return warn(node, "Type of node should be an Object");
        }
        for (var key in node) {
          var valid = true;
          if (hasOwnProperty2.call(node, key) === false) {
            continue;
          }
          if (key === "type") {
            if (node.type !== type) {
              warn(node, "Wrong node type `" + node.type + "`, expected `" + type + "`");
            }
          } else if (key === "loc") {
            if (node.loc === null) {
              continue;
            } else if (node.loc && node.loc.constructor === Object) {
              if (typeof node.loc.source !== "string") {
                key += ".source";
              } else if (!isValidLocation(node.loc.start)) {
                key += ".start";
              } else if (!isValidLocation(node.loc.end)) {
                key += ".end";
              } else {
                continue;
              }
            }
            valid = false;
          } else if (fields.hasOwnProperty(key)) {
            for (var i = 0, valid = false; !valid && i < fields[key].length; i++) {
              var fieldType = fields[key][i];
              switch (fieldType) {
                case String:
                  valid = typeof node[key] === "string";
                  break;
                case Boolean:
                  valid = typeof node[key] === "boolean";
                  break;
                case null:
                  valid = node[key] === null;
                  break;
                default:
                  if (typeof fieldType === "string") {
                    valid = node[key] && node[key].type === fieldType;
                  } else if (Array.isArray(fieldType)) {
                    valid = node[key] instanceof List;
                  }
              }
            }
          } else {
            warn(node, "Unknown field `" + key + "` for " + type + " node type");
          }
          if (!valid) {
            warn(node, "Bad value for `" + type + "." + key + "`");
          }
        }
        for (var key in fields) {
          if (hasOwnProperty2.call(fields, key) && hasOwnProperty2.call(node, key) === false) {
            warn(node, "Field `" + type + "." + key + "` is missed");
          }
        }
      };
    }
    function processStructure(name, nodeType) {
      var structure = nodeType.structure;
      var fields = {
        type: String,
        loc: true
      };
      var docs = {
        type: '"' + name + '"'
      };
      for (var key in structure) {
        if (hasOwnProperty2.call(structure, key) === false) {
          continue;
        }
        var docsTypes = [];
        var fieldTypes = fields[key] = Array.isArray(structure[key]) ? structure[key].slice() : [structure[key]];
        for (var i = 0; i < fieldTypes.length; i++) {
          var fieldType = fieldTypes[i];
          if (fieldType === String || fieldType === Boolean) {
            docsTypes.push(fieldType.name);
          } else if (fieldType === null) {
            docsTypes.push("null");
          } else if (typeof fieldType === "string") {
            docsTypes.push("<" + fieldType + ">");
          } else if (Array.isArray(fieldType)) {
            docsTypes.push("List");
          } else {
            throw new Error("Wrong value `" + fieldType + "` in `" + name + "." + key + "` structure definition");
          }
        }
        docs[key] = docsTypes.join(" | ");
      }
      return {
        docs,
        check: createNodeStructureChecker(name, fields)
      };
    }
    module2.exports = {
      getStructureFromConfig: function(config) {
        var structure = {};
        if (config.node) {
          for (var name in config.node) {
            if (hasOwnProperty2.call(config.node, name)) {
              var nodeType = config.node[name];
              if (nodeType.structure) {
                structure[name] = processStructure(name, nodeType);
              } else {
                throw new Error("Missed `structure` field in `" + name + "` node type definition");
              }
            }
          }
        }
        return structure;
      }
    };
  }
});

// node_modules/css-tree/lib/lexer/Lexer.js
var require_Lexer = __commonJS({
  "node_modules/css-tree/lib/lexer/Lexer.js"(exports2, module2) {
    var SyntaxReferenceError = require_error2().SyntaxReferenceError;
    var SyntaxMatchError = require_error2().SyntaxMatchError;
    var names = require_names2();
    var generic = require_generic();
    var parse = require_parse5();
    var generate = require_generate();
    var walk = require_walk2();
    var prepareTokens = require_prepare_tokens();
    var buildMatchGraph = require_match_graph().buildMatchGraph;
    var matchAsTree = require_match().matchAsTree;
    var trace = require_trace();
    var search = require_search();
    var getStructureFromConfig = require_structure().getStructureFromConfig;
    var cssWideKeywords = buildMatchGraph("inherit | initial | unset");
    var cssWideKeywordsWithExpression = buildMatchGraph("inherit | initial | unset | <-ms-legacy-expression>");
    function dumpMapSyntax(map, compact, syntaxAsAst) {
      var result = {};
      for (var name in map) {
        if (map[name].syntax) {
          result[name] = syntaxAsAst ? map[name].syntax : generate(map[name].syntax, { compact });
        }
      }
      return result;
    }
    function dumpAtruleMapSyntax(map, compact, syntaxAsAst) {
      const result = {};
      for (const [name, atrule] of Object.entries(map)) {
        result[name] = {
          prelude: atrule.prelude && (syntaxAsAst ? atrule.prelude.syntax : generate(atrule.prelude.syntax, { compact })),
          descriptors: atrule.descriptors && dumpMapSyntax(atrule.descriptors, compact, syntaxAsAst)
        };
      }
      return result;
    }
    function valueHasVar(tokens) {
      for (var i = 0; i < tokens.length; i++) {
        if (tokens[i].value.toLowerCase() === "var(") {
          return true;
        }
      }
      return false;
    }
    function buildMatchResult(match, error, iterations) {
      return {
        matched: match,
        iterations,
        error,
        getTrace: trace.getTrace,
        isType: trace.isType,
        isProperty: trace.isProperty,
        isKeyword: trace.isKeyword
      };
    }
    function matchSyntax(lexer, syntax, value, useCommon) {
      var tokens = prepareTokens(value, lexer.syntax);
      var result;
      if (valueHasVar(tokens)) {
        return buildMatchResult(null, new Error("Matching for a tree with var() is not supported"));
      }
      if (useCommon) {
        result = matchAsTree(tokens, lexer.valueCommonSyntax, lexer);
      }
      if (!useCommon || !result.match) {
        result = matchAsTree(tokens, syntax.match, lexer);
        if (!result.match) {
          return buildMatchResult(null, new SyntaxMatchError(result.reason, syntax.syntax, value, result), result.iterations);
        }
      }
      return buildMatchResult(result.match, null, result.iterations);
    }
    var Lexer = function(config, syntax, structure) {
      this.valueCommonSyntax = cssWideKeywords;
      this.syntax = syntax;
      this.generic = false;
      this.atrules = {};
      this.properties = {};
      this.types = {};
      this.structure = structure || getStructureFromConfig(config);
      if (config) {
        if (config.types) {
          for (var name in config.types) {
            this.addType_(name, config.types[name]);
          }
        }
        if (config.generic) {
          this.generic = true;
          for (var name in generic) {
            this.addType_(name, generic[name]);
          }
        }
        if (config.atrules) {
          for (var name in config.atrules) {
            this.addAtrule_(name, config.atrules[name]);
          }
        }
        if (config.properties) {
          for (var name in config.properties) {
            this.addProperty_(name, config.properties[name]);
          }
        }
      }
    };
    Lexer.prototype = {
      structure: {},
      checkStructure: function(ast) {
        function collectWarning(node, message) {
          warns.push({
            node,
            message
          });
        }
        var structure = this.structure;
        var warns = [];
        this.syntax.walk(ast, function(node) {
          if (structure.hasOwnProperty(node.type)) {
            structure[node.type].check(node, collectWarning);
          } else {
            collectWarning(node, "Unknown node type `" + node.type + "`");
          }
        });
        return warns.length ? warns : false;
      },
      createDescriptor: function(syntax, type, name, parent = null) {
        var ref = {
          type,
          name
        };
        var descriptor = {
          type,
          name,
          parent,
          syntax: null,
          match: null
        };
        if (typeof syntax === "function") {
          descriptor.match = buildMatchGraph(syntax, ref);
        } else {
          if (typeof syntax === "string") {
            Object.defineProperty(descriptor, "syntax", {
              get: function() {
                Object.defineProperty(descriptor, "syntax", {
                  value: parse(syntax)
                });
                return descriptor.syntax;
              }
            });
          } else {
            descriptor.syntax = syntax;
          }
          Object.defineProperty(descriptor, "match", {
            get: function() {
              Object.defineProperty(descriptor, "match", {
                value: buildMatchGraph(descriptor.syntax, ref)
              });
              return descriptor.match;
            }
          });
        }
        return descriptor;
      },
      addAtrule_: function(name, syntax) {
        if (!syntax) {
          return;
        }
        this.atrules[name] = {
          type: "Atrule",
          name,
          prelude: syntax.prelude ? this.createDescriptor(syntax.prelude, "AtrulePrelude", name) : null,
          descriptors: syntax.descriptors ? Object.keys(syntax.descriptors).reduce((res, descName) => {
            res[descName] = this.createDescriptor(syntax.descriptors[descName], "AtruleDescriptor", descName, name);
            return res;
          }, {}) : null
        };
      },
      addProperty_: function(name, syntax) {
        if (!syntax) {
          return;
        }
        this.properties[name] = this.createDescriptor(syntax, "Property", name);
      },
      addType_: function(name, syntax) {
        if (!syntax) {
          return;
        }
        this.types[name] = this.createDescriptor(syntax, "Type", name);
        if (syntax === generic["-ms-legacy-expression"]) {
          this.valueCommonSyntax = cssWideKeywordsWithExpression;
        }
      },
      checkAtruleName: function(atruleName) {
        if (!this.getAtrule(atruleName)) {
          return new SyntaxReferenceError("Unknown at-rule", "@" + atruleName);
        }
      },
      checkAtrulePrelude: function(atruleName, prelude) {
        let error = this.checkAtruleName(atruleName);
        if (error) {
          return error;
        }
        var atrule = this.getAtrule(atruleName);
        if (!atrule.prelude && prelude) {
          return new SyntaxError("At-rule `@" + atruleName + "` should not contain a prelude");
        }
        if (atrule.prelude && !prelude) {
          return new SyntaxError("At-rule `@" + atruleName + "` should contain a prelude");
        }
      },
      checkAtruleDescriptorName: function(atruleName, descriptorName) {
        let error = this.checkAtruleName(atruleName);
        if (error) {
          return error;
        }
        var atrule = this.getAtrule(atruleName);
        var descriptor = names.keyword(descriptorName);
        if (!atrule.descriptors) {
          return new SyntaxError("At-rule `@" + atruleName + "` has no known descriptors");
        }
        if (!atrule.descriptors[descriptor.name] && !atrule.descriptors[descriptor.basename]) {
          return new SyntaxReferenceError("Unknown at-rule descriptor", descriptorName);
        }
      },
      checkPropertyName: function(propertyName) {
        var property = names.property(propertyName);
        if (property.custom) {
          return new Error("Lexer matching doesn't applicable for custom properties");
        }
        if (!this.getProperty(propertyName)) {
          return new SyntaxReferenceError("Unknown property", propertyName);
        }
      },
      matchAtrulePrelude: function(atruleName, prelude) {
        var error = this.checkAtrulePrelude(atruleName, prelude);
        if (error) {
          return buildMatchResult(null, error);
        }
        if (!prelude) {
          return buildMatchResult(null, null);
        }
        return matchSyntax(this, this.getAtrule(atruleName).prelude, prelude, false);
      },
      matchAtruleDescriptor: function(atruleName, descriptorName, value) {
        var error = this.checkAtruleDescriptorName(atruleName, descriptorName);
        if (error) {
          return buildMatchResult(null, error);
        }
        var atrule = this.getAtrule(atruleName);
        var descriptor = names.keyword(descriptorName);
        return matchSyntax(this, atrule.descriptors[descriptor.name] || atrule.descriptors[descriptor.basename], value, false);
      },
      matchDeclaration: function(node) {
        if (node.type !== "Declaration") {
          return buildMatchResult(null, new Error("Not a Declaration node"));
        }
        return this.matchProperty(node.property, node.value);
      },
      matchProperty: function(propertyName, value) {
        var error = this.checkPropertyName(propertyName);
        if (error) {
          return buildMatchResult(null, error);
        }
        return matchSyntax(this, this.getProperty(propertyName), value, true);
      },
      matchType: function(typeName, value) {
        var typeSyntax = this.getType(typeName);
        if (!typeSyntax) {
          return buildMatchResult(null, new SyntaxReferenceError("Unknown type", typeName));
        }
        return matchSyntax(this, typeSyntax, value, false);
      },
      match: function(syntax, value) {
        if (typeof syntax !== "string" && (!syntax || !syntax.type)) {
          return buildMatchResult(null, new SyntaxReferenceError("Bad syntax"));
        }
        if (typeof syntax === "string" || !syntax.match) {
          syntax = this.createDescriptor(syntax, "Type", "anonymous");
        }
        return matchSyntax(this, syntax, value, false);
      },
      findValueFragments: function(propertyName, value, type, name) {
        return search.matchFragments(this, value, this.matchProperty(propertyName, value), type, name);
      },
      findDeclarationValueFragments: function(declaration, type, name) {
        return search.matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name);
      },
      findAllFragments: function(ast, type, name) {
        var result = [];
        this.syntax.walk(ast, {
          visit: "Declaration",
          enter: function(declaration) {
            result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name));
          }.bind(this)
        });
        return result;
      },
      getAtrule: function(atruleName, fallbackBasename = true) {
        var atrule = names.keyword(atruleName);
        var atruleEntry = atrule.vendor && fallbackBasename ? this.atrules[atrule.name] || this.atrules[atrule.basename] : this.atrules[atrule.name];
        return atruleEntry || null;
      },
      getAtrulePrelude: function(atruleName, fallbackBasename = true) {
        const atrule = this.getAtrule(atruleName, fallbackBasename);
        return atrule && atrule.prelude || null;
      },
      getAtruleDescriptor: function(atruleName, name) {
        return this.atrules.hasOwnProperty(atruleName) && this.atrules.declarators ? this.atrules[atruleName].declarators[name] || null : null;
      },
      getProperty: function(propertyName, fallbackBasename = true) {
        var property = names.property(propertyName);
        var propertyEntry = property.vendor && fallbackBasename ? this.properties[property.name] || this.properties[property.basename] : this.properties[property.name];
        return propertyEntry || null;
      },
      getType: function(name) {
        return this.types.hasOwnProperty(name) ? this.types[name] : null;
      },
      validate: function() {
        function validate(syntax, name, broken, descriptor) {
          if (broken.hasOwnProperty(name)) {
            return broken[name];
          }
          broken[name] = false;
          if (descriptor.syntax !== null) {
            walk(descriptor.syntax, function(node) {
              if (node.type !== "Type" && node.type !== "Property") {
                return;
              }
              var map = node.type === "Type" ? syntax.types : syntax.properties;
              var brokenMap = node.type === "Type" ? brokenTypes : brokenProperties;
              if (!map.hasOwnProperty(node.name) || validate(syntax, node.name, brokenMap, map[node.name])) {
                broken[name] = true;
              }
            }, this);
          }
        }
        var brokenTypes = {};
        var brokenProperties = {};
        for (var key in this.types) {
          validate(this, key, brokenTypes, this.types[key]);
        }
        for (var key in this.properties) {
          validate(this, key, brokenProperties, this.properties[key]);
        }
        brokenTypes = Object.keys(brokenTypes).filter(function(name) {
          return brokenTypes[name];
        });
        brokenProperties = Object.keys(brokenProperties).filter(function(name) {
          return brokenProperties[name];
        });
        if (brokenTypes.length || brokenProperties.length) {
          return {
            types: brokenTypes,
            properties: brokenProperties
          };
        }
        return null;
      },
      dump: function(syntaxAsAst, pretty) {
        return {
          generic: this.generic,
          types: dumpMapSyntax(this.types, !pretty, syntaxAsAst),
          properties: dumpMapSyntax(this.properties, !pretty, syntaxAsAst),
          atrules: dumpAtruleMapSyntax(this.atrules, !pretty, syntaxAsAst)
        };
      },
      toString: function() {
        return JSON.stringify(this.dump());
      }
    };
    module2.exports = Lexer;
  }
});

// node_modules/css-tree/lib/definition-syntax/index.js
var require_definition_syntax = __commonJS({
  "node_modules/css-tree/lib/definition-syntax/index.js"(exports2, module2) {
    module2.exports = {
      SyntaxError: require_SyntaxError2(),
      parse: require_parse5(),
      generate: require_generate(),
      walk: require_walk2()
    };
  }
});

// node_modules/css-tree/lib/common/OffsetToLocation.js
var require_OffsetToLocation = __commonJS({
  "node_modules/css-tree/lib/common/OffsetToLocation.js"(exports2, module2) {
    var adoptBuffer = require_adopt_buffer();
    var isBOM = require_tokenizer().isBOM;
    var N = 10;
    var F = 12;
    var R = 13;
    function computeLinesAndColumns(host, source) {
      var sourceLength = source.length;
      var lines = adoptBuffer(host.lines, sourceLength);
      var line = host.startLine;
      var columns = adoptBuffer(host.columns, sourceLength);
      var column = host.startColumn;
      var startOffset = source.length > 0 ? isBOM(source.charCodeAt(0)) : 0;
      for (var i = startOffset; i < sourceLength; i++) {
        var code = source.charCodeAt(i);
        lines[i] = line;
        columns[i] = column++;
        if (code === N || code === R || code === F) {
          if (code === R && i + 1 < sourceLength && source.charCodeAt(i + 1) === N) {
            i++;
            lines[i] = line;
            columns[i] = column;
          }
          line++;
          column = 1;
        }
      }
      lines[i] = line;
      columns[i] = column;
      host.lines = lines;
      host.columns = columns;
    }
    var OffsetToLocation = function() {
      this.lines = null;
      this.columns = null;
      this.linesAndColumnsComputed = false;
    };
    OffsetToLocation.prototype = {
      setSource: function(source, startOffset, startLine, startColumn) {
        this.source = source;
        this.startOffset = typeof startOffset === "undefined" ? 0 : startOffset;
        this.startLine = typeof startLine === "undefined" ? 1 : startLine;
        this.startColumn = typeof startColumn === "undefined" ? 1 : startColumn;
        this.linesAndColumnsComputed = false;
      },
      ensureLinesAndColumnsComputed: function() {
        if (!this.linesAndColumnsComputed) {
          computeLinesAndColumns(this, this.source);
          this.linesAndColumnsComputed = true;
        }
      },
      getLocation: function(offset, filename) {
        this.ensureLinesAndColumnsComputed();
        return {
          source: filename,
          offset: this.startOffset + offset,
          line: this.lines[offset],
          column: this.columns[offset]
        };
      },
      getLocationRange: function(start, end, filename) {
        this.ensureLinesAndColumnsComputed();
        return {
          source: filename,
          start: {
            offset: this.startOffset + start,
            line: this.lines[start],
            column: this.columns[start]
          },
          end: {
            offset: this.startOffset + end,
            line: this.lines[end],
            column: this.columns[end]
          }
        };
      }
    };
    module2.exports = OffsetToLocation;
  }
});

// node_modules/css-tree/lib/parser/sequence.js
var require_sequence = __commonJS({
  "node_modules/css-tree/lib/parser/sequence.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    module2.exports = function readSequence(recognizer) {
      var children = this.createList();
      var child = null;
      var context = {
        recognizer,
        space: null,
        ignoreWS: false,
        ignoreWSAfter: false
      };
      this.scanner.skipSC();
      while (!this.scanner.eof) {
        switch (this.scanner.tokenType) {
          case COMMENT:
            this.scanner.next();
            continue;
          case WHITESPACE:
            if (context.ignoreWS) {
              this.scanner.next();
            } else {
              context.space = this.WhiteSpace();
            }
            continue;
        }
        child = recognizer.getNode.call(this, context);
        if (child === void 0) {
          break;
        }
        if (context.space !== null) {
          children.push(context.space);
          context.space = null;
        }
        children.push(child);
        if (context.ignoreWSAfter) {
          context.ignoreWSAfter = false;
          context.ignoreWS = true;
        } else {
          context.ignoreWS = false;
        }
      }
      return children;
    };
  }
});

// node_modules/css-tree/lib/parser/create.js
var require_create = __commonJS({
  "node_modules/css-tree/lib/parser/create.js"(exports2, module2) {
    var OffsetToLocation = require_OffsetToLocation();
    var SyntaxError2 = require_SyntaxError();
    var TokenStream = require_TokenStream();
    var List = require_List();
    var tokenize = require_tokenizer();
    var constants = require_const2();
    var { findWhiteSpaceStart, cmpStr } = require_utils3();
    var sequence = require_sequence();
    var noop = function() {
    };
    var TYPE = constants.TYPE;
    var NAME = constants.NAME;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    var IDENT = TYPE.Ident;
    var FUNCTION = TYPE.Function;
    var URL2 = TYPE.Url;
    var HASH = TYPE.Hash;
    var PERCENTAGE = TYPE.Percentage;
    var NUMBER = TYPE.Number;
    var NUMBERSIGN = 35;
    var NULL = 0;
    function createParseContext(name) {
      return function() {
        return this[name]();
      };
    }
    function processConfig(config) {
      var parserConfig = {
        context: {},
        scope: {},
        atrule: {},
        pseudo: {}
      };
      if (config.parseContext) {
        for (var name in config.parseContext) {
          switch (typeof config.parseContext[name]) {
            case "function":
              parserConfig.context[name] = config.parseContext[name];
              break;
            case "string":
              parserConfig.context[name] = createParseContext(config.parseContext[name]);
              break;
          }
        }
      }
      if (config.scope) {
        for (var name in config.scope) {
          parserConfig.scope[name] = config.scope[name];
        }
      }
      if (config.atrule) {
        for (var name in config.atrule) {
          var atrule = config.atrule[name];
          if (atrule.parse) {
            parserConfig.atrule[name] = atrule.parse;
          }
        }
      }
      if (config.pseudo) {
        for (var name in config.pseudo) {
          var pseudo = config.pseudo[name];
          if (pseudo.parse) {
            parserConfig.pseudo[name] = pseudo.parse;
          }
        }
      }
      if (config.node) {
        for (var name in config.node) {
          parserConfig[name] = config.node[name].parse;
        }
      }
      return parserConfig;
    }
    module2.exports = function createParser(config) {
      var parser = {
        scanner: new TokenStream(),
        locationMap: new OffsetToLocation(),
        filename: "<unknown>",
        needPositions: false,
        onParseError: noop,
        onParseErrorThrow: false,
        parseAtrulePrelude: true,
        parseRulePrelude: true,
        parseValue: true,
        parseCustomProperty: false,
        readSequence: sequence,
        createList: function() {
          return new List();
        },
        createSingleNodeList: function(node) {
          return new List().appendData(node);
        },
        getFirstListNode: function(list) {
          return list && list.first();
        },
        getLastListNode: function(list) {
          return list.last();
        },
        parseWithFallback: function(consumer, fallback) {
          var startToken = this.scanner.tokenIndex;
          try {
            return consumer.call(this);
          } catch (e) {
            if (this.onParseErrorThrow) {
              throw e;
            }
            var fallbackNode = fallback.call(this, startToken);
            this.onParseErrorThrow = true;
            this.onParseError(e, fallbackNode);
            this.onParseErrorThrow = false;
            return fallbackNode;
          }
        },
        lookupNonWSType: function(offset) {
          do {
            var type = this.scanner.lookupType(offset++);
            if (type !== WHITESPACE) {
              return type;
            }
          } while (type !== NULL);
          return NULL;
        },
        eat: function(tokenType) {
          if (this.scanner.tokenType !== tokenType) {
            var offset = this.scanner.tokenStart;
            var message = NAME[tokenType] + " is expected";
            switch (tokenType) {
              case IDENT:
                if (this.scanner.tokenType === FUNCTION || this.scanner.tokenType === URL2) {
                  offset = this.scanner.tokenEnd - 1;
                  message = "Identifier is expected but function found";
                } else {
                  message = "Identifier is expected";
                }
                break;
              case HASH:
                if (this.scanner.isDelim(NUMBERSIGN)) {
                  this.scanner.next();
                  offset++;
                  message = "Name is expected";
                }
                break;
              case PERCENTAGE:
                if (this.scanner.tokenType === NUMBER) {
                  offset = this.scanner.tokenEnd;
                  message = "Percent sign is expected";
                }
                break;
              default:
                if (this.scanner.source.charCodeAt(this.scanner.tokenStart) === tokenType) {
                  offset = offset + 1;
                }
            }
            this.error(message, offset);
          }
          this.scanner.next();
        },
        consume: function(tokenType) {
          var value = this.scanner.getTokenValue();
          this.eat(tokenType);
          return value;
        },
        consumeFunctionName: function() {
          var name = this.scanner.source.substring(this.scanner.tokenStart, this.scanner.tokenEnd - 1);
          this.eat(FUNCTION);
          return name;
        },
        getLocation: function(start, end) {
          if (this.needPositions) {
            return this.locationMap.getLocationRange(start, end, this.filename);
          }
          return null;
        },
        getLocationFromList: function(list) {
          if (this.needPositions) {
            var head = this.getFirstListNode(list);
            var tail = this.getLastListNode(list);
            return this.locationMap.getLocationRange(head !== null ? head.loc.start.offset - this.locationMap.startOffset : this.scanner.tokenStart, tail !== null ? tail.loc.end.offset - this.locationMap.startOffset : this.scanner.tokenStart, this.filename);
          }
          return null;
        },
        error: function(message, offset) {
          var location = typeof offset !== "undefined" && offset < this.scanner.source.length ? this.locationMap.getLocation(offset) : this.scanner.eof ? this.locationMap.getLocation(findWhiteSpaceStart(this.scanner.source, this.scanner.source.length - 1)) : this.locationMap.getLocation(this.scanner.tokenStart);
          throw new SyntaxError2(message || "Unexpected input", this.scanner.source, location.offset, location.line, location.column);
        }
      };
      config = processConfig(config || {});
      for (var key in config) {
        parser[key] = config[key];
      }
      return function(source, options) {
        options = options || {};
        var context = options.context || "default";
        var onComment = options.onComment;
        var ast;
        tokenize(source, parser.scanner);
        parser.locationMap.setSource(source, options.offset, options.line, options.column);
        parser.filename = options.filename || "<unknown>";
        parser.needPositions = Boolean(options.positions);
        parser.onParseError = typeof options.onParseError === "function" ? options.onParseError : noop;
        parser.onParseErrorThrow = false;
        parser.parseAtrulePrelude = "parseAtrulePrelude" in options ? Boolean(options.parseAtrulePrelude) : true;
        parser.parseRulePrelude = "parseRulePrelude" in options ? Boolean(options.parseRulePrelude) : true;
        parser.parseValue = "parseValue" in options ? Boolean(options.parseValue) : true;
        parser.parseCustomProperty = "parseCustomProperty" in options ? Boolean(options.parseCustomProperty) : false;
        if (!parser.context.hasOwnProperty(context)) {
          throw new Error("Unknown context `" + context + "`");
        }
        if (typeof onComment === "function") {
          parser.scanner.forEachToken((type, start, end) => {
            if (type === COMMENT) {
              const loc = parser.getLocation(start, end);
              const value = cmpStr(source, end - 2, end, "*/") ? source.slice(start + 2, end - 2) : source.slice(start + 2, end);
              onComment(value, loc);
            }
          });
        }
        ast = parser.context[context].call(parser, options);
        if (!parser.scanner.eof) {
          parser.error();
        }
        return ast;
      };
    };
  }
});

// node_modules/source-map/lib/base64.js
var require_base642 = __commonJS({
  "node_modules/source-map/lib/base64.js"(exports2) {
    var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
    exports2.encode = function(number) {
      if (0 <= number && number < intToCharMap.length) {
        return intToCharMap[number];
      }
      throw new TypeError("Must be between 0 and 63: " + number);
    };
    exports2.decode = function(charCode) {
      var bigA = 65;
      var bigZ = 90;
      var littleA = 97;
      var littleZ = 122;
      var zero = 48;
      var nine = 57;
      var plus = 43;
      var slash = 47;
      var littleOffset = 26;
      var numberOffset = 52;
      if (bigA <= charCode && charCode <= bigZ) {
        return charCode - bigA;
      }
      if (littleA <= charCode && charCode <= littleZ) {
        return charCode - littleA + littleOffset;
      }
      if (zero <= charCode && charCode <= nine) {
        return charCode - zero + numberOffset;
      }
      if (charCode == plus) {
        return 62;
      }
      if (charCode == slash) {
        return 63;
      }
      return -1;
    };
  }
});

// node_modules/source-map/lib/base64-vlq.js
var require_base64_vlq2 = __commonJS({
  "node_modules/source-map/lib/base64-vlq.js"(exports2) {
    var base64 = require_base642();
    var VLQ_BASE_SHIFT = 5;
    var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
    var VLQ_BASE_MASK = VLQ_BASE - 1;
    var VLQ_CONTINUATION_BIT = VLQ_BASE;
    function toVLQSigned(aValue) {
      return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
    }
    function fromVLQSigned(aValue) {
      var isNegative = (aValue & 1) === 1;
      var shifted = aValue >> 1;
      return isNegative ? -shifted : shifted;
    }
    exports2.encode = function base64VLQ_encode(aValue) {
      var encoded = "";
      var digit;
      var vlq = toVLQSigned(aValue);
      do {
        digit = vlq & VLQ_BASE_MASK;
        vlq >>>= VLQ_BASE_SHIFT;
        if (vlq > 0) {
          digit |= VLQ_CONTINUATION_BIT;
        }
        encoded += base64.encode(digit);
      } while (vlq > 0);
      return encoded;
    };
    exports2.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
      var strLen = aStr.length;
      var result = 0;
      var shift = 0;
      var continuation, digit;
      do {
        if (aIndex >= strLen) {
          throw new Error("Expected more digits in base 64 VLQ value.");
        }
        digit = base64.decode(aStr.charCodeAt(aIndex++));
        if (digit === -1) {
          throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
        }
        continuation = !!(digit & VLQ_CONTINUATION_BIT);
        digit &= VLQ_BASE_MASK;
        result = result + (digit << shift);
        shift += VLQ_BASE_SHIFT;
      } while (continuation);
      aOutParam.value = fromVLQSigned(result);
      aOutParam.rest = aIndex;
    };
  }
});

// node_modules/source-map/lib/util.js
var require_util2 = __commonJS({
  "node_modules/source-map/lib/util.js"(exports2) {
    function getArg(aArgs, aName, aDefaultValue) {
      if (aName in aArgs) {
        return aArgs[aName];
      } else if (arguments.length === 3) {
        return aDefaultValue;
      } else {
        throw new Error('"' + aName + '" is a required argument.');
      }
    }
    exports2.getArg = getArg;
    var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
    var dataUrlRegexp = /^data:.+\,.+$/;
    function urlParse(aUrl) {
      var match = aUrl.match(urlRegexp);
      if (!match) {
        return null;
      }
      return {
        scheme: match[1],
        auth: match[2],
        host: match[3],
        port: match[4],
        path: match[5]
      };
    }
    exports2.urlParse = urlParse;
    function urlGenerate(aParsedUrl) {
      var url = "";
      if (aParsedUrl.scheme) {
        url += aParsedUrl.scheme + ":";
      }
      url += "//";
      if (aParsedUrl.auth) {
        url += aParsedUrl.auth + "@";
      }
      if (aParsedUrl.host) {
        url += aParsedUrl.host;
      }
      if (aParsedUrl.port) {
        url += ":" + aParsedUrl.port;
      }
      if (aParsedUrl.path) {
        url += aParsedUrl.path;
      }
      return url;
    }
    exports2.urlGenerate = urlGenerate;
    function normalize(aPath) {
      var path = aPath;
      var url = urlParse(aPath);
      if (url) {
        if (!url.path) {
          return aPath;
        }
        path = url.path;
      }
      var isAbsolute = exports2.isAbsolute(path);
      var parts = path.split(/\/+/);
      for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
        part = parts[i];
        if (part === ".") {
          parts.splice(i, 1);
        } else if (part === "..") {
          up++;
        } else if (up > 0) {
          if (part === "") {
            parts.splice(i + 1, up);
            up = 0;
          } else {
            parts.splice(i, 2);
            up--;
          }
        }
      }
      path = parts.join("/");
      if (path === "") {
        path = isAbsolute ? "/" : ".";
      }
      if (url) {
        url.path = path;
        return urlGenerate(url);
      }
      return path;
    }
    exports2.normalize = normalize;
    function join(aRoot, aPath) {
      if (aRoot === "") {
        aRoot = ".";
      }
      if (aPath === "") {
        aPath = ".";
      }
      var aPathUrl = urlParse(aPath);
      var aRootUrl = urlParse(aRoot);
      if (aRootUrl) {
        aRoot = aRootUrl.path || "/";
      }
      if (aPathUrl && !aPathUrl.scheme) {
        if (aRootUrl) {
          aPathUrl.scheme = aRootUrl.scheme;
        }
        return urlGenerate(aPathUrl);
      }
      if (aPathUrl || aPath.match(dataUrlRegexp)) {
        return aPath;
      }
      if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
        aRootUrl.host = aPath;
        return urlGenerate(aRootUrl);
      }
      var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
      if (aRootUrl) {
        aRootUrl.path = joined;
        return urlGenerate(aRootUrl);
      }
      return joined;
    }
    exports2.join = join;
    exports2.isAbsolute = function(aPath) {
      return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
    };
    function relative(aRoot, aPath) {
      if (aRoot === "") {
        aRoot = ".";
      }
      aRoot = aRoot.replace(/\/$/, "");
      var level = 0;
      while (aPath.indexOf(aRoot + "/") !== 0) {
        var index = aRoot.lastIndexOf("/");
        if (index < 0) {
          return aPath;
        }
        aRoot = aRoot.slice(0, index);
        if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
          return aPath;
        }
        ++level;
      }
      return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
    }
    exports2.relative = relative;
    var supportsNullProto = function() {
      var obj = /* @__PURE__ */ Object.create(null);
      return !("__proto__" in obj);
    }();
    function identity(s) {
      return s;
    }
    function toSetString(aStr) {
      if (isProtoString(aStr)) {
        return "$" + aStr;
      }
      return aStr;
    }
    exports2.toSetString = supportsNullProto ? identity : toSetString;
    function fromSetString(aStr) {
      if (isProtoString(aStr)) {
        return aStr.slice(1);
      }
      return aStr;
    }
    exports2.fromSetString = supportsNullProto ? identity : fromSetString;
    function isProtoString(s) {
      if (!s) {
        return false;
      }
      var length = s.length;
      if (length < 9) {
        return false;
      }
      if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
        return false;
      }
      for (var i = length - 10; i >= 0; i--) {
        if (s.charCodeAt(i) !== 36) {
          return false;
        }
      }
      return true;
    }
    function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
      var cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0 || onlyCompareOriginal) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByOriginalPositions = compareByOriginalPositions;
    function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
      var cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0 || onlyCompareGenerated) {
        return cmp;
      }
      cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
    function strcmp(aStr1, aStr2) {
      if (aStr1 === aStr2) {
        return 0;
      }
      if (aStr1 === null) {
        return 1;
      }
      if (aStr2 === null) {
        return -1;
      }
      if (aStr1 > aStr2) {
        return 1;
      }
      return -1;
    }
    function compareByGeneratedPositionsInflated(mappingA, mappingB) {
      var cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
    function parseSourceMapInput(str) {
      return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
    }
    exports2.parseSourceMapInput = parseSourceMapInput;
    function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
      sourceURL = sourceURL || "";
      if (sourceRoot) {
        if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
          sourceRoot += "/";
        }
        sourceURL = sourceRoot + sourceURL;
      }
      if (sourceMapURL) {
        var parsed = urlParse(sourceMapURL);
        if (!parsed) {
          throw new Error("sourceMapURL could not be parsed");
        }
        if (parsed.path) {
          var index = parsed.path.lastIndexOf("/");
          if (index >= 0) {
            parsed.path = parsed.path.substring(0, index + 1);
          }
        }
        sourceURL = join(urlGenerate(parsed), sourceURL);
      }
      return normalize(sourceURL);
    }
    exports2.computeSourceURL = computeSourceURL;
  }
});

// node_modules/source-map/lib/array-set.js
var require_array_set2 = __commonJS({
  "node_modules/source-map/lib/array-set.js"(exports2) {
    var util = require_util2();
    var has = Object.prototype.hasOwnProperty;
    var hasNativeMap = typeof Map !== "undefined";
    function ArraySet() {
      this._array = [];
      this._set = hasNativeMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null);
    }
    ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
      var set = new ArraySet();
      for (var i = 0, len = aArray.length; i < len; i++) {
        set.add(aArray[i], aAllowDuplicates);
      }
      return set;
    };
    ArraySet.prototype.size = function ArraySet_size() {
      return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
    };
    ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
      var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
      var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
      var idx = this._array.length;
      if (!isDuplicate || aAllowDuplicates) {
        this._array.push(aStr);
      }
      if (!isDuplicate) {
        if (hasNativeMap) {
          this._set.set(aStr, idx);
        } else {
          this._set[sStr] = idx;
        }
      }
    };
    ArraySet.prototype.has = function ArraySet_has(aStr) {
      if (hasNativeMap) {
        return this._set.has(aStr);
      } else {
        var sStr = util.toSetString(aStr);
        return has.call(this._set, sStr);
      }
    };
    ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
      if (hasNativeMap) {
        var idx = this._set.get(aStr);
        if (idx >= 0) {
          return idx;
        }
      } else {
        var sStr = util.toSetString(aStr);
        if (has.call(this._set, sStr)) {
          return this._set[sStr];
        }
      }
      throw new Error('"' + aStr + '" is not in the set.');
    };
    ArraySet.prototype.at = function ArraySet_at(aIdx) {
      if (aIdx >= 0 && aIdx < this._array.length) {
        return this._array[aIdx];
      }
      throw new Error("No element indexed by " + aIdx);
    };
    ArraySet.prototype.toArray = function ArraySet_toArray() {
      return this._array.slice();
    };
    exports2.ArraySet = ArraySet;
  }
});

// node_modules/source-map/lib/mapping-list.js
var require_mapping_list2 = __commonJS({
  "node_modules/source-map/lib/mapping-list.js"(exports2) {
    var util = require_util2();
    function generatedPositionAfter(mappingA, mappingB) {
      var lineA = mappingA.generatedLine;
      var lineB = mappingB.generatedLine;
      var columnA = mappingA.generatedColumn;
      var columnB = mappingB.generatedColumn;
      return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
    }
    function MappingList() {
      this._array = [];
      this._sorted = true;
      this._last = { generatedLine: -1, generatedColumn: 0 };
    }
    MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
      this._array.forEach(aCallback, aThisArg);
    };
    MappingList.prototype.add = function MappingList_add(aMapping) {
      if (generatedPositionAfter(this._last, aMapping)) {
        this._last = aMapping;
        this._array.push(aMapping);
      } else {
        this._sorted = false;
        this._array.push(aMapping);
      }
    };
    MappingList.prototype.toArray = function MappingList_toArray() {
      if (!this._sorted) {
        this._array.sort(util.compareByGeneratedPositionsInflated);
        this._sorted = true;
      }
      return this._array;
    };
    exports2.MappingList = MappingList;
  }
});

// node_modules/source-map/lib/source-map-generator.js
var require_source_map_generator2 = __commonJS({
  "node_modules/source-map/lib/source-map-generator.js"(exports2) {
    var base64VLQ = require_base64_vlq2();
    var util = require_util2();
    var ArraySet = require_array_set2().ArraySet;
    var MappingList = require_mapping_list2().MappingList;
    function SourceMapGenerator(aArgs) {
      if (!aArgs) {
        aArgs = {};
      }
      this._file = util.getArg(aArgs, "file", null);
      this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
      this._skipValidation = util.getArg(aArgs, "skipValidation", false);
      this._sources = new ArraySet();
      this._names = new ArraySet();
      this._mappings = new MappingList();
      this._sourcesContents = null;
    }
    SourceMapGenerator.prototype._version = 3;
    SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
      var sourceRoot = aSourceMapConsumer.sourceRoot;
      var generator = new SourceMapGenerator({
        file: aSourceMapConsumer.file,
        sourceRoot
      });
      aSourceMapConsumer.eachMapping(function(mapping) {
        var newMapping = {
          generated: {
            line: mapping.generatedLine,
            column: mapping.generatedColumn
          }
        };
        if (mapping.source != null) {
          newMapping.source = mapping.source;
          if (sourceRoot != null) {
            newMapping.source = util.relative(sourceRoot, newMapping.source);
          }
          newMapping.original = {
            line: mapping.originalLine,
            column: mapping.originalColumn
          };
          if (mapping.name != null) {
            newMapping.name = mapping.name;
          }
        }
        generator.addMapping(newMapping);
      });
      aSourceMapConsumer.sources.forEach(function(sourceFile) {
        var sourceRelative = sourceFile;
        if (sourceRoot !== null) {
          sourceRelative = util.relative(sourceRoot, sourceFile);
        }
        if (!generator._sources.has(sourceRelative)) {
          generator._sources.add(sourceRelative);
        }
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content != null) {
          generator.setSourceContent(sourceFile, content);
        }
      });
      return generator;
    };
    SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
      var generated = util.getArg(aArgs, "generated");
      var original = util.getArg(aArgs, "original", null);
      var source = util.getArg(aArgs, "source", null);
      var name = util.getArg(aArgs, "name", null);
      if (!this._skipValidation) {
        this._validateMapping(generated, original, source, name);
      }
      if (source != null) {
        source = String(source);
        if (!this._sources.has(source)) {
          this._sources.add(source);
        }
      }
      if (name != null) {
        name = String(name);
        if (!this._names.has(name)) {
          this._names.add(name);
        }
      }
      this._mappings.add({
        generatedLine: generated.line,
        generatedColumn: generated.column,
        originalLine: original != null && original.line,
        originalColumn: original != null && original.column,
        source,
        name
      });
    };
    SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
      var source = aSourceFile;
      if (this._sourceRoot != null) {
        source = util.relative(this._sourceRoot, source);
      }
      if (aSourceContent != null) {
        if (!this._sourcesContents) {
          this._sourcesContents = /* @__PURE__ */ Object.create(null);
        }
        this._sourcesContents[util.toSetString(source)] = aSourceContent;
      } else if (this._sourcesContents) {
        delete this._sourcesContents[util.toSetString(source)];
        if (Object.keys(this._sourcesContents).length === 0) {
          this._sourcesContents = null;
        }
      }
    };
    SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
      var sourceFile = aSourceFile;
      if (aSourceFile == null) {
        if (aSourceMapConsumer.file == null) {
          throw new Error(`SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`);
        }
        sourceFile = aSourceMapConsumer.file;
      }
      var sourceRoot = this._sourceRoot;
      if (sourceRoot != null) {
        sourceFile = util.relative(sourceRoot, sourceFile);
      }
      var newSources = new ArraySet();
      var newNames = new ArraySet();
      this._mappings.unsortedForEach(function(mapping) {
        if (mapping.source === sourceFile && mapping.originalLine != null) {
          var original = aSourceMapConsumer.originalPositionFor({
            line: mapping.originalLine,
            column: mapping.originalColumn
          });
          if (original.source != null) {
            mapping.source = original.source;
            if (aSourceMapPath != null) {
              mapping.source = util.join(aSourceMapPath, mapping.source);
            }
            if (sourceRoot != null) {
              mapping.source = util.relative(sourceRoot, mapping.source);
            }
            mapping.originalLine = original.line;
            mapping.originalColumn = original.column;
            if (original.name != null) {
              mapping.name = original.name;
            }
          }
        }
        var source = mapping.source;
        if (source != null && !newSources.has(source)) {
          newSources.add(source);
        }
        var name = mapping.name;
        if (name != null && !newNames.has(name)) {
          newNames.add(name);
        }
      }, this);
      this._sources = newSources;
      this._names = newNames;
      aSourceMapConsumer.sources.forEach(function(sourceFile2) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile2);
        if (content != null) {
          if (aSourceMapPath != null) {
            sourceFile2 = util.join(aSourceMapPath, sourceFile2);
          }
          if (sourceRoot != null) {
            sourceFile2 = util.relative(sourceRoot, sourceFile2);
          }
          this.setSourceContent(sourceFile2, content);
        }
      }, this);
    };
    SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
      if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
        throw new Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.");
      }
      if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
        return;
      } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
        return;
      } else {
        throw new Error("Invalid mapping: " + JSON.stringify({
          generated: aGenerated,
          source: aSource,
          original: aOriginal,
          name: aName
        }));
      }
    };
    SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
      var previousGeneratedColumn = 0;
      var previousGeneratedLine = 1;
      var previousOriginalColumn = 0;
      var previousOriginalLine = 0;
      var previousName = 0;
      var previousSource = 0;
      var result = "";
      var next;
      var mapping;
      var nameIdx;
      var sourceIdx;
      var mappings = this._mappings.toArray();
      for (var i = 0, len = mappings.length; i < len; i++) {
        mapping = mappings[i];
        next = "";
        if (mapping.generatedLine !== previousGeneratedLine) {
          previousGeneratedColumn = 0;
          while (mapping.generatedLine !== previousGeneratedLine) {
            next += ";";
            previousGeneratedLine++;
          }
        } else {
          if (i > 0) {
            if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
              continue;
            }
            next += ",";
          }
        }
        next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
        previousGeneratedColumn = mapping.generatedColumn;
        if (mapping.source != null) {
          sourceIdx = this._sources.indexOf(mapping.source);
          next += base64VLQ.encode(sourceIdx - previousSource);
          previousSource = sourceIdx;
          next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
          previousOriginalLine = mapping.originalLine - 1;
          next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
          previousOriginalColumn = mapping.originalColumn;
          if (mapping.name != null) {
            nameIdx = this._names.indexOf(mapping.name);
            next += base64VLQ.encode(nameIdx - previousName);
            previousName = nameIdx;
          }
        }
        result += next;
      }
      return result;
    };
    SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
      return aSources.map(function(source) {
        if (!this._sourcesContents) {
          return null;
        }
        if (aSourceRoot != null) {
          source = util.relative(aSourceRoot, source);
        }
        var key = util.toSetString(source);
        return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
      }, this);
    };
    SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
      var map = {
        version: this._version,
        sources: this._sources.toArray(),
        names: this._names.toArray(),
        mappings: this._serializeMappings()
      };
      if (this._file != null) {
        map.file = this._file;
      }
      if (this._sourceRoot != null) {
        map.sourceRoot = this._sourceRoot;
      }
      if (this._sourcesContents) {
        map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
      }
      return map;
    };
    SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
      return JSON.stringify(this.toJSON());
    };
    exports2.SourceMapGenerator = SourceMapGenerator;
  }
});

// node_modules/css-tree/lib/generator/sourceMap.js
var require_sourceMap = __commonJS({
  "node_modules/css-tree/lib/generator/sourceMap.js"(exports2, module2) {
    var SourceMapGenerator = require_source_map_generator2().SourceMapGenerator;
    var trackNodes = {
      Atrule: true,
      Selector: true,
      Declaration: true
    };
    module2.exports = function generateSourceMap(handlers) {
      var map = new SourceMapGenerator();
      var line = 1;
      var column = 0;
      var generated = {
        line: 1,
        column: 0
      };
      var original = {
        line: 0,
        column: 0
      };
      var sourceMappingActive = false;
      var activatedGenerated = {
        line: 1,
        column: 0
      };
      var activatedMapping = {
        generated: activatedGenerated
      };
      var handlersNode = handlers.node;
      handlers.node = function(node) {
        if (node.loc && node.loc.start && trackNodes.hasOwnProperty(node.type)) {
          var nodeLine = node.loc.start.line;
          var nodeColumn = node.loc.start.column - 1;
          if (original.line !== nodeLine || original.column !== nodeColumn) {
            original.line = nodeLine;
            original.column = nodeColumn;
            generated.line = line;
            generated.column = column;
            if (sourceMappingActive) {
              sourceMappingActive = false;
              if (generated.line !== activatedGenerated.line || generated.column !== activatedGenerated.column) {
                map.addMapping(activatedMapping);
              }
            }
            sourceMappingActive = true;
            map.addMapping({
              source: node.loc.source,
              original,
              generated
            });
          }
        }
        handlersNode.call(this, node);
        if (sourceMappingActive && trackNodes.hasOwnProperty(node.type)) {
          activatedGenerated.line = line;
          activatedGenerated.column = column;
        }
      };
      var handlersChunk = handlers.chunk;
      handlers.chunk = function(chunk) {
        for (var i = 0; i < chunk.length; i++) {
          if (chunk.charCodeAt(i) === 10) {
            line++;
            column = 0;
          } else {
            column++;
          }
        }
        handlersChunk(chunk);
      };
      var handlersResult = handlers.result;
      handlers.result = function() {
        if (sourceMappingActive) {
          map.addMapping(activatedMapping);
        }
        return {
          css: handlersResult(),
          map
        };
      };
      return handlers;
    };
  }
});

// node_modules/css-tree/lib/generator/create.js
var require_create2 = __commonJS({
  "node_modules/css-tree/lib/generator/create.js"(exports2, module2) {
    var sourceMap = require_sourceMap();
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    function processChildren(node, delimeter) {
      var list = node.children;
      var prev = null;
      if (typeof delimeter !== "function") {
        list.forEach(this.node, this);
      } else {
        list.forEach(function(node2) {
          if (prev !== null) {
            delimeter.call(this, prev);
          }
          this.node(node2);
          prev = node2;
        }, this);
      }
    }
    module2.exports = function createGenerator(config) {
      function processNode(node) {
        if (hasOwnProperty2.call(types, node.type)) {
          types[node.type].call(this, node);
        } else {
          throw new Error("Unknown node type: " + node.type);
        }
      }
      var types = {};
      if (config.node) {
        for (var name in config.node) {
          types[name] = config.node[name].generate;
        }
      }
      return function(node, options) {
        var buffer = "";
        var handlers = {
          children: processChildren,
          node: processNode,
          chunk: function(chunk) {
            buffer += chunk;
          },
          result: function() {
            return buffer;
          }
        };
        if (options) {
          if (typeof options.decorator === "function") {
            handlers = options.decorator(handlers);
          }
          if (options.sourceMap) {
            handlers = sourceMap(handlers);
          }
        }
        handlers.node(node);
        return handlers.result();
      };
    };
  }
});

// node_modules/css-tree/lib/convertor/create.js
var require_create3 = __commonJS({
  "node_modules/css-tree/lib/convertor/create.js"(exports2, module2) {
    var List = require_List();
    module2.exports = function createConvertors(walk) {
      return {
        fromPlainObject: function(ast) {
          walk(ast, {
            enter: function(node) {
              if (node.children && node.children instanceof List === false) {
                node.children = new List().fromArray(node.children);
              }
            }
          });
          return ast;
        },
        toPlainObject: function(ast) {
          walk(ast, {
            leave: function(node) {
              if (node.children && node.children instanceof List) {
                node.children = node.children.toArray();
              }
            }
          });
          return ast;
        }
      };
    };
  }
});

// node_modules/css-tree/lib/walker/create.js
var require_create4 = __commonJS({
  "node_modules/css-tree/lib/walker/create.js"(exports2, module2) {
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    var noop = function() {
    };
    function ensureFunction(value) {
      return typeof value === "function" ? value : noop;
    }
    function invokeForType(fn, type) {
      return function(node, item, list) {
        if (node.type === type) {
          fn.call(this, node, item, list);
        }
      };
    }
    function getWalkersFromStructure(name, nodeType) {
      var structure = nodeType.structure;
      var walkers = [];
      for (var key in structure) {
        if (hasOwnProperty2.call(structure, key) === false) {
          continue;
        }
        var fieldTypes = structure[key];
        var walker = {
          name: key,
          type: false,
          nullable: false
        };
        if (!Array.isArray(structure[key])) {
          fieldTypes = [structure[key]];
        }
        for (var i = 0; i < fieldTypes.length; i++) {
          var fieldType = fieldTypes[i];
          if (fieldType === null) {
            walker.nullable = true;
          } else if (typeof fieldType === "string") {
            walker.type = "node";
          } else if (Array.isArray(fieldType)) {
            walker.type = "list";
          }
        }
        if (walker.type) {
          walkers.push(walker);
        }
      }
      if (walkers.length) {
        return {
          context: nodeType.walkContext,
          fields: walkers
        };
      }
      return null;
    }
    function getTypesFromConfig(config) {
      var types = {};
      for (var name in config.node) {
        if (hasOwnProperty2.call(config.node, name)) {
          var nodeType = config.node[name];
          if (!nodeType.structure) {
            throw new Error("Missed `structure` field in `" + name + "` node type definition");
          }
          types[name] = getWalkersFromStructure(name, nodeType);
        }
      }
      return types;
    }
    function createTypeIterator(config, reverse) {
      var fields = config.fields.slice();
      var contextName = config.context;
      var useContext = typeof contextName === "string";
      if (reverse) {
        fields.reverse();
      }
      return function(node, context, walk, walkReducer) {
        var prevContextValue;
        if (useContext) {
          prevContextValue = context[contextName];
          context[contextName] = node;
        }
        for (var i = 0; i < fields.length; i++) {
          var field = fields[i];
          var ref = node[field.name];
          if (!field.nullable || ref) {
            if (field.type === "list") {
              var breakWalk = reverse ? ref.reduceRight(walkReducer, false) : ref.reduce(walkReducer, false);
              if (breakWalk) {
                return true;
              }
            } else if (walk(ref)) {
              return true;
            }
          }
        }
        if (useContext) {
          context[contextName] = prevContextValue;
        }
      };
    }
    function createFastTraveralMap(iterators) {
      return {
        Atrule: {
          StyleSheet: iterators.StyleSheet,
          Atrule: iterators.Atrule,
          Rule: iterators.Rule,
          Block: iterators.Block
        },
        Rule: {
          StyleSheet: iterators.StyleSheet,
          Atrule: iterators.Atrule,
          Rule: iterators.Rule,
          Block: iterators.Block
        },
        Declaration: {
          StyleSheet: iterators.StyleSheet,
          Atrule: iterators.Atrule,
          Rule: iterators.Rule,
          Block: iterators.Block,
          DeclarationList: iterators.DeclarationList
        }
      };
    }
    module2.exports = function createWalker(config) {
      var types = getTypesFromConfig(config);
      var iteratorsNatural = {};
      var iteratorsReverse = {};
      var breakWalk = Symbol("break-walk");
      var skipNode = Symbol("skip-node");
      for (var name in types) {
        if (hasOwnProperty2.call(types, name) && types[name] !== null) {
          iteratorsNatural[name] = createTypeIterator(types[name], false);
          iteratorsReverse[name] = createTypeIterator(types[name], true);
        }
      }
      var fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural);
      var fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse);
      var walk = function(root, options) {
        function walkNode(node, item, list) {
          var enterRet = enter.call(context, node, item, list);
          if (enterRet === breakWalk) {
            debugger;
            return true;
          }
          if (enterRet === skipNode) {
            return false;
          }
          if (iterators.hasOwnProperty(node.type)) {
            if (iterators[node.type](node, context, walkNode, walkReducer)) {
              return true;
            }
          }
          if (leave.call(context, node, item, list) === breakWalk) {
            return true;
          }
          return false;
        }
        var walkReducer = (ret, data, item, list) => ret || walkNode(data, item, list);
        var enter = noop;
        var leave = noop;
        var iterators = iteratorsNatural;
        var context = {
          break: breakWalk,
          skip: skipNode,
          root,
          stylesheet: null,
          atrule: null,
          atrulePrelude: null,
          rule: null,
          selector: null,
          block: null,
          declaration: null,
          function: null
        };
        if (typeof options === "function") {
          enter = options;
        } else if (options) {
          enter = ensureFunction(options.enter);
          leave = ensureFunction(options.leave);
          if (options.reverse) {
            iterators = iteratorsReverse;
          }
          if (options.visit) {
            if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) {
              iterators = options.reverse ? fastTraversalIteratorsReverse[options.visit] : fastTraversalIteratorsNatural[options.visit];
            } else if (!types.hasOwnProperty(options.visit)) {
              throw new Error("Bad value `" + options.visit + "` for `visit` option (should be: " + Object.keys(types).join(", ") + ")");
            }
            enter = invokeForType(enter, options.visit);
            leave = invokeForType(leave, options.visit);
          }
        }
        if (enter === noop && leave === noop) {
          throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function");
        }
        walkNode(root);
      };
      walk.break = breakWalk;
      walk.skip = skipNode;
      walk.find = function(ast, fn) {
        var found = null;
        walk(ast, function(node, item, list) {
          if (fn.call(this, node, item, list)) {
            found = node;
            return breakWalk;
          }
        });
        return found;
      };
      walk.findLast = function(ast, fn) {
        var found = null;
        walk(ast, {
          reverse: true,
          enter: function(node, item, list) {
            if (fn.call(this, node, item, list)) {
              found = node;
              return breakWalk;
            }
          }
        });
        return found;
      };
      walk.findAll = function(ast, fn) {
        var found = [];
        walk(ast, function(node, item, list) {
          if (fn.call(this, node, item, list)) {
            found.push(node);
          }
        });
        return found;
      };
      return walk;
    };
  }
});

// node_modules/css-tree/lib/utils/clone.js
var require_clone = __commonJS({
  "node_modules/css-tree/lib/utils/clone.js"(exports2, module2) {
    var List = require_List();
    module2.exports = function clone(node) {
      var result = {};
      for (var key in node) {
        var value = node[key];
        if (value) {
          if (Array.isArray(value) || value instanceof List) {
            value = value.map(clone);
          } else if (value.constructor === Object) {
            value = clone(value);
          }
        }
        result[key] = value;
      }
      return result;
    };
  }
});

// node_modules/css-tree/lib/syntax/config/mix.js
var require_mix = __commonJS({
  "node_modules/css-tree/lib/syntax/config/mix.js"(exports2, module2) {
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    var shape = {
      generic: true,
      types: appendOrAssign,
      atrules: {
        prelude: appendOrAssignOrNull,
        descriptors: appendOrAssignOrNull
      },
      properties: appendOrAssign,
      parseContext: assign,
      scope: deepAssign,
      atrule: ["parse"],
      pseudo: ["parse"],
      node: ["name", "structure", "parse", "generate", "walkContext"]
    };
    function isObject(value) {
      return value && value.constructor === Object;
    }
    function copy(value) {
      return isObject(value) ? Object.assign({}, value) : value;
    }
    function assign(dest, src) {
      return Object.assign(dest, src);
    }
    function deepAssign(dest, src) {
      for (const key in src) {
        if (hasOwnProperty2.call(src, key)) {
          if (isObject(dest[key])) {
            deepAssign(dest[key], copy(src[key]));
          } else {
            dest[key] = copy(src[key]);
          }
        }
      }
      return dest;
    }
    function append(a, b) {
      if (typeof b === "string" && /^\s*\|/.test(b)) {
        return typeof a === "string" ? a + b : b.replace(/^\s*\|\s*/, "");
      }
      return b || null;
    }
    function appendOrAssign(a, b) {
      if (typeof b === "string") {
        return append(a, b);
      }
      const result = Object.assign({}, a);
      for (let key in b) {
        if (hasOwnProperty2.call(b, key)) {
          result[key] = append(hasOwnProperty2.call(a, key) ? a[key] : void 0, b[key]);
        }
      }
      return result;
    }
    function appendOrAssignOrNull(a, b) {
      const result = appendOrAssign(a, b);
      return !isObject(result) || Object.keys(result).length ? result : null;
    }
    function mix(dest, src, shape2) {
      for (const key in shape2) {
        if (hasOwnProperty2.call(shape2, key) === false) {
          continue;
        }
        if (shape2[key] === true) {
          if (key in src) {
            if (hasOwnProperty2.call(src, key)) {
              dest[key] = copy(src[key]);
            }
          }
        } else if (shape2[key]) {
          if (typeof shape2[key] === "function") {
            const fn = shape2[key];
            dest[key] = fn({}, dest[key]);
            dest[key] = fn(dest[key] || {}, src[key]);
          } else if (isObject(shape2[key])) {
            const result = {};
            for (let name in dest[key]) {
              result[name] = mix({}, dest[key][name], shape2[key]);
            }
            for (let name in src[key]) {
              result[name] = mix(result[name] || {}, src[key][name], shape2[key]);
            }
            dest[key] = result;
          } else if (Array.isArray(shape2[key])) {
            const res = {};
            const innerShape = shape2[key].reduce(function(s, k) {
              s[k] = true;
              return s;
            }, {});
            for (const [name, value] of Object.entries(dest[key] || {})) {
              res[name] = {};
              if (value) {
                mix(res[name], value, innerShape);
              }
            }
            for (const name in src[key]) {
              if (hasOwnProperty2.call(src[key], name)) {
                if (!res[name]) {
                  res[name] = {};
                }
                if (src[key] && src[key][name]) {
                  mix(res[name], src[key][name], innerShape);
                }
              }
            }
            dest[key] = res;
          }
        }
      }
      return dest;
    }
    module2.exports = (dest, src) => mix(dest, src, shape);
  }
});

// node_modules/css-tree/lib/syntax/create.js
var require_create5 = __commonJS({
  "node_modules/css-tree/lib/syntax/create.js"(exports2) {
    var List = require_List();
    var SyntaxError2 = require_SyntaxError();
    var TokenStream = require_TokenStream();
    var Lexer = require_Lexer();
    var definitionSyntax = require_definition_syntax();
    var tokenize = require_tokenizer();
    var createParser = require_create();
    var createGenerator = require_create2();
    var createConvertor = require_create3();
    var createWalker = require_create4();
    var clone = require_clone();
    var names = require_names2();
    var mix = require_mix();
    function createSyntax(config) {
      var parse = createParser(config);
      var walk = createWalker(config);
      var generate = createGenerator(config);
      var convert = createConvertor(walk);
      var syntax = {
        List,
        SyntaxError: SyntaxError2,
        TokenStream,
        Lexer,
        vendorPrefix: names.vendorPrefix,
        keyword: names.keyword,
        property: names.property,
        isCustomProperty: names.isCustomProperty,
        definitionSyntax,
        lexer: null,
        createLexer: function(config2) {
          return new Lexer(config2, syntax, syntax.lexer.structure);
        },
        tokenize,
        parse,
        walk,
        generate,
        find: walk.find,
        findLast: walk.findLast,
        findAll: walk.findAll,
        clone,
        fromPlainObject: convert.fromPlainObject,
        toPlainObject: convert.toPlainObject,
        createSyntax: function(config2) {
          return createSyntax(mix({}, config2));
        },
        fork: function(extension) {
          var base = mix({}, config);
          return createSyntax(typeof extension === "function" ? extension(base, Object.assign) : mix(base, extension));
        }
      };
      syntax.lexer = new Lexer({
        generic: true,
        types: config.types,
        atrules: config.atrules,
        properties: config.properties,
        node: config.node
      }, syntax);
      return syntax;
    }
    exports2.create = function(config) {
      return createSyntax(mix({}, config));
    };
  }
});

// node_modules/mdn-data/css/at-rules.json
var require_at_rules = __commonJS({
  "node_modules/mdn-data/css/at-rules.json"(exports2, module2) {
    module2.exports = {
      "@charset": {
        syntax: '@charset "<charset>";',
        groups: [
          "CSS Charsets"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@charset"
      },
      "@counter-style": {
        syntax: "@counter-style <counter-style-name> {\n  [ system: <counter-system>; ] ||\n  [ symbols: <counter-symbols>; ] ||\n  [ additive-symbols: <additive-symbols>; ] ||\n  [ negative: <negative-symbol>; ] ||\n  [ prefix: <prefix>; ] ||\n  [ suffix: <suffix>; ] ||\n  [ range: <range>; ] ||\n  [ pad: <padding>; ] ||\n  [ speak-as: <speak-as>; ] ||\n  [ fallback: <counter-style-name>; ]\n}",
        interfaces: [
          "CSSCounterStyleRule"
        ],
        groups: [
          "CSS Counter Styles"
        ],
        descriptors: {
          "additive-symbols": {
            syntax: "[ <integer> && <symbol> ]#",
            media: "all",
            initial: "n/a (required)",
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          },
          fallback: {
            syntax: "<counter-style-name>",
            media: "all",
            initial: "decimal",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          negative: {
            syntax: "<symbol> <symbol>?",
            media: "all",
            initial: '"-" hyphen-minus',
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          },
          pad: {
            syntax: "<integer> && <symbol>",
            media: "all",
            initial: '0 ""',
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          prefix: {
            syntax: "<symbol>",
            media: "all",
            initial: '""',
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          range: {
            syntax: "[ [ <integer> | infinite ]{2} ]# | auto",
            media: "all",
            initial: "auto",
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          },
          "speak-as": {
            syntax: "auto | bullets | numbers | words | spell-out | <counter-style-name>",
            media: "all",
            initial: "auto",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          suffix: {
            syntax: "<symbol>",
            media: "all",
            initial: '". "',
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          symbols: {
            syntax: "<symbol>+",
            media: "all",
            initial: "n/a (required)",
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          },
          system: {
            syntax: "cyclic | numeric | alphabetic | symbolic | additive | [ fixed <integer>? ] | [ extends <counter-style-name> ]",
            media: "all",
            initial: "symbolic",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          }
        },
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@counter-style"
      },
      "@document": {
        syntax: "@document [ <url> | url-prefix(<string>) | domain(<string>) | media-document(<string>) | regexp(<string>) ]# {\n  <group-rule-body>\n}",
        interfaces: [
          "CSSGroupingRule",
          "CSSConditionRule"
        ],
        groups: [
          "CSS Conditional Rules"
        ],
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@document"
      },
      "@font-face": {
        syntax: "@font-face {\n  [ font-family: <family-name>; ] ||\n  [ src: <src>; ] ||\n  [ unicode-range: <unicode-range>; ] ||\n  [ font-variant: <font-variant>; ] ||\n  [ font-feature-settings: <font-feature-settings>; ] ||\n  [ font-variation-settings: <font-variation-settings>; ] ||\n  [ font-stretch: <font-stretch>; ] ||\n  [ font-weight: <font-weight>; ] ||\n  [ font-style: <font-style>; ]\n}",
        interfaces: [
          "CSSFontFaceRule"
        ],
        groups: [
          "CSS Fonts"
        ],
        descriptors: {
          "font-display": {
            syntax: "[ auto | block | swap | fallback | optional ]",
            media: "visual",
            percentages: "no",
            initial: "auto",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "experimental"
          },
          "font-family": {
            syntax: "<family-name>",
            media: "all",
            initial: "n/a (required)",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          "font-feature-settings": {
            syntax: "normal | <feature-tag-value>#",
            media: "all",
            initial: "normal",
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          },
          "font-variation-settings": {
            syntax: "normal | [ <string> <number> ]#",
            media: "all",
            initial: "normal",
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          },
          "font-stretch": {
            syntax: "<font-stretch-absolute>{1,2}",
            media: "all",
            initial: "normal",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          "font-style": {
            syntax: "normal | italic | oblique <angle>{0,2}",
            media: "all",
            initial: "normal",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          "font-weight": {
            syntax: "<font-weight-absolute>{1,2}",
            media: "all",
            initial: "normal",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          "font-variant": {
            syntax: "normal | none | [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> || stylistic(<feature-value-name>) || historical-forms || styleset(<feature-value-name>#) || character-variant(<feature-value-name>#) || swash(<feature-value-name>) || ornaments(<feature-value-name>) || annotation(<feature-value-name>) || [ small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps ] || <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero || <east-asian-variant-values> || <east-asian-width-values> || ruby ]",
            media: "all",
            initial: "normal",
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          },
          src: {
            syntax: "[ <url> [ format( <string># ) ]? | local( <family-name> ) ]#",
            media: "all",
            initial: "n/a (required)",
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          },
          "unicode-range": {
            syntax: "<unicode-range>#",
            media: "all",
            initial: "U+0-10FFFF",
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          }
        },
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@font-face"
      },
      "@font-feature-values": {
        syntax: "@font-feature-values <family-name># {\n  <feature-value-block-list>\n}",
        interfaces: [
          "CSSFontFeatureValuesRule"
        ],
        groups: [
          "CSS Fonts"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@font-feature-values"
      },
      "@import": {
        syntax: "@import [ <string> | <url> ] [ <media-query-list> ]?;",
        groups: [
          "Media Queries"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@import"
      },
      "@keyframes": {
        syntax: "@keyframes <keyframes-name> {\n  <keyframe-block-list>\n}",
        interfaces: [
          "CSSKeyframeRule",
          "CSSKeyframesRule"
        ],
        groups: [
          "CSS Animations"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@keyframes"
      },
      "@media": {
        syntax: "@media <media-query-list> {\n  <group-rule-body>\n}",
        interfaces: [
          "CSSGroupingRule",
          "CSSConditionRule",
          "CSSMediaRule",
          "CSSCustomMediaRule"
        ],
        groups: [
          "CSS Conditional Rules",
          "Media Queries"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@media"
      },
      "@namespace": {
        syntax: "@namespace <namespace-prefix>? [ <string> | <url> ];",
        groups: [
          "CSS Namespaces"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@namespace"
      },
      "@page": {
        syntax: "@page <page-selector-list> {\n  <page-body>\n}",
        interfaces: [
          "CSSPageRule"
        ],
        groups: [
          "CSS Pages"
        ],
        descriptors: {
          bleed: {
            syntax: "auto | <length>",
            media: [
              "visual",
              "paged"
            ],
            initial: "auto",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          marks: {
            syntax: "none | [ crop || cross ]",
            media: [
              "visual",
              "paged"
            ],
            initial: "none",
            percentages: "no",
            computed: "asSpecified",
            order: "orderOfAppearance",
            status: "standard"
          },
          size: {
            syntax: "<length>{1,2} | auto | [ <page-size> || [ portrait | landscape ] ]",
            media: [
              "visual",
              "paged"
            ],
            initial: "auto",
            percentages: "no",
            computed: "asSpecifiedRelativeToAbsoluteLengths",
            order: "orderOfAppearance",
            status: "standard"
          }
        },
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@page"
      },
      "@property": {
        syntax: "@property <custom-property-name> {\n  <declaration-list>\n}",
        interfaces: [
          "CSS",
          "CSSPropertyRule"
        ],
        groups: [
          "CSS Houdini"
        ],
        descriptors: {
          syntax: {
            syntax: "<string>",
            media: "all",
            percentages: "no",
            initial: "n/a (required)",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "experimental"
          },
          inherits: {
            syntax: "true | false",
            media: "all",
            percentages: "no",
            initial: "auto",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "experimental"
          },
          "initial-value": {
            syntax: "<string>",
            media: "all",
            initial: "n/a (required)",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "experimental"
          }
        },
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@property"
      },
      "@supports": {
        syntax: "@supports <supports-condition> {\n  <group-rule-body>\n}",
        interfaces: [
          "CSSGroupingRule",
          "CSSConditionRule",
          "CSSSupportsRule"
        ],
        groups: [
          "CSS Conditional Rules"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@supports"
      },
      "@viewport": {
        syntax: "@viewport {\n  <group-rule-body>\n}",
        interfaces: [
          "CSSViewportRule"
        ],
        groups: [
          "CSS Device Adaptation"
        ],
        descriptors: {
          height: {
            syntax: "<viewport-length>{1,2}",
            media: [
              "visual",
              "continuous"
            ],
            initial: [
              "min-height",
              "max-height"
            ],
            percentages: [
              "min-height",
              "max-height"
            ],
            computed: [
              "min-height",
              "max-height"
            ],
            order: "orderOfAppearance",
            status: "standard"
          },
          "max-height": {
            syntax: "<viewport-length>",
            media: [
              "visual",
              "continuous"
            ],
            initial: "auto",
            percentages: "referToHeightOfInitialViewport",
            computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
            order: "uniqueOrder",
            status: "standard"
          },
          "max-width": {
            syntax: "<viewport-length>",
            media: [
              "visual",
              "continuous"
            ],
            initial: "auto",
            percentages: "referToWidthOfInitialViewport",
            computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
            order: "uniqueOrder",
            status: "standard"
          },
          "max-zoom": {
            syntax: "auto | <number> | <percentage>",
            media: [
              "visual",
              "continuous"
            ],
            initial: "auto",
            percentages: "the zoom factor itself",
            computed: "autoNonNegativeOrPercentage",
            order: "uniqueOrder",
            status: "standard"
          },
          "min-height": {
            syntax: "<viewport-length>",
            media: [
              "visual",
              "continuous"
            ],
            initial: "auto",
            percentages: "referToHeightOfInitialViewport",
            computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
            order: "uniqueOrder",
            status: "standard"
          },
          "min-width": {
            syntax: "<viewport-length>",
            media: [
              "visual",
              "continuous"
            ],
            initial: "auto",
            percentages: "referToWidthOfInitialViewport",
            computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
            order: "uniqueOrder",
            status: "standard"
          },
          "min-zoom": {
            syntax: "auto | <number> | <percentage>",
            media: [
              "visual",
              "continuous"
            ],
            initial: "auto",
            percentages: "the zoom factor itself",
            computed: "autoNonNegativeOrPercentage",
            order: "uniqueOrder",
            status: "standard"
          },
          orientation: {
            syntax: "auto | portrait | landscape",
            media: [
              "visual",
              "continuous"
            ],
            initial: "auto",
            percentages: "referToSizeOfBoundingBox",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          "user-zoom": {
            syntax: "zoom | fixed",
            media: [
              "visual",
              "continuous"
            ],
            initial: "zoom",
            percentages: "referToSizeOfBoundingBox",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          "viewport-fit": {
            syntax: "auto | contain | cover",
            media: [
              "visual",
              "continuous"
            ],
            initial: "auto",
            percentages: "no",
            computed: "asSpecified",
            order: "uniqueOrder",
            status: "standard"
          },
          width: {
            syntax: "<viewport-length>{1,2}",
            media: [
              "visual",
              "continuous"
            ],
            initial: [
              "min-width",
              "max-width"
            ],
            percentages: [
              "min-width",
              "max-width"
            ],
            computed: [
              "min-width",
              "max-width"
            ],
            order: "orderOfAppearance",
            status: "standard"
          },
          zoom: {
            syntax: "auto | <number> | <percentage>",
            media: [
              "visual",
              "continuous"
            ],
            initial: "auto",
            percentages: "the zoom factor itself",
            computed: "autoNonNegativeOrPercentage",
            order: "uniqueOrder",
            status: "standard"
          }
        },
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/@viewport"
      }
    };
  }
});

// node_modules/mdn-data/css/properties.json
var require_properties = __commonJS({
  "node_modules/mdn-data/css/properties.json"(exports2, module2) {
    module2.exports = {
      "--*": {
        syntax: "<declaration-value>",
        media: "all",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Variables"
        ],
        initial: "seeProse",
        appliesto: "allElements",
        computed: "asSpecifiedWithVarsSubstituted",
        order: "perGrammar",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/--*"
      },
      "-ms-accelerator": {
        syntax: "false | true",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "false",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-accelerator"
      },
      "-ms-block-progression": {
        syntax: "tb | rl | bt | lr",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "tb",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-block-progression"
      },
      "-ms-content-zoom-chaining": {
        syntax: "none | chained",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "none",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-content-zoom-chaining"
      },
      "-ms-content-zooming": {
        syntax: "none | zoom",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "zoomForTheTopLevelNoneForTheRest",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-content-zooming"
      },
      "-ms-content-zoom-limit": {
        syntax: "<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: [
          "-ms-content-zoom-limit-max",
          "-ms-content-zoom-limit-min"
        ],
        groups: [
          "Microsoft Extensions"
        ],
        initial: [
          "-ms-content-zoom-limit-max",
          "-ms-content-zoom-limit-min"
        ],
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: [
          "-ms-content-zoom-limit-max",
          "-ms-content-zoom-limit-min"
        ],
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-content-zoom-limit"
      },
      "-ms-content-zoom-limit-max": {
        syntax: "<percentage>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "maxZoomFactor",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "400%",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-content-zoom-limit-max"
      },
      "-ms-content-zoom-limit-min": {
        syntax: "<percentage>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "minZoomFactor",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "100%",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-content-zoom-limit-min"
      },
      "-ms-content-zoom-snap": {
        syntax: "<'-ms-content-zoom-snap-type'> || <'-ms-content-zoom-snap-points'>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: [
          "-ms-content-zoom-snap-type",
          "-ms-content-zoom-snap-points"
        ],
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: [
          "-ms-content-zoom-snap-type",
          "-ms-content-zoom-snap-points"
        ],
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-content-zoom-snap"
      },
      "-ms-content-zoom-snap-points": {
        syntax: "snapInterval( <percentage>, <percentage> ) | snapList( <percentage># )",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "snapInterval(0%, 100%)",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-content-zoom-snap-points"
      },
      "-ms-content-zoom-snap-type": {
        syntax: "none | proximity | mandatory",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "none",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-content-zoom-snap-type"
      },
      "-ms-filter": {
        syntax: "<string>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: '""',
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-filter"
      },
      "-ms-flow-from": {
        syntax: "[ none | <custom-ident> ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "none",
        appliesto: "nonReplacedElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-flow-from"
      },
      "-ms-flow-into": {
        syntax: "[ none | <custom-ident> ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "none",
        appliesto: "iframeElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-flow-into"
      },
      "-ms-grid-columns": {
        syntax: "none | <track-list> | <auto-track-list>",
        media: "visual",
        inherited: false,
        animationType: "simpleListOfLpcDifferenceLpc",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "none",
        appliesto: "gridContainers",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-grid-columns"
      },
      "-ms-grid-rows": {
        syntax: "none | <track-list> | <auto-track-list>",
        media: "visual",
        inherited: false,
        animationType: "simpleListOfLpcDifferenceLpc",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "none",
        appliesto: "gridContainers",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-grid-rows"
      },
      "-ms-high-contrast-adjust": {
        syntax: "auto | none",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-high-contrast-adjust"
      },
      "-ms-hyphenate-limit-chars": {
        syntax: "auto | <integer>{1,3}",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-hyphenate-limit-chars"
      },
      "-ms-hyphenate-limit-lines": {
        syntax: "no-limit | <integer>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "no-limit",
        appliesto: "blockContainerElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-hyphenate-limit-lines"
      },
      "-ms-hyphenate-limit-zone": {
        syntax: "<percentage> | <length>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "referToLineBoxWidth",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "0",
        appliesto: "blockContainerElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-hyphenate-limit-zone"
      },
      "-ms-ime-align": {
        syntax: "auto | after",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-ime-align"
      },
      "-ms-overflow-style": {
        syntax: "auto | none | scrollbar | -ms-autohiding-scrollbar",
        media: "interactive",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "auto",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-overflow-style"
      },
      "-ms-scrollbar-3dlight-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "dependsOnUserAgent",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scrollbar-3dlight-color"
      },
      "-ms-scrollbar-arrow-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "ButtonText",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scrollbar-arrow-color"
      },
      "-ms-scrollbar-base-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "dependsOnUserAgent",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scrollbar-base-color"
      },
      "-ms-scrollbar-darkshadow-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "ThreeDDarkShadow",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scrollbar-darkshadow-color"
      },
      "-ms-scrollbar-face-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "ThreeDFace",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scrollbar-face-color"
      },
      "-ms-scrollbar-highlight-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "ThreeDHighlight",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scrollbar-highlight-color"
      },
      "-ms-scrollbar-shadow-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "ThreeDDarkShadow",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scrollbar-shadow-color"
      },
      "-ms-scrollbar-track-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "Scrollbar",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scrollbar-track-color"
      },
      "-ms-scroll-chaining": {
        syntax: "chained | none",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "chained",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-chaining"
      },
      "-ms-scroll-limit": {
        syntax: "<'-ms-scroll-limit-x-min'> <'-ms-scroll-limit-y-min'> <'-ms-scroll-limit-x-max'> <'-ms-scroll-limit-y-max'>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: [
          "-ms-scroll-limit-x-min",
          "-ms-scroll-limit-y-min",
          "-ms-scroll-limit-x-max",
          "-ms-scroll-limit-y-max"
        ],
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: [
          "-ms-scroll-limit-x-min",
          "-ms-scroll-limit-y-min",
          "-ms-scroll-limit-x-max",
          "-ms-scroll-limit-y-max"
        ],
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-limit"
      },
      "-ms-scroll-limit-x-max": {
        syntax: "auto | <length>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "auto",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-limit-x-max"
      },
      "-ms-scroll-limit-x-min": {
        syntax: "<length>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "0",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-limit-x-min"
      },
      "-ms-scroll-limit-y-max": {
        syntax: "auto | <length>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "auto",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-limit-y-max"
      },
      "-ms-scroll-limit-y-min": {
        syntax: "<length>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "0",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-limit-y-min"
      },
      "-ms-scroll-rails": {
        syntax: "none | railed",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "railed",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-rails"
      },
      "-ms-scroll-snap-points-x": {
        syntax: "snapInterval( <length-percentage>, <length-percentage> ) | snapList( <length-percentage># )",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "snapInterval(0px, 100%)",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-snap-points-x"
      },
      "-ms-scroll-snap-points-y": {
        syntax: "snapInterval( <length-percentage>, <length-percentage> ) | snapList( <length-percentage># )",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "snapInterval(0px, 100%)",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-snap-points-y"
      },
      "-ms-scroll-snap-type": {
        syntax: "none | proximity | mandatory",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "none",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-snap-type"
      },
      "-ms-scroll-snap-x": {
        syntax: "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: [
          "-ms-scroll-snap-type",
          "-ms-scroll-snap-points-x"
        ],
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: [
          "-ms-scroll-snap-type",
          "-ms-scroll-snap-points-x"
        ],
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-snap-x"
      },
      "-ms-scroll-snap-y": {
        syntax: "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: [
          "-ms-scroll-snap-type",
          "-ms-scroll-snap-points-y"
        ],
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: [
          "-ms-scroll-snap-type",
          "-ms-scroll-snap-points-y"
        ],
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-snap-y"
      },
      "-ms-scroll-translation": {
        syntax: "none | vertical-to-horizontal",
        media: "interactive",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-scroll-translation"
      },
      "-ms-text-autospace": {
        syntax: "none | ideograph-alpha | ideograph-numeric | ideograph-parenthesis | ideograph-space",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-text-autospace"
      },
      "-ms-touch-select": {
        syntax: "grippers | none",
        media: "interactive",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "grippers",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-touch-select"
      },
      "-ms-user-select": {
        syntax: "none | element | text",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "text",
        appliesto: "nonReplacedElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-user-select"
      },
      "-ms-wrap-flow": {
        syntax: "auto | both | start | end | maximum | clear",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "auto",
        appliesto: "blockLevelElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-wrap-flow"
      },
      "-ms-wrap-margin": {
        syntax: "<length>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "0",
        appliesto: "exclusionElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-wrap-margin"
      },
      "-ms-wrap-through": {
        syntax: "wrap | none",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "wrap",
        appliesto: "blockLevelElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-ms-wrap-through"
      },
      "-moz-appearance": {
        syntax: "none | button | button-arrow-down | button-arrow-next | button-arrow-previous | button-arrow-up | button-bevel | button-focus | caret | checkbox | checkbox-container | checkbox-label | checkmenuitem | dualbutton | groupbox | listbox | listitem | menuarrow | menubar | menucheckbox | menuimage | menuitem | menuitemtext | menulist | menulist-button | menulist-text | menulist-textfield | menupopup | menuradio | menuseparator | meterbar | meterchunk | progressbar | progressbar-vertical | progresschunk | progresschunk-vertical | radio | radio-container | radio-label | radiomenuitem | range | range-thumb | resizer | resizerpanel | scale-horizontal | scalethumbend | scalethumb-horizontal | scalethumbstart | scalethumbtick | scalethumb-vertical | scale-vertical | scrollbarbutton-down | scrollbarbutton-left | scrollbarbutton-right | scrollbarbutton-up | scrollbarthumb-horizontal | scrollbarthumb-vertical | scrollbartrack-horizontal | scrollbartrack-vertical | searchfield | separator | sheet | spinner | spinner-downbutton | spinner-textfield | spinner-upbutton | splitter | statusbar | statusbarpanel | tab | tabpanel | tabpanels | tab-scroll-arrow-back | tab-scroll-arrow-forward | textfield | textfield-multiline | toolbar | toolbarbutton | toolbarbutton-dropdown | toolbargripper | toolbox | tooltip | treeheader | treeheadercell | treeheadersortarrow | treeitem | treeline | treetwisty | treetwistyopen | treeview | -moz-mac-unified-toolbar | -moz-win-borderless-glass | -moz-win-browsertabbar-toolbox | -moz-win-communicationstext | -moz-win-communications-toolbox | -moz-win-exclude-glass | -moz-win-glass | -moz-win-mediatext | -moz-win-media-toolbox | -moz-window-button-box | -moz-window-button-box-maximized | -moz-window-button-close | -moz-window-button-maximize | -moz-window-button-minimize | -moz-window-button-restore | -moz-window-frame-bottom | -moz-window-frame-left | -moz-window-frame-right | -moz-window-titlebar | -moz-window-titlebar-maximized",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions",
          "WebKit Extensions"
        ],
        initial: "noneButOverriddenInUserAgentCSS",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/appearance"
      },
      "-moz-binding": {
        syntax: "<url> | none",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "none",
        appliesto: "allElementsExceptGeneratedContentOrPseudoElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-binding"
      },
      "-moz-border-bottom-colors": {
        syntax: "<color>+ | none",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-border-bottom-colors"
      },
      "-moz-border-left-colors": {
        syntax: "<color>+ | none",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-border-left-colors"
      },
      "-moz-border-right-colors": {
        syntax: "<color>+ | none",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-border-right-colors"
      },
      "-moz-border-top-colors": {
        syntax: "<color>+ | none",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-border-top-colors"
      },
      "-moz-context-properties": {
        syntax: "none | [ fill | fill-opacity | stroke | stroke-opacity ]#",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "none",
        appliesto: "allElementsThatCanReferenceImages",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-context-properties"
      },
      "-moz-float-edge": {
        syntax: "border-box | content-box | margin-box | padding-box",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "content-box",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-float-edge"
      },
      "-moz-force-broken-image-icon": {
        syntax: "<integer [0,1]>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "0",
        appliesto: "images",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-force-broken-image-icon"
      },
      "-moz-image-region": {
        syntax: "<shape> | auto",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "auto",
        appliesto: "xulImageElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-image-region"
      },
      "-moz-orient": {
        syntax: "inline | block | horizontal | vertical",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "inline",
        appliesto: "anyElementEffectOnProgressAndMeter",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-orient"
      },
      "-moz-outline-radius": {
        syntax: "<outline-radius>{1,4} [ / <outline-radius>{1,4} ]?",
        media: "visual",
        inherited: false,
        animationType: [
          "-moz-outline-radius-topleft",
          "-moz-outline-radius-topright",
          "-moz-outline-radius-bottomright",
          "-moz-outline-radius-bottomleft"
        ],
        percentages: [
          "-moz-outline-radius-topleft",
          "-moz-outline-radius-topright",
          "-moz-outline-radius-bottomright",
          "-moz-outline-radius-bottomleft"
        ],
        groups: [
          "Mozilla Extensions"
        ],
        initial: [
          "-moz-outline-radius-topleft",
          "-moz-outline-radius-topright",
          "-moz-outline-radius-bottomright",
          "-moz-outline-radius-bottomleft"
        ],
        appliesto: "allElements",
        computed: [
          "-moz-outline-radius-topleft",
          "-moz-outline-radius-topright",
          "-moz-outline-radius-bottomright",
          "-moz-outline-radius-bottomleft"
        ],
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-outline-radius"
      },
      "-moz-outline-radius-bottomleft": {
        syntax: "<outline-radius>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-outline-radius-bottomleft"
      },
      "-moz-outline-radius-bottomright": {
        syntax: "<outline-radius>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-outline-radius-bottomright"
      },
      "-moz-outline-radius-topleft": {
        syntax: "<outline-radius>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-outline-radius-topleft"
      },
      "-moz-outline-radius-topright": {
        syntax: "<outline-radius>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-outline-radius-topright"
      },
      "-moz-stack-sizing": {
        syntax: "ignore | stretch-to-fit",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "stretch-to-fit",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-stack-sizing"
      },
      "-moz-text-blink": {
        syntax: "none | blink",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-text-blink"
      },
      "-moz-user-focus": {
        syntax: "ignore | normal | select-after | select-before | select-menu | select-same | select-all | none",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-user-focus"
      },
      "-moz-user-input": {
        syntax: "auto | none | enabled | disabled",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-user-input"
      },
      "-moz-user-modify": {
        syntax: "read-only | read-write | write-only",
        media: "interactive",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "read-only",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-user-modify"
      },
      "-moz-window-dragging": {
        syntax: "drag | no-drag",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "drag",
        appliesto: "allElementsCreatingNativeWindows",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-window-dragging"
      },
      "-moz-window-shadow": {
        syntax: "default | menu | tooltip | sheet | none",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "default",
        appliesto: "allElementsCreatingNativeWindows",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-moz-window-shadow"
      },
      "-webkit-appearance": {
        syntax: "none | button | button-bevel | caret | checkbox | default-button | inner-spin-button | listbox | listitem | media-controls-background | media-controls-fullscreen-background | media-current-time-display | media-enter-fullscreen-button | media-exit-fullscreen-button | media-fullscreen-button | media-mute-button | media-overlay-play-button | media-play-button | media-seek-back-button | media-seek-forward-button | media-slider | media-sliderthumb | media-time-remaining-display | media-toggle-closed-captions-button | media-volume-slider | media-volume-slider-container | media-volume-sliderthumb | menulist | menulist-button | menulist-text | menulist-textfield | meter | progress-bar | progress-bar-value | push-button | radio | searchfield | searchfield-cancel-button | searchfield-decoration | searchfield-results-button | searchfield-results-decoration | slider-horizontal | slider-vertical | sliderthumb-horizontal | sliderthumb-vertical | square-button | textarea | textfield | -apple-pay-button",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "noneButOverriddenInUserAgentCSS",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/appearance"
      },
      "-webkit-border-before": {
        syntax: "<'border-width'> || <'border-style'> || <'color'>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: [
          "-webkit-border-before-width"
        ],
        groups: [
          "WebKit Extensions"
        ],
        initial: [
          "border-width",
          "border-style",
          "color"
        ],
        appliesto: "allElements",
        computed: [
          "border-width",
          "border-style",
          "color"
        ],
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-border-before"
      },
      "-webkit-border-before-color": {
        syntax: "<'color'>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "nonstandard"
      },
      "-webkit-border-before-style": {
        syntax: "<'border-style'>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard"
      },
      "-webkit-border-before-width": {
        syntax: "<'border-width'>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "WebKit Extensions"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
        order: "uniqueOrder",
        status: "nonstandard"
      },
      "-webkit-box-reflect": {
        syntax: "[ above | below | right | left ]? <length>? <image>?",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-box-reflect"
      },
      "-webkit-line-clamp": {
        syntax: "none | <integer>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "WebKit Extensions",
          "CSS Overflow"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-line-clamp"
      },
      "-webkit-mask": {
        syntax: "[ <mask-reference> || <position> [ / <bg-size> ]? || <repeat-style> || [ <box> | border | padding | content | text ] || [ <box> | border | padding | content ] ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: [
          "-webkit-mask-image",
          "-webkit-mask-repeat",
          "-webkit-mask-attachment",
          "-webkit-mask-position",
          "-webkit-mask-origin",
          "-webkit-mask-clip"
        ],
        appliesto: "allElements",
        computed: [
          "-webkit-mask-image",
          "-webkit-mask-repeat",
          "-webkit-mask-attachment",
          "-webkit-mask-position",
          "-webkit-mask-origin",
          "-webkit-mask-clip"
        ],
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask"
      },
      "-webkit-mask-attachment": {
        syntax: "<attachment>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "scroll",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-mask-attachment"
      },
      "-webkit-mask-clip": {
        syntax: "[ <box> | border | padding | content | text ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "border",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-clip"
      },
      "-webkit-mask-composite": {
        syntax: "<composite-style>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "source-over",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-mask-composite"
      },
      "-webkit-mask-image": {
        syntax: "<mask-reference>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "absoluteURIOrNone",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-image"
      },
      "-webkit-mask-origin": {
        syntax: "[ <box> | border | padding | content ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "padding",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-origin"
      },
      "-webkit-mask-position": {
        syntax: "<position>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "referToSizeOfElement",
        groups: [
          "WebKit Extensions"
        ],
        initial: "0% 0%",
        appliesto: "allElements",
        computed: "absoluteLengthOrPercentage",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-position"
      },
      "-webkit-mask-position-x": {
        syntax: "[ <length-percentage> | left | center | right ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "referToSizeOfElement",
        groups: [
          "WebKit Extensions"
        ],
        initial: "0%",
        appliesto: "allElements",
        computed: "absoluteLengthOrPercentage",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-mask-position-x"
      },
      "-webkit-mask-position-y": {
        syntax: "[ <length-percentage> | top | center | bottom ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "referToSizeOfElement",
        groups: [
          "WebKit Extensions"
        ],
        initial: "0%",
        appliesto: "allElements",
        computed: "absoluteLengthOrPercentage",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-mask-position-y"
      },
      "-webkit-mask-repeat": {
        syntax: "<repeat-style>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "repeat",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-repeat"
      },
      "-webkit-mask-repeat-x": {
        syntax: "repeat | no-repeat | space | round",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "repeat",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-mask-repeat-x"
      },
      "-webkit-mask-repeat-y": {
        syntax: "repeat | no-repeat | space | round",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "repeat",
        appliesto: "allElements",
        computed: "absoluteLengthOrPercentage",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-mask-repeat-y"
      },
      "-webkit-mask-size": {
        syntax: "<bg-size>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "relativeToBackgroundPositioningArea",
        groups: [
          "WebKit Extensions"
        ],
        initial: "auto auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-size"
      },
      "-webkit-overflow-scrolling": {
        syntax: "auto | touch",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "auto",
        appliesto: "scrollingBoxes",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-overflow-scrolling"
      },
      "-webkit-tap-highlight-color": {
        syntax: "<color>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "black",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-tap-highlight-color"
      },
      "-webkit-text-fill-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "color",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-text-fill-color"
      },
      "-webkit-text-stroke": {
        syntax: "<length> || <color>",
        media: "visual",
        inherited: true,
        animationType: [
          "-webkit-text-stroke-width",
          "-webkit-text-stroke-color"
        ],
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: [
          "-webkit-text-stroke-width",
          "-webkit-text-stroke-color"
        ],
        appliesto: "allElements",
        computed: [
          "-webkit-text-stroke-width",
          "-webkit-text-stroke-color"
        ],
        order: "canonicalOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-text-stroke"
      },
      "-webkit-text-stroke-color": {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "color",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-text-stroke-color"
      },
      "-webkit-text-stroke-width": {
        syntax: "<length>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "absoluteLength",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-text-stroke-width"
      },
      "-webkit-touch-callout": {
        syntax: "default | none",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "default",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/-webkit-touch-callout"
      },
      "-webkit-user-modify": {
        syntax: "read-only | read-write | read-write-plaintext-only",
        media: "interactive",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "WebKit Extensions"
        ],
        initial: "read-only",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard"
      },
      "align-content": {
        syntax: "normal | <baseline-position> | <content-distribution> | <overflow-position>? <content-position>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: "normal",
        appliesto: "multilineFlexContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/align-content"
      },
      "align-items": {
        syntax: "normal | stretch | <baseline-position> | [ <overflow-position>? <self-position> ]",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/align-items"
      },
      "align-self": {
        syntax: "auto | normal | stretch | <baseline-position> | <overflow-position>? <self-position>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: "auto",
        appliesto: "flexItemsGridItemsAndAbsolutelyPositionedBoxes",
        computed: "autoOnAbsolutelyPositionedElementsValueOfAlignItemsOnParent",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/align-self"
      },
      "align-tracks": {
        syntax: "[ normal | <baseline-position> | <content-distribution> | <overflow-position>? <content-position> ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "normal",
        appliesto: "gridContainersWithMasonryLayoutInTheirBlockAxis",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/align-tracks"
      },
      all: {
        syntax: "initial | inherit | unset | revert",
        media: "noPracticalMedia",
        inherited: false,
        animationType: "eachOfShorthandPropertiesExceptUnicodeBiDiAndDirection",
        percentages: "no",
        groups: [
          "CSS Miscellaneous"
        ],
        initial: "noPracticalInitialValue",
        appliesto: "allElements",
        computed: "asSpecifiedAppliesToEachProperty",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/all"
      },
      animation: {
        syntax: "<single-animation>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Animations"
        ],
        initial: [
          "animation-name",
          "animation-duration",
          "animation-timing-function",
          "animation-delay",
          "animation-iteration-count",
          "animation-direction",
          "animation-fill-mode",
          "animation-play-state"
        ],
        appliesto: "allElementsAndPseudos",
        computed: [
          "animation-name",
          "animation-duration",
          "animation-timing-function",
          "animation-delay",
          "animation-direction",
          "animation-iteration-count",
          "animation-fill-mode",
          "animation-play-state"
        ],
        order: "orderOfAppearance",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/animation"
      },
      "animation-delay": {
        syntax: "<time>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Animations"
        ],
        initial: "0s",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/animation-delay"
      },
      "animation-direction": {
        syntax: "<single-animation-direction>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Animations"
        ],
        initial: "normal",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/animation-direction"
      },
      "animation-duration": {
        syntax: "<time>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Animations"
        ],
        initial: "0s",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/animation-duration"
      },
      "animation-fill-mode": {
        syntax: "<single-animation-fill-mode>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Animations"
        ],
        initial: "none",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/animation-fill-mode"
      },
      "animation-iteration-count": {
        syntax: "<single-animation-iteration-count>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Animations"
        ],
        initial: "1",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/animation-iteration-count"
      },
      "animation-name": {
        syntax: "[ none | <keyframes-name> ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Animations"
        ],
        initial: "none",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/animation-name"
      },
      "animation-play-state": {
        syntax: "<single-animation-play-state>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Animations"
        ],
        initial: "running",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/animation-play-state"
      },
      "animation-timing-function": {
        syntax: "<timing-function>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Animations"
        ],
        initial: "ease",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/animation-timing-function"
      },
      appearance: {
        syntax: "none | auto | textfield | menulist-button | <compat-auto>",
        media: "all",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/appearance"
      },
      "aspect-ratio": {
        syntax: "auto | <ratio>",
        media: "all",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "auto",
        appliesto: "allElementsExceptInlineBoxesAndInternalRubyOrTableBoxes",
        computed: "asSpecified",
        order: "perGrammar",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/aspect-ratio"
      },
      azimuth: {
        syntax: "<angle> | [ [ left-side | far-left | left | center-left | center | center-right | right | far-right | right-side ] || behind ] | leftwards | rightwards",
        media: "aural",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Speech"
        ],
        initial: "center",
        appliesto: "allElements",
        computed: "normalizedAngle",
        order: "orderOfAppearance",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/azimuth"
      },
      "backdrop-filter": {
        syntax: "none | <filter-function-list>",
        media: "visual",
        inherited: false,
        animationType: "filterList",
        percentages: "no",
        groups: [
          "Filter Effects"
        ],
        initial: "none",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/backdrop-filter"
      },
      "backface-visibility": {
        syntax: "visible | hidden",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Transforms"
        ],
        initial: "visible",
        appliesto: "transformableElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/backface-visibility"
      },
      background: {
        syntax: "[ <bg-layer> , ]* <final-bg-layer>",
        media: "visual",
        inherited: false,
        animationType: [
          "background-color",
          "background-image",
          "background-clip",
          "background-position",
          "background-size",
          "background-repeat",
          "background-attachment"
        ],
        percentages: [
          "background-position",
          "background-size"
        ],
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "background-image",
          "background-position",
          "background-size",
          "background-repeat",
          "background-origin",
          "background-clip",
          "background-attachment",
          "background-color"
        ],
        appliesto: "allElements",
        computed: [
          "background-image",
          "background-position",
          "background-size",
          "background-repeat",
          "background-origin",
          "background-clip",
          "background-attachment",
          "background-color"
        ],
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background"
      },
      "background-attachment": {
        syntax: "<attachment>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "scroll",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-attachment"
      },
      "background-blend-mode": {
        syntax: "<blend-mode>#",
        media: "none",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Compositing and Blending"
        ],
        initial: "normal",
        appliesto: "allElementsSVGContainerGraphicsAndGraphicsReferencingElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-blend-mode"
      },
      "background-clip": {
        syntax: "<box>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "border-box",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-clip"
      },
      "background-color": {
        syntax: "<color>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "transparent",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-color"
      },
      "background-image": {
        syntax: "<bg-image>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecifiedURLsAbsolute",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-image"
      },
      "background-origin": {
        syntax: "<box>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "padding-box",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-origin"
      },
      "background-position": {
        syntax: "<bg-position>#",
        media: "visual",
        inherited: false,
        animationType: "repeatableListOfSimpleListOfLpc",
        percentages: "referToSizeOfBackgroundPositioningAreaMinusBackgroundImageSize",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "0% 0%",
        appliesto: "allElements",
        computed: "listEachItemTwoKeywordsOriginOffsets",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-position"
      },
      "background-position-x": {
        syntax: "[ center | [ [ left | right | x-start | x-end ]? <length-percentage>? ]! ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "referToWidthOfBackgroundPositioningAreaMinusBackgroundImageHeight",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "left",
        appliesto: "allElements",
        computed: "listEachItemConsistingOfAbsoluteLengthPercentageAndOrigin",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-position-x"
      },
      "background-position-y": {
        syntax: "[ center | [ [ top | bottom | y-start | y-end ]? <length-percentage>? ]! ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "referToHeightOfBackgroundPositioningAreaMinusBackgroundImageHeight",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "top",
        appliesto: "allElements",
        computed: "listEachItemConsistingOfAbsoluteLengthPercentageAndOrigin",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-position-y"
      },
      "background-repeat": {
        syntax: "<repeat-style>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "repeat",
        appliesto: "allElements",
        computed: "listEachItemHasTwoKeywordsOnePerDimension",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-repeat"
      },
      "background-size": {
        syntax: "<bg-size>#",
        media: "visual",
        inherited: false,
        animationType: "repeatableListOfSimpleListOfLpc",
        percentages: "relativeToBackgroundPositioningArea",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "auto auto",
        appliesto: "allElements",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/background-size"
      },
      "block-overflow": {
        syntax: "clip | ellipsis | <string>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Overflow"
        ],
        initial: "clip",
        appliesto: "blockContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "experimental"
      },
      "block-size": {
        syntax: "<'width'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "blockSizeOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "auto",
        appliesto: "sameAsWidthAndHeight",
        computed: "sameAsWidthAndHeight",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/block-size"
      },
      border: {
        syntax: "<line-width> || <line-style> || <color>",
        media: "visual",
        inherited: false,
        animationType: [
          "border-color",
          "border-style",
          "border-width"
        ],
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-width",
          "border-style",
          "border-color"
        ],
        appliesto: "allElements",
        computed: [
          "border-width",
          "border-style",
          "border-color"
        ],
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border"
      },
      "border-block": {
        syntax: "<'border-top-width'> || <'border-top-style'> || <'color'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: [
          "border-top-width",
          "border-top-style",
          "border-top-color"
        ],
        appliesto: "allElements",
        computed: [
          "border-top-width",
          "border-top-style",
          "border-top-color"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block"
      },
      "border-block-color": {
        syntax: "<'border-top-color'>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-color"
      },
      "border-block-style": {
        syntax: "<'border-top-style'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-style"
      },
      "border-block-width": {
        syntax: "<'border-top-width'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-width"
      },
      "border-block-end": {
        syntax: "<'border-top-width'> || <'border-top-style'> || <'color'>",
        media: "visual",
        inherited: false,
        animationType: [
          "border-block-end-color",
          "border-block-end-style",
          "border-block-end-width"
        ],
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: [
          "border-top-width",
          "border-top-style",
          "border-top-color"
        ],
        appliesto: "allElements",
        computed: [
          "border-top-width",
          "border-top-style",
          "border-top-color"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-end"
      },
      "border-block-end-color": {
        syntax: "<'border-top-color'>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-end-color"
      },
      "border-block-end-style": {
        syntax: "<'border-top-style'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-end-style"
      },
      "border-block-end-width": {
        syntax: "<'border-top-width'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-end-width"
      },
      "border-block-start": {
        syntax: "<'border-top-width'> || <'border-top-style'> || <'color'>",
        media: "visual",
        inherited: false,
        animationType: [
          "border-block-start-color",
          "border-block-start-style",
          "border-block-start-width"
        ],
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: [
          "border-width",
          "border-style",
          "color"
        ],
        appliesto: "allElements",
        computed: [
          "border-width",
          "border-style",
          "border-block-start-color"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-start"
      },
      "border-block-start-color": {
        syntax: "<'border-top-color'>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-start-color"
      },
      "border-block-start-style": {
        syntax: "<'border-top-style'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-start-style"
      },
      "border-block-start-width": {
        syntax: "<'border-top-width'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-block-start-width"
      },
      "border-bottom": {
        syntax: "<line-width> || <line-style> || <color>",
        media: "visual",
        inherited: false,
        animationType: [
          "border-bottom-color",
          "border-bottom-style",
          "border-bottom-width"
        ],
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-bottom-width",
          "border-bottom-style",
          "border-bottom-color"
        ],
        appliesto: "allElements",
        computed: [
          "border-bottom-width",
          "border-bottom-style",
          "border-bottom-color"
        ],
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-bottom"
      },
      "border-bottom-color": {
        syntax: "<'border-top-color'>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-bottom-color"
      },
      "border-bottom-left-radius": {
        syntax: "<length-percentage>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "0",
        appliesto: "allElementsUAsNotRequiredWhenCollapse",
        computed: "twoAbsoluteLengthOrPercentages",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-bottom-left-radius"
      },
      "border-bottom-right-radius": {
        syntax: "<length-percentage>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "0",
        appliesto: "allElementsUAsNotRequiredWhenCollapse",
        computed: "twoAbsoluteLengthOrPercentages",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-bottom-right-radius"
      },
      "border-bottom-style": {
        syntax: "<line-style>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-bottom-style"
      },
      "border-bottom-width": {
        syntax: "<line-width>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthOr0IfBorderBottomStyleNoneOrHidden",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-bottom-width"
      },
      "border-collapse": {
        syntax: "collapse | separate",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Table"
        ],
        initial: "separate",
        appliesto: "tableElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-collapse"
      },
      "border-color": {
        syntax: "<color>{1,4}",
        media: "visual",
        inherited: false,
        animationType: [
          "border-bottom-color",
          "border-left-color",
          "border-right-color",
          "border-top-color"
        ],
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-top-color",
          "border-right-color",
          "border-bottom-color",
          "border-left-color"
        ],
        appliesto: "allElements",
        computed: [
          "border-bottom-color",
          "border-left-color",
          "border-right-color",
          "border-top-color"
        ],
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-color"
      },
      "border-end-end-radius": {
        syntax: "<length-percentage>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElementsUAsNotRequiredWhenCollapse",
        computed: "twoAbsoluteLengthOrPercentages",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-end-end-radius"
      },
      "border-end-start-radius": {
        syntax: "<length-percentage>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElementsUAsNotRequiredWhenCollapse",
        computed: "twoAbsoluteLengthOrPercentages",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-end-start-radius"
      },
      "border-image": {
        syntax: "<'border-image-source'> || <'border-image-slice'> [ / <'border-image-width'> | / <'border-image-width'>? / <'border-image-outset'> ]? || <'border-image-repeat'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: [
          "border-image-slice",
          "border-image-width"
        ],
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-image-source",
          "border-image-slice",
          "border-image-width",
          "border-image-outset",
          "border-image-repeat"
        ],
        appliesto: "allElementsExceptTableElementsWhenCollapse",
        computed: [
          "border-image-outset",
          "border-image-repeat",
          "border-image-slice",
          "border-image-source",
          "border-image-width"
        ],
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-image"
      },
      "border-image-outset": {
        syntax: "[ <length> | <number> ]{1,4}",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "0",
        appliesto: "allElementsExceptTableElementsWhenCollapse",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-image-outset"
      },
      "border-image-repeat": {
        syntax: "[ stretch | repeat | round | space ]{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "stretch",
        appliesto: "allElementsExceptTableElementsWhenCollapse",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-image-repeat"
      },
      "border-image-slice": {
        syntax: "<number-percentage>{1,4} && fill?",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "referToSizeOfBorderImage",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "100%",
        appliesto: "allElementsExceptTableElementsWhenCollapse",
        computed: "oneToFourPercentagesOrAbsoluteLengthsPlusFill",
        order: "percentagesOrLengthsFollowedByFill",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-image-slice"
      },
      "border-image-source": {
        syntax: "none | <image>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "none",
        appliesto: "allElementsExceptTableElementsWhenCollapse",
        computed: "noneOrImageWithAbsoluteURI",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-image-source"
      },
      "border-image-width": {
        syntax: "[ <length-percentage> | <number> | auto ]{1,4}",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "referToWidthOrHeightOfBorderImageArea",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "1",
        appliesto: "allElementsExceptTableElementsWhenCollapse",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-image-width"
      },
      "border-inline": {
        syntax: "<'border-top-width'> || <'border-top-style'> || <'color'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: [
          "border-top-width",
          "border-top-style",
          "border-top-color"
        ],
        appliesto: "allElements",
        computed: [
          "border-top-width",
          "border-top-style",
          "border-top-color"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline"
      },
      "border-inline-end": {
        syntax: "<'border-top-width'> || <'border-top-style'> || <'color'>",
        media: "visual",
        inherited: false,
        animationType: [
          "border-inline-end-color",
          "border-inline-end-style",
          "border-inline-end-width"
        ],
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: [
          "border-width",
          "border-style",
          "color"
        ],
        appliesto: "allElements",
        computed: [
          "border-width",
          "border-style",
          "border-inline-end-color"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-end"
      },
      "border-inline-color": {
        syntax: "<'border-top-color'>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-color"
      },
      "border-inline-style": {
        syntax: "<'border-top-style'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-style"
      },
      "border-inline-width": {
        syntax: "<'border-top-width'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-width"
      },
      "border-inline-end-color": {
        syntax: "<'border-top-color'>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-end-color"
      },
      "border-inline-end-style": {
        syntax: "<'border-top-style'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-end-style"
      },
      "border-inline-end-width": {
        syntax: "<'border-top-width'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-end-width"
      },
      "border-inline-start": {
        syntax: "<'border-top-width'> || <'border-top-style'> || <'color'>",
        media: "visual",
        inherited: false,
        animationType: [
          "border-inline-start-color",
          "border-inline-start-style",
          "border-inline-start-width"
        ],
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: [
          "border-width",
          "border-style",
          "color"
        ],
        appliesto: "allElements",
        computed: [
          "border-width",
          "border-style",
          "border-inline-start-color"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-start"
      },
      "border-inline-start-color": {
        syntax: "<'border-top-color'>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-start-color"
      },
      "border-inline-start-style": {
        syntax: "<'border-top-style'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-start-style"
      },
      "border-inline-start-width": {
        syntax: "<'border-top-width'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthZeroIfBorderStyleNoneOrHidden",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-inline-start-width"
      },
      "border-left": {
        syntax: "<line-width> || <line-style> || <color>",
        media: "visual",
        inherited: false,
        animationType: [
          "border-left-color",
          "border-left-style",
          "border-left-width"
        ],
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-left-width",
          "border-left-style",
          "border-left-color"
        ],
        appliesto: "allElements",
        computed: [
          "border-left-width",
          "border-left-style",
          "border-left-color"
        ],
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-left"
      },
      "border-left-color": {
        syntax: "<color>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-left-color"
      },
      "border-left-style": {
        syntax: "<line-style>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-left-style"
      },
      "border-left-width": {
        syntax: "<line-width>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthOr0IfBorderLeftStyleNoneOrHidden",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-left-width"
      },
      "border-radius": {
        syntax: "<length-percentage>{1,4} [ / <length-percentage>{1,4} ]?",
        media: "visual",
        inherited: false,
        animationType: [
          "border-top-left-radius",
          "border-top-right-radius",
          "border-bottom-right-radius",
          "border-bottom-left-radius"
        ],
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-top-left-radius",
          "border-top-right-radius",
          "border-bottom-right-radius",
          "border-bottom-left-radius"
        ],
        appliesto: "allElementsUAsNotRequiredWhenCollapse",
        computed: [
          "border-bottom-left-radius",
          "border-bottom-right-radius",
          "border-top-left-radius",
          "border-top-right-radius"
        ],
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-radius"
      },
      "border-right": {
        syntax: "<line-width> || <line-style> || <color>",
        media: "visual",
        inherited: false,
        animationType: [
          "border-right-color",
          "border-right-style",
          "border-right-width"
        ],
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-right-width",
          "border-right-style",
          "border-right-color"
        ],
        appliesto: "allElements",
        computed: [
          "border-right-width",
          "border-right-style",
          "border-right-color"
        ],
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-right"
      },
      "border-right-color": {
        syntax: "<color>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-right-color"
      },
      "border-right-style": {
        syntax: "<line-style>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-right-style"
      },
      "border-right-width": {
        syntax: "<line-width>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthOr0IfBorderRightStyleNoneOrHidden",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-right-width"
      },
      "border-spacing": {
        syntax: "<length> <length>?",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Table"
        ],
        initial: "0",
        appliesto: "tableElements",
        computed: "twoAbsoluteLengths",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-spacing"
      },
      "border-start-end-radius": {
        syntax: "<length-percentage>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElementsUAsNotRequiredWhenCollapse",
        computed: "twoAbsoluteLengthOrPercentages",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-start-end-radius"
      },
      "border-start-start-radius": {
        syntax: "<length-percentage>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElementsUAsNotRequiredWhenCollapse",
        computed: "twoAbsoluteLengthOrPercentages",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-start-start-radius"
      },
      "border-style": {
        syntax: "<line-style>{1,4}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-top-style",
          "border-right-style",
          "border-bottom-style",
          "border-left-style"
        ],
        appliesto: "allElements",
        computed: [
          "border-bottom-style",
          "border-left-style",
          "border-right-style",
          "border-top-style"
        ],
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-style"
      },
      "border-top": {
        syntax: "<line-width> || <line-style> || <color>",
        media: "visual",
        inherited: false,
        animationType: [
          "border-top-color",
          "border-top-style",
          "border-top-width"
        ],
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-top-width",
          "border-top-style",
          "border-top-color"
        ],
        appliesto: "allElements",
        computed: [
          "border-top-width",
          "border-top-style",
          "border-top-color"
        ],
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-top"
      },
      "border-top-color": {
        syntax: "<color>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-top-color"
      },
      "border-top-left-radius": {
        syntax: "<length-percentage>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "0",
        appliesto: "allElementsUAsNotRequiredWhenCollapse",
        computed: "twoAbsoluteLengthOrPercentages",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-top-left-radius"
      },
      "border-top-right-radius": {
        syntax: "<length-percentage>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfBorderBox",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "0",
        appliesto: "allElementsUAsNotRequiredWhenCollapse",
        computed: "twoAbsoluteLengthOrPercentages",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-top-right-radius"
      },
      "border-top-style": {
        syntax: "<line-style>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-top-style"
      },
      "border-top-width": {
        syntax: "<line-width>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLengthOr0IfBorderTopStyleNoneOrHidden",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-top-width"
      },
      "border-width": {
        syntax: "<line-width>{1,4}",
        media: "visual",
        inherited: false,
        animationType: [
          "border-bottom-width",
          "border-left-width",
          "border-right-width",
          "border-top-width"
        ],
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: [
          "border-top-width",
          "border-right-width",
          "border-bottom-width",
          "border-left-width"
        ],
        appliesto: "allElements",
        computed: [
          "border-bottom-width",
          "border-left-width",
          "border-right-width",
          "border-top-width"
        ],
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/border-width"
      },
      bottom: {
        syntax: "<length> | <percentage> | auto",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToContainingBlockHeight",
        groups: [
          "CSS Positioning"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/bottom"
      },
      "box-align": {
        syntax: "start | center | end | baseline | stretch",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions",
          "WebKit Extensions"
        ],
        initial: "stretch",
        appliesto: "elementsWithDisplayBoxOrInlineBox",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-align"
      },
      "box-decoration-break": {
        syntax: "slice | clone",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fragmentation"
        ],
        initial: "slice",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-decoration-break"
      },
      "box-direction": {
        syntax: "normal | reverse | inherit",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions",
          "WebKit Extensions"
        ],
        initial: "normal",
        appliesto: "elementsWithDisplayBoxOrInlineBox",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-direction"
      },
      "box-flex": {
        syntax: "<number>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions",
          "WebKit Extensions"
        ],
        initial: "0",
        appliesto: "directChildrenOfElementsWithDisplayMozBoxMozInlineBox",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-flex"
      },
      "box-flex-group": {
        syntax: "<integer>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions",
          "WebKit Extensions"
        ],
        initial: "1",
        appliesto: "inFlowChildrenOfBoxElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-flex-group"
      },
      "box-lines": {
        syntax: "single | multiple",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions",
          "WebKit Extensions"
        ],
        initial: "single",
        appliesto: "boxElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-lines"
      },
      "box-ordinal-group": {
        syntax: "<integer>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions",
          "WebKit Extensions"
        ],
        initial: "1",
        appliesto: "childrenOfBoxElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-ordinal-group"
      },
      "box-orient": {
        syntax: "horizontal | vertical | inline-axis | block-axis | inherit",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions",
          "WebKit Extensions"
        ],
        initial: "inlineAxisHorizontalInXUL",
        appliesto: "elementsWithDisplayBoxOrInlineBox",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-orient"
      },
      "box-pack": {
        syntax: "start | center | end | justify",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions",
          "WebKit Extensions"
        ],
        initial: "start",
        appliesto: "elementsWithDisplayMozBoxMozInlineBox",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-pack"
      },
      "box-shadow": {
        syntax: "none | <shadow>#",
        media: "visual",
        inherited: false,
        animationType: "shadowList",
        percentages: "no",
        groups: [
          "CSS Backgrounds and Borders"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "absoluteLengthsSpecifiedColorAsSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-shadow"
      },
      "box-sizing": {
        syntax: "content-box | border-box",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "content-box",
        appliesto: "allElementsAcceptingWidthOrHeight",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/box-sizing"
      },
      "break-after": {
        syntax: "auto | avoid | always | all | avoid-page | page | left | right | recto | verso | avoid-column | column | avoid-region | region",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fragmentation"
        ],
        initial: "auto",
        appliesto: "blockLevelElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/break-after"
      },
      "break-before": {
        syntax: "auto | avoid | always | all | avoid-page | page | left | right | recto | verso | avoid-column | column | avoid-region | region",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fragmentation"
        ],
        initial: "auto",
        appliesto: "blockLevelElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/break-before"
      },
      "break-inside": {
        syntax: "auto | avoid | avoid-page | avoid-column | avoid-region",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fragmentation"
        ],
        initial: "auto",
        appliesto: "blockLevelElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/break-inside"
      },
      "caption-side": {
        syntax: "top | bottom | block-start | block-end | inline-start | inline-end",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Table"
        ],
        initial: "top",
        appliesto: "tableCaptionElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/caption-side"
      },
      "caret-color": {
        syntax: "auto | <color>",
        media: "interactive",
        inherited: true,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asAutoOrColor",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/caret-color"
      },
      clear: {
        syntax: "none | left | right | both | inline-start | inline-end",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Positioning"
        ],
        initial: "none",
        appliesto: "blockLevelElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/clear"
      },
      clip: {
        syntax: "<shape> | auto",
        media: "visual",
        inherited: false,
        animationType: "rectangle",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "auto",
        appliesto: "absolutelyPositionedElements",
        computed: "autoOrRectangle",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/clip"
      },
      "clip-path": {
        syntax: "<clip-source> | [ <basic-shape> || <geometry-box> ] | none",
        media: "visual",
        inherited: false,
        animationType: "basicShapeOtherwiseNo",
        percentages: "referToReferenceBoxWhenSpecifiedOtherwiseBorderBox",
        groups: [
          "CSS Masking"
        ],
        initial: "none",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecifiedURLsAbsolute",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/clip-path"
      },
      color: {
        syntax: "<color>",
        media: "visual",
        inherited: true,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Color"
        ],
        initial: "variesFromBrowserToBrowser",
        appliesto: "allElements",
        computed: "translucentValuesRGBAOtherwiseRGB",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/color"
      },
      "color-adjust": {
        syntax: "economy | exact",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Color"
        ],
        initial: "economy",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/color-adjust"
      },
      "column-count": {
        syntax: "<integer> | auto",
        media: "visual",
        inherited: false,
        animationType: "integer",
        percentages: "no",
        groups: [
          "CSS Columns"
        ],
        initial: "auto",
        appliesto: "blockContainersExceptTableWrappers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-count"
      },
      "column-fill": {
        syntax: "auto | balance | balance-all",
        media: "visualInContinuousMediaNoEffectInOverflowColumns",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Columns"
        ],
        initial: "balance",
        appliesto: "multicolElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-fill"
      },
      "column-gap": {
        syntax: "normal | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Box Alignment"
        ],
        initial: "normal",
        appliesto: "multiColumnElementsFlexContainersGridContainers",
        computed: "asSpecifiedWithLengthsAbsoluteAndNormalComputingToZeroExceptMultiColumn",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-gap"
      },
      "column-rule": {
        syntax: "<'column-rule-width'> || <'column-rule-style'> || <'column-rule-color'>",
        media: "visual",
        inherited: false,
        animationType: [
          "column-rule-color",
          "column-rule-style",
          "column-rule-width"
        ],
        percentages: "no",
        groups: [
          "CSS Columns"
        ],
        initial: [
          "column-rule-width",
          "column-rule-style",
          "column-rule-color"
        ],
        appliesto: "multicolElements",
        computed: [
          "column-rule-color",
          "column-rule-style",
          "column-rule-width"
        ],
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-rule"
      },
      "column-rule-color": {
        syntax: "<color>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Columns"
        ],
        initial: "currentcolor",
        appliesto: "multicolElements",
        computed: "computedColor",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-rule-color"
      },
      "column-rule-style": {
        syntax: "<'border-style'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Columns"
        ],
        initial: "none",
        appliesto: "multicolElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-rule-style"
      },
      "column-rule-width": {
        syntax: "<'border-width'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Columns"
        ],
        initial: "medium",
        appliesto: "multicolElements",
        computed: "absoluteLength0IfColumnRuleStyleNoneOrHidden",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-rule-width"
      },
      "column-span": {
        syntax: "none | all",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Columns"
        ],
        initial: "none",
        appliesto: "inFlowBlockLevelElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-span"
      },
      "column-width": {
        syntax: "<length> | auto",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Columns"
        ],
        initial: "auto",
        appliesto: "blockContainersExceptTableWrappers",
        computed: "absoluteLengthZeroOrLarger",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-width"
      },
      columns: {
        syntax: "<'column-width'> || <'column-count'>",
        media: "visual",
        inherited: false,
        animationType: [
          "column-width",
          "column-count"
        ],
        percentages: "no",
        groups: [
          "CSS Columns"
        ],
        initial: [
          "column-width",
          "column-count"
        ],
        appliesto: "blockContainersExceptTableWrappers",
        computed: [
          "column-width",
          "column-count"
        ],
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/columns"
      },
      contain: {
        syntax: "none | strict | content | [ size || layout || style || paint ]",
        media: "all",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Containment"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/contain"
      },
      content: {
        syntax: "normal | none | [ <content-replacement> | <content-list> ] [/ <string> ]?",
        media: "all",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Generated Content"
        ],
        initial: "normal",
        appliesto: "beforeAndAfterPseudos",
        computed: "normalOnElementsForPseudosNoneAbsoluteURIStringOrAsSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/content"
      },
      "counter-increment": {
        syntax: "[ <custom-ident> <integer>? ]+ | none",
        media: "all",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Counter Styles"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/counter-increment"
      },
      "counter-reset": {
        syntax: "[ <custom-ident> <integer>? ]+ | none",
        media: "all",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Counter Styles"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/counter-reset"
      },
      "counter-set": {
        syntax: "[ <custom-ident> <integer>? ]+ | none",
        media: "all",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Counter Styles"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/counter-set"
      },
      cursor: {
        syntax: "[ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing ] ]",
        media: [
          "visual",
          "interactive"
        ],
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecifiedURLsAbsolute",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/cursor"
      },
      direction: {
        syntax: "ltr | rtl",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Writing Modes"
        ],
        initial: "ltr",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/direction"
      },
      display: {
        syntax: "[ <display-outside> || <display-inside> ] | <display-listitem> | <display-internal> | <display-box> | <display-legacy>",
        media: "all",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Display"
        ],
        initial: "inline",
        appliesto: "allElements",
        computed: "asSpecifiedExceptPositionedFloatingAndRootElementsKeywordMaybeDifferent",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/display"
      },
      "empty-cells": {
        syntax: "show | hide",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Table"
        ],
        initial: "show",
        appliesto: "tableCellElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/empty-cells"
      },
      filter: {
        syntax: "none | <filter-function-list>",
        media: "visual",
        inherited: false,
        animationType: "filterList",
        percentages: "no",
        groups: [
          "Filter Effects"
        ],
        initial: "none",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/filter"
      },
      flex: {
        syntax: "none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]",
        media: "visual",
        inherited: false,
        animationType: [
          "flex-grow",
          "flex-shrink",
          "flex-basis"
        ],
        percentages: "no",
        groups: [
          "CSS Flexible Box Layout"
        ],
        initial: [
          "flex-grow",
          "flex-shrink",
          "flex-basis"
        ],
        appliesto: "flexItemsAndInFlowPseudos",
        computed: [
          "flex-grow",
          "flex-shrink",
          "flex-basis"
        ],
        order: "orderOfAppearance",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/flex"
      },
      "flex-basis": {
        syntax: "content | <'width'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToFlexContainersInnerMainSize",
        groups: [
          "CSS Flexible Box Layout"
        ],
        initial: "auto",
        appliesto: "flexItemsAndInFlowPseudos",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "lengthOrPercentageBeforeKeywordIfBothPresent",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/flex-basis"
      },
      "flex-direction": {
        syntax: "row | row-reverse | column | column-reverse",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Flexible Box Layout"
        ],
        initial: "row",
        appliesto: "flexContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/flex-direction"
      },
      "flex-flow": {
        syntax: "<'flex-direction'> || <'flex-wrap'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Flexible Box Layout"
        ],
        initial: [
          "flex-direction",
          "flex-wrap"
        ],
        appliesto: "flexContainers",
        computed: [
          "flex-direction",
          "flex-wrap"
        ],
        order: "orderOfAppearance",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/flex-flow"
      },
      "flex-grow": {
        syntax: "<number>",
        media: "visual",
        inherited: false,
        animationType: "number",
        percentages: "no",
        groups: [
          "CSS Flexible Box Layout"
        ],
        initial: "0",
        appliesto: "flexItemsAndInFlowPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/flex-grow"
      },
      "flex-shrink": {
        syntax: "<number>",
        media: "visual",
        inherited: false,
        animationType: "number",
        percentages: "no",
        groups: [
          "CSS Flexible Box Layout"
        ],
        initial: "1",
        appliesto: "flexItemsAndInFlowPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/flex-shrink"
      },
      "flex-wrap": {
        syntax: "nowrap | wrap | wrap-reverse",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Flexible Box Layout"
        ],
        initial: "nowrap",
        appliesto: "flexContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/flex-wrap"
      },
      float: {
        syntax: "left | right | none | inline-start | inline-end",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Positioning"
        ],
        initial: "none",
        appliesto: "allElementsNoEffectIfDisplayNone",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/float"
      },
      font: {
        syntax: "[ [ <'font-style'> || <font-variant-css21> || <'font-weight'> || <'font-stretch'> ]? <'font-size'> [ / <'line-height'> ]? <'font-family'> ] | caption | icon | menu | message-box | small-caption | status-bar",
        media: "visual",
        inherited: true,
        animationType: [
          "font-style",
          "font-variant",
          "font-weight",
          "font-stretch",
          "font-size",
          "line-height",
          "font-family"
        ],
        percentages: [
          "font-size",
          "line-height"
        ],
        groups: [
          "CSS Fonts"
        ],
        initial: [
          "font-style",
          "font-variant",
          "font-weight",
          "font-stretch",
          "font-size",
          "line-height",
          "font-family"
        ],
        appliesto: "allElements",
        computed: [
          "font-style",
          "font-variant",
          "font-weight",
          "font-stretch",
          "font-size",
          "line-height",
          "font-family"
        ],
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font"
      },
      "font-family": {
        syntax: "[ <family-name> | <generic-family> ]#",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "dependsOnUserAgent",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-family"
      },
      "font-feature-settings": {
        syntax: "normal | <feature-tag-value>#",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-feature-settings"
      },
      "font-kerning": {
        syntax: "auto | normal | none",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-kerning"
      },
      "font-language-override": {
        syntax: "normal | <string>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-language-override"
      },
      "font-optical-sizing": {
        syntax: "auto | none",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-optical-sizing"
      },
      "font-variation-settings": {
        syntax: "normal | [ <string> <number> ]#",
        media: "visual",
        inherited: true,
        animationType: "transform",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-variation-settings"
      },
      "font-size": {
        syntax: "<absolute-size> | <relative-size> | <length-percentage>",
        media: "visual",
        inherited: true,
        animationType: "length",
        percentages: "referToParentElementsFontSize",
        groups: [
          "CSS Fonts"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-size"
      },
      "font-size-adjust": {
        syntax: "none | <number>",
        media: "visual",
        inherited: true,
        animationType: "number",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-size-adjust"
      },
      "font-smooth": {
        syntax: "auto | never | always | <absolute-size> | <length>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-smooth"
      },
      "font-stretch": {
        syntax: "<font-stretch-absolute>",
        media: "visual",
        inherited: true,
        animationType: "fontStretch",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-stretch"
      },
      "font-style": {
        syntax: "normal | italic | oblique <angle>?",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-style"
      },
      "font-synthesis": {
        syntax: "none | [ weight || style ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "weight style",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-synthesis"
      },
      "font-variant": {
        syntax: "normal | none | [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> || stylistic( <feature-value-name> ) || historical-forms || styleset( <feature-value-name># ) || character-variant( <feature-value-name># ) || swash( <feature-value-name> ) || ornaments( <feature-value-name> ) || annotation( <feature-value-name> ) || [ small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps ] || <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero || <east-asian-variant-values> || <east-asian-width-values> || ruby ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-variant"
      },
      "font-variant-alternates": {
        syntax: "normal | [ stylistic( <feature-value-name> ) || historical-forms || styleset( <feature-value-name># ) || character-variant( <feature-value-name># ) || swash( <feature-value-name> ) || ornaments( <feature-value-name> ) || annotation( <feature-value-name> ) ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-variant-alternates"
      },
      "font-variant-caps": {
        syntax: "normal | small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-variant-caps"
      },
      "font-variant-east-asian": {
        syntax: "normal | [ <east-asian-variant-values> || <east-asian-width-values> || ruby ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-variant-east-asian"
      },
      "font-variant-ligatures": {
        syntax: "normal | none | [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-variant-ligatures"
      },
      "font-variant-numeric": {
        syntax: "normal | [ <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-variant-numeric"
      },
      "font-variant-position": {
        syntax: "normal | sub | super",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-variant-position"
      },
      "font-weight": {
        syntax: "<font-weight-absolute> | bolder | lighter",
        media: "visual",
        inherited: true,
        animationType: "fontWeight",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "keywordOrNumericalValueBolderLighterTransformedToRealValue",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/font-weight"
      },
      gap: {
        syntax: "<'row-gap'> <'column-gap'>?",
        media: "visual",
        inherited: false,
        animationType: [
          "row-gap",
          "column-gap"
        ],
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: [
          "row-gap",
          "column-gap"
        ],
        appliesto: "multiColumnElementsFlexContainersGridContainers",
        computed: [
          "row-gap",
          "column-gap"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/gap"
      },
      grid: {
        syntax: "<'grid-template'> | <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>? | [ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: [
          "grid-template-rows",
          "grid-template-columns",
          "grid-auto-rows",
          "grid-auto-columns"
        ],
        groups: [
          "CSS Grid Layout"
        ],
        initial: [
          "grid-template-rows",
          "grid-template-columns",
          "grid-template-areas",
          "grid-auto-rows",
          "grid-auto-columns",
          "grid-auto-flow",
          "grid-column-gap",
          "grid-row-gap",
          "column-gap",
          "row-gap"
        ],
        appliesto: "gridContainers",
        computed: [
          "grid-template-rows",
          "grid-template-columns",
          "grid-template-areas",
          "grid-auto-rows",
          "grid-auto-columns",
          "grid-auto-flow",
          "grid-column-gap",
          "grid-row-gap",
          "column-gap",
          "row-gap"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid"
      },
      "grid-area": {
        syntax: "<grid-line> [ / <grid-line> ]{0,3}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: [
          "grid-row-start",
          "grid-column-start",
          "grid-row-end",
          "grid-column-end"
        ],
        appliesto: "gridItemsAndBoxesWithinGridContainer",
        computed: [
          "grid-row-start",
          "grid-column-start",
          "grid-row-end",
          "grid-column-end"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-area"
      },
      "grid-auto-columns": {
        syntax: "<track-size>+",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "auto",
        appliesto: "gridContainers",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-auto-columns"
      },
      "grid-auto-flow": {
        syntax: "[ row | column ] || dense",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "row",
        appliesto: "gridContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-auto-flow"
      },
      "grid-auto-rows": {
        syntax: "<track-size>+",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "auto",
        appliesto: "gridContainers",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-auto-rows"
      },
      "grid-column": {
        syntax: "<grid-line> [ / <grid-line> ]?",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: [
          "grid-column-start",
          "grid-column-end"
        ],
        appliesto: "gridItemsAndBoxesWithinGridContainer",
        computed: [
          "grid-column-start",
          "grid-column-end"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-column"
      },
      "grid-column-end": {
        syntax: "<grid-line>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "auto",
        appliesto: "gridItemsAndBoxesWithinGridContainer",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-column-end"
      },
      "grid-column-gap": {
        syntax: "<length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "0",
        appliesto: "gridContainers",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/column-gap"
      },
      "grid-column-start": {
        syntax: "<grid-line>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "auto",
        appliesto: "gridItemsAndBoxesWithinGridContainer",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-column-start"
      },
      "grid-gap": {
        syntax: "<'grid-row-gap'> <'grid-column-gap'>?",
        media: "visual",
        inherited: false,
        animationType: [
          "grid-row-gap",
          "grid-column-gap"
        ],
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: [
          "grid-row-gap",
          "grid-column-gap"
        ],
        appliesto: "gridContainers",
        computed: [
          "grid-row-gap",
          "grid-column-gap"
        ],
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/gap"
      },
      "grid-row": {
        syntax: "<grid-line> [ / <grid-line> ]?",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: [
          "grid-row-start",
          "grid-row-end"
        ],
        appliesto: "gridItemsAndBoxesWithinGridContainer",
        computed: [
          "grid-row-start",
          "grid-row-end"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-row"
      },
      "grid-row-end": {
        syntax: "<grid-line>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "auto",
        appliesto: "gridItemsAndBoxesWithinGridContainer",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-row-end"
      },
      "grid-row-gap": {
        syntax: "<length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "0",
        appliesto: "gridContainers",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/row-gap"
      },
      "grid-row-start": {
        syntax: "<grid-line>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "auto",
        appliesto: "gridItemsAndBoxesWithinGridContainer",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-row-start"
      },
      "grid-template": {
        syntax: "none | [ <'grid-template-rows'> / <'grid-template-columns'> ] | [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <explicit-track-list> ]?",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: [
          "grid-template-columns",
          "grid-template-rows"
        ],
        groups: [
          "CSS Grid Layout"
        ],
        initial: [
          "grid-template-columns",
          "grid-template-rows",
          "grid-template-areas"
        ],
        appliesto: "gridContainers",
        computed: [
          "grid-template-columns",
          "grid-template-rows",
          "grid-template-areas"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-template"
      },
      "grid-template-areas": {
        syntax: "none | <string>+",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "none",
        appliesto: "gridContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-template-areas"
      },
      "grid-template-columns": {
        syntax: "none | <track-list> | <auto-track-list> | subgrid <line-name-list>?",
        media: "visual",
        inherited: false,
        animationType: "simpleListOfLpcDifferenceLpc",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "none",
        appliesto: "gridContainers",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-template-columns"
      },
      "grid-template-rows": {
        syntax: "none | <track-list> | <auto-track-list> | subgrid <line-name-list>?",
        media: "visual",
        inherited: false,
        animationType: "simpleListOfLpcDifferenceLpc",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "none",
        appliesto: "gridContainers",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/grid-template-rows"
      },
      "hanging-punctuation": {
        syntax: "none | [ first || [ force-end | allow-end ] || last ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/hanging-punctuation"
      },
      height: {
        syntax: "auto | <length> | <percentage> | min-content | max-content | fit-content(<length-percentage>)",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "regardingHeightOfGeneratedBoxContainingBlockPercentagesRelativeToContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "auto",
        appliesto: "allElementsButNonReplacedAndTableColumns",
        computed: "percentageAutoOrAbsoluteLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/height"
      },
      hyphens: {
        syntax: "none | manual | auto",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "manual",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/hyphens"
      },
      "image-orientation": {
        syntax: "from-image | <angle> | [ <angle>? flip ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Images"
        ],
        initial: "from-image",
        appliesto: "allElements",
        computed: "angleRoundedToNextQuarter",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/image-orientation"
      },
      "image-rendering": {
        syntax: "auto | crisp-edges | pixelated",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Images"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/image-rendering"
      },
      "image-resolution": {
        syntax: "[ from-image || <resolution> ] && snap?",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Images"
        ],
        initial: "1dppx",
        appliesto: "allElements",
        computed: "asSpecifiedWithExceptionOfResolution",
        order: "uniqueOrder",
        status: "experimental"
      },
      "ime-mode": {
        syntax: "auto | normal | active | inactive | disabled",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "auto",
        appliesto: "textFields",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/ime-mode"
      },
      "initial-letter": {
        syntax: "normal | [ <number> <integer>? ]",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Inline"
        ],
        initial: "normal",
        appliesto: "firstLetterPseudoElementsAndInlineLevelFirstChildren",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/initial-letter"
      },
      "initial-letter-align": {
        syntax: "[ auto | alphabetic | hanging | ideographic ]",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Inline"
        ],
        initial: "auto",
        appliesto: "firstLetterPseudoElementsAndInlineLevelFirstChildren",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/initial-letter-align"
      },
      "inline-size": {
        syntax: "<'width'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "inlineSizeOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "auto",
        appliesto: "sameAsWidthAndHeight",
        computed: "sameAsWidthAndHeight",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/inline-size"
      },
      inset: {
        syntax: "<'top'>{1,4}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "logicalHeightOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "sameAsBoxOffsets",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/inset"
      },
      "inset-block": {
        syntax: "<'top'>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "logicalHeightOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "sameAsBoxOffsets",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/inset-block"
      },
      "inset-block-end": {
        syntax: "<'top'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "logicalHeightOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "sameAsBoxOffsets",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/inset-block-end"
      },
      "inset-block-start": {
        syntax: "<'top'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "logicalHeightOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "sameAsBoxOffsets",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/inset-block-start"
      },
      "inset-inline": {
        syntax: "<'top'>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "sameAsBoxOffsets",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/inset-inline"
      },
      "inset-inline-end": {
        syntax: "<'top'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "sameAsBoxOffsets",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/inset-inline-end"
      },
      "inset-inline-start": {
        syntax: "<'top'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "sameAsBoxOffsets",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/inset-inline-start"
      },
      isolation: {
        syntax: "auto | isolate",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Compositing and Blending"
        ],
        initial: "auto",
        appliesto: "allElementsSVGContainerGraphicsAndGraphicsReferencingElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/isolation"
      },
      "justify-content": {
        syntax: "normal | <content-distribution> | <overflow-position>? [ <content-position> | left | right ]",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: "normal",
        appliesto: "flexContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/justify-content"
      },
      "justify-items": {
        syntax: "normal | stretch | <baseline-position> | <overflow-position>? [ <self-position> | left | right ] | legacy | legacy && [ left | right | center ]",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: "legacy",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/justify-items"
      },
      "justify-self": {
        syntax: "auto | normal | stretch | <baseline-position> | <overflow-position>? [ <self-position> | left | right ]",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: "auto",
        appliesto: "blockLevelBoxesAndAbsolutelyPositionedBoxesAndGridItems",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/justify-self"
      },
      "justify-tracks": {
        syntax: "[ normal | <content-distribution> | <overflow-position>? [ <content-position> | left | right ] ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "normal",
        appliesto: "gridContainersWithMasonryLayoutInTheirInlineAxis",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/justify-tracks"
      },
      left: {
        syntax: "<length> | <percentage> | auto",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Positioning"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/left"
      },
      "letter-spacing": {
        syntax: "normal | <length>",
        media: "visual",
        inherited: true,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "optimumValueOfAbsoluteLengthOrNormal",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/letter-spacing"
      },
      "line-break": {
        syntax: "auto | loose | normal | strict | anywhere",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/line-break"
      },
      "line-clamp": {
        syntax: "none | <integer>",
        media: "visual",
        inherited: false,
        animationType: "integer",
        percentages: "no",
        groups: [
          "CSS Overflow"
        ],
        initial: "none",
        appliesto: "blockContainersExceptMultiColumnContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "experimental"
      },
      "line-height": {
        syntax: "normal | <number> | <length> | <percentage>",
        media: "visual",
        inherited: true,
        animationType: "numberOrLength",
        percentages: "referToElementFontSize",
        groups: [
          "CSS Fonts"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "absoluteLengthOrAsSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/line-height"
      },
      "line-height-step": {
        syntax: "<length>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fonts"
        ],
        initial: "0",
        appliesto: "blockContainers",
        computed: "absoluteLength",
        order: "perGrammar",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/line-height-step"
      },
      "list-style": {
        syntax: "<'list-style-type'> || <'list-style-position'> || <'list-style-image'>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Lists and Counters"
        ],
        initial: [
          "list-style-type",
          "list-style-position",
          "list-style-image"
        ],
        appliesto: "listItems",
        computed: [
          "list-style-image",
          "list-style-position",
          "list-style-type"
        ],
        order: "orderOfAppearance",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/list-style"
      },
      "list-style-image": {
        syntax: "<url> | none",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Lists and Counters"
        ],
        initial: "none",
        appliesto: "listItems",
        computed: "noneOrImageWithAbsoluteURI",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/list-style-image"
      },
      "list-style-position": {
        syntax: "inside | outside",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Lists and Counters"
        ],
        initial: "outside",
        appliesto: "listItems",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/list-style-position"
      },
      "list-style-type": {
        syntax: "<counter-style> | <string> | none",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Lists and Counters"
        ],
        initial: "disc",
        appliesto: "listItems",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/list-style-type"
      },
      margin: {
        syntax: "[ <length> | <percentage> | auto ]{1,4}",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: [
          "margin-bottom",
          "margin-left",
          "margin-right",
          "margin-top"
        ],
        appliesto: "allElementsExceptTableDisplayTypes",
        computed: [
          "margin-bottom",
          "margin-left",
          "margin-right",
          "margin-top"
        ],
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin"
      },
      "margin-block": {
        syntax: "<'margin-left'>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "dependsOnLayoutModel",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsMargin",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-block"
      },
      "margin-block-end": {
        syntax: "<'margin-left'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "dependsOnLayoutModel",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsMargin",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-block-end"
      },
      "margin-block-start": {
        syntax: "<'margin-left'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "dependsOnLayoutModel",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsMargin",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-block-start"
      },
      "margin-bottom": {
        syntax: "<length> | <percentage> | auto",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "0",
        appliesto: "allElementsExceptTableDisplayTypes",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-bottom"
      },
      "margin-inline": {
        syntax: "<'margin-left'>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "dependsOnLayoutModel",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsMargin",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-inline"
      },
      "margin-inline-end": {
        syntax: "<'margin-left'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "dependsOnLayoutModel",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsMargin",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-inline-end"
      },
      "margin-inline-start": {
        syntax: "<'margin-left'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "dependsOnLayoutModel",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsMargin",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-inline-start"
      },
      "margin-left": {
        syntax: "<length> | <percentage> | auto",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "0",
        appliesto: "allElementsExceptTableDisplayTypes",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-left"
      },
      "margin-right": {
        syntax: "<length> | <percentage> | auto",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "0",
        appliesto: "allElementsExceptTableDisplayTypes",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-right"
      },
      "margin-top": {
        syntax: "<length> | <percentage> | auto",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "0",
        appliesto: "allElementsExceptTableDisplayTypes",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-top"
      },
      "margin-trim": {
        syntax: "none | in-flow | all",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Model"
        ],
        initial: "none",
        appliesto: "blockContainersAndMultiColumnContainers",
        computed: "asSpecified",
        order: "perGrammar",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/margin-trim"
      },
      mask: {
        syntax: "<mask-layer>#",
        media: "visual",
        inherited: false,
        animationType: [
          "mask-image",
          "mask-mode",
          "mask-repeat",
          "mask-position",
          "mask-clip",
          "mask-origin",
          "mask-size",
          "mask-composite"
        ],
        percentages: [
          "mask-position"
        ],
        groups: [
          "CSS Masking"
        ],
        initial: [
          "mask-image",
          "mask-mode",
          "mask-repeat",
          "mask-position",
          "mask-clip",
          "mask-origin",
          "mask-size",
          "mask-composite"
        ],
        appliesto: "allElementsSVGContainerElements",
        computed: [
          "mask-image",
          "mask-mode",
          "mask-repeat",
          "mask-position",
          "mask-clip",
          "mask-origin",
          "mask-size",
          "mask-composite"
        ],
        order: "perGrammar",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask"
      },
      "mask-border": {
        syntax: "<'mask-border-source'> || <'mask-border-slice'> [ / <'mask-border-width'>? [ / <'mask-border-outset'> ]? ]? || <'mask-border-repeat'> || <'mask-border-mode'>",
        media: "visual",
        inherited: false,
        animationType: [
          "mask-border-mode",
          "mask-border-outset",
          "mask-border-repeat",
          "mask-border-slice",
          "mask-border-source",
          "mask-border-width"
        ],
        percentages: [
          "mask-border-slice",
          "mask-border-width"
        ],
        groups: [
          "CSS Masking"
        ],
        initial: [
          "mask-border-mode",
          "mask-border-outset",
          "mask-border-repeat",
          "mask-border-slice",
          "mask-border-source",
          "mask-border-width"
        ],
        appliesto: "allElementsSVGContainerElements",
        computed: [
          "mask-border-mode",
          "mask-border-outset",
          "mask-border-repeat",
          "mask-border-slice",
          "mask-border-source",
          "mask-border-width"
        ],
        order: "perGrammar",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-border"
      },
      "mask-border-mode": {
        syntax: "luminance | alpha",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "alpha",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-border-mode"
      },
      "mask-border-outset": {
        syntax: "[ <length> | <number> ]{1,4}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "0",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-border-outset"
      },
      "mask-border-repeat": {
        syntax: "[ stretch | repeat | round | space ]{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "stretch",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-border-repeat"
      },
      "mask-border-slice": {
        syntax: "<number-percentage>{1,4} fill?",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "referToSizeOfMaskBorderImage",
        groups: [
          "CSS Masking"
        ],
        initial: "0",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-border-slice"
      },
      "mask-border-source": {
        syntax: "none | <image>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "none",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecifiedURLsAbsolute",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-border-source"
      },
      "mask-border-width": {
        syntax: "[ <length-percentage> | <number> | auto ]{1,4}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "relativeToMaskBorderImageArea",
        groups: [
          "CSS Masking"
        ],
        initial: "auto",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-border-width"
      },
      "mask-clip": {
        syntax: "[ <geometry-box> | no-clip ]#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "border-box",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-clip"
      },
      "mask-composite": {
        syntax: "<compositing-operator>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "add",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-composite"
      },
      "mask-image": {
        syntax: "<mask-reference>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "none",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecifiedURLsAbsolute",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-image"
      },
      "mask-mode": {
        syntax: "<masking-mode>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "match-source",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-mode"
      },
      "mask-origin": {
        syntax: "<geometry-box>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "border-box",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-origin"
      },
      "mask-position": {
        syntax: "<position>#",
        media: "visual",
        inherited: false,
        animationType: "repeatableListOfSimpleListOfLpc",
        percentages: "referToSizeOfMaskPaintingArea",
        groups: [
          "CSS Masking"
        ],
        initial: "center",
        appliesto: "allElementsSVGContainerElements",
        computed: "consistsOfTwoKeywordsForOriginAndOffsets",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-position"
      },
      "mask-repeat": {
        syntax: "<repeat-style>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "no-repeat",
        appliesto: "allElementsSVGContainerElements",
        computed: "consistsOfTwoDimensionKeywords",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-repeat"
      },
      "mask-size": {
        syntax: "<bg-size>#",
        media: "visual",
        inherited: false,
        animationType: "repeatableListOfSimpleListOfLpc",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "auto",
        appliesto: "allElementsSVGContainerElements",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-size"
      },
      "mask-type": {
        syntax: "luminance | alpha",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Masking"
        ],
        initial: "luminance",
        appliesto: "maskElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mask-type"
      },
      "masonry-auto-flow": {
        syntax: "[ pack | next ] || [ definite-first | ordered ]",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Grid Layout"
        ],
        initial: "pack",
        appliesto: "gridContainersWithMasonryLayout",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/masonry-auto-flow"
      },
      "math-style": {
        syntax: "normal | compact",
        media: "visual",
        inherited: true,
        animationType: "notAnimatable",
        percentages: "no",
        groups: [
          "MathML"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/math-style"
      },
      "max-block-size": {
        syntax: "<'max-width'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "blockSizeOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsWidthAndHeight",
        computed: "sameAsMaxWidthAndMaxHeight",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/max-block-size"
      },
      "max-height": {
        syntax: "none | <length-percentage> | min-content | max-content | fit-content(<length-percentage>)",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "regardingHeightOfGeneratedBoxContainingBlockPercentagesNone",
        groups: [
          "CSS Box Model"
        ],
        initial: "none",
        appliesto: "allElementsButNonReplacedAndTableColumns",
        computed: "percentageAsSpecifiedAbsoluteLengthOrNone",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/max-height"
      },
      "max-inline-size": {
        syntax: "<'max-width'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "inlineSizeOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsWidthAndHeight",
        computed: "sameAsMaxWidthAndMaxHeight",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/max-inline-size"
      },
      "max-lines": {
        syntax: "none | <integer>",
        media: "visual",
        inherited: false,
        animationType: "integer",
        percentages: "no",
        groups: [
          "CSS Overflow"
        ],
        initial: "none",
        appliesto: "blockContainersExceptMultiColumnContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "experimental"
      },
      "max-width": {
        syntax: "none | <length-percentage> | min-content | max-content | fit-content(<length-percentage>)",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "none",
        appliesto: "allElementsButNonReplacedAndTableRows",
        computed: "percentageAsSpecifiedAbsoluteLengthOrNone",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/max-width"
      },
      "min-block-size": {
        syntax: "<'min-width'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "blockSizeOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsWidthAndHeight",
        computed: "sameAsMinWidthAndMinHeight",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/min-block-size"
      },
      "min-height": {
        syntax: "auto | <length> | <percentage> | min-content | max-content | fit-content(<length-percentage>)",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "regardingHeightOfGeneratedBoxContainingBlockPercentages0",
        groups: [
          "CSS Box Model"
        ],
        initial: "auto",
        appliesto: "allElementsButNonReplacedAndTableColumns",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/min-height"
      },
      "min-inline-size": {
        syntax: "<'min-width'>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "inlineSizeOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "sameAsWidthAndHeight",
        computed: "sameAsMinWidthAndMinHeight",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/min-inline-size"
      },
      "min-width": {
        syntax: "auto | <length> | <percentage> | min-content | max-content | fit-content(<length-percentage>)",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "auto",
        appliesto: "allElementsButNonReplacedAndTableRows",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/min-width"
      },
      "mix-blend-mode": {
        syntax: "<blend-mode>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Compositing and Blending"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/mix-blend-mode"
      },
      "object-fit": {
        syntax: "fill | contain | cover | none | scale-down",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Images"
        ],
        initial: "fill",
        appliesto: "replacedElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/object-fit"
      },
      "object-position": {
        syntax: "<position>",
        media: "visual",
        inherited: true,
        animationType: "repeatableListOfSimpleListOfLpc",
        percentages: "referToWidthAndHeightOfElement",
        groups: [
          "CSS Images"
        ],
        initial: "50% 50%",
        appliesto: "replacedElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/object-position"
      },
      offset: {
        syntax: "[ <'offset-position'>? [ <'offset-path'> [ <'offset-distance'> || <'offset-rotate'> ]? ]? ]! [ / <'offset-anchor'> ]?",
        media: "visual",
        inherited: false,
        animationType: [
          "offset-position",
          "offset-path",
          "offset-distance",
          "offset-anchor",
          "offset-rotate"
        ],
        percentages: [
          "offset-position",
          "offset-distance",
          "offset-anchor"
        ],
        groups: [
          "CSS Motion Path"
        ],
        initial: [
          "offset-position",
          "offset-path",
          "offset-distance",
          "offset-anchor",
          "offset-rotate"
        ],
        appliesto: "transformableElements",
        computed: [
          "offset-position",
          "offset-path",
          "offset-distance",
          "offset-anchor",
          "offset-rotate"
        ],
        order: "perGrammar",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/offset"
      },
      "offset-anchor": {
        syntax: "auto | <position>",
        media: "visual",
        inherited: false,
        animationType: "position",
        percentages: "relativeToWidthAndHeight",
        groups: [
          "CSS Motion Path"
        ],
        initial: "auto",
        appliesto: "transformableElements",
        computed: "forLengthAbsoluteValueOtherwisePercentage",
        order: "perGrammar",
        status: "standard"
      },
      "offset-distance": {
        syntax: "<length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToTotalPathLength",
        groups: [
          "CSS Motion Path"
        ],
        initial: "0",
        appliesto: "transformableElements",
        computed: "forLengthAbsoluteValueOtherwisePercentage",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/offset-distance"
      },
      "offset-path": {
        syntax: "none | ray( [ <angle> && <size> && contain? ] ) | <path()> | <url> | [ <basic-shape> || <geometry-box> ]",
        media: "visual",
        inherited: false,
        animationType: "angleOrBasicShapeOrPath",
        percentages: "no",
        groups: [
          "CSS Motion Path"
        ],
        initial: "none",
        appliesto: "transformableElements",
        computed: "asSpecified",
        order: "perGrammar",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/offset-path"
      },
      "offset-position": {
        syntax: "auto | <position>",
        media: "visual",
        inherited: false,
        animationType: "position",
        percentages: "referToSizeOfContainingBlock",
        groups: [
          "CSS Motion Path"
        ],
        initial: "auto",
        appliesto: "transformableElements",
        computed: "forLengthAbsoluteValueOtherwisePercentage",
        order: "perGrammar",
        status: "experimental"
      },
      "offset-rotate": {
        syntax: "[ auto | reverse ] || <angle>",
        media: "visual",
        inherited: false,
        animationType: "angleOrBasicShapeOrPath",
        percentages: "no",
        groups: [
          "CSS Motion Path"
        ],
        initial: "auto",
        appliesto: "transformableElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/offset-rotate"
      },
      opacity: {
        syntax: "<alpha-value>",
        media: "visual",
        inherited: false,
        animationType: "number",
        percentages: "no",
        groups: [
          "CSS Color"
        ],
        initial: "1.0",
        appliesto: "allElements",
        computed: "specifiedValueClipped0To1",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/opacity"
      },
      order: {
        syntax: "<integer>",
        media: "visual",
        inherited: false,
        animationType: "integer",
        percentages: "no",
        groups: [
          "CSS Flexible Box Layout"
        ],
        initial: "0",
        appliesto: "flexItemsGridItemsAbsolutelyPositionedContainerChildren",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/order"
      },
      orphans: {
        syntax: "<integer>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fragmentation"
        ],
        initial: "2",
        appliesto: "blockContainerElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/orphans"
      },
      outline: {
        syntax: "[ <'outline-color'> || <'outline-style'> || <'outline-width'> ]",
        media: [
          "visual",
          "interactive"
        ],
        inherited: false,
        animationType: [
          "outline-color",
          "outline-width",
          "outline-style"
        ],
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: [
          "outline-color",
          "outline-style",
          "outline-width"
        ],
        appliesto: "allElements",
        computed: [
          "outline-color",
          "outline-width",
          "outline-style"
        ],
        order: "orderOfAppearance",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/outline"
      },
      "outline-color": {
        syntax: "<color> | invert",
        media: [
          "visual",
          "interactive"
        ],
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "invertOrCurrentColor",
        appliesto: "allElements",
        computed: "invertForTranslucentColorRGBAOtherwiseRGB",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/outline-color"
      },
      "outline-offset": {
        syntax: "<length>",
        media: [
          "visual",
          "interactive"
        ],
        inherited: false,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/outline-offset"
      },
      "outline-style": {
        syntax: "auto | <'border-style'>",
        media: [
          "visual",
          "interactive"
        ],
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/outline-style"
      },
      "outline-width": {
        syntax: "<line-width>",
        media: [
          "visual",
          "interactive"
        ],
        inherited: false,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "medium",
        appliesto: "allElements",
        computed: "absoluteLength0ForNone",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/outline-width"
      },
      overflow: {
        syntax: "[ visible | hidden | clip | scroll | auto ]{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Overflow"
        ],
        initial: "visible",
        appliesto: "blockContainersFlexContainersGridContainers",
        computed: [
          "overflow-x",
          "overflow-y"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overflow"
      },
      "overflow-anchor": {
        syntax: "auto | none",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Scroll Anchoring"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard"
      },
      "overflow-block": {
        syntax: "visible | hidden | clip | scroll | auto",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Overflow"
        ],
        initial: "auto",
        appliesto: "blockContainersFlexContainersGridContainers",
        computed: "asSpecifiedButVisibleOrClipReplacedToAutoOrHiddenIfOtherValueDifferent",
        order: "perGrammar",
        status: "standard"
      },
      "overflow-clip-box": {
        syntax: "padding-box | content-box",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Mozilla Extensions"
        ],
        initial: "padding-box",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Mozilla/CSS/overflow-clip-box"
      },
      "overflow-inline": {
        syntax: "visible | hidden | clip | scroll | auto",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Overflow"
        ],
        initial: "auto",
        appliesto: "blockContainersFlexContainersGridContainers",
        computed: "asSpecifiedButVisibleOrClipReplacedToAutoOrHiddenIfOtherValueDifferent",
        order: "perGrammar",
        status: "standard"
      },
      "overflow-wrap": {
        syntax: "normal | break-word | anywhere",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "normal",
        appliesto: "nonReplacedInlineElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overflow-wrap"
      },
      "overflow-x": {
        syntax: "visible | hidden | clip | scroll | auto",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Overflow"
        ],
        initial: "visible",
        appliesto: "blockContainersFlexContainersGridContainers",
        computed: "asSpecifiedButVisibleOrClipReplacedToAutoOrHiddenIfOtherValueDifferent",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overflow-x"
      },
      "overflow-y": {
        syntax: "visible | hidden | clip | scroll | auto",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Overflow"
        ],
        initial: "visible",
        appliesto: "blockContainersFlexContainersGridContainers",
        computed: "asSpecifiedButVisibleOrClipReplacedToAutoOrHiddenIfOtherValueDifferent",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overflow-y"
      },
      "overscroll-behavior": {
        syntax: "[ contain | none | auto ]{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Model"
        ],
        initial: "auto",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overscroll-behavior"
      },
      "overscroll-behavior-block": {
        syntax: "contain | none | auto",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Model"
        ],
        initial: "auto",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overscroll-behavior-block"
      },
      "overscroll-behavior-inline": {
        syntax: "contain | none | auto",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Model"
        ],
        initial: "auto",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overscroll-behavior-inline"
      },
      "overscroll-behavior-x": {
        syntax: "contain | none | auto",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Model"
        ],
        initial: "auto",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overscroll-behavior-x"
      },
      "overscroll-behavior-y": {
        syntax: "contain | none | auto",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Model"
        ],
        initial: "auto",
        appliesto: "nonReplacedBlockAndInlineBlockElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overscroll-behavior-y"
      },
      padding: {
        syntax: "[ <length> | <percentage> ]{1,4}",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: [
          "padding-bottom",
          "padding-left",
          "padding-right",
          "padding-top"
        ],
        appliesto: "allElementsExceptInternalTableDisplayTypes",
        computed: [
          "padding-bottom",
          "padding-left",
          "padding-right",
          "padding-top"
        ],
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding"
      },
      "padding-block": {
        syntax: "<'padding-left'>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-block"
      },
      "padding-block-end": {
        syntax: "<'padding-left'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-block-end"
      },
      "padding-block-start": {
        syntax: "<'padding-left'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-block-start"
      },
      "padding-bottom": {
        syntax: "<length> | <percentage>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "0",
        appliesto: "allElementsExceptInternalTableDisplayTypes",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-bottom"
      },
      "padding-inline": {
        syntax: "<'padding-left'>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-inline"
      },
      "padding-inline-end": {
        syntax: "<'padding-left'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-inline-end"
      },
      "padding-inline-start": {
        syntax: "<'padding-left'>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "logicalWidthOfContainingBlock",
        groups: [
          "CSS Logical Properties"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-inline-start"
      },
      "padding-left": {
        syntax: "<length> | <percentage>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "0",
        appliesto: "allElementsExceptInternalTableDisplayTypes",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-left"
      },
      "padding-right": {
        syntax: "<length> | <percentage>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "0",
        appliesto: "allElementsExceptInternalTableDisplayTypes",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-right"
      },
      "padding-top": {
        syntax: "<length> | <percentage>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "0",
        appliesto: "allElementsExceptInternalTableDisplayTypes",
        computed: "percentageAsSpecifiedOrAbsoluteLength",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/padding-top"
      },
      "page-break-after": {
        syntax: "auto | always | avoid | left | right | recto | verso",
        media: [
          "visual",
          "paged"
        ],
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Pages"
        ],
        initial: "auto",
        appliesto: "blockElementsInNormalFlow",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/page-break-after"
      },
      "page-break-before": {
        syntax: "auto | always | avoid | left | right | recto | verso",
        media: [
          "visual",
          "paged"
        ],
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Pages"
        ],
        initial: "auto",
        appliesto: "blockElementsInNormalFlow",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/page-break-before"
      },
      "page-break-inside": {
        syntax: "auto | avoid",
        media: [
          "visual",
          "paged"
        ],
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Pages"
        ],
        initial: "auto",
        appliesto: "blockElementsInNormalFlow",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/page-break-inside"
      },
      "paint-order": {
        syntax: "normal | [ fill || stroke || markers ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "normal",
        appliesto: "textElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/paint-order"
      },
      perspective: {
        syntax: "none | <length>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Transforms"
        ],
        initial: "none",
        appliesto: "transformableElements",
        computed: "absoluteLengthOrNone",
        order: "uniqueOrder",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/perspective"
      },
      "perspective-origin": {
        syntax: "<position>",
        media: "visual",
        inherited: false,
        animationType: "simpleListOfLpc",
        percentages: "referToSizeOfBoundingBox",
        groups: [
          "CSS Transforms"
        ],
        initial: "50% 50%",
        appliesto: "transformableElements",
        computed: "forLengthAbsoluteValueOtherwisePercentage",
        order: "oneOrTwoValuesLengthAbsoluteKeywordsPercentages",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/perspective-origin"
      },
      "place-content": {
        syntax: "<'align-content'> <'justify-content'>?",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: "normal",
        appliesto: "multilineFlexContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/place-content"
      },
      "place-items": {
        syntax: "<'align-items'> <'justify-items'>?",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: [
          "align-items",
          "justify-items"
        ],
        appliesto: "allElements",
        computed: [
          "align-items",
          "justify-items"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/place-items"
      },
      "place-self": {
        syntax: "<'align-self'> <'justify-self'>?",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Box Alignment"
        ],
        initial: [
          "align-self",
          "justify-self"
        ],
        appliesto: "blockLevelBoxesAndAbsolutelyPositionedBoxesAndGridItems",
        computed: [
          "align-self",
          "justify-self"
        ],
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/place-self"
      },
      "pointer-events": {
        syntax: "auto | none | visiblePainted | visibleFill | visibleStroke | visible | painted | fill | stroke | all | inherit",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Pointer Events"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/pointer-events"
      },
      position: {
        syntax: "static | relative | absolute | sticky | fixed",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Positioning"
        ],
        initial: "static",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/position"
      },
      quotes: {
        syntax: "none | auto | [ <string> <string> ]+",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Generated Content"
        ],
        initial: "dependsOnUserAgent",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/quotes"
      },
      resize: {
        syntax: "none | both | horizontal | vertical | block | inline",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "none",
        appliesto: "elementsWithOverflowNotVisibleAndReplacedElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/resize"
      },
      right: {
        syntax: "<length> | <percentage> | auto",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Positioning"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/right"
      },
      rotate: {
        syntax: "none | <angle> | [ x | y | z | <number>{3} ] && <angle>",
        media: "visual",
        inherited: false,
        animationType: "transform",
        percentages: "no",
        groups: [
          "CSS Transforms"
        ],
        initial: "none",
        appliesto: "transformableElements",
        computed: "asSpecified",
        order: "perGrammar",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/rotate"
      },
      "row-gap": {
        syntax: "normal | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToDimensionOfContentArea",
        groups: [
          "CSS Box Alignment"
        ],
        initial: "normal",
        appliesto: "multiColumnElementsFlexContainersGridContainers",
        computed: "asSpecifiedWithLengthsAbsoluteAndNormalComputingToZeroExceptMultiColumn",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/row-gap"
      },
      "ruby-align": {
        syntax: "start | center | space-between | space-around",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Ruby"
        ],
        initial: "space-around",
        appliesto: "rubyBasesAnnotationsBaseAnnotationContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/ruby-align"
      },
      "ruby-merge": {
        syntax: "separate | collapse | auto",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Ruby"
        ],
        initial: "separate",
        appliesto: "rubyAnnotationsContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "experimental"
      },
      "ruby-position": {
        syntax: "over | under | inter-character",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Ruby"
        ],
        initial: "over",
        appliesto: "rubyAnnotationsContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/ruby-position"
      },
      scale: {
        syntax: "none | <number>{1,3}",
        media: "visual",
        inherited: false,
        animationType: "transform",
        percentages: "no",
        groups: [
          "CSS Transforms"
        ],
        initial: "none",
        appliesto: "transformableElements",
        computed: "asSpecified",
        order: "perGrammar",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scale"
      },
      "scrollbar-color": {
        syntax: "auto | dark | light | <color>{2}",
        media: "visual",
        inherited: true,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Scrollbars"
        ],
        initial: "auto",
        appliesto: "scrollingBoxes",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scrollbar-color"
      },
      "scrollbar-gutter": {
        syntax: "auto | [ stable | always ] && both? && force?",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Overflow"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scrollbar-gutter"
      },
      "scrollbar-width": {
        syntax: "auto | thin | none",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Scrollbars"
        ],
        initial: "auto",
        appliesto: "scrollingBoxes",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scrollbar-width"
      },
      "scroll-behavior": {
        syntax: "auto | smooth",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSSOM View"
        ],
        initial: "auto",
        appliesto: "scrollingBoxes",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-behavior"
      },
      "scroll-margin": {
        syntax: "<length>{1,4}",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin"
      },
      "scroll-margin-block": {
        syntax: "<length>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-block"
      },
      "scroll-margin-block-start": {
        syntax: "<length>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-block-start"
      },
      "scroll-margin-block-end": {
        syntax: "<length>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-block-end"
      },
      "scroll-margin-bottom": {
        syntax: "<length>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-bottom"
      },
      "scroll-margin-inline": {
        syntax: "<length>{1,2}",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-inline"
      },
      "scroll-margin-inline-start": {
        syntax: "<length>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-inline-start"
      },
      "scroll-margin-inline-end": {
        syntax: "<length>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-inline-end"
      },
      "scroll-margin-left": {
        syntax: "<length>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-left"
      },
      "scroll-margin-right": {
        syntax: "<length>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-right"
      },
      "scroll-margin-top": {
        syntax: "<length>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-margin-top"
      },
      "scroll-padding": {
        syntax: "[ auto | <length-percentage> ]{1,4}",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding"
      },
      "scroll-padding-block": {
        syntax: "[ auto | <length-percentage> ]{1,2}",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-block"
      },
      "scroll-padding-block-start": {
        syntax: "auto | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-block-start"
      },
      "scroll-padding-block-end": {
        syntax: "auto | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-block-end"
      },
      "scroll-padding-bottom": {
        syntax: "auto | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-bottom"
      },
      "scroll-padding-inline": {
        syntax: "[ auto | <length-percentage> ]{1,2}",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-inline"
      },
      "scroll-padding-inline-start": {
        syntax: "auto | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-inline-start"
      },
      "scroll-padding-inline-end": {
        syntax: "auto | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-inline-end"
      },
      "scroll-padding-left": {
        syntax: "auto | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-left"
      },
      "scroll-padding-right": {
        syntax: "auto | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-right"
      },
      "scroll-padding-top": {
        syntax: "auto | <length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "relativeToTheScrollContainersScrollport",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "auto",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-padding-top"
      },
      "scroll-snap-align": {
        syntax: "[ none | start | end | center ]{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-snap-align"
      },
      "scroll-snap-coordinate": {
        syntax: "none | <position>#",
        media: "interactive",
        inherited: false,
        animationType: "position",
        percentages: "referToBorderBox",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-snap-coordinate"
      },
      "scroll-snap-destination": {
        syntax: "<position>",
        media: "interactive",
        inherited: false,
        animationType: "position",
        percentages: "relativeToScrollContainerPaddingBoxAxis",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "0px 0px",
        appliesto: "scrollContainers",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-snap-destination"
      },
      "scroll-snap-points-x": {
        syntax: "none | repeat( <length-percentage> )",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "relativeToScrollContainerPaddingBoxAxis",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "none",
        appliesto: "scrollContainers",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-snap-points-x"
      },
      "scroll-snap-points-y": {
        syntax: "none | repeat( <length-percentage> )",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "relativeToScrollContainerPaddingBoxAxis",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "none",
        appliesto: "scrollContainers",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-snap-points-y"
      },
      "scroll-snap-stop": {
        syntax: "normal | always",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-snap-stop"
      },
      "scroll-snap-type": {
        syntax: "none | [ x | y | block | inline | both ] [ mandatory | proximity ]?",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-snap-type"
      },
      "scroll-snap-type-x": {
        syntax: "none | mandatory | proximity",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "none",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-snap-type-x"
      },
      "scroll-snap-type-y": {
        syntax: "none | mandatory | proximity",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Scroll Snap"
        ],
        initial: "none",
        appliesto: "scrollContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "obsolete",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/scroll-snap-type-y"
      },
      "shape-image-threshold": {
        syntax: "<alpha-value>",
        media: "visual",
        inherited: false,
        animationType: "number",
        percentages: "no",
        groups: [
          "CSS Shapes"
        ],
        initial: "0.0",
        appliesto: "floats",
        computed: "specifiedValueNumberClipped0To1",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/shape-image-threshold"
      },
      "shape-margin": {
        syntax: "<length-percentage>",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Shapes"
        ],
        initial: "0",
        appliesto: "floats",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/shape-margin"
      },
      "shape-outside": {
        syntax: "none | <shape-box> || <basic-shape> | <image>",
        media: "visual",
        inherited: false,
        animationType: "basicShapeOtherwiseNo",
        percentages: "no",
        groups: [
          "CSS Shapes"
        ],
        initial: "none",
        appliesto: "floats",
        computed: "asDefinedForBasicShapeWithAbsoluteURIOtherwiseAsSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/shape-outside"
      },
      "tab-size": {
        syntax: "<integer> | <length>",
        media: "visual",
        inherited: true,
        animationType: "length",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "8",
        appliesto: "blockContainers",
        computed: "specifiedIntegerOrAbsoluteLength",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/tab-size"
      },
      "table-layout": {
        syntax: "auto | fixed",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Table"
        ],
        initial: "auto",
        appliesto: "tableElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/table-layout"
      },
      "text-align": {
        syntax: "start | end | left | right | center | justify | match-parent",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "startOrNamelessValueIfLTRRightIfRTL",
        appliesto: "blockContainers",
        computed: "asSpecifiedExceptMatchParent",
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-align"
      },
      "text-align-last": {
        syntax: "auto | start | end | left | right | center | justify",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "auto",
        appliesto: "blockContainers",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-align-last"
      },
      "text-combine-upright": {
        syntax: "none | all | [ digits <integer>? ]",
        media: "visual",
        inherited: true,
        animationType: "notAnimatable",
        percentages: "no",
        groups: [
          "CSS Writing Modes"
        ],
        initial: "none",
        appliesto: "nonReplacedInlineElements",
        computed: "keywordPlusIntegerIfDigits",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-combine-upright"
      },
      "text-decoration": {
        syntax: "<'text-decoration-line'> || <'text-decoration-style'> || <'text-decoration-color'> || <'text-decoration-thickness'>",
        media: "visual",
        inherited: false,
        animationType: [
          "text-decoration-color",
          "text-decoration-style",
          "text-decoration-line",
          "text-decoration-thickness"
        ],
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: [
          "text-decoration-color",
          "text-decoration-style",
          "text-decoration-line"
        ],
        appliesto: "allElements",
        computed: [
          "text-decoration-line",
          "text-decoration-style",
          "text-decoration-color",
          "text-decoration-thickness"
        ],
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-decoration"
      },
      "text-decoration-color": {
        syntax: "<color>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-decoration-color"
      },
      "text-decoration-line": {
        syntax: "none | [ underline || overline || line-through || blink ] | spelling-error | grammar-error",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-decoration-line"
      },
      "text-decoration-skip": {
        syntax: "none | [ objects || [ spaces | [ leading-spaces || trailing-spaces ] ] || edges || box-decoration ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "objects",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-decoration-skip"
      },
      "text-decoration-skip-ink": {
        syntax: "auto | all | none",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-decoration-skip-ink"
      },
      "text-decoration-style": {
        syntax: "solid | double | dotted | dashed | wavy",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "solid",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-decoration-style"
      },
      "text-decoration-thickness": {
        syntax: "auto | from-font | <length> | <percentage> ",
        media: "visual",
        inherited: false,
        animationType: "byComputedValueType",
        percentages: "referToElementFontSize",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-decoration-thickness"
      },
      "text-emphasis": {
        syntax: "<'text-emphasis-style'> || <'text-emphasis-color'>",
        media: "visual",
        inherited: false,
        animationType: [
          "text-emphasis-color",
          "text-emphasis-style"
        ],
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: [
          "text-emphasis-style",
          "text-emphasis-color"
        ],
        appliesto: "allElements",
        computed: [
          "text-emphasis-style",
          "text-emphasis-color"
        ],
        order: "orderOfAppearance",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-emphasis"
      },
      "text-emphasis-color": {
        syntax: "<color>",
        media: "visual",
        inherited: false,
        animationType: "color",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "currentcolor",
        appliesto: "allElements",
        computed: "computedColor",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-emphasis-color"
      },
      "text-emphasis-position": {
        syntax: "[ over | under ] && [ right | left ]",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "over right",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-emphasis-position"
      },
      "text-emphasis-style": {
        syntax: "none | [ [ filled | open ] || [ dot | circle | double-circle | triangle | sesame ] ] | <string>",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-emphasis-style"
      },
      "text-indent": {
        syntax: "<length-percentage> && hanging? && each-line?",
        media: "visual",
        inherited: true,
        animationType: "lpc",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Text"
        ],
        initial: "0",
        appliesto: "blockContainers",
        computed: "percentageOrAbsoluteLengthPlusKeywords",
        order: "lengthOrPercentageBeforeKeywords",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-indent"
      },
      "text-justify": {
        syntax: "auto | inter-character | inter-word | none",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "auto",
        appliesto: "inlineLevelAndTableCellElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-justify"
      },
      "text-orientation": {
        syntax: "mixed | upright | sideways",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Writing Modes"
        ],
        initial: "mixed",
        appliesto: "allElementsExceptTableRowGroupsRowsColumnGroupsAndColumns",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-orientation"
      },
      "text-overflow": {
        syntax: "[ clip | ellipsis | <string> ]{1,2}",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "clip",
        appliesto: "blockContainerElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-overflow"
      },
      "text-rendering": {
        syntax: "auto | optimizeSpeed | optimizeLegibility | geometricPrecision",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Miscellaneous"
        ],
        initial: "auto",
        appliesto: "textElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-rendering"
      },
      "text-shadow": {
        syntax: "none | <shadow-t>#",
        media: "visual",
        inherited: true,
        animationType: "shadowList",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "colorPlusThreeAbsoluteLengths",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-shadow"
      },
      "text-size-adjust": {
        syntax: "none | auto | <percentage>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "referToSizeOfFont",
        groups: [
          "CSS Text"
        ],
        initial: "autoForSmartphoneBrowsersSupportingInflation",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "experimental",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-size-adjust"
      },
      "text-transform": {
        syntax: "none | capitalize | uppercase | lowercase | full-width | full-size-kana",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "none",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-transform"
      },
      "text-underline-offset": {
        syntax: "auto | <length> | <percentage> ",
        media: "visual",
        inherited: true,
        animationType: "byComputedValueType",
        percentages: "referToElementFontSize",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-underline-offset"
      },
      "text-underline-position": {
        syntax: "auto | from-font | [ under || [ left | right ] ]",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text Decoration"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "orderOfAppearance",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/text-underline-position"
      },
      top: {
        syntax: "<length> | <percentage> | auto",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToContainingBlockHeight",
        groups: [
          "CSS Positioning"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "lengthAbsolutePercentageAsSpecifiedOtherwiseAuto",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/top"
      },
      "touch-action": {
        syntax: "auto | none | [ [ pan-x | pan-left | pan-right ] || [ pan-y | pan-up | pan-down ] || pinch-zoom ] | manipulation",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "Pointer Events"
        ],
        initial: "auto",
        appliesto: "allElementsExceptNonReplacedInlineElementsTableRowsColumnsRowColumnGroups",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/touch-action"
      },
      transform: {
        syntax: "none | <transform-list>",
        media: "visual",
        inherited: false,
        animationType: "transform",
        percentages: "referToSizeOfBoundingBox",
        groups: [
          "CSS Transforms"
        ],
        initial: "none",
        appliesto: "transformableElements",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "uniqueOrder",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/transform"
      },
      "transform-box": {
        syntax: "content-box | border-box | fill-box | stroke-box | view-box",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Transforms"
        ],
        initial: "view-box",
        appliesto: "transformableElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/transform-box"
      },
      "transform-origin": {
        syntax: "[ <length-percentage> | left | center | right | top | bottom ] | [ [ <length-percentage> | left | center | right ] && [ <length-percentage> | top | center | bottom ] ] <length>?",
        media: "visual",
        inherited: false,
        animationType: "simpleListOfLpc",
        percentages: "referToSizeOfBoundingBox",
        groups: [
          "CSS Transforms"
        ],
        initial: "50% 50% 0",
        appliesto: "transformableElements",
        computed: "forLengthAbsoluteValueOtherwisePercentage",
        order: "oneOrTwoValuesLengthAbsoluteKeywordsPercentages",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/transform-origin"
      },
      "transform-style": {
        syntax: "flat | preserve-3d",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Transforms"
        ],
        initial: "flat",
        appliesto: "transformableElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/transform-style"
      },
      transition: {
        syntax: "<single-transition>#",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Transitions"
        ],
        initial: [
          "transition-delay",
          "transition-duration",
          "transition-property",
          "transition-timing-function"
        ],
        appliesto: "allElementsAndPseudos",
        computed: [
          "transition-delay",
          "transition-duration",
          "transition-property",
          "transition-timing-function"
        ],
        order: "orderOfAppearance",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/transition"
      },
      "transition-delay": {
        syntax: "<time>#",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Transitions"
        ],
        initial: "0s",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/transition-delay"
      },
      "transition-duration": {
        syntax: "<time>#",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Transitions"
        ],
        initial: "0s",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/transition-duration"
      },
      "transition-property": {
        syntax: "none | <single-transition-property>#",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Transitions"
        ],
        initial: "all",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/transition-property"
      },
      "transition-timing-function": {
        syntax: "<timing-function>#",
        media: "interactive",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Transitions"
        ],
        initial: "ease",
        appliesto: "allElementsAndPseudos",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/transition-timing-function"
      },
      translate: {
        syntax: "none | <length-percentage> [ <length-percentage> <length>? ]?",
        media: "visual",
        inherited: false,
        animationType: "transform",
        percentages: "referToSizeOfBoundingBox",
        groups: [
          "CSS Transforms"
        ],
        initial: "none",
        appliesto: "transformableElements",
        computed: "asSpecifiedRelativeToAbsoluteLengths",
        order: "perGrammar",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/translate"
      },
      "unicode-bidi": {
        syntax: "normal | embed | isolate | bidi-override | isolate-override | plaintext",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Writing Modes"
        ],
        initial: "normal",
        appliesto: "allElementsSomeValuesNoEffectOnNonInlineElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/unicode-bidi"
      },
      "user-select": {
        syntax: "auto | text | none | contain | all",
        media: "visual",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Basic User Interface"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/user-select"
      },
      "vertical-align": {
        syntax: "baseline | sub | super | text-top | text-bottom | middle | top | bottom | <percentage> | <length>",
        media: "visual",
        inherited: false,
        animationType: "length",
        percentages: "referToLineHeight",
        groups: [
          "CSS Table"
        ],
        initial: "baseline",
        appliesto: "inlineLevelAndTableCellElements",
        computed: "absoluteLengthOrKeyword",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/vertical-align"
      },
      visibility: {
        syntax: "visible | hidden | collapse",
        media: "visual",
        inherited: true,
        animationType: "visibility",
        percentages: "no",
        groups: [
          "CSS Box Model"
        ],
        initial: "visible",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/visibility"
      },
      "white-space": {
        syntax: "normal | pre | nowrap | pre-wrap | pre-line | break-spaces",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/white-space"
      },
      widows: {
        syntax: "<integer>",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Fragmentation"
        ],
        initial: "2",
        appliesto: "blockContainerElements",
        computed: "asSpecified",
        order: "perGrammar",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/widows"
      },
      width: {
        syntax: "auto | <length> | <percentage> | min-content | max-content | fit-content(<length-percentage>)",
        media: "visual",
        inherited: false,
        animationType: "lpc",
        percentages: "referToWidthOfContainingBlock",
        groups: [
          "CSS Box Model"
        ],
        initial: "auto",
        appliesto: "allElementsButNonReplacedAndTableRows",
        computed: "percentageAutoOrAbsoluteLength",
        order: "lengthOrPercentageBeforeKeywordIfBothPresent",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/width"
      },
      "will-change": {
        syntax: "auto | <animateable-feature>#",
        media: "all",
        inherited: false,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Will Change"
        ],
        initial: "auto",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/will-change"
      },
      "word-break": {
        syntax: "normal | break-all | keep-all | break-word",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/word-break"
      },
      "word-spacing": {
        syntax: "normal | <length-percentage>",
        media: "visual",
        inherited: true,
        animationType: "length",
        percentages: "referToWidthOfAffectedGlyph",
        groups: [
          "CSS Text"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "optimumMinAndMaxValueOfAbsoluteLengthPercentageOrNormal",
        order: "uniqueOrder",
        alsoAppliesTo: [
          "::first-letter",
          "::first-line",
          "::placeholder"
        ],
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/word-spacing"
      },
      "word-wrap": {
        syntax: "normal | break-word",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Text"
        ],
        initial: "normal",
        appliesto: "nonReplacedInlineElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/overflow-wrap"
      },
      "writing-mode": {
        syntax: "horizontal-tb | vertical-rl | vertical-lr | sideways-rl | sideways-lr",
        media: "visual",
        inherited: true,
        animationType: "discrete",
        percentages: "no",
        groups: [
          "CSS Writing Modes"
        ],
        initial: "horizontal-tb",
        appliesto: "allElementsExceptTableRowColumnGroupsTableRowsColumns",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/writing-mode"
      },
      "z-index": {
        syntax: "auto | <integer>",
        media: "visual",
        inherited: false,
        animationType: "integer",
        percentages: "no",
        groups: [
          "CSS Positioning"
        ],
        initial: "auto",
        appliesto: "positionedElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        stacking: true,
        status: "standard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/z-index"
      },
      zoom: {
        syntax: "normal | reset | <number> | <percentage>",
        media: "visual",
        inherited: false,
        animationType: "integer",
        percentages: "no",
        groups: [
          "Microsoft Extensions"
        ],
        initial: "normal",
        appliesto: "allElements",
        computed: "asSpecified",
        order: "uniqueOrder",
        status: "nonstandard",
        mdn_url: "https://developer.mozilla.org/docs/Web/CSS/zoom"
      }
    };
  }
});

// node_modules/mdn-data/css/syntaxes.json
var require_syntaxes = __commonJS({
  "node_modules/mdn-data/css/syntaxes.json"(exports2, module2) {
    module2.exports = {
      "absolute-size": {
        syntax: "xx-small | x-small | small | medium | large | x-large | xx-large | xxx-large"
      },
      "alpha-value": {
        syntax: "<number> | <percentage>"
      },
      "angle-percentage": {
        syntax: "<angle> | <percentage>"
      },
      "angular-color-hint": {
        syntax: "<angle-percentage>"
      },
      "angular-color-stop": {
        syntax: "<color> && <color-stop-angle>?"
      },
      "angular-color-stop-list": {
        syntax: "[ <angular-color-stop> [, <angular-color-hint>]? ]# , <angular-color-stop>"
      },
      "animateable-feature": {
        syntax: "scroll-position | contents | <custom-ident>"
      },
      attachment: {
        syntax: "scroll | fixed | local"
      },
      "attr()": {
        syntax: "attr( <attr-name> <type-or-unit>? [, <attr-fallback> ]? )"
      },
      "attr-matcher": {
        syntax: "[ '~' | '|' | '^' | '$' | '*' ]? '='"
      },
      "attr-modifier": {
        syntax: "i | s"
      },
      "attribute-selector": {
        syntax: "'[' <wq-name> ']' | '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'"
      },
      "auto-repeat": {
        syntax: "repeat( [ auto-fill | auto-fit ] , [ <line-names>? <fixed-size> ]+ <line-names>? )"
      },
      "auto-track-list": {
        syntax: "[ <line-names>? [ <fixed-size> | <fixed-repeat> ] ]* <line-names>? <auto-repeat>\n[ <line-names>? [ <fixed-size> | <fixed-repeat> ] ]* <line-names>?"
      },
      "baseline-position": {
        syntax: "[ first | last ]? baseline"
      },
      "basic-shape": {
        syntax: "<inset()> | <circle()> | <ellipse()> | <polygon()> | <path()>"
      },
      "bg-image": {
        syntax: "none | <image>"
      },
      "bg-layer": {
        syntax: "<bg-image> || <bg-position> [ / <bg-size> ]? || <repeat-style> || <attachment> || <box> || <box>"
      },
      "bg-position": {
        syntax: "[ [ left | center | right | top | bottom | <length-percentage> ] | [ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ] | [ center | [ left | right ] <length-percentage>? ] && [ center | [ top | bottom ] <length-percentage>? ] ]"
      },
      "bg-size": {
        syntax: "[ <length-percentage> | auto ]{1,2} | cover | contain"
      },
      "blur()": {
        syntax: "blur( <length> )"
      },
      "blend-mode": {
        syntax: "normal | multiply | screen | overlay | darken | lighten | color-dodge | color-burn | hard-light | soft-light | difference | exclusion | hue | saturation | color | luminosity"
      },
      box: {
        syntax: "border-box | padding-box | content-box"
      },
      "brightness()": {
        syntax: "brightness( <number-percentage> )"
      },
      "calc()": {
        syntax: "calc( <calc-sum> )"
      },
      "calc-sum": {
        syntax: "<calc-product> [ [ '+' | '-' ] <calc-product> ]*"
      },
      "calc-product": {
        syntax: "<calc-value> [ '*' <calc-value> | '/' <number> ]*"
      },
      "calc-value": {
        syntax: "<number> | <dimension> | <percentage> | ( <calc-sum> )"
      },
      "cf-final-image": {
        syntax: "<image> | <color>"
      },
      "cf-mixing-image": {
        syntax: "<percentage>? && <image>"
      },
      "circle()": {
        syntax: "circle( [ <shape-radius> ]? [ at <position> ]? )"
      },
      "clamp()": {
        syntax: "clamp( <calc-sum>#{3} )"
      },
      "class-selector": {
        syntax: "'.' <ident-token>"
      },
      "clip-source": {
        syntax: "<url>"
      },
      color: {
        syntax: "<rgb()> | <rgba()> | <hsl()> | <hsla()> | <hex-color> | <named-color> | currentcolor | <deprecated-system-color>"
      },
      "color-stop": {
        syntax: "<color-stop-length> | <color-stop-angle>"
      },
      "color-stop-angle": {
        syntax: "<angle-percentage>{1,2}"
      },
      "color-stop-length": {
        syntax: "<length-percentage>{1,2}"
      },
      "color-stop-list": {
        syntax: "[ <linear-color-stop> [, <linear-color-hint>]? ]# , <linear-color-stop>"
      },
      combinator: {
        syntax: "'>' | '+' | '~' | [ '||' ]"
      },
      "common-lig-values": {
        syntax: "[ common-ligatures | no-common-ligatures ]"
      },
      "compat-auto": {
        syntax: "searchfield | textarea | push-button | slider-horizontal | checkbox | radio | square-button | menulist | listbox | meter | progress-bar | button"
      },
      "composite-style": {
        syntax: "clear | copy | source-over | source-in | source-out | source-atop | destination-over | destination-in | destination-out | destination-atop | xor"
      },
      "compositing-operator": {
        syntax: "add | subtract | intersect | exclude"
      },
      "compound-selector": {
        syntax: "[ <type-selector>? <subclass-selector>* [ <pseudo-element-selector> <pseudo-class-selector>* ]* ]!"
      },
      "compound-selector-list": {
        syntax: "<compound-selector>#"
      },
      "complex-selector": {
        syntax: "<compound-selector> [ <combinator>? <compound-selector> ]*"
      },
      "complex-selector-list": {
        syntax: "<complex-selector>#"
      },
      "conic-gradient()": {
        syntax: "conic-gradient( [ from <angle> ]? [ at <position> ]?, <angular-color-stop-list> )"
      },
      "contextual-alt-values": {
        syntax: "[ contextual | no-contextual ]"
      },
      "content-distribution": {
        syntax: "space-between | space-around | space-evenly | stretch"
      },
      "content-list": {
        syntax: "[ <string> | contents | <image> | <quote> | <target> | <leader()> ]+"
      },
      "content-position": {
        syntax: "center | start | end | flex-start | flex-end"
      },
      "content-replacement": {
        syntax: "<image>"
      },
      "contrast()": {
        syntax: "contrast( [ <number-percentage> ] )"
      },
      "counter()": {
        syntax: "counter( <custom-ident>, <counter-style>? )"
      },
      "counter-style": {
        syntax: "<counter-style-name> | symbols()"
      },
      "counter-style-name": {
        syntax: "<custom-ident>"
      },
      "counters()": {
        syntax: "counters( <custom-ident>, <string>, <counter-style>? )"
      },
      "cross-fade()": {
        syntax: "cross-fade( <cf-mixing-image> , <cf-final-image>? )"
      },
      "cubic-bezier-timing-function": {
        syntax: "ease | ease-in | ease-out | ease-in-out | cubic-bezier(<number [0,1]>, <number>, <number [0,1]>, <number>)"
      },
      "deprecated-system-color": {
        syntax: "ActiveBorder | ActiveCaption | AppWorkspace | Background | ButtonFace | ButtonHighlight | ButtonShadow | ButtonText | CaptionText | GrayText | Highlight | HighlightText | InactiveBorder | InactiveCaption | InactiveCaptionText | InfoBackground | InfoText | Menu | MenuText | Scrollbar | ThreeDDarkShadow | ThreeDFace | ThreeDHighlight | ThreeDLightShadow | ThreeDShadow | Window | WindowFrame | WindowText"
      },
      "discretionary-lig-values": {
        syntax: "[ discretionary-ligatures | no-discretionary-ligatures ]"
      },
      "display-box": {
        syntax: "contents | none"
      },
      "display-inside": {
        syntax: "flow | flow-root | table | flex | grid | ruby"
      },
      "display-internal": {
        syntax: "table-row-group | table-header-group | table-footer-group | table-row | table-cell | table-column-group | table-column | table-caption | ruby-base | ruby-text | ruby-base-container | ruby-text-container"
      },
      "display-legacy": {
        syntax: "inline-block | inline-list-item | inline-table | inline-flex | inline-grid"
      },
      "display-listitem": {
        syntax: "<display-outside>? && [ flow | flow-root ]? && list-item"
      },
      "display-outside": {
        syntax: "block | inline | run-in"
      },
      "drop-shadow()": {
        syntax: "drop-shadow( <length>{2,3} <color>? )"
      },
      "east-asian-variant-values": {
        syntax: "[ jis78 | jis83 | jis90 | jis04 | simplified | traditional ]"
      },
      "east-asian-width-values": {
        syntax: "[ full-width | proportional-width ]"
      },
      "element()": {
        syntax: "element( <id-selector> )"
      },
      "ellipse()": {
        syntax: "ellipse( [ <shape-radius>{2} ]? [ at <position> ]? )"
      },
      "ending-shape": {
        syntax: "circle | ellipse"
      },
      "env()": {
        syntax: "env( <custom-ident> , <declaration-value>? )"
      },
      "explicit-track-list": {
        syntax: "[ <line-names>? <track-size> ]+ <line-names>?"
      },
      "family-name": {
        syntax: "<string> | <custom-ident>+"
      },
      "feature-tag-value": {
        syntax: "<string> [ <integer> | on | off ]?"
      },
      "feature-type": {
        syntax: "@stylistic | @historical-forms | @styleset | @character-variant | @swash | @ornaments | @annotation"
      },
      "feature-value-block": {
        syntax: "<feature-type> '{' <feature-value-declaration-list> '}'"
      },
      "feature-value-block-list": {
        syntax: "<feature-value-block>+"
      },
      "feature-value-declaration": {
        syntax: "<custom-ident>: <integer>+;"
      },
      "feature-value-declaration-list": {
        syntax: "<feature-value-declaration>"
      },
      "feature-value-name": {
        syntax: "<custom-ident>"
      },
      "fill-rule": {
        syntax: "nonzero | evenodd"
      },
      "filter-function": {
        syntax: "<blur()> | <brightness()> | <contrast()> | <drop-shadow()> | <grayscale()> | <hue-rotate()> | <invert()> | <opacity()> | <saturate()> | <sepia()>"
      },
      "filter-function-list": {
        syntax: "[ <filter-function> | <url> ]+"
      },
      "final-bg-layer": {
        syntax: "<'background-color'> || <bg-image> || <bg-position> [ / <bg-size> ]? || <repeat-style> || <attachment> || <box> || <box>"
      },
      "fit-content()": {
        syntax: "fit-content( [ <length> | <percentage> ] )"
      },
      "fixed-breadth": {
        syntax: "<length-percentage>"
      },
      "fixed-repeat": {
        syntax: "repeat( [ <positive-integer> ] , [ <line-names>? <fixed-size> ]+ <line-names>? )"
      },
      "fixed-size": {
        syntax: "<fixed-breadth> | minmax( <fixed-breadth> , <track-breadth> ) | minmax( <inflexible-breadth> , <fixed-breadth> )"
      },
      "font-stretch-absolute": {
        syntax: "normal | ultra-condensed | extra-condensed | condensed | semi-condensed | semi-expanded | expanded | extra-expanded | ultra-expanded | <percentage>"
      },
      "font-variant-css21": {
        syntax: "[ normal | small-caps ]"
      },
      "font-weight-absolute": {
        syntax: "normal | bold | <number [1,1000]>"
      },
      "frequency-percentage": {
        syntax: "<frequency> | <percentage>"
      },
      "general-enclosed": {
        syntax: "[ <function-token> <any-value> ) ] | ( <ident> <any-value> )"
      },
      "generic-family": {
        syntax: "serif | sans-serif | cursive | fantasy | monospace"
      },
      "generic-name": {
        syntax: "serif | sans-serif | cursive | fantasy | monospace"
      },
      "geometry-box": {
        syntax: "<shape-box> | fill-box | stroke-box | view-box"
      },
      gradient: {
        syntax: "<linear-gradient()> | <repeating-linear-gradient()> | <radial-gradient()> | <repeating-radial-gradient()> | <conic-gradient()>"
      },
      "grayscale()": {
        syntax: "grayscale( <number-percentage> )"
      },
      "grid-line": {
        syntax: "auto | <custom-ident> | [ <integer> && <custom-ident>? ] | [ span && [ <integer> || <custom-ident> ] ]"
      },
      "historical-lig-values": {
        syntax: "[ historical-ligatures | no-historical-ligatures ]"
      },
      "hsl()": {
        syntax: "hsl( <hue> <percentage> <percentage> [ / <alpha-value> ]? ) | hsl( <hue>, <percentage>, <percentage>, <alpha-value>? )"
      },
      "hsla()": {
        syntax: "hsla( <hue> <percentage> <percentage> [ / <alpha-value> ]? ) | hsla( <hue>, <percentage>, <percentage>, <alpha-value>? )"
      },
      hue: {
        syntax: "<number> | <angle>"
      },
      "hue-rotate()": {
        syntax: "hue-rotate( <angle> )"
      },
      "id-selector": {
        syntax: "<hash-token>"
      },
      image: {
        syntax: "<url> | <image()> | <image-set()> | <element()> | <paint()> | <cross-fade()> | <gradient>"
      },
      "image()": {
        syntax: "image( <image-tags>? [ <image-src>? , <color>? ]! )"
      },
      "image-set()": {
        syntax: "image-set( <image-set-option># )"
      },
      "image-set-option": {
        syntax: "[ <image> | <string> ] <resolution>"
      },
      "image-src": {
        syntax: "<url> | <string>"
      },
      "image-tags": {
        syntax: "ltr | rtl"
      },
      "inflexible-breadth": {
        syntax: "<length> | <percentage> | min-content | max-content | auto"
      },
      "inset()": {
        syntax: "inset( <length-percentage>{1,4} [ round <'border-radius'> ]? )"
      },
      "invert()": {
        syntax: "invert( <number-percentage> )"
      },
      "keyframes-name": {
        syntax: "<custom-ident> | <string>"
      },
      "keyframe-block": {
        syntax: "<keyframe-selector># {\n  <declaration-list>\n}"
      },
      "keyframe-block-list": {
        syntax: "<keyframe-block>+"
      },
      "keyframe-selector": {
        syntax: "from | to | <percentage>"
      },
      "leader()": {
        syntax: "leader( <leader-type> )"
      },
      "leader-type": {
        syntax: "dotted | solid | space | <string>"
      },
      "length-percentage": {
        syntax: "<length> | <percentage>"
      },
      "line-names": {
        syntax: "'[' <custom-ident>* ']'"
      },
      "line-name-list": {
        syntax: "[ <line-names> | <name-repeat> ]+"
      },
      "line-style": {
        syntax: "none | hidden | dotted | dashed | solid | double | groove | ridge | inset | outset"
      },
      "line-width": {
        syntax: "<length> | thin | medium | thick"
      },
      "linear-color-hint": {
        syntax: "<length-percentage>"
      },
      "linear-color-stop": {
        syntax: "<color> <color-stop-length>?"
      },
      "linear-gradient()": {
        syntax: "linear-gradient( [ <angle> | to <side-or-corner> ]? , <color-stop-list> )"
      },
      "mask-layer": {
        syntax: "<mask-reference> || <position> [ / <bg-size> ]? || <repeat-style> || <geometry-box> || [ <geometry-box> | no-clip ] || <compositing-operator> || <masking-mode>"
      },
      "mask-position": {
        syntax: "[ <length-percentage> | left | center | right ] [ <length-percentage> | top | center | bottom ]?"
      },
      "mask-reference": {
        syntax: "none | <image> | <mask-source>"
      },
      "mask-source": {
        syntax: "<url>"
      },
      "masking-mode": {
        syntax: "alpha | luminance | match-source"
      },
      "matrix()": {
        syntax: "matrix( <number>#{6} )"
      },
      "matrix3d()": {
        syntax: "matrix3d( <number>#{16} )"
      },
      "max()": {
        syntax: "max( <calc-sum># )"
      },
      "media-and": {
        syntax: "<media-in-parens> [ and <media-in-parens> ]+"
      },
      "media-condition": {
        syntax: "<media-not> | <media-and> | <media-or> | <media-in-parens>"
      },
      "media-condition-without-or": {
        syntax: "<media-not> | <media-and> | <media-in-parens>"
      },
      "media-feature": {
        syntax: "( [ <mf-plain> | <mf-boolean> | <mf-range> ] )"
      },
      "media-in-parens": {
        syntax: "( <media-condition> ) | <media-feature> | <general-enclosed>"
      },
      "media-not": {
        syntax: "not <media-in-parens>"
      },
      "media-or": {
        syntax: "<media-in-parens> [ or <media-in-parens> ]+"
      },
      "media-query": {
        syntax: "<media-condition> | [ not | only ]? <media-type> [ and <media-condition-without-or> ]?"
      },
      "media-query-list": {
        syntax: "<media-query>#"
      },
      "media-type": {
        syntax: "<ident>"
      },
      "mf-boolean": {
        syntax: "<mf-name>"
      },
      "mf-name": {
        syntax: "<ident>"
      },
      "mf-plain": {
        syntax: "<mf-name> : <mf-value>"
      },
      "mf-range": {
        syntax: "<mf-name> [ '<' | '>' ]? '='? <mf-value>\n| <mf-value> [ '<' | '>' ]? '='? <mf-name>\n| <mf-value> '<' '='? <mf-name> '<' '='? <mf-value>\n| <mf-value> '>' '='? <mf-name> '>' '='? <mf-value>"
      },
      "mf-value": {
        syntax: "<number> | <dimension> | <ident> | <ratio>"
      },
      "min()": {
        syntax: "min( <calc-sum># )"
      },
      "minmax()": {
        syntax: "minmax( [ <length> | <percentage> | min-content | max-content | auto ] , [ <length> | <percentage> | <flex> | min-content | max-content | auto ] )"
      },
      "named-color": {
        syntax: "transparent | aliceblue | antiquewhite | aqua | aquamarine | azure | beige | bisque | black | blanchedalmond | blue | blueviolet | brown | burlywood | cadetblue | chartreuse | chocolate | coral | cornflowerblue | cornsilk | crimson | cyan | darkblue | darkcyan | darkgoldenrod | darkgray | darkgreen | darkgrey | darkkhaki | darkmagenta | darkolivegreen | darkorange | darkorchid | darkred | darksalmon | darkseagreen | darkslateblue | darkslategray | darkslategrey | darkturquoise | darkviolet | deeppink | deepskyblue | dimgray | dimgrey | dodgerblue | firebrick | floralwhite | forestgreen | fuchsia | gainsboro | ghostwhite | gold | goldenrod | gray | green | greenyellow | grey | honeydew | hotpink | indianred | indigo | ivory | khaki | lavender | lavenderblush | lawngreen | lemonchiffon | lightblue | lightcoral | lightcyan | lightgoldenrodyellow | lightgray | lightgreen | lightgrey | lightpink | lightsalmon | lightseagreen | lightskyblue | lightslategray | lightslategrey | lightsteelblue | lightyellow | lime | limegreen | linen | magenta | maroon | mediumaquamarine | mediumblue | mediumorchid | mediumpurple | mediumseagreen | mediumslateblue | mediumspringgreen | mediumturquoise | mediumvioletred | midnightblue | mintcream | mistyrose | moccasin | navajowhite | navy | oldlace | olive | olivedrab | orange | orangered | orchid | palegoldenrod | palegreen | paleturquoise | palevioletred | papayawhip | peachpuff | peru | pink | plum | powderblue | purple | rebeccapurple | red | rosybrown | royalblue | saddlebrown | salmon | sandybrown | seagreen | seashell | sienna | silver | skyblue | slateblue | slategray | slategrey | snow | springgreen | steelblue | tan | teal | thistle | tomato | turquoise | violet | wheat | white | whitesmoke | yellow | yellowgreen"
      },
      "namespace-prefix": {
        syntax: "<ident>"
      },
      "ns-prefix": {
        syntax: "[ <ident-token> | '*' ]? '|'"
      },
      "number-percentage": {
        syntax: "<number> | <percentage>"
      },
      "numeric-figure-values": {
        syntax: "[ lining-nums | oldstyle-nums ]"
      },
      "numeric-fraction-values": {
        syntax: "[ diagonal-fractions | stacked-fractions ]"
      },
      "numeric-spacing-values": {
        syntax: "[ proportional-nums | tabular-nums ]"
      },
      nth: {
        syntax: "<an-plus-b> | even | odd"
      },
      "opacity()": {
        syntax: "opacity( [ <number-percentage> ] )"
      },
      "overflow-position": {
        syntax: "unsafe | safe"
      },
      "outline-radius": {
        syntax: "<length> | <percentage>"
      },
      "page-body": {
        syntax: "<declaration>? [ ; <page-body> ]? | <page-margin-box> <page-body>"
      },
      "page-margin-box": {
        syntax: "<page-margin-box-type> '{' <declaration-list> '}'"
      },
      "page-margin-box-type": {
        syntax: "@top-left-corner | @top-left | @top-center | @top-right | @top-right-corner | @bottom-left-corner | @bottom-left | @bottom-center | @bottom-right | @bottom-right-corner | @left-top | @left-middle | @left-bottom | @right-top | @right-middle | @right-bottom"
      },
      "page-selector-list": {
        syntax: "[ <page-selector># ]?"
      },
      "page-selector": {
        syntax: "<pseudo-page>+ | <ident> <pseudo-page>*"
      },
      "path()": {
        syntax: "path( [ <fill-rule>, ]? <string> )"
      },
      "paint()": {
        syntax: "paint( <ident>, <declaration-value>? )"
      },
      "perspective()": {
        syntax: "perspective( <length> )"
      },
      "polygon()": {
        syntax: "polygon( <fill-rule>? , [ <length-percentage> <length-percentage> ]# )"
      },
      position: {
        syntax: "[ [ left | center | right ] || [ top | center | bottom ] | [ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ]? | [ [ left | right ] <length-percentage> ] && [ [ top | bottom ] <length-percentage> ] ]"
      },
      "pseudo-class-selector": {
        syntax: "':' <ident-token> | ':' <function-token> <any-value> ')'"
      },
      "pseudo-element-selector": {
        syntax: "':' <pseudo-class-selector>"
      },
      "pseudo-page": {
        syntax: ": [ left | right | first | blank ]"
      },
      quote: {
        syntax: "open-quote | close-quote | no-open-quote | no-close-quote"
      },
      "radial-gradient()": {
        syntax: "radial-gradient( [ <ending-shape> || <size> ]? [ at <position> ]? , <color-stop-list> )"
      },
      "relative-selector": {
        syntax: "<combinator>? <complex-selector>"
      },
      "relative-selector-list": {
        syntax: "<relative-selector>#"
      },
      "relative-size": {
        syntax: "larger | smaller"
      },
      "repeat-style": {
        syntax: "repeat-x | repeat-y | [ repeat | space | round | no-repeat ]{1,2}"
      },
      "repeating-linear-gradient()": {
        syntax: "repeating-linear-gradient( [ <angle> | to <side-or-corner> ]? , <color-stop-list> )"
      },
      "repeating-radial-gradient()": {
        syntax: "repeating-radial-gradient( [ <ending-shape> || <size> ]? [ at <position> ]? , <color-stop-list> )"
      },
      "rgb()": {
        syntax: "rgb( <percentage>{3} [ / <alpha-value> ]? ) | rgb( <number>{3} [ / <alpha-value> ]? ) | rgb( <percentage>#{3} , <alpha-value>? ) | rgb( <number>#{3} , <alpha-value>? )"
      },
      "rgba()": {
        syntax: "rgba( <percentage>{3} [ / <alpha-value> ]? ) | rgba( <number>{3} [ / <alpha-value> ]? ) | rgba( <percentage>#{3} , <alpha-value>? ) | rgba( <number>#{3} , <alpha-value>? )"
      },
      "rotate()": {
        syntax: "rotate( [ <angle> | <zero> ] )"
      },
      "rotate3d()": {
        syntax: "rotate3d( <number> , <number> , <number> , [ <angle> | <zero> ] )"
      },
      "rotateX()": {
        syntax: "rotateX( [ <angle> | <zero> ] )"
      },
      "rotateY()": {
        syntax: "rotateY( [ <angle> | <zero> ] )"
      },
      "rotateZ()": {
        syntax: "rotateZ( [ <angle> | <zero> ] )"
      },
      "saturate()": {
        syntax: "saturate( <number-percentage> )"
      },
      "scale()": {
        syntax: "scale( <number> , <number>? )"
      },
      "scale3d()": {
        syntax: "scale3d( <number> , <number> , <number> )"
      },
      "scaleX()": {
        syntax: "scaleX( <number> )"
      },
      "scaleY()": {
        syntax: "scaleY( <number> )"
      },
      "scaleZ()": {
        syntax: "scaleZ( <number> )"
      },
      "self-position": {
        syntax: "center | start | end | self-start | self-end | flex-start | flex-end"
      },
      "shape-radius": {
        syntax: "<length-percentage> | closest-side | farthest-side"
      },
      "skew()": {
        syntax: "skew( [ <angle> | <zero> ] , [ <angle> | <zero> ]? )"
      },
      "skewX()": {
        syntax: "skewX( [ <angle> | <zero> ] )"
      },
      "skewY()": {
        syntax: "skewY( [ <angle> | <zero> ] )"
      },
      "sepia()": {
        syntax: "sepia( <number-percentage> )"
      },
      shadow: {
        syntax: "inset? && <length>{2,4} && <color>?"
      },
      "shadow-t": {
        syntax: "[ <length>{2,3} && <color>? ]"
      },
      shape: {
        syntax: "rect(<top>, <right>, <bottom>, <left>)"
      },
      "shape-box": {
        syntax: "<box> | margin-box"
      },
      "side-or-corner": {
        syntax: "[ left | right ] || [ top | bottom ]"
      },
      "single-animation": {
        syntax: "<time> || <timing-function> || <time> || <single-animation-iteration-count> || <single-animation-direction> || <single-animation-fill-mode> || <single-animation-play-state> || [ none | <keyframes-name> ]"
      },
      "single-animation-direction": {
        syntax: "normal | reverse | alternate | alternate-reverse"
      },
      "single-animation-fill-mode": {
        syntax: "none | forwards | backwards | both"
      },
      "single-animation-iteration-count": {
        syntax: "infinite | <number>"
      },
      "single-animation-play-state": {
        syntax: "running | paused"
      },
      "single-transition": {
        syntax: "[ none | <single-transition-property> ] || <time> || <timing-function> || <time>"
      },
      "single-transition-property": {
        syntax: "all | <custom-ident>"
      },
      size: {
        syntax: "closest-side | farthest-side | closest-corner | farthest-corner | <length> | <length-percentage>{2}"
      },
      "step-position": {
        syntax: "jump-start | jump-end | jump-none | jump-both | start | end"
      },
      "step-timing-function": {
        syntax: "step-start | step-end | steps(<integer>[, <step-position>]?)"
      },
      "subclass-selector": {
        syntax: "<id-selector> | <class-selector> | <attribute-selector> | <pseudo-class-selector>"
      },
      "supports-condition": {
        syntax: "not <supports-in-parens> | <supports-in-parens> [ and <supports-in-parens> ]* | <supports-in-parens> [ or <supports-in-parens> ]*"
      },
      "supports-in-parens": {
        syntax: "( <supports-condition> ) | <supports-feature> | <general-enclosed>"
      },
      "supports-feature": {
        syntax: "<supports-decl> | <supports-selector-fn>"
      },
      "supports-decl": {
        syntax: "( <declaration> )"
      },
      "supports-selector-fn": {
        syntax: "selector( <complex-selector> )"
      },
      symbol: {
        syntax: "<string> | <image> | <custom-ident>"
      },
      target: {
        syntax: "<target-counter()> | <target-counters()> | <target-text()>"
      },
      "target-counter()": {
        syntax: "target-counter( [ <string> | <url> ] , <custom-ident> , <counter-style>? )"
      },
      "target-counters()": {
        syntax: "target-counters( [ <string> | <url> ] , <custom-ident> , <string> , <counter-style>? )"
      },
      "target-text()": {
        syntax: "target-text( [ <string> | <url> ] , [ content | before | after | first-letter ]? )"
      },
      "time-percentage": {
        syntax: "<time> | <percentage>"
      },
      "timing-function": {
        syntax: "linear | <cubic-bezier-timing-function> | <step-timing-function>"
      },
      "track-breadth": {
        syntax: "<length-percentage> | <flex> | min-content | max-content | auto"
      },
      "track-list": {
        syntax: "[ <line-names>? [ <track-size> | <track-repeat> ] ]+ <line-names>?"
      },
      "track-repeat": {
        syntax: "repeat( [ <positive-integer> ] , [ <line-names>? <track-size> ]+ <line-names>? )"
      },
      "track-size": {
        syntax: "<track-breadth> | minmax( <inflexible-breadth> , <track-breadth> ) | fit-content( [ <length> | <percentage> ] )"
      },
      "transform-function": {
        syntax: "<matrix()> | <translate()> | <translateX()> | <translateY()> | <scale()> | <scaleX()> | <scaleY()> | <rotate()> | <skew()> | <skewX()> | <skewY()> | <matrix3d()> | <translate3d()> | <translateZ()> | <scale3d()> | <scaleZ()> | <rotate3d()> | <rotateX()> | <rotateY()> | <rotateZ()> | <perspective()>"
      },
      "transform-list": {
        syntax: "<transform-function>+"
      },
      "translate()": {
        syntax: "translate( <length-percentage> , <length-percentage>? )"
      },
      "translate3d()": {
        syntax: "translate3d( <length-percentage> , <length-percentage> , <length> )"
      },
      "translateX()": {
        syntax: "translateX( <length-percentage> )"
      },
      "translateY()": {
        syntax: "translateY( <length-percentage> )"
      },
      "translateZ()": {
        syntax: "translateZ( <length> )"
      },
      "type-or-unit": {
        syntax: "string | color | url | integer | number | length | angle | time | frequency | cap | ch | em | ex | ic | lh | rlh | rem | vb | vi | vw | vh | vmin | vmax | mm | Q | cm | in | pt | pc | px | deg | grad | rad | turn | ms | s | Hz | kHz | %"
      },
      "type-selector": {
        syntax: "<wq-name> | <ns-prefix>? '*'"
      },
      "var()": {
        syntax: "var( <custom-property-name> , <declaration-value>? )"
      },
      "viewport-length": {
        syntax: "auto | <length-percentage>"
      },
      "wq-name": {
        syntax: "<ns-prefix>? <ident-token>"
      }
    };
  }
});

// node_modules/css-tree/data/patch.json
var require_patch = __commonJS({
  "node_modules/css-tree/data/patch.json"(exports2, module2) {
    module2.exports = {
      atrules: {
        charset: {
          prelude: "<string>"
        },
        "font-face": {
          descriptors: {
            "unicode-range": {
              comment: "replaces <unicode-range>, an old production name",
              syntax: "<urange>#"
            }
          }
        }
      },
      properties: {
        "-moz-background-clip": {
          comment: "deprecated syntax in old Firefox, https://developer.mozilla.org/en/docs/Web/CSS/background-clip",
          syntax: "padding | border"
        },
        "-moz-border-radius-bottomleft": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-left-radius",
          syntax: "<'border-bottom-left-radius'>"
        },
        "-moz-border-radius-bottomright": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-right-radius",
          syntax: "<'border-bottom-right-radius'>"
        },
        "-moz-border-radius-topleft": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-left-radius",
          syntax: "<'border-top-left-radius'>"
        },
        "-moz-border-radius-topright": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-right-radius",
          syntax: "<'border-bottom-right-radius'>"
        },
        "-moz-control-character-visibility": {
          comment: "firefox specific keywords, https://bugzilla.mozilla.org/show_bug.cgi?id=947588",
          syntax: "visible | hidden"
        },
        "-moz-osx-font-smoothing": {
          comment: "misssed old syntax https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth",
          syntax: "auto | grayscale"
        },
        "-moz-user-select": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/user-select",
          syntax: "none | text | all | -moz-none"
        },
        "-ms-flex-align": {
          comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align",
          syntax: "start | end | center | baseline | stretch"
        },
        "-ms-flex-item-align": {
          comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align",
          syntax: "auto | start | end | center | baseline | stretch"
        },
        "-ms-flex-line-pack": {
          comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack",
          syntax: "start | end | center | justify | distribute | stretch"
        },
        "-ms-flex-negative": {
          comment: "misssed old syntax implemented in IE; TODO: find references for comfirmation",
          syntax: "<'flex-shrink'>"
        },
        "-ms-flex-pack": {
          comment: "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack",
          syntax: "start | end | center | justify | distribute"
        },
        "-ms-flex-order": {
          comment: "misssed old syntax implemented in IE; https://msdn.microsoft.com/en-us/library/jj127303(v=vs.85).aspx",
          syntax: "<integer>"
        },
        "-ms-flex-positive": {
          comment: "misssed old syntax implemented in IE; TODO: find references for comfirmation",
          syntax: "<'flex-grow'>"
        },
        "-ms-flex-preferred-size": {
          comment: "misssed old syntax implemented in IE; TODO: find references for comfirmation",
          syntax: "<'flex-basis'>"
        },
        "-ms-interpolation-mode": {
          comment: "https://msdn.microsoft.com/en-us/library/ff521095(v=vs.85).aspx",
          syntax: "nearest-neighbor | bicubic"
        },
        "-ms-grid-column-align": {
          comment: "add this property first since it uses as fallback for flexbox, https://msdn.microsoft.com/en-us/library/windows/apps/hh466338.aspx",
          syntax: "start | end | center | stretch"
        },
        "-ms-grid-row-align": {
          comment: "add this property first since it uses as fallback for flexbox, https://msdn.microsoft.com/en-us/library/windows/apps/hh466348.aspx",
          syntax: "start | end | center | stretch"
        },
        "-ms-hyphenate-limit-last": {
          comment: "misssed old syntax implemented in IE; https://www.w3.org/TR/css-text-4/#hyphenate-line-limits",
          syntax: "none | always | column | page | spread"
        },
        "-webkit-appearance": {
          comment: "webkit specific keywords",
          references: [
            "http://css-infos.net/property/-webkit-appearance"
          ],
          syntax: "none | button | button-bevel | caps-lock-indicator | caret | checkbox | default-button | inner-spin-button | listbox | listitem | media-controls-background | media-controls-fullscreen-background | media-current-time-display | media-enter-fullscreen-button | media-exit-fullscreen-button | media-fullscreen-button | media-mute-button | media-overlay-play-button | media-play-button | media-seek-back-button | media-seek-forward-button | media-slider | media-sliderthumb | media-time-remaining-display | media-toggle-closed-captions-button | media-volume-slider | media-volume-slider-container | media-volume-sliderthumb | menulist | menulist-button | menulist-text | menulist-textfield | meter | progress-bar | progress-bar-value | push-button | radio | scrollbarbutton-down | scrollbarbutton-left | scrollbarbutton-right | scrollbarbutton-up | scrollbargripper-horizontal | scrollbargripper-vertical | scrollbarthumb-horizontal | scrollbarthumb-vertical | scrollbartrack-horizontal | scrollbartrack-vertical | searchfield | searchfield-cancel-button | searchfield-decoration | searchfield-results-button | searchfield-results-decoration | slider-horizontal | slider-vertical | sliderthumb-horizontal | sliderthumb-vertical | square-button | textarea | textfield | -apple-pay-button"
        },
        "-webkit-background-clip": {
          comment: "https://developer.mozilla.org/en/docs/Web/CSS/background-clip",
          syntax: "[ <box> | border | padding | content | text ]#"
        },
        "-webkit-column-break-after": {
          comment: "added, http://help.dottoro.com/lcrthhhv.php",
          syntax: "always | auto | avoid"
        },
        "-webkit-column-break-before": {
          comment: "added, http://help.dottoro.com/lcxquvkf.php",
          syntax: "always | auto | avoid"
        },
        "-webkit-column-break-inside": {
          comment: "added, http://help.dottoro.com/lclhnthl.php",
          syntax: "always | auto | avoid"
        },
        "-webkit-font-smoothing": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth",
          syntax: "auto | none | antialiased | subpixel-antialiased"
        },
        "-webkit-mask-box-image": {
          comment: "missed; https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-box-image",
          syntax: "[ <url> | <gradient> | none ] [ <length-percentage>{4} <-webkit-mask-box-repeat>{2} ]?"
        },
        "-webkit-print-color-adjust": {
          comment: "missed",
          references: [
            "https://developer.mozilla.org/en/docs/Web/CSS/-webkit-print-color-adjust"
          ],
          syntax: "economy | exact"
        },
        "-webkit-text-security": {
          comment: "missed; http://help.dottoro.com/lcbkewgt.php",
          syntax: "none | circle | disc | square"
        },
        "-webkit-user-drag": {
          comment: "missed; http://help.dottoro.com/lcbixvwm.php",
          syntax: "none | element | auto"
        },
        "-webkit-user-select": {
          comment: "auto is supported by old webkit, https://developer.mozilla.org/en-US/docs/Web/CSS/user-select",
          syntax: "auto | none | text | all"
        },
        "alignment-baseline": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/text.html#AlignmentBaselineProperty"
          ],
          syntax: "auto | baseline | before-edge | text-before-edge | middle | central | after-edge | text-after-edge | ideographic | alphabetic | hanging | mathematical"
        },
        "baseline-shift": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/text.html#BaselineShiftProperty"
          ],
          syntax: "baseline | sub | super | <svg-length>"
        },
        behavior: {
          comment: "added old IE property https://msdn.microsoft.com/en-us/library/ms530723(v=vs.85).aspx",
          syntax: "<url>+"
        },
        "clip-rule": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/masking.html#ClipRuleProperty"
          ],
          syntax: "nonzero | evenodd"
        },
        cue: {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<'cue-before'> <'cue-after'>?"
        },
        "cue-after": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<url> <decibel>? | none"
        },
        "cue-before": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<url> <decibel>? | none"
        },
        cursor: {
          comment: "added legacy keywords: hand, -webkit-grab. -webkit-grabbing, -webkit-zoom-in, -webkit-zoom-out, -moz-grab, -moz-grabbing, -moz-zoom-in, -moz-zoom-out",
          references: [
            "https://www.sitepoint.com/css3-cursor-styles/"
          ],
          syntax: "[ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing | hand | -webkit-grab | -webkit-grabbing | -webkit-zoom-in | -webkit-zoom-out | -moz-grab | -moz-grabbing | -moz-zoom-in | -moz-zoom-out ] ]"
        },
        display: {
          comment: "extended with -ms-flexbox",
          syntax: "| <-non-standard-display>"
        },
        position: {
          comment: "extended with -webkit-sticky",
          syntax: "| -webkit-sticky"
        },
        "dominant-baseline": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/text.html#DominantBaselineProperty"
          ],
          syntax: "auto | use-script | no-change | reset-size | ideographic | alphabetic | hanging | mathematical | central | middle | text-after-edge | text-before-edge"
        },
        "image-rendering": {
          comment: "extended with <-non-standard-image-rendering>, added SVG keywords optimizeSpeed and optimizeQuality",
          references: [
            "https://developer.mozilla.org/en/docs/Web/CSS/image-rendering",
            "https://www.w3.org/TR/SVG/painting.html#ImageRenderingProperty"
          ],
          syntax: "| optimizeSpeed | optimizeQuality | <-non-standard-image-rendering>"
        },
        fill: {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#FillProperty"
          ],
          syntax: "<paint>"
        },
        "fill-opacity": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#FillProperty"
          ],
          syntax: "<number-zero-one>"
        },
        "fill-rule": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#FillProperty"
          ],
          syntax: "nonzero | evenodd"
        },
        filter: {
          comment: "extend with IE legacy syntaxes",
          syntax: "| <-ms-filter-function-list>"
        },
        "glyph-orientation-horizontal": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/text.html#GlyphOrientationHorizontalProperty"
          ],
          syntax: "<angle>"
        },
        "glyph-orientation-vertical": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/text.html#GlyphOrientationVerticalProperty"
          ],
          syntax: "<angle>"
        },
        kerning: {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/text.html#KerningProperty"
          ],
          syntax: "auto | <svg-length>"
        },
        "letter-spacing": {
          comment: "fix syntax <length> -> <length-percentage>",
          references: [
            "https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/letter-spacing"
          ],
          syntax: "normal | <length-percentage>"
        },
        marker: {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
          ],
          syntax: "none | <url>"
        },
        "marker-end": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
          ],
          syntax: "none | <url>"
        },
        "marker-mid": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
          ],
          syntax: "none | <url>"
        },
        "marker-start": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
          ],
          syntax: "none | <url>"
        },
        "max-width": {
          comment: "fix auto -> none (https://github.com/mdn/data/pull/431); extend by non-standard width keywords https://developer.mozilla.org/en-US/docs/Web/CSS/max-width",
          syntax: "none | <length-percentage> | min-content | max-content | fit-content(<length-percentage>) | <-non-standard-width>"
        },
        width: {
          comment: "per spec fit-content should be a function, however browsers are supporting it as a keyword (https://github.com/csstree/stylelint-validator/issues/29)",
          syntax: "| fit-content | -moz-fit-content | -webkit-fit-content"
        },
        "min-width": {
          comment: "extend by non-standard width keywords https://developer.mozilla.org/en-US/docs/Web/CSS/width",
          syntax: "auto | <length-percentage> | min-content | max-content | fit-content(<length-percentage>) | <-non-standard-width>"
        },
        overflow: {
          comment: "extend by vendor keywords https://developer.mozilla.org/en-US/docs/Web/CSS/overflow",
          syntax: "| <-non-standard-overflow>"
        },
        pause: {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<'pause-before'> <'pause-after'>?"
        },
        "pause-after": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
        },
        "pause-before": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
        },
        rest: {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<'rest-before'> <'rest-after'>?"
        },
        "rest-after": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
        },
        "rest-before": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<time> | none | x-weak | weak | medium | strong | x-strong"
        },
        "shape-rendering": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#ShapeRenderingPropert"
          ],
          syntax: "auto | optimizeSpeed | crispEdges | geometricPrecision"
        },
        src: {
          comment: "added @font-face's src property https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/src",
          syntax: "[ <url> [ format( <string># ) ]? | local( <family-name> ) ]#"
        },
        speak: {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "auto | none | normal"
        },
        "speak-as": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "normal | spell-out || digits || [ literal-punctuation | no-punctuation ]"
        },
        stroke: {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
          ],
          syntax: "<paint>"
        },
        "stroke-dasharray": {
          comment: "added SVG property; a list of comma and/or white space separated <length>s and <percentage>s",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
          ],
          syntax: "none | [ <svg-length>+ ]#"
        },
        "stroke-dashoffset": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
          ],
          syntax: "<svg-length>"
        },
        "stroke-linecap": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
          ],
          syntax: "butt | round | square"
        },
        "stroke-linejoin": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
          ],
          syntax: "miter | round | bevel"
        },
        "stroke-miterlimit": {
          comment: "added SVG property (<miterlimit> = <number-one-or-greater>) ",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
          ],
          syntax: "<number-one-or-greater>"
        },
        "stroke-opacity": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
          ],
          syntax: "<number-zero-one>"
        },
        "stroke-width": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
          ],
          syntax: "<svg-length>"
        },
        "text-anchor": {
          comment: "added SVG property",
          references: [
            "https://www.w3.org/TR/SVG/text.html#TextAlignmentProperties"
          ],
          syntax: "start | middle | end"
        },
        "unicode-bidi": {
          comment: "added prefixed keywords https://developer.mozilla.org/en-US/docs/Web/CSS/unicode-bidi",
          syntax: "| -moz-isolate | -moz-isolate-override | -moz-plaintext | -webkit-isolate | -webkit-isolate-override | -webkit-plaintext"
        },
        "unicode-range": {
          comment: "added missed property https://developer.mozilla.org/en-US/docs/Web/CSS/%40font-face/unicode-range",
          syntax: "<urange>#"
        },
        "voice-balance": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<number> | left | center | right | leftwards | rightwards"
        },
        "voice-duration": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "auto | <time>"
        },
        "voice-family": {
          comment: "<name> -> <family-name>, https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "[ [ <family-name> | <generic-voice> ] , ]* [ <family-name> | <generic-voice> ] | preserve"
        },
        "voice-pitch": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<frequency> && absolute | [ [ x-low | low | medium | high | x-high ] || [ <frequency> | <semitones> | <percentage> ] ]"
        },
        "voice-range": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "<frequency> && absolute | [ [ x-low | low | medium | high | x-high ] || [ <frequency> | <semitones> | <percentage> ] ]"
        },
        "voice-rate": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "[ normal | x-slow | slow | medium | fast | x-fast ] || <percentage>"
        },
        "voice-stress": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "normal | strong | moderate | none | reduced"
        },
        "voice-volume": {
          comment: "https://www.w3.org/TR/css3-speech/#property-index",
          syntax: "silent | [ [ x-soft | soft | medium | loud | x-loud ] || <decibel> ]"
        },
        "writing-mode": {
          comment: "extend with SVG keywords",
          syntax: "| <svg-writing-mode>"
        }
      },
      syntaxes: {
        "-legacy-gradient": {
          comment: "added collection of legacy gradient syntaxes",
          syntax: "<-webkit-gradient()> | <-legacy-linear-gradient> | <-legacy-repeating-linear-gradient> | <-legacy-radial-gradient> | <-legacy-repeating-radial-gradient>"
        },
        "-legacy-linear-gradient": {
          comment: "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
          syntax: "-moz-linear-gradient( <-legacy-linear-gradient-arguments> ) | -webkit-linear-gradient( <-legacy-linear-gradient-arguments> ) | -o-linear-gradient( <-legacy-linear-gradient-arguments> )"
        },
        "-legacy-repeating-linear-gradient": {
          comment: "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
          syntax: "-moz-repeating-linear-gradient( <-legacy-linear-gradient-arguments> ) | -webkit-repeating-linear-gradient( <-legacy-linear-gradient-arguments> ) | -o-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )"
        },
        "-legacy-linear-gradient-arguments": {
          comment: "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
          syntax: "[ <angle> | <side-or-corner> ]? , <color-stop-list>"
        },
        "-legacy-radial-gradient": {
          comment: "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
          syntax: "-moz-radial-gradient( <-legacy-radial-gradient-arguments> ) | -webkit-radial-gradient( <-legacy-radial-gradient-arguments> ) | -o-radial-gradient( <-legacy-radial-gradient-arguments> )"
        },
        "-legacy-repeating-radial-gradient": {
          comment: "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
          syntax: "-moz-repeating-radial-gradient( <-legacy-radial-gradient-arguments> ) | -webkit-repeating-radial-gradient( <-legacy-radial-gradient-arguments> ) | -o-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )"
        },
        "-legacy-radial-gradient-arguments": {
          comment: "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
          syntax: "[ <position> , ]? [ [ [ <-legacy-radial-gradient-shape> || <-legacy-radial-gradient-size> ] | [ <length> | <percentage> ]{2} ] , ]? <color-stop-list>"
        },
        "-legacy-radial-gradient-size": {
          comment: "before a standard it contains 2 extra keywords (`contain` and `cover`) https://www.w3.org/TR/2011/WD-css3-images-20110908/#ltsize",
          syntax: "closest-side | closest-corner | farthest-side | farthest-corner | contain | cover"
        },
        "-legacy-radial-gradient-shape": {
          comment: "define to double sure it doesn't extends in future https://www.w3.org/TR/2011/WD-css3-images-20110908/#ltshape",
          syntax: "circle | ellipse"
        },
        "-non-standard-font": {
          comment: "non standard fonts",
          references: [
            "https://webkit.org/blog/3709/using-the-system-font-in-web-content/"
          ],
          syntax: "-apple-system-body | -apple-system-headline | -apple-system-subheadline | -apple-system-caption1 | -apple-system-caption2 | -apple-system-footnote | -apple-system-short-body | -apple-system-short-headline | -apple-system-short-subheadline | -apple-system-short-caption1 | -apple-system-short-footnote | -apple-system-tall-body"
        },
        "-non-standard-color": {
          comment: "non standard colors",
          references: [
            "http://cssdot.ru/%D0%A1%D0%BF%D1%80%D0%B0%D0%B2%D0%BE%D1%87%D0%BD%D0%B8%D0%BA_CSS/color-i305.html",
            "https://developer.mozilla.org/en-US/docs/Web/CSS/color_value#Mozilla_Color_Preference_Extensions"
          ],
          syntax: "-moz-ButtonDefault | -moz-ButtonHoverFace | -moz-ButtonHoverText | -moz-CellHighlight | -moz-CellHighlightText | -moz-Combobox | -moz-ComboboxText | -moz-Dialog | -moz-DialogText | -moz-dragtargetzone | -moz-EvenTreeRow | -moz-Field | -moz-FieldText | -moz-html-CellHighlight | -moz-html-CellHighlightText | -moz-mac-accentdarkestshadow | -moz-mac-accentdarkshadow | -moz-mac-accentface | -moz-mac-accentlightesthighlight | -moz-mac-accentlightshadow | -moz-mac-accentregularhighlight | -moz-mac-accentregularshadow | -moz-mac-chrome-active | -moz-mac-chrome-inactive | -moz-mac-focusring | -moz-mac-menuselect | -moz-mac-menushadow | -moz-mac-menutextselect | -moz-MenuHover | -moz-MenuHoverText | -moz-MenuBarText | -moz-MenuBarHoverText | -moz-nativehyperlinktext | -moz-OddTreeRow | -moz-win-communicationstext | -moz-win-mediatext | -moz-activehyperlinktext | -moz-default-background-color | -moz-default-color | -moz-hyperlinktext | -moz-visitedhyperlinktext | -webkit-activelink | -webkit-focus-ring-color | -webkit-link | -webkit-text"
        },
        "-non-standard-image-rendering": {
          comment: "non-standard keywords http://phrogz.net/tmp/canvas_image_zoom.html",
          syntax: "optimize-contrast | -moz-crisp-edges | -o-crisp-edges | -webkit-optimize-contrast"
        },
        "-non-standard-overflow": {
          comment: "non-standard keywords https://developer.mozilla.org/en-US/docs/Web/CSS/overflow",
          syntax: "-moz-scrollbars-none | -moz-scrollbars-horizontal | -moz-scrollbars-vertical | -moz-hidden-unscrollable"
        },
        "-non-standard-width": {
          comment: "non-standard keywords https://developer.mozilla.org/en-US/docs/Web/CSS/width",
          syntax: "fill-available | min-intrinsic | intrinsic | -moz-available | -moz-fit-content | -moz-min-content | -moz-max-content | -webkit-min-content | -webkit-max-content"
        },
        "-webkit-gradient()": {
          comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/ - TODO: simplify when after match algorithm improvement ( [, point, radius | , point] -> [, radius]? , point )",
          syntax: "-webkit-gradient( <-webkit-gradient-type>, <-webkit-gradient-point> [, <-webkit-gradient-point> | , <-webkit-gradient-radius>, <-webkit-gradient-point> ] [, <-webkit-gradient-radius>]? [, <-webkit-gradient-color-stop>]* )"
        },
        "-webkit-gradient-color-stop": {
          comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
          syntax: "from( <color> ) | color-stop( [ <number-zero-one> | <percentage> ] , <color> ) | to( <color> )"
        },
        "-webkit-gradient-point": {
          comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
          syntax: "[ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ]"
        },
        "-webkit-gradient-radius": {
          comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
          syntax: "<length> | <percentage>"
        },
        "-webkit-gradient-type": {
          comment: "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
          syntax: "linear | radial"
        },
        "-webkit-mask-box-repeat": {
          comment: "missed; https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-box-image",
          syntax: "repeat | stretch | round"
        },
        "-webkit-mask-clip-style": {
          comment: "missed; there is no enough information about `-webkit-mask-clip` property, but looks like all those keywords are working",
          syntax: "border | border-box | padding | padding-box | content | content-box | text"
        },
        "-ms-filter-function-list": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/-ms-filter",
          syntax: "<-ms-filter-function>+"
        },
        "-ms-filter-function": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/-ms-filter",
          syntax: "<-ms-filter-function-progid> | <-ms-filter-function-legacy>"
        },
        "-ms-filter-function-progid": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/-ms-filter",
          syntax: "'progid:' [ <ident-token> '.' ]* [ <ident-token> | <function-token> <any-value>? ) ]"
        },
        "-ms-filter-function-legacy": {
          comment: "https://developer.mozilla.org/en-US/docs/Web/CSS/-ms-filter",
          syntax: "<ident-token> | <function-token> <any-value>? )"
        },
        "-ms-filter": {
          syntax: "<string>"
        },
        age: {
          comment: "https://www.w3.org/TR/css3-speech/#voice-family",
          syntax: "child | young | old"
        },
        "attr-name": {
          syntax: "<wq-name>"
        },
        "attr-fallback": {
          syntax: "<any-value>"
        },
        "border-radius": {
          comment: "missed, https://drafts.csswg.org/css-backgrounds-3/#the-border-radius",
          syntax: "<length-percentage>{1,2}"
        },
        bottom: {
          comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
          syntax: "<length> | auto"
        },
        "content-list": {
          comment: "missed -> https://drafts.csswg.org/css-content/#typedef-content-list (document-url, <target> and leader() is omitted util stabilization)",
          syntax: "[ <string> | contents | <image> | <quote> | <target> | <leader()> | <attr()> | counter( <ident>, <'list-style-type'>? ) ]+"
        },
        "element()": {
          comment: "https://drafts.csswg.org/css-gcpm/#element-syntax & https://drafts.csswg.org/css-images-4/#element-notation",
          syntax: "element( <custom-ident> , [ first | start | last | first-except ]? ) | element( <id-selector> )"
        },
        "generic-voice": {
          comment: "https://www.w3.org/TR/css3-speech/#voice-family",
          syntax: "[ <age>? <gender> <integer>? ]"
        },
        gender: {
          comment: "https://www.w3.org/TR/css3-speech/#voice-family",
          syntax: "male | female | neutral"
        },
        "generic-family": {
          comment: "added -apple-system",
          references: [
            "https://webkit.org/blog/3709/using-the-system-font-in-web-content/"
          ],
          syntax: "| -apple-system"
        },
        gradient: {
          comment: "added legacy syntaxes support",
          syntax: "| <-legacy-gradient>"
        },
        left: {
          comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
          syntax: "<length> | auto"
        },
        "mask-image": {
          comment: "missed; https://drafts.fxtf.org/css-masking-1/#the-mask-image",
          syntax: "<mask-reference>#"
        },
        "name-repeat": {
          comment: "missed, and looks like obsolete, keep it as is since other property syntaxes should be changed too; https://www.w3.org/TR/2015/WD-css-grid-1-20150917/#typedef-name-repeat",
          syntax: "repeat( [ <positive-integer> | auto-fill ], <line-names>+)"
        },
        "named-color": {
          comment: "added non standard color names",
          syntax: "| <-non-standard-color>"
        },
        paint: {
          comment: "used by SVG https://www.w3.org/TR/SVG/painting.html#SpecifyingPaint",
          syntax: "none | <color> | <url> [ none | <color> ]? | context-fill | context-stroke"
        },
        "page-size": {
          comment: "https://www.w3.org/TR/css-page-3/#typedef-page-size-page-size",
          syntax: "A5 | A4 | A3 | B5 | B4 | JIS-B5 | JIS-B4 | letter | legal | ledger"
        },
        ratio: {
          comment: "missed, https://drafts.csswg.org/mediaqueries-4/#typedef-ratio",
          syntax: "<integer> / <integer>"
        },
        right: {
          comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
          syntax: "<length> | auto"
        },
        shape: {
          comment: "missed spaces in function body and add backwards compatible syntax",
          syntax: "rect( <top>, <right>, <bottom>, <left> ) | rect( <top> <right> <bottom> <left> )"
        },
        "svg-length": {
          comment: "All coordinates and lengths in SVG can be specified with or without a unit identifier",
          references: [
            "https://www.w3.org/TR/SVG11/coords.html#Units"
          ],
          syntax: "<percentage> | <length> | <number>"
        },
        "svg-writing-mode": {
          comment: "SVG specific keywords (deprecated for CSS)",
          references: [
            "https://developer.mozilla.org/en/docs/Web/CSS/writing-mode",
            "https://www.w3.org/TR/SVG/text.html#WritingModeProperty"
          ],
          syntax: "lr-tb | rl-tb | tb-rl | lr | rl | tb"
        },
        top: {
          comment: "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
          syntax: "<length> | auto"
        },
        "track-group": {
          comment: "used by old grid-columns and grid-rows syntax v0",
          syntax: "'(' [ <string>* <track-minmax> <string>* ]+ ')' [ '[' <positive-integer> ']' ]? | <track-minmax>"
        },
        "track-list-v0": {
          comment: "used by old grid-columns and grid-rows syntax v0",
          syntax: "[ <string>* <track-group> <string>* ]+ | none"
        },
        "track-minmax": {
          comment: "used by old grid-columns and grid-rows syntax v0",
          syntax: "minmax( <track-breadth> , <track-breadth> ) | auto | <track-breadth> | fit-content"
        },
        x: {
          comment: "missed; not sure we should add it, but no others except `cursor` is using it so it's ok for now; https://drafts.csswg.org/css-ui-3/#cursor",
          syntax: "<number>"
        },
        y: {
          comment: "missed; not sure we should add it, but no others except `cursor` is using so it's ok for now; https://drafts.csswg.org/css-ui-3/#cursor",
          syntax: "<number>"
        },
        declaration: {
          comment: "missed, restored by https://drafts.csswg.org/css-syntax",
          syntax: "<ident-token> : <declaration-value>? [ '!' important ]?"
        },
        "declaration-list": {
          comment: "missed, restored by https://drafts.csswg.org/css-syntax",
          syntax: "[ <declaration>? ';' ]* <declaration>?"
        },
        url: {
          comment: "https://drafts.csswg.org/css-values-4/#urls",
          syntax: "url( <string> <url-modifier>* ) | <url-token>"
        },
        "url-modifier": {
          comment: "https://drafts.csswg.org/css-values-4/#typedef-url-modifier",
          syntax: "<ident> | <function-token> <any-value> )"
        },
        "number-zero-one": {
          syntax: "<number [0,1]>"
        },
        "number-one-or-greater": {
          syntax: "<number [1,\u221E]>"
        },
        "positive-integer": {
          syntax: "<integer [0,\u221E]>"
        },
        "-non-standard-display": {
          syntax: "-ms-inline-flexbox | -ms-grid | -ms-inline-grid | -webkit-flex | -webkit-inline-flex | -webkit-box | -webkit-inline-box | -moz-inline-stack | -moz-box | -moz-inline-box"
        }
      }
    };
  }
});

// node_modules/css-tree/data/index.js
var require_data = __commonJS({
  "node_modules/css-tree/data/index.js"(exports2, module2) {
    var mdnAtrules = require_at_rules();
    var mdnProperties = require_properties();
    var mdnSyntaxes = require_syntaxes();
    var patch = require_patch();
    var extendSyntax = /^\s*\|\s*/;
    function preprocessAtrules(dict) {
      const result = /* @__PURE__ */ Object.create(null);
      for (const atruleName in dict) {
        const atrule = dict[atruleName];
        let descriptors = null;
        if (atrule.descriptors) {
          descriptors = /* @__PURE__ */ Object.create(null);
          for (const descriptor in atrule.descriptors) {
            descriptors[descriptor] = atrule.descriptors[descriptor].syntax;
          }
        }
        result[atruleName.substr(1)] = {
          prelude: atrule.syntax.trim().match(/^@\S+\s+([^;\{]*)/)[1].trim() || null,
          descriptors
        };
      }
      return result;
    }
    function patchDictionary(dict, patchDict) {
      const result = {};
      for (const key in dict) {
        result[key] = dict[key].syntax || dict[key];
      }
      for (const key in patchDict) {
        if (key in dict) {
          if (patchDict[key].syntax) {
            result[key] = extendSyntax.test(patchDict[key].syntax) ? result[key] + " " + patchDict[key].syntax.trim() : patchDict[key].syntax;
          } else {
            delete result[key];
          }
        } else {
          if (patchDict[key].syntax) {
            result[key] = patchDict[key].syntax.replace(extendSyntax, "");
          }
        }
      }
      return result;
    }
    function unpackSyntaxes(dict) {
      const result = {};
      for (const key in dict) {
        result[key] = dict[key].syntax;
      }
      return result;
    }
    function patchAtrules(dict, patchDict) {
      const result = {};
      for (const key in dict) {
        const patchDescriptors = patchDict[key] && patchDict[key].descriptors || null;
        result[key] = {
          prelude: key in patchDict && "prelude" in patchDict[key] ? patchDict[key].prelude : dict[key].prelude || null,
          descriptors: dict[key].descriptors ? patchDictionary(dict[key].descriptors, patchDescriptors || {}) : patchDescriptors && unpackSyntaxes(patchDescriptors)
        };
      }
      for (const key in patchDict) {
        if (!hasOwnProperty.call(dict, key)) {
          result[key] = {
            prelude: patchDict[key].prelude || null,
            descriptors: patchDict[key].descriptors && unpackSyntaxes(patchDict[key].descriptors)
          };
        }
      }
      return result;
    }
    module2.exports = {
      types: patchDictionary(mdnSyntaxes, patch.syntaxes),
      atrules: patchAtrules(preprocessAtrules(mdnAtrules), patch.atrules),
      properties: patchDictionary(mdnProperties, patch.properties)
    };
  }
});

// node_modules/css-tree/lib/syntax/node/AnPlusB.js
var require_AnPlusB = __commonJS({
  "node_modules/css-tree/lib/syntax/node/AnPlusB.js"(exports2, module2) {
    var cmpChar = require_tokenizer().cmpChar;
    var isDigit = require_tokenizer().isDigit;
    var TYPE = require_tokenizer().TYPE;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    var IDENT = TYPE.Ident;
    var NUMBER = TYPE.Number;
    var DIMENSION = TYPE.Dimension;
    var PLUSSIGN = 43;
    var HYPHENMINUS = 45;
    var N = 110;
    var DISALLOW_SIGN = true;
    var ALLOW_SIGN = false;
    function checkInteger(offset, disallowSign) {
      var pos = this.scanner.tokenStart + offset;
      var code = this.scanner.source.charCodeAt(pos);
      if (code === PLUSSIGN || code === HYPHENMINUS) {
        if (disallowSign) {
          this.error("Number sign is not allowed");
        }
        pos++;
      }
      for (; pos < this.scanner.tokenEnd; pos++) {
        if (!isDigit(this.scanner.source.charCodeAt(pos))) {
          this.error("Integer is expected", pos);
        }
      }
    }
    function checkTokenIsInteger(disallowSign) {
      return checkInteger.call(this, 0, disallowSign);
    }
    function expectCharCode(offset, code) {
      if (!cmpChar(this.scanner.source, this.scanner.tokenStart + offset, code)) {
        var msg = "";
        switch (code) {
          case N:
            msg = "N is expected";
            break;
          case HYPHENMINUS:
            msg = "HyphenMinus is expected";
            break;
        }
        this.error(msg, this.scanner.tokenStart + offset);
      }
    }
    function consumeB() {
      var offset = 0;
      var sign = 0;
      var type = this.scanner.tokenType;
      while (type === WHITESPACE || type === COMMENT) {
        type = this.scanner.lookupType(++offset);
      }
      if (type !== NUMBER) {
        if (this.scanner.isDelim(PLUSSIGN, offset) || this.scanner.isDelim(HYPHENMINUS, offset)) {
          sign = this.scanner.isDelim(PLUSSIGN, offset) ? PLUSSIGN : HYPHENMINUS;
          do {
            type = this.scanner.lookupType(++offset);
          } while (type === WHITESPACE || type === COMMENT);
          if (type !== NUMBER) {
            this.scanner.skip(offset);
            checkTokenIsInteger.call(this, DISALLOW_SIGN);
          }
        } else {
          return null;
        }
      }
      if (offset > 0) {
        this.scanner.skip(offset);
      }
      if (sign === 0) {
        type = this.scanner.source.charCodeAt(this.scanner.tokenStart);
        if (type !== PLUSSIGN && type !== HYPHENMINUS) {
          this.error("Number sign is expected");
        }
      }
      checkTokenIsInteger.call(this, sign !== 0);
      return sign === HYPHENMINUS ? "-" + this.consume(NUMBER) : this.consume(NUMBER);
    }
    module2.exports = {
      name: "AnPlusB",
      structure: {
        a: [String, null],
        b: [String, null]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var a = null;
        var b = null;
        if (this.scanner.tokenType === NUMBER) {
          checkTokenIsInteger.call(this, ALLOW_SIGN);
          b = this.consume(NUMBER);
        } else if (this.scanner.tokenType === IDENT && cmpChar(this.scanner.source, this.scanner.tokenStart, HYPHENMINUS)) {
          a = "-1";
          expectCharCode.call(this, 1, N);
          switch (this.scanner.getTokenLength()) {
            case 2:
              this.scanner.next();
              b = consumeB.call(this);
              break;
            case 3:
              expectCharCode.call(this, 2, HYPHENMINUS);
              this.scanner.next();
              this.scanner.skipSC();
              checkTokenIsInteger.call(this, DISALLOW_SIGN);
              b = "-" + this.consume(NUMBER);
              break;
            default:
              expectCharCode.call(this, 2, HYPHENMINUS);
              checkInteger.call(this, 3, DISALLOW_SIGN);
              this.scanner.next();
              b = this.scanner.substrToCursor(start + 2);
          }
        } else if (this.scanner.tokenType === IDENT || this.scanner.isDelim(PLUSSIGN) && this.scanner.lookupType(1) === IDENT) {
          var sign = 0;
          a = "1";
          if (this.scanner.isDelim(PLUSSIGN)) {
            sign = 1;
            this.scanner.next();
          }
          expectCharCode.call(this, 0, N);
          switch (this.scanner.getTokenLength()) {
            case 1:
              this.scanner.next();
              b = consumeB.call(this);
              break;
            case 2:
              expectCharCode.call(this, 1, HYPHENMINUS);
              this.scanner.next();
              this.scanner.skipSC();
              checkTokenIsInteger.call(this, DISALLOW_SIGN);
              b = "-" + this.consume(NUMBER);
              break;
            default:
              expectCharCode.call(this, 1, HYPHENMINUS);
              checkInteger.call(this, 2, DISALLOW_SIGN);
              this.scanner.next();
              b = this.scanner.substrToCursor(start + sign + 1);
          }
        } else if (this.scanner.tokenType === DIMENSION) {
          var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
          var sign = code === PLUSSIGN || code === HYPHENMINUS;
          for (var i = this.scanner.tokenStart + sign; i < this.scanner.tokenEnd; i++) {
            if (!isDigit(this.scanner.source.charCodeAt(i))) {
              break;
            }
          }
          if (i === this.scanner.tokenStart + sign) {
            this.error("Integer is expected", this.scanner.tokenStart + sign);
          }
          expectCharCode.call(this, i - this.scanner.tokenStart, N);
          a = this.scanner.source.substring(start, i);
          if (i + 1 === this.scanner.tokenEnd) {
            this.scanner.next();
            b = consumeB.call(this);
          } else {
            expectCharCode.call(this, i - this.scanner.tokenStart + 1, HYPHENMINUS);
            if (i + 2 === this.scanner.tokenEnd) {
              this.scanner.next();
              this.scanner.skipSC();
              checkTokenIsInteger.call(this, DISALLOW_SIGN);
              b = "-" + this.consume(NUMBER);
            } else {
              checkInteger.call(this, i - this.scanner.tokenStart + 2, DISALLOW_SIGN);
              this.scanner.next();
              b = this.scanner.substrToCursor(i + 1);
            }
          }
        } else {
          this.error();
        }
        if (a !== null && a.charCodeAt(0) === PLUSSIGN) {
          a = a.substr(1);
        }
        if (b !== null && b.charCodeAt(0) === PLUSSIGN) {
          b = b.substr(1);
        }
        return {
          type: "AnPlusB",
          loc: this.getLocation(start, this.scanner.tokenStart),
          a,
          b
        };
      },
      generate: function(node) {
        var a = node.a !== null && node.a !== void 0;
        var b = node.b !== null && node.b !== void 0;
        if (a) {
          this.chunk(node.a === "+1" ? "+n" : node.a === "1" ? "n" : node.a === "-1" ? "-n" : node.a + "n");
          if (b) {
            b = String(node.b);
            if (b.charAt(0) === "-" || b.charAt(0) === "+") {
              this.chunk(b.charAt(0));
              this.chunk(b.substr(1));
            } else {
              this.chunk("+");
              this.chunk(b);
            }
          }
        } else {
          this.chunk(String(node.b));
        }
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Raw.js
var require_Raw = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Raw.js"(exports2, module2) {
    var tokenizer = require_tokenizer();
    var TYPE = tokenizer.TYPE;
    var WhiteSpace = TYPE.WhiteSpace;
    var Semicolon = TYPE.Semicolon;
    var LeftCurlyBracket = TYPE.LeftCurlyBracket;
    var Delim = TYPE.Delim;
    var EXCLAMATIONMARK = 33;
    function getOffsetExcludeWS() {
      if (this.scanner.tokenIndex > 0) {
        if (this.scanner.lookupType(-1) === WhiteSpace) {
          return this.scanner.tokenIndex > 1 ? this.scanner.getTokenStart(this.scanner.tokenIndex - 1) : this.scanner.firstCharOffset;
        }
      }
      return this.scanner.tokenStart;
    }
    function balanceEnd() {
      return 0;
    }
    function leftCurlyBracket(tokenType) {
      return tokenType === LeftCurlyBracket ? 1 : 0;
    }
    function leftCurlyBracketOrSemicolon(tokenType) {
      return tokenType === LeftCurlyBracket || tokenType === Semicolon ? 1 : 0;
    }
    function exclamationMarkOrSemicolon(tokenType, source, offset) {
      if (tokenType === Delim && source.charCodeAt(offset) === EXCLAMATIONMARK) {
        return 1;
      }
      return tokenType === Semicolon ? 1 : 0;
    }
    function semicolonIncluded(tokenType) {
      return tokenType === Semicolon ? 2 : 0;
    }
    module2.exports = {
      name: "Raw",
      structure: {
        value: String
      },
      parse: function(startToken, mode, excludeWhiteSpace) {
        var startOffset = this.scanner.getTokenStart(startToken);
        var endOffset;
        this.scanner.skip(this.scanner.getRawLength(startToken, mode || balanceEnd));
        if (excludeWhiteSpace && this.scanner.tokenStart > startOffset) {
          endOffset = getOffsetExcludeWS.call(this);
        } else {
          endOffset = this.scanner.tokenStart;
        }
        return {
          type: "Raw",
          loc: this.getLocation(startOffset, endOffset),
          value: this.scanner.source.substring(startOffset, endOffset)
        };
      },
      generate: function(node) {
        this.chunk(node.value);
      },
      mode: {
        default: balanceEnd,
        leftCurlyBracket,
        leftCurlyBracketOrSemicolon,
        exclamationMarkOrSemicolon,
        semicolonIncluded
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Atrule.js
var require_Atrule = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Atrule.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var rawMode = require_Raw().mode;
    var ATKEYWORD = TYPE.AtKeyword;
    var SEMICOLON = TYPE.Semicolon;
    var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
    var RIGHTCURLYBRACKET = TYPE.RightCurlyBracket;
    function consumeRaw(startToken) {
      return this.Raw(startToken, rawMode.leftCurlyBracketOrSemicolon, true);
    }
    function isDeclarationBlockAtrule() {
      for (var offset = 1, type; type = this.scanner.lookupType(offset); offset++) {
        if (type === RIGHTCURLYBRACKET) {
          return true;
        }
        if (type === LEFTCURLYBRACKET || type === ATKEYWORD) {
          return false;
        }
      }
      return false;
    }
    module2.exports = {
      name: "Atrule",
      structure: {
        name: String,
        prelude: ["AtrulePrelude", "Raw", null],
        block: ["Block", null]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var name;
        var nameLowerCase;
        var prelude = null;
        var block = null;
        this.eat(ATKEYWORD);
        name = this.scanner.substrToCursor(start + 1);
        nameLowerCase = name.toLowerCase();
        this.scanner.skipSC();
        if (this.scanner.eof === false && this.scanner.tokenType !== LEFTCURLYBRACKET && this.scanner.tokenType !== SEMICOLON) {
          if (this.parseAtrulePrelude) {
            prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name), consumeRaw);
            if (prelude.type === "AtrulePrelude" && prelude.children.head === null) {
              prelude = null;
            }
          } else {
            prelude = consumeRaw.call(this, this.scanner.tokenIndex);
          }
          this.scanner.skipSC();
        }
        switch (this.scanner.tokenType) {
          case SEMICOLON:
            this.scanner.next();
            break;
          case LEFTCURLYBRACKET:
            if (this.atrule.hasOwnProperty(nameLowerCase) && typeof this.atrule[nameLowerCase].block === "function") {
              block = this.atrule[nameLowerCase].block.call(this);
            } else {
              block = this.Block(isDeclarationBlockAtrule.call(this));
            }
            break;
        }
        return {
          type: "Atrule",
          loc: this.getLocation(start, this.scanner.tokenStart),
          name,
          prelude,
          block
        };
      },
      generate: function(node) {
        this.chunk("@");
        this.chunk(node.name);
        if (node.prelude !== null) {
          this.chunk(" ");
          this.node(node.prelude);
        }
        if (node.block) {
          this.node(node.block);
        } else {
          this.chunk(";");
        }
      },
      walkContext: "atrule"
    };
  }
});

// node_modules/css-tree/lib/syntax/node/AtrulePrelude.js
var require_AtrulePrelude = __commonJS({
  "node_modules/css-tree/lib/syntax/node/AtrulePrelude.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var SEMICOLON = TYPE.Semicolon;
    var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
    module2.exports = {
      name: "AtrulePrelude",
      structure: {
        children: [[]]
      },
      parse: function(name) {
        var children = null;
        if (name !== null) {
          name = name.toLowerCase();
        }
        this.scanner.skipSC();
        if (this.atrule.hasOwnProperty(name) && typeof this.atrule[name].prelude === "function") {
          children = this.atrule[name].prelude.call(this);
        } else {
          children = this.readSequence(this.scope.AtrulePrelude);
        }
        this.scanner.skipSC();
        if (this.scanner.eof !== true && this.scanner.tokenType !== LEFTCURLYBRACKET && this.scanner.tokenType !== SEMICOLON) {
          this.error("Semicolon or block is expected");
        }
        if (children === null) {
          children = this.createList();
        }
        return {
          type: "AtrulePrelude",
          loc: this.getLocationFromList(children),
          children
        };
      },
      generate: function(node) {
        this.children(node);
      },
      walkContext: "atrulePrelude"
    };
  }
});

// node_modules/css-tree/lib/syntax/node/AttributeSelector.js
var require_AttributeSelector = __commonJS({
  "node_modules/css-tree/lib/syntax/node/AttributeSelector.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    var STRING = TYPE.String;
    var COLON = TYPE.Colon;
    var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
    var RIGHTSQUAREBRACKET = TYPE.RightSquareBracket;
    var DOLLARSIGN = 36;
    var ASTERISK = 42;
    var EQUALSSIGN = 61;
    var CIRCUMFLEXACCENT = 94;
    var VERTICALLINE = 124;
    var TILDE = 126;
    function getAttributeName() {
      if (this.scanner.eof) {
        this.error("Unexpected end of input");
      }
      var start = this.scanner.tokenStart;
      var expectIdent = false;
      var checkColon = true;
      if (this.scanner.isDelim(ASTERISK)) {
        expectIdent = true;
        checkColon = false;
        this.scanner.next();
      } else if (!this.scanner.isDelim(VERTICALLINE)) {
        this.eat(IDENT);
      }
      if (this.scanner.isDelim(VERTICALLINE)) {
        if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 1) !== EQUALSSIGN) {
          this.scanner.next();
          this.eat(IDENT);
        } else if (expectIdent) {
          this.error("Identifier is expected", this.scanner.tokenEnd);
        }
      } else if (expectIdent) {
        this.error("Vertical line is expected");
      }
      if (checkColon && this.scanner.tokenType === COLON) {
        this.scanner.next();
        this.eat(IDENT);
      }
      return {
        type: "Identifier",
        loc: this.getLocation(start, this.scanner.tokenStart),
        name: this.scanner.substrToCursor(start)
      };
    }
    function getOperator() {
      var start = this.scanner.tokenStart;
      var code = this.scanner.source.charCodeAt(start);
      if (code !== EQUALSSIGN && code !== TILDE && code !== CIRCUMFLEXACCENT && code !== DOLLARSIGN && code !== ASTERISK && code !== VERTICALLINE) {
        this.error("Attribute selector (=, ~=, ^=, $=, *=, |=) is expected");
      }
      this.scanner.next();
      if (code !== EQUALSSIGN) {
        if (!this.scanner.isDelim(EQUALSSIGN)) {
          this.error("Equal sign is expected");
        }
        this.scanner.next();
      }
      return this.scanner.substrToCursor(start);
    }
    module2.exports = {
      name: "AttributeSelector",
      structure: {
        name: "Identifier",
        matcher: [String, null],
        value: ["String", "Identifier", null],
        flags: [String, null]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var name;
        var matcher = null;
        var value = null;
        var flags = null;
        this.eat(LEFTSQUAREBRACKET);
        this.scanner.skipSC();
        name = getAttributeName.call(this);
        this.scanner.skipSC();
        if (this.scanner.tokenType !== RIGHTSQUAREBRACKET) {
          if (this.scanner.tokenType !== IDENT) {
            matcher = getOperator.call(this);
            this.scanner.skipSC();
            value = this.scanner.tokenType === STRING ? this.String() : this.Identifier();
            this.scanner.skipSC();
          }
          if (this.scanner.tokenType === IDENT) {
            flags = this.scanner.getTokenValue();
            this.scanner.next();
            this.scanner.skipSC();
          }
        }
        this.eat(RIGHTSQUAREBRACKET);
        return {
          type: "AttributeSelector",
          loc: this.getLocation(start, this.scanner.tokenStart),
          name,
          matcher,
          value,
          flags
        };
      },
      generate: function(node) {
        var flagsPrefix = " ";
        this.chunk("[");
        this.node(node.name);
        if (node.matcher !== null) {
          this.chunk(node.matcher);
          if (node.value !== null) {
            this.node(node.value);
            if (node.value.type === "String") {
              flagsPrefix = "";
            }
          }
        }
        if (node.flags !== null) {
          this.chunk(flagsPrefix);
          this.chunk(node.flags);
        }
        this.chunk("]");
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Block.js
var require_Block = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Block.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var rawMode = require_Raw().mode;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    var SEMICOLON = TYPE.Semicolon;
    var ATKEYWORD = TYPE.AtKeyword;
    var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
    var RIGHTCURLYBRACKET = TYPE.RightCurlyBracket;
    function consumeRaw(startToken) {
      return this.Raw(startToken, null, true);
    }
    function consumeRule() {
      return this.parseWithFallback(this.Rule, consumeRaw);
    }
    function consumeRawDeclaration(startToken) {
      return this.Raw(startToken, rawMode.semicolonIncluded, true);
    }
    function consumeDeclaration() {
      if (this.scanner.tokenType === SEMICOLON) {
        return consumeRawDeclaration.call(this, this.scanner.tokenIndex);
      }
      var node = this.parseWithFallback(this.Declaration, consumeRawDeclaration);
      if (this.scanner.tokenType === SEMICOLON) {
        this.scanner.next();
      }
      return node;
    }
    module2.exports = {
      name: "Block",
      structure: {
        children: [[
          "Atrule",
          "Rule",
          "Declaration"
        ]]
      },
      parse: function(isDeclaration) {
        var consumer = isDeclaration ? consumeDeclaration : consumeRule;
        var start = this.scanner.tokenStart;
        var children = this.createList();
        this.eat(LEFTCURLYBRACKET);
        scan:
          while (!this.scanner.eof) {
            switch (this.scanner.tokenType) {
              case RIGHTCURLYBRACKET:
                break scan;
              case WHITESPACE:
              case COMMENT:
                this.scanner.next();
                break;
              case ATKEYWORD:
                children.push(this.parseWithFallback(this.Atrule, consumeRaw));
                break;
              default:
                children.push(consumer.call(this));
            }
          }
        if (!this.scanner.eof) {
          this.eat(RIGHTCURLYBRACKET);
        }
        return {
          type: "Block",
          loc: this.getLocation(start, this.scanner.tokenStart),
          children
        };
      },
      generate: function(node) {
        this.chunk("{");
        this.children(node, function(prev) {
          if (prev.type === "Declaration") {
            this.chunk(";");
          }
        });
        this.chunk("}");
      },
      walkContext: "block"
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Brackets.js
var require_Brackets = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Brackets.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
    var RIGHTSQUAREBRACKET = TYPE.RightSquareBracket;
    module2.exports = {
      name: "Brackets",
      structure: {
        children: [[]]
      },
      parse: function(readSequence, recognizer) {
        var start = this.scanner.tokenStart;
        var children = null;
        this.eat(LEFTSQUAREBRACKET);
        children = readSequence.call(this, recognizer);
        if (!this.scanner.eof) {
          this.eat(RIGHTSQUAREBRACKET);
        }
        return {
          type: "Brackets",
          loc: this.getLocation(start, this.scanner.tokenStart),
          children
        };
      },
      generate: function(node) {
        this.chunk("[");
        this.children(node);
        this.chunk("]");
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/CDC.js
var require_CDC = __commonJS({
  "node_modules/css-tree/lib/syntax/node/CDC.js"(exports2, module2) {
    var CDC = require_tokenizer().TYPE.CDC;
    module2.exports = {
      name: "CDC",
      structure: [],
      parse: function() {
        var start = this.scanner.tokenStart;
        this.eat(CDC);
        return {
          type: "CDC",
          loc: this.getLocation(start, this.scanner.tokenStart)
        };
      },
      generate: function() {
        this.chunk("-->");
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/CDO.js
var require_CDO = __commonJS({
  "node_modules/css-tree/lib/syntax/node/CDO.js"(exports2, module2) {
    var CDO = require_tokenizer().TYPE.CDO;
    module2.exports = {
      name: "CDO",
      structure: [],
      parse: function() {
        var start = this.scanner.tokenStart;
        this.eat(CDO);
        return {
          type: "CDO",
          loc: this.getLocation(start, this.scanner.tokenStart)
        };
      },
      generate: function() {
        this.chunk("<!--");
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/ClassSelector.js
var require_ClassSelector = __commonJS({
  "node_modules/css-tree/lib/syntax/node/ClassSelector.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    var FULLSTOP = 46;
    module2.exports = {
      name: "ClassSelector",
      structure: {
        name: String
      },
      parse: function() {
        if (!this.scanner.isDelim(FULLSTOP)) {
          this.error("Full stop is expected");
        }
        this.scanner.next();
        return {
          type: "ClassSelector",
          loc: this.getLocation(this.scanner.tokenStart - 1, this.scanner.tokenEnd),
          name: this.consume(IDENT)
        };
      },
      generate: function(node) {
        this.chunk(".");
        this.chunk(node.name);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Combinator.js
var require_Combinator = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Combinator.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    var PLUSSIGN = 43;
    var SOLIDUS = 47;
    var GREATERTHANSIGN = 62;
    var TILDE = 126;
    module2.exports = {
      name: "Combinator",
      structure: {
        name: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
        switch (code) {
          case GREATERTHANSIGN:
          case PLUSSIGN:
          case TILDE:
            this.scanner.next();
            break;
          case SOLIDUS:
            this.scanner.next();
            if (this.scanner.tokenType !== IDENT || this.scanner.lookupValue(0, "deep") === false) {
              this.error("Identifier `deep` is expected");
            }
            this.scanner.next();
            if (!this.scanner.isDelim(SOLIDUS)) {
              this.error("Solidus is expected");
            }
            this.scanner.next();
            break;
          default:
            this.error("Combinator is expected");
        }
        return {
          type: "Combinator",
          loc: this.getLocation(start, this.scanner.tokenStart),
          name: this.scanner.substrToCursor(start)
        };
      },
      generate: function(node) {
        this.chunk(node.name);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Comment.js
var require_Comment = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Comment.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var COMMENT = TYPE.Comment;
    var ASTERISK = 42;
    var SOLIDUS = 47;
    module2.exports = {
      name: "Comment",
      structure: {
        value: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var end = this.scanner.tokenEnd;
        this.eat(COMMENT);
        if (end - start + 2 >= 2 && this.scanner.source.charCodeAt(end - 2) === ASTERISK && this.scanner.source.charCodeAt(end - 1) === SOLIDUS) {
          end -= 2;
        }
        return {
          type: "Comment",
          loc: this.getLocation(start, this.scanner.tokenStart),
          value: this.scanner.source.substring(start + 2, end)
        };
      },
      generate: function(node) {
        this.chunk("/*");
        this.chunk(node.value);
        this.chunk("*/");
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Declaration.js
var require_Declaration = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Declaration.js"(exports2, module2) {
    var isCustomProperty = require_names2().isCustomProperty;
    var TYPE = require_tokenizer().TYPE;
    var rawMode = require_Raw().mode;
    var IDENT = TYPE.Ident;
    var HASH = TYPE.Hash;
    var COLON = TYPE.Colon;
    var SEMICOLON = TYPE.Semicolon;
    var DELIM = TYPE.Delim;
    var WHITESPACE = TYPE.WhiteSpace;
    var EXCLAMATIONMARK = 33;
    var NUMBERSIGN = 35;
    var DOLLARSIGN = 36;
    var AMPERSAND = 38;
    var ASTERISK = 42;
    var PLUSSIGN = 43;
    var SOLIDUS = 47;
    function consumeValueRaw(startToken) {
      return this.Raw(startToken, rawMode.exclamationMarkOrSemicolon, true);
    }
    function consumeCustomPropertyRaw(startToken) {
      return this.Raw(startToken, rawMode.exclamationMarkOrSemicolon, false);
    }
    function consumeValue() {
      var startValueToken = this.scanner.tokenIndex;
      var value = this.Value();
      if (value.type !== "Raw" && this.scanner.eof === false && this.scanner.tokenType !== SEMICOLON && this.scanner.isDelim(EXCLAMATIONMARK) === false && this.scanner.isBalanceEdge(startValueToken) === false) {
        this.error();
      }
      return value;
    }
    module2.exports = {
      name: "Declaration",
      structure: {
        important: [Boolean, String],
        property: String,
        value: ["Value", "Raw"]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var startToken = this.scanner.tokenIndex;
        var property = readProperty.call(this);
        var customProperty = isCustomProperty(property);
        var parseValue = customProperty ? this.parseCustomProperty : this.parseValue;
        var consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw;
        var important = false;
        var value;
        this.scanner.skipSC();
        this.eat(COLON);
        const valueStart = this.scanner.tokenIndex;
        if (!customProperty) {
          this.scanner.skipSC();
        }
        if (parseValue) {
          value = this.parseWithFallback(consumeValue, consumeRaw);
        } else {
          value = consumeRaw.call(this, this.scanner.tokenIndex);
        }
        if (customProperty && value.type === "Value" && value.children.isEmpty()) {
          for (let offset = valueStart - this.scanner.tokenIndex; offset <= 0; offset++) {
            if (this.scanner.lookupType(offset) === WHITESPACE) {
              value.children.appendData({
                type: "WhiteSpace",
                loc: null,
                value: " "
              });
              break;
            }
          }
        }
        if (this.scanner.isDelim(EXCLAMATIONMARK)) {
          important = getImportant.call(this);
          this.scanner.skipSC();
        }
        if (this.scanner.eof === false && this.scanner.tokenType !== SEMICOLON && this.scanner.isBalanceEdge(startToken) === false) {
          this.error();
        }
        return {
          type: "Declaration",
          loc: this.getLocation(start, this.scanner.tokenStart),
          important,
          property,
          value
        };
      },
      generate: function(node) {
        this.chunk(node.property);
        this.chunk(":");
        this.node(node.value);
        if (node.important) {
          this.chunk(node.important === true ? "!important" : "!" + node.important);
        }
      },
      walkContext: "declaration"
    };
    function readProperty() {
      var start = this.scanner.tokenStart;
      var prefix = 0;
      if (this.scanner.tokenType === DELIM) {
        switch (this.scanner.source.charCodeAt(this.scanner.tokenStart)) {
          case ASTERISK:
          case DOLLARSIGN:
          case PLUSSIGN:
          case NUMBERSIGN:
          case AMPERSAND:
            this.scanner.next();
            break;
          case SOLIDUS:
            this.scanner.next();
            if (this.scanner.isDelim(SOLIDUS)) {
              this.scanner.next();
            }
            break;
        }
      }
      if (prefix) {
        this.scanner.skip(prefix);
      }
      if (this.scanner.tokenType === HASH) {
        this.eat(HASH);
      } else {
        this.eat(IDENT);
      }
      return this.scanner.substrToCursor(start);
    }
    function getImportant() {
      this.eat(DELIM);
      this.scanner.skipSC();
      var important = this.consume(IDENT);
      return important === "important" ? true : important;
    }
  }
});

// node_modules/css-tree/lib/syntax/node/DeclarationList.js
var require_DeclarationList = __commonJS({
  "node_modules/css-tree/lib/syntax/node/DeclarationList.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var rawMode = require_Raw().mode;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    var SEMICOLON = TYPE.Semicolon;
    function consumeRaw(startToken) {
      return this.Raw(startToken, rawMode.semicolonIncluded, true);
    }
    module2.exports = {
      name: "DeclarationList",
      structure: {
        children: [[
          "Declaration"
        ]]
      },
      parse: function() {
        var children = this.createList();
        scan:
          while (!this.scanner.eof) {
            switch (this.scanner.tokenType) {
              case WHITESPACE:
              case COMMENT:
              case SEMICOLON:
                this.scanner.next();
                break;
              default:
                children.push(this.parseWithFallback(this.Declaration, consumeRaw));
            }
          }
        return {
          type: "DeclarationList",
          loc: this.getLocationFromList(children),
          children
        };
      },
      generate: function(node) {
        this.children(node, function(prev) {
          if (prev.type === "Declaration") {
            this.chunk(";");
          }
        });
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Dimension.js
var require_Dimension = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Dimension.js"(exports2, module2) {
    var consumeNumber = require_utils3().consumeNumber;
    var TYPE = require_tokenizer().TYPE;
    var DIMENSION = TYPE.Dimension;
    module2.exports = {
      name: "Dimension",
      structure: {
        value: String,
        unit: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var numberEnd = consumeNumber(this.scanner.source, start);
        this.eat(DIMENSION);
        return {
          type: "Dimension",
          loc: this.getLocation(start, this.scanner.tokenStart),
          value: this.scanner.source.substring(start, numberEnd),
          unit: this.scanner.source.substring(numberEnd, this.scanner.tokenStart)
        };
      },
      generate: function(node) {
        this.chunk(node.value);
        this.chunk(node.unit);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Function.js
var require_Function = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Function.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var RIGHTPARENTHESIS = TYPE.RightParenthesis;
    module2.exports = {
      name: "Function",
      structure: {
        name: String,
        children: [[]]
      },
      parse: function(readSequence, recognizer) {
        var start = this.scanner.tokenStart;
        var name = this.consumeFunctionName();
        var nameLowerCase = name.toLowerCase();
        var children;
        children = recognizer.hasOwnProperty(nameLowerCase) ? recognizer[nameLowerCase].call(this, recognizer) : readSequence.call(this, recognizer);
        if (!this.scanner.eof) {
          this.eat(RIGHTPARENTHESIS);
        }
        return {
          type: "Function",
          loc: this.getLocation(start, this.scanner.tokenStart),
          name,
          children
        };
      },
      generate: function(node) {
        this.chunk(node.name);
        this.chunk("(");
        this.children(node);
        this.chunk(")");
      },
      walkContext: "function"
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Hash.js
var require_Hash = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Hash.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var HASH = TYPE.Hash;
    module2.exports = {
      name: "Hash",
      structure: {
        value: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        this.eat(HASH);
        return {
          type: "Hash",
          loc: this.getLocation(start, this.scanner.tokenStart),
          value: this.scanner.substrToCursor(start + 1)
        };
      },
      generate: function(node) {
        this.chunk("#");
        this.chunk(node.value);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Identifier.js
var require_Identifier = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Identifier.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    module2.exports = {
      name: "Identifier",
      structure: {
        name: String
      },
      parse: function() {
        return {
          type: "Identifier",
          loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
          name: this.consume(IDENT)
        };
      },
      generate: function(node) {
        this.chunk(node.name);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/IdSelector.js
var require_IdSelector = __commonJS({
  "node_modules/css-tree/lib/syntax/node/IdSelector.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var HASH = TYPE.Hash;
    module2.exports = {
      name: "IdSelector",
      structure: {
        name: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        this.eat(HASH);
        return {
          type: "IdSelector",
          loc: this.getLocation(start, this.scanner.tokenStart),
          name: this.scanner.substrToCursor(start + 1)
        };
      },
      generate: function(node) {
        this.chunk("#");
        this.chunk(node.name);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/MediaFeature.js
var require_MediaFeature = __commonJS({
  "node_modules/css-tree/lib/syntax/node/MediaFeature.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    var NUMBER = TYPE.Number;
    var DIMENSION = TYPE.Dimension;
    var LEFTPARENTHESIS = TYPE.LeftParenthesis;
    var RIGHTPARENTHESIS = TYPE.RightParenthesis;
    var COLON = TYPE.Colon;
    var DELIM = TYPE.Delim;
    module2.exports = {
      name: "MediaFeature",
      structure: {
        name: String,
        value: ["Identifier", "Number", "Dimension", "Ratio", null]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var name;
        var value = null;
        this.eat(LEFTPARENTHESIS);
        this.scanner.skipSC();
        name = this.consume(IDENT);
        this.scanner.skipSC();
        if (this.scanner.tokenType !== RIGHTPARENTHESIS) {
          this.eat(COLON);
          this.scanner.skipSC();
          switch (this.scanner.tokenType) {
            case NUMBER:
              if (this.lookupNonWSType(1) === DELIM) {
                value = this.Ratio();
              } else {
                value = this.Number();
              }
              break;
            case DIMENSION:
              value = this.Dimension();
              break;
            case IDENT:
              value = this.Identifier();
              break;
            default:
              this.error("Number, dimension, ratio or identifier is expected");
          }
          this.scanner.skipSC();
        }
        this.eat(RIGHTPARENTHESIS);
        return {
          type: "MediaFeature",
          loc: this.getLocation(start, this.scanner.tokenStart),
          name,
          value
        };
      },
      generate: function(node) {
        this.chunk("(");
        this.chunk(node.name);
        if (node.value !== null) {
          this.chunk(":");
          this.node(node.value);
        }
        this.chunk(")");
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/MediaQuery.js
var require_MediaQuery = __commonJS({
  "node_modules/css-tree/lib/syntax/node/MediaQuery.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    var IDENT = TYPE.Ident;
    var LEFTPARENTHESIS = TYPE.LeftParenthesis;
    module2.exports = {
      name: "MediaQuery",
      structure: {
        children: [[
          "Identifier",
          "MediaFeature",
          "WhiteSpace"
        ]]
      },
      parse: function() {
        this.scanner.skipSC();
        var children = this.createList();
        var child = null;
        var space = null;
        scan:
          while (!this.scanner.eof) {
            switch (this.scanner.tokenType) {
              case COMMENT:
                this.scanner.next();
                continue;
              case WHITESPACE:
                space = this.WhiteSpace();
                continue;
              case IDENT:
                child = this.Identifier();
                break;
              case LEFTPARENTHESIS:
                child = this.MediaFeature();
                break;
              default:
                break scan;
            }
            if (space !== null) {
              children.push(space);
              space = null;
            }
            children.push(child);
          }
        if (child === null) {
          this.error("Identifier or parenthesis is expected");
        }
        return {
          type: "MediaQuery",
          loc: this.getLocationFromList(children),
          children
        };
      },
      generate: function(node) {
        this.children(node);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/MediaQueryList.js
var require_MediaQueryList = __commonJS({
  "node_modules/css-tree/lib/syntax/node/MediaQueryList.js"(exports2, module2) {
    var COMMA = require_tokenizer().TYPE.Comma;
    module2.exports = {
      name: "MediaQueryList",
      structure: {
        children: [[
          "MediaQuery"
        ]]
      },
      parse: function(relative) {
        var children = this.createList();
        this.scanner.skipSC();
        while (!this.scanner.eof) {
          children.push(this.MediaQuery(relative));
          if (this.scanner.tokenType !== COMMA) {
            break;
          }
          this.scanner.next();
        }
        return {
          type: "MediaQueryList",
          loc: this.getLocationFromList(children),
          children
        };
      },
      generate: function(node) {
        this.children(node, function() {
          this.chunk(",");
        });
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Nth.js
var require_Nth = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Nth.js"(exports2, module2) {
    module2.exports = {
      name: "Nth",
      structure: {
        nth: ["AnPlusB", "Identifier"],
        selector: ["SelectorList", null]
      },
      parse: function(allowOfClause) {
        this.scanner.skipSC();
        var start = this.scanner.tokenStart;
        var end = start;
        var selector = null;
        var query;
        if (this.scanner.lookupValue(0, "odd") || this.scanner.lookupValue(0, "even")) {
          query = this.Identifier();
        } else {
          query = this.AnPlusB();
        }
        this.scanner.skipSC();
        if (allowOfClause && this.scanner.lookupValue(0, "of")) {
          this.scanner.next();
          selector = this.SelectorList();
          if (this.needPositions) {
            end = this.getLastListNode(selector.children).loc.end.offset;
          }
        } else {
          if (this.needPositions) {
            end = query.loc.end.offset;
          }
        }
        return {
          type: "Nth",
          loc: this.getLocation(start, end),
          nth: query,
          selector
        };
      },
      generate: function(node) {
        this.node(node.nth);
        if (node.selector !== null) {
          this.chunk(" of ");
          this.node(node.selector);
        }
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Number.js
var require_Number = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Number.js"(exports2, module2) {
    var NUMBER = require_tokenizer().TYPE.Number;
    module2.exports = {
      name: "Number",
      structure: {
        value: String
      },
      parse: function() {
        return {
          type: "Number",
          loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
          value: this.consume(NUMBER)
        };
      },
      generate: function(node) {
        this.chunk(node.value);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Operator.js
var require_Operator = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Operator.js"(exports2, module2) {
    module2.exports = {
      name: "Operator",
      structure: {
        value: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        this.scanner.next();
        return {
          type: "Operator",
          loc: this.getLocation(start, this.scanner.tokenStart),
          value: this.scanner.substrToCursor(start)
        };
      },
      generate: function(node) {
        this.chunk(node.value);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Parentheses.js
var require_Parentheses = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Parentheses.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var LEFTPARENTHESIS = TYPE.LeftParenthesis;
    var RIGHTPARENTHESIS = TYPE.RightParenthesis;
    module2.exports = {
      name: "Parentheses",
      structure: {
        children: [[]]
      },
      parse: function(readSequence, recognizer) {
        var start = this.scanner.tokenStart;
        var children = null;
        this.eat(LEFTPARENTHESIS);
        children = readSequence.call(this, recognizer);
        if (!this.scanner.eof) {
          this.eat(RIGHTPARENTHESIS);
        }
        return {
          type: "Parentheses",
          loc: this.getLocation(start, this.scanner.tokenStart),
          children
        };
      },
      generate: function(node) {
        this.chunk("(");
        this.children(node);
        this.chunk(")");
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Percentage.js
var require_Percentage = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Percentage.js"(exports2, module2) {
    var consumeNumber = require_utils3().consumeNumber;
    var TYPE = require_tokenizer().TYPE;
    var PERCENTAGE = TYPE.Percentage;
    module2.exports = {
      name: "Percentage",
      structure: {
        value: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var numberEnd = consumeNumber(this.scanner.source, start);
        this.eat(PERCENTAGE);
        return {
          type: "Percentage",
          loc: this.getLocation(start, this.scanner.tokenStart),
          value: this.scanner.source.substring(start, numberEnd)
        };
      },
      generate: function(node) {
        this.chunk(node.value);
        this.chunk("%");
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/PseudoClassSelector.js
var require_PseudoClassSelector = __commonJS({
  "node_modules/css-tree/lib/syntax/node/PseudoClassSelector.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    var FUNCTION = TYPE.Function;
    var COLON = TYPE.Colon;
    var RIGHTPARENTHESIS = TYPE.RightParenthesis;
    module2.exports = {
      name: "PseudoClassSelector",
      structure: {
        name: String,
        children: [["Raw"], null]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var children = null;
        var name;
        var nameLowerCase;
        this.eat(COLON);
        if (this.scanner.tokenType === FUNCTION) {
          name = this.consumeFunctionName();
          nameLowerCase = name.toLowerCase();
          if (this.pseudo.hasOwnProperty(nameLowerCase)) {
            this.scanner.skipSC();
            children = this.pseudo[nameLowerCase].call(this);
            this.scanner.skipSC();
          } else {
            children = this.createList();
            children.push(this.Raw(this.scanner.tokenIndex, null, false));
          }
          this.eat(RIGHTPARENTHESIS);
        } else {
          name = this.consume(IDENT);
        }
        return {
          type: "PseudoClassSelector",
          loc: this.getLocation(start, this.scanner.tokenStart),
          name,
          children
        };
      },
      generate: function(node) {
        this.chunk(":");
        this.chunk(node.name);
        if (node.children !== null) {
          this.chunk("(");
          this.children(node);
          this.chunk(")");
        }
      },
      walkContext: "function"
    };
  }
});

// node_modules/css-tree/lib/syntax/node/PseudoElementSelector.js
var require_PseudoElementSelector = __commonJS({
  "node_modules/css-tree/lib/syntax/node/PseudoElementSelector.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    var FUNCTION = TYPE.Function;
    var COLON = TYPE.Colon;
    var RIGHTPARENTHESIS = TYPE.RightParenthesis;
    module2.exports = {
      name: "PseudoElementSelector",
      structure: {
        name: String,
        children: [["Raw"], null]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var children = null;
        var name;
        var nameLowerCase;
        this.eat(COLON);
        this.eat(COLON);
        if (this.scanner.tokenType === FUNCTION) {
          name = this.consumeFunctionName();
          nameLowerCase = name.toLowerCase();
          if (this.pseudo.hasOwnProperty(nameLowerCase)) {
            this.scanner.skipSC();
            children = this.pseudo[nameLowerCase].call(this);
            this.scanner.skipSC();
          } else {
            children = this.createList();
            children.push(this.Raw(this.scanner.tokenIndex, null, false));
          }
          this.eat(RIGHTPARENTHESIS);
        } else {
          name = this.consume(IDENT);
        }
        return {
          type: "PseudoElementSelector",
          loc: this.getLocation(start, this.scanner.tokenStart),
          name,
          children
        };
      },
      generate: function(node) {
        this.chunk("::");
        this.chunk(node.name);
        if (node.children !== null) {
          this.chunk("(");
          this.children(node);
          this.chunk(")");
        }
      },
      walkContext: "function"
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Ratio.js
var require_Ratio = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Ratio.js"(exports2, module2) {
    var isDigit = require_tokenizer().isDigit;
    var TYPE = require_tokenizer().TYPE;
    var NUMBER = TYPE.Number;
    var DELIM = TYPE.Delim;
    var SOLIDUS = 47;
    var FULLSTOP = 46;
    function consumeNumber() {
      this.scanner.skipWS();
      var value = this.consume(NUMBER);
      for (var i = 0; i < value.length; i++) {
        var code = value.charCodeAt(i);
        if (!isDigit(code) && code !== FULLSTOP) {
          this.error("Unsigned number is expected", this.scanner.tokenStart - value.length + i);
        }
      }
      if (Number(value) === 0) {
        this.error("Zero number is not allowed", this.scanner.tokenStart - value.length);
      }
      return value;
    }
    module2.exports = {
      name: "Ratio",
      structure: {
        left: String,
        right: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var left = consumeNumber.call(this);
        var right;
        this.scanner.skipWS();
        if (!this.scanner.isDelim(SOLIDUS)) {
          this.error("Solidus is expected");
        }
        this.eat(DELIM);
        right = consumeNumber.call(this);
        return {
          type: "Ratio",
          loc: this.getLocation(start, this.scanner.tokenStart),
          left,
          right
        };
      },
      generate: function(node) {
        this.chunk(node.left);
        this.chunk("/");
        this.chunk(node.right);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Rule.js
var require_Rule = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Rule.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var rawMode = require_Raw().mode;
    var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
    function consumeRaw(startToken) {
      return this.Raw(startToken, rawMode.leftCurlyBracket, true);
    }
    function consumePrelude() {
      var prelude = this.SelectorList();
      if (prelude.type !== "Raw" && this.scanner.eof === false && this.scanner.tokenType !== LEFTCURLYBRACKET) {
        this.error();
      }
      return prelude;
    }
    module2.exports = {
      name: "Rule",
      structure: {
        prelude: ["SelectorList", "Raw"],
        block: ["Block"]
      },
      parse: function() {
        var startToken = this.scanner.tokenIndex;
        var startOffset = this.scanner.tokenStart;
        var prelude;
        var block;
        if (this.parseRulePrelude) {
          prelude = this.parseWithFallback(consumePrelude, consumeRaw);
        } else {
          prelude = consumeRaw.call(this, startToken);
        }
        block = this.Block(true);
        return {
          type: "Rule",
          loc: this.getLocation(startOffset, this.scanner.tokenStart),
          prelude,
          block
        };
      },
      generate: function(node) {
        this.node(node.prelude);
        this.node(node.block);
      },
      walkContext: "rule"
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Selector.js
var require_Selector = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Selector.js"(exports2, module2) {
    module2.exports = {
      name: "Selector",
      structure: {
        children: [[
          "TypeSelector",
          "IdSelector",
          "ClassSelector",
          "AttributeSelector",
          "PseudoClassSelector",
          "PseudoElementSelector",
          "Combinator",
          "WhiteSpace"
        ]]
      },
      parse: function() {
        var children = this.readSequence(this.scope.Selector);
        if (this.getFirstListNode(children) === null) {
          this.error("Selector is expected");
        }
        return {
          type: "Selector",
          loc: this.getLocationFromList(children),
          children
        };
      },
      generate: function(node) {
        this.children(node);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/SelectorList.js
var require_SelectorList = __commonJS({
  "node_modules/css-tree/lib/syntax/node/SelectorList.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var COMMA = TYPE.Comma;
    module2.exports = {
      name: "SelectorList",
      structure: {
        children: [[
          "Selector",
          "Raw"
        ]]
      },
      parse: function() {
        var children = this.createList();
        while (!this.scanner.eof) {
          children.push(this.Selector());
          if (this.scanner.tokenType === COMMA) {
            this.scanner.next();
            continue;
          }
          break;
        }
        return {
          type: "SelectorList",
          loc: this.getLocationFromList(children),
          children
        };
      },
      generate: function(node) {
        this.children(node, function() {
          this.chunk(",");
        });
      },
      walkContext: "selector"
    };
  }
});

// node_modules/css-tree/lib/syntax/node/String.js
var require_String = __commonJS({
  "node_modules/css-tree/lib/syntax/node/String.js"(exports2, module2) {
    var STRING = require_tokenizer().TYPE.String;
    module2.exports = {
      name: "String",
      structure: {
        value: String
      },
      parse: function() {
        return {
          type: "String",
          loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
          value: this.consume(STRING)
        };
      },
      generate: function(node) {
        this.chunk(node.value);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/StyleSheet.js
var require_StyleSheet = __commonJS({
  "node_modules/css-tree/lib/syntax/node/StyleSheet.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    var ATKEYWORD = TYPE.AtKeyword;
    var CDO = TYPE.CDO;
    var CDC = TYPE.CDC;
    var EXCLAMATIONMARK = 33;
    function consumeRaw(startToken) {
      return this.Raw(startToken, null, false);
    }
    module2.exports = {
      name: "StyleSheet",
      structure: {
        children: [[
          "Comment",
          "CDO",
          "CDC",
          "Atrule",
          "Rule",
          "Raw"
        ]]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var children = this.createList();
        var child;
        scan:
          while (!this.scanner.eof) {
            switch (this.scanner.tokenType) {
              case WHITESPACE:
                this.scanner.next();
                continue;
              case COMMENT:
                if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 2) !== EXCLAMATIONMARK) {
                  this.scanner.next();
                  continue;
                }
                child = this.Comment();
                break;
              case CDO:
                child = this.CDO();
                break;
              case CDC:
                child = this.CDC();
                break;
              case ATKEYWORD:
                child = this.parseWithFallback(this.Atrule, consumeRaw);
                break;
              default:
                child = this.parseWithFallback(this.Rule, consumeRaw);
            }
            children.push(child);
          }
        return {
          type: "StyleSheet",
          loc: this.getLocation(start, this.scanner.tokenStart),
          children
        };
      },
      generate: function(node) {
        this.children(node);
      },
      walkContext: "stylesheet"
    };
  }
});

// node_modules/css-tree/lib/syntax/node/TypeSelector.js
var require_TypeSelector = __commonJS({
  "node_modules/css-tree/lib/syntax/node/TypeSelector.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    var ASTERISK = 42;
    var VERTICALLINE = 124;
    function eatIdentifierOrAsterisk() {
      if (this.scanner.tokenType !== IDENT && this.scanner.isDelim(ASTERISK) === false) {
        this.error("Identifier or asterisk is expected");
      }
      this.scanner.next();
    }
    module2.exports = {
      name: "TypeSelector",
      structure: {
        name: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        if (this.scanner.isDelim(VERTICALLINE)) {
          this.scanner.next();
          eatIdentifierOrAsterisk.call(this);
        } else {
          eatIdentifierOrAsterisk.call(this);
          if (this.scanner.isDelim(VERTICALLINE)) {
            this.scanner.next();
            eatIdentifierOrAsterisk.call(this);
          }
        }
        return {
          type: "TypeSelector",
          loc: this.getLocation(start, this.scanner.tokenStart),
          name: this.scanner.substrToCursor(start)
        };
      },
      generate: function(node) {
        this.chunk(node.name);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/UnicodeRange.js
var require_UnicodeRange = __commonJS({
  "node_modules/css-tree/lib/syntax/node/UnicodeRange.js"(exports2, module2) {
    var isHexDigit = require_tokenizer().isHexDigit;
    var cmpChar = require_tokenizer().cmpChar;
    var TYPE = require_tokenizer().TYPE;
    var NAME = require_tokenizer().NAME;
    var IDENT = TYPE.Ident;
    var NUMBER = TYPE.Number;
    var DIMENSION = TYPE.Dimension;
    var PLUSSIGN = 43;
    var HYPHENMINUS = 45;
    var QUESTIONMARK = 63;
    var U = 117;
    function eatHexSequence(offset, allowDash) {
      for (var pos = this.scanner.tokenStart + offset, len = 0; pos < this.scanner.tokenEnd; pos++) {
        var code = this.scanner.source.charCodeAt(pos);
        if (code === HYPHENMINUS && allowDash && len !== 0) {
          if (eatHexSequence.call(this, offset + len + 1, false) === 0) {
            this.error();
          }
          return -1;
        }
        if (!isHexDigit(code)) {
          this.error(allowDash && len !== 0 ? "HyphenMinus" + (len < 6 ? " or hex digit" : "") + " is expected" : len < 6 ? "Hex digit is expected" : "Unexpected input", pos);
        }
        if (++len > 6) {
          this.error("Too many hex digits", pos);
        }
        ;
      }
      this.scanner.next();
      return len;
    }
    function eatQuestionMarkSequence(max) {
      var count = 0;
      while (this.scanner.isDelim(QUESTIONMARK)) {
        if (++count > max) {
          this.error("Too many question marks");
        }
        this.scanner.next();
      }
    }
    function startsWith(code) {
      if (this.scanner.source.charCodeAt(this.scanner.tokenStart) !== code) {
        this.error(NAME[code] + " is expected");
      }
    }
    function scanUnicodeRange() {
      var hexLength = 0;
      if (this.scanner.isDelim(PLUSSIGN)) {
        this.scanner.next();
        if (this.scanner.tokenType === IDENT) {
          hexLength = eatHexSequence.call(this, 0, true);
          if (hexLength > 0) {
            eatQuestionMarkSequence.call(this, 6 - hexLength);
          }
          return;
        }
        if (this.scanner.isDelim(QUESTIONMARK)) {
          this.scanner.next();
          eatQuestionMarkSequence.call(this, 5);
          return;
        }
        this.error("Hex digit or question mark is expected");
        return;
      }
      if (this.scanner.tokenType === NUMBER) {
        startsWith.call(this, PLUSSIGN);
        hexLength = eatHexSequence.call(this, 1, true);
        if (this.scanner.isDelim(QUESTIONMARK)) {
          eatQuestionMarkSequence.call(this, 6 - hexLength);
          return;
        }
        if (this.scanner.tokenType === DIMENSION || this.scanner.tokenType === NUMBER) {
          startsWith.call(this, HYPHENMINUS);
          eatHexSequence.call(this, 1, false);
          return;
        }
        return;
      }
      if (this.scanner.tokenType === DIMENSION) {
        startsWith.call(this, PLUSSIGN);
        hexLength = eatHexSequence.call(this, 1, true);
        if (hexLength > 0) {
          eatQuestionMarkSequence.call(this, 6 - hexLength);
        }
        return;
      }
      this.error();
    }
    module2.exports = {
      name: "UnicodeRange",
      structure: {
        value: String
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        if (!cmpChar(this.scanner.source, start, U)) {
          this.error("U is expected");
        }
        if (!cmpChar(this.scanner.source, start + 1, PLUSSIGN)) {
          this.error("Plus sign is expected");
        }
        this.scanner.next();
        scanUnicodeRange.call(this);
        return {
          type: "UnicodeRange",
          loc: this.getLocation(start, this.scanner.tokenStart),
          value: this.scanner.substrToCursor(start)
        };
      },
      generate: function(node) {
        this.chunk(node.value);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Url.js
var require_Url = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Url.js"(exports2, module2) {
    var isWhiteSpace = require_tokenizer().isWhiteSpace;
    var cmpStr = require_tokenizer().cmpStr;
    var TYPE = require_tokenizer().TYPE;
    var FUNCTION = TYPE.Function;
    var URL2 = TYPE.Url;
    var RIGHTPARENTHESIS = TYPE.RightParenthesis;
    module2.exports = {
      name: "Url",
      structure: {
        value: ["String", "Raw"]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var value;
        switch (this.scanner.tokenType) {
          case URL2:
            var rawStart = start + 4;
            var rawEnd = this.scanner.tokenEnd - 1;
            while (rawStart < rawEnd && isWhiteSpace(this.scanner.source.charCodeAt(rawStart))) {
              rawStart++;
            }
            while (rawStart < rawEnd && isWhiteSpace(this.scanner.source.charCodeAt(rawEnd - 1))) {
              rawEnd--;
            }
            value = {
              type: "Raw",
              loc: this.getLocation(rawStart, rawEnd),
              value: this.scanner.source.substring(rawStart, rawEnd)
            };
            this.eat(URL2);
            break;
          case FUNCTION:
            if (!cmpStr(this.scanner.source, this.scanner.tokenStart, this.scanner.tokenEnd, "url(")) {
              this.error("Function name must be `url`");
            }
            this.eat(FUNCTION);
            this.scanner.skipSC();
            value = this.String();
            this.scanner.skipSC();
            this.eat(RIGHTPARENTHESIS);
            break;
          default:
            this.error("Url or Function is expected");
        }
        return {
          type: "Url",
          loc: this.getLocation(start, this.scanner.tokenStart),
          value
        };
      },
      generate: function(node) {
        this.chunk("url");
        this.chunk("(");
        this.node(node.value);
        this.chunk(")");
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/Value.js
var require_Value = __commonJS({
  "node_modules/css-tree/lib/syntax/node/Value.js"(exports2, module2) {
    module2.exports = {
      name: "Value",
      structure: {
        children: [[]]
      },
      parse: function() {
        var start = this.scanner.tokenStart;
        var children = this.readSequence(this.scope.Value);
        return {
          type: "Value",
          loc: this.getLocation(start, this.scanner.tokenStart),
          children
        };
      },
      generate: function(node) {
        this.children(node);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/WhiteSpace.js
var require_WhiteSpace = __commonJS({
  "node_modules/css-tree/lib/syntax/node/WhiteSpace.js"(exports2, module2) {
    var WHITESPACE = require_tokenizer().TYPE.WhiteSpace;
    var SPACE = Object.freeze({
      type: "WhiteSpace",
      loc: null,
      value: " "
    });
    module2.exports = {
      name: "WhiteSpace",
      structure: {
        value: String
      },
      parse: function() {
        this.eat(WHITESPACE);
        return SPACE;
      },
      generate: function(node) {
        this.chunk(node.value);
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/node/index.js
var require_node4 = __commonJS({
  "node_modules/css-tree/lib/syntax/node/index.js"(exports2, module2) {
    module2.exports = {
      AnPlusB: require_AnPlusB(),
      Atrule: require_Atrule(),
      AtrulePrelude: require_AtrulePrelude(),
      AttributeSelector: require_AttributeSelector(),
      Block: require_Block(),
      Brackets: require_Brackets(),
      CDC: require_CDC(),
      CDO: require_CDO(),
      ClassSelector: require_ClassSelector(),
      Combinator: require_Combinator(),
      Comment: require_Comment(),
      Declaration: require_Declaration(),
      DeclarationList: require_DeclarationList(),
      Dimension: require_Dimension(),
      Function: require_Function(),
      Hash: require_Hash(),
      Identifier: require_Identifier(),
      IdSelector: require_IdSelector(),
      MediaFeature: require_MediaFeature(),
      MediaQuery: require_MediaQuery(),
      MediaQueryList: require_MediaQueryList(),
      Nth: require_Nth(),
      Number: require_Number(),
      Operator: require_Operator(),
      Parentheses: require_Parentheses(),
      Percentage: require_Percentage(),
      PseudoClassSelector: require_PseudoClassSelector(),
      PseudoElementSelector: require_PseudoElementSelector(),
      Ratio: require_Ratio(),
      Raw: require_Raw(),
      Rule: require_Rule(),
      Selector: require_Selector(),
      SelectorList: require_SelectorList(),
      String: require_String(),
      StyleSheet: require_StyleSheet(),
      TypeSelector: require_TypeSelector(),
      UnicodeRange: require_UnicodeRange(),
      Url: require_Url(),
      Value: require_Value(),
      WhiteSpace: require_WhiteSpace()
    };
  }
});

// node_modules/css-tree/lib/syntax/config/lexer.js
var require_lexer = __commonJS({
  "node_modules/css-tree/lib/syntax/config/lexer.js"(exports2, module2) {
    var data = require_data();
    module2.exports = {
      generic: true,
      types: data.types,
      atrules: data.atrules,
      properties: data.properties,
      node: require_node4()
    };
  }
});

// node_modules/css-tree/lib/syntax/scope/default.js
var require_default = __commonJS({
  "node_modules/css-tree/lib/syntax/scope/default.js"(exports2, module2) {
    var cmpChar = require_tokenizer().cmpChar;
    var cmpStr = require_tokenizer().cmpStr;
    var TYPE = require_tokenizer().TYPE;
    var IDENT = TYPE.Ident;
    var STRING = TYPE.String;
    var NUMBER = TYPE.Number;
    var FUNCTION = TYPE.Function;
    var URL2 = TYPE.Url;
    var HASH = TYPE.Hash;
    var DIMENSION = TYPE.Dimension;
    var PERCENTAGE = TYPE.Percentage;
    var LEFTPARENTHESIS = TYPE.LeftParenthesis;
    var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
    var COMMA = TYPE.Comma;
    var DELIM = TYPE.Delim;
    var NUMBERSIGN = 35;
    var ASTERISK = 42;
    var PLUSSIGN = 43;
    var HYPHENMINUS = 45;
    var SOLIDUS = 47;
    var U = 117;
    module2.exports = function defaultRecognizer(context) {
      switch (this.scanner.tokenType) {
        case HASH:
          return this.Hash();
        case COMMA:
          context.space = null;
          context.ignoreWSAfter = true;
          return this.Operator();
        case LEFTPARENTHESIS:
          return this.Parentheses(this.readSequence, context.recognizer);
        case LEFTSQUAREBRACKET:
          return this.Brackets(this.readSequence, context.recognizer);
        case STRING:
          return this.String();
        case DIMENSION:
          return this.Dimension();
        case PERCENTAGE:
          return this.Percentage();
        case NUMBER:
          return this.Number();
        case FUNCTION:
          return cmpStr(this.scanner.source, this.scanner.tokenStart, this.scanner.tokenEnd, "url(") ? this.Url() : this.Function(this.readSequence, context.recognizer);
        case URL2:
          return this.Url();
        case IDENT:
          if (cmpChar(this.scanner.source, this.scanner.tokenStart, U) && cmpChar(this.scanner.source, this.scanner.tokenStart + 1, PLUSSIGN)) {
            return this.UnicodeRange();
          } else {
            return this.Identifier();
          }
        case DELIM:
          var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
          if (code === SOLIDUS || code === ASTERISK || code === PLUSSIGN || code === HYPHENMINUS) {
            return this.Operator();
          }
          if (code === NUMBERSIGN) {
            this.error("Hex or identifier is expected", this.scanner.tokenStart + 1);
          }
          break;
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/scope/atrulePrelude.js
var require_atrulePrelude = __commonJS({
  "node_modules/css-tree/lib/syntax/scope/atrulePrelude.js"(exports2, module2) {
    module2.exports = {
      getNode: require_default()
    };
  }
});

// node_modules/css-tree/lib/syntax/scope/selector.js
var require_selector2 = __commonJS({
  "node_modules/css-tree/lib/syntax/scope/selector.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var DELIM = TYPE.Delim;
    var IDENT = TYPE.Ident;
    var DIMENSION = TYPE.Dimension;
    var PERCENTAGE = TYPE.Percentage;
    var NUMBER = TYPE.Number;
    var HASH = TYPE.Hash;
    var COLON = TYPE.Colon;
    var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
    var NUMBERSIGN = 35;
    var ASTERISK = 42;
    var PLUSSIGN = 43;
    var SOLIDUS = 47;
    var FULLSTOP = 46;
    var GREATERTHANSIGN = 62;
    var VERTICALLINE = 124;
    var TILDE = 126;
    function getNode(context) {
      switch (this.scanner.tokenType) {
        case LEFTSQUAREBRACKET:
          return this.AttributeSelector();
        case HASH:
          return this.IdSelector();
        case COLON:
          if (this.scanner.lookupType(1) === COLON) {
            return this.PseudoElementSelector();
          } else {
            return this.PseudoClassSelector();
          }
        case IDENT:
          return this.TypeSelector();
        case NUMBER:
        case PERCENTAGE:
          return this.Percentage();
        case DIMENSION:
          if (this.scanner.source.charCodeAt(this.scanner.tokenStart) === FULLSTOP) {
            this.error("Identifier is expected", this.scanner.tokenStart + 1);
          }
          break;
        case DELIM:
          var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
          switch (code) {
            case PLUSSIGN:
            case GREATERTHANSIGN:
            case TILDE:
              context.space = null;
              context.ignoreWSAfter = true;
              return this.Combinator();
            case SOLIDUS:
              return this.Combinator();
            case FULLSTOP:
              return this.ClassSelector();
            case ASTERISK:
            case VERTICALLINE:
              return this.TypeSelector();
            case NUMBERSIGN:
              return this.IdSelector();
          }
          break;
      }
    }
    module2.exports = {
      getNode
    };
  }
});

// node_modules/css-tree/lib/syntax/function/expression.js
var require_expression = __commonJS({
  "node_modules/css-tree/lib/syntax/function/expression.js"(exports2, module2) {
    module2.exports = function() {
      return this.createSingleNodeList(this.Raw(this.scanner.tokenIndex, null, false));
    };
  }
});

// node_modules/css-tree/lib/syntax/function/var.js
var require_var = __commonJS({
  "node_modules/css-tree/lib/syntax/function/var.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var rawMode = require_Raw().mode;
    var COMMA = TYPE.Comma;
    var WHITESPACE = TYPE.WhiteSpace;
    module2.exports = function() {
      var children = this.createList();
      this.scanner.skipSC();
      children.push(this.Identifier());
      this.scanner.skipSC();
      if (this.scanner.tokenType === COMMA) {
        children.push(this.Operator());
        const startIndex = this.scanner.tokenIndex;
        const value = this.parseCustomProperty ? this.Value(null) : this.Raw(this.scanner.tokenIndex, rawMode.exclamationMarkOrSemicolon, false);
        if (value.type === "Value" && value.children.isEmpty()) {
          for (let offset = startIndex - this.scanner.tokenIndex; offset <= 0; offset++) {
            if (this.scanner.lookupType(offset) === WHITESPACE) {
              value.children.appendData({
                type: "WhiteSpace",
                loc: null,
                value: " "
              });
              break;
            }
          }
        }
        children.push(value);
      }
      return children;
    };
  }
});

// node_modules/css-tree/lib/syntax/scope/value.js
var require_value2 = __commonJS({
  "node_modules/css-tree/lib/syntax/scope/value.js"(exports2, module2) {
    module2.exports = {
      getNode: require_default(),
      "expression": require_expression(),
      "var": require_var()
    };
  }
});

// node_modules/css-tree/lib/syntax/scope/index.js
var require_scope = __commonJS({
  "node_modules/css-tree/lib/syntax/scope/index.js"(exports2, module2) {
    module2.exports = {
      AtrulePrelude: require_atrulePrelude(),
      Selector: require_selector2(),
      Value: require_value2()
    };
  }
});

// node_modules/css-tree/lib/syntax/atrule/font-face.js
var require_font_face = __commonJS({
  "node_modules/css-tree/lib/syntax/atrule/font-face.js"(exports2, module2) {
    module2.exports = {
      parse: {
        prelude: null,
        block: function() {
          return this.Block(true);
        }
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/atrule/import.js
var require_import = __commonJS({
  "node_modules/css-tree/lib/syntax/atrule/import.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var STRING = TYPE.String;
    var IDENT = TYPE.Ident;
    var URL2 = TYPE.Url;
    var FUNCTION = TYPE.Function;
    var LEFTPARENTHESIS = TYPE.LeftParenthesis;
    module2.exports = {
      parse: {
        prelude: function() {
          var children = this.createList();
          this.scanner.skipSC();
          switch (this.scanner.tokenType) {
            case STRING:
              children.push(this.String());
              break;
            case URL2:
            case FUNCTION:
              children.push(this.Url());
              break;
            default:
              this.error("String or url() is expected");
          }
          if (this.lookupNonWSType(0) === IDENT || this.lookupNonWSType(0) === LEFTPARENTHESIS) {
            children.push(this.WhiteSpace());
            children.push(this.MediaQueryList());
          }
          return children;
        },
        block: null
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/atrule/media.js
var require_media = __commonJS({
  "node_modules/css-tree/lib/syntax/atrule/media.js"(exports2, module2) {
    module2.exports = {
      parse: {
        prelude: function() {
          return this.createSingleNodeList(this.MediaQueryList());
        },
        block: function() {
          return this.Block(false);
        }
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/atrule/page.js
var require_page = __commonJS({
  "node_modules/css-tree/lib/syntax/atrule/page.js"(exports2, module2) {
    module2.exports = {
      parse: {
        prelude: function() {
          return this.createSingleNodeList(this.SelectorList());
        },
        block: function() {
          return this.Block(true);
        }
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/atrule/supports.js
var require_supports2 = __commonJS({
  "node_modules/css-tree/lib/syntax/atrule/supports.js"(exports2, module2) {
    var TYPE = require_tokenizer().TYPE;
    var WHITESPACE = TYPE.WhiteSpace;
    var COMMENT = TYPE.Comment;
    var IDENT = TYPE.Ident;
    var FUNCTION = TYPE.Function;
    var COLON = TYPE.Colon;
    var LEFTPARENTHESIS = TYPE.LeftParenthesis;
    function consumeRaw() {
      return this.createSingleNodeList(this.Raw(this.scanner.tokenIndex, null, false));
    }
    function parentheses() {
      this.scanner.skipSC();
      if (this.scanner.tokenType === IDENT && this.lookupNonWSType(1) === COLON) {
        return this.createSingleNodeList(this.Declaration());
      }
      return readSequence.call(this);
    }
    function readSequence() {
      var children = this.createList();
      var space = null;
      var child;
      this.scanner.skipSC();
      scan:
        while (!this.scanner.eof) {
          switch (this.scanner.tokenType) {
            case WHITESPACE:
              space = this.WhiteSpace();
              continue;
            case COMMENT:
              this.scanner.next();
              continue;
            case FUNCTION:
              child = this.Function(consumeRaw, this.scope.AtrulePrelude);
              break;
            case IDENT:
              child = this.Identifier();
              break;
            case LEFTPARENTHESIS:
              child = this.Parentheses(parentheses, this.scope.AtrulePrelude);
              break;
            default:
              break scan;
          }
          if (space !== null) {
            children.push(space);
            space = null;
          }
          children.push(child);
        }
      return children;
    }
    module2.exports = {
      parse: {
        prelude: function() {
          var children = readSequence.call(this);
          if (this.getFirstListNode(children) === null) {
            this.error("Condition is expected");
          }
          return children;
        },
        block: function() {
          return this.Block(false);
        }
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/atrule/index.js
var require_atrule = __commonJS({
  "node_modules/css-tree/lib/syntax/atrule/index.js"(exports2, module2) {
    module2.exports = {
      "font-face": require_font_face(),
      "import": require_import(),
      "media": require_media(),
      "page": require_page(),
      "supports": require_supports2()
    };
  }
});

// node_modules/css-tree/lib/syntax/pseudo/dir.js
var require_dir = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/dir.js"(exports2, module2) {
    module2.exports = {
      parse: function() {
        return this.createSingleNodeList(this.Identifier());
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/pseudo/has.js
var require_has = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/has.js"(exports2, module2) {
    module2.exports = {
      parse: function() {
        return this.createSingleNodeList(this.SelectorList());
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/pseudo/lang.js
var require_lang = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/lang.js"(exports2, module2) {
    module2.exports = {
      parse: function() {
        return this.createSingleNodeList(this.Identifier());
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/pseudo/common/selectorList.js
var require_selectorList = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/common/selectorList.js"(exports2, module2) {
    module2.exports = {
      parse: function selectorList() {
        return this.createSingleNodeList(this.SelectorList());
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/pseudo/matches.js
var require_matches = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/matches.js"(exports2, module2) {
    module2.exports = require_selectorList();
  }
});

// node_modules/css-tree/lib/syntax/pseudo/not.js
var require_not = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/not.js"(exports2, module2) {
    module2.exports = require_selectorList();
  }
});

// node_modules/css-tree/lib/syntax/pseudo/common/nthWithOfClause.js
var require_nthWithOfClause = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/common/nthWithOfClause.js"(exports2, module2) {
    var ALLOW_OF_CLAUSE = true;
    module2.exports = {
      parse: function nthWithOfClause() {
        return this.createSingleNodeList(this.Nth(ALLOW_OF_CLAUSE));
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/pseudo/nth-child.js
var require_nth_child = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/nth-child.js"(exports2, module2) {
    module2.exports = require_nthWithOfClause();
  }
});

// node_modules/css-tree/lib/syntax/pseudo/nth-last-child.js
var require_nth_last_child = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/nth-last-child.js"(exports2, module2) {
    module2.exports = require_nthWithOfClause();
  }
});

// node_modules/css-tree/lib/syntax/pseudo/common/nth.js
var require_nth = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/common/nth.js"(exports2, module2) {
    var DISALLOW_OF_CLAUSE = false;
    module2.exports = {
      parse: function nth() {
        return this.createSingleNodeList(this.Nth(DISALLOW_OF_CLAUSE));
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/pseudo/nth-last-of-type.js
var require_nth_last_of_type = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/nth-last-of-type.js"(exports2, module2) {
    module2.exports = require_nth();
  }
});

// node_modules/css-tree/lib/syntax/pseudo/nth-of-type.js
var require_nth_of_type = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/nth-of-type.js"(exports2, module2) {
    module2.exports = require_nth();
  }
});

// node_modules/css-tree/lib/syntax/pseudo/slotted.js
var require_slotted = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/slotted.js"(exports2, module2) {
    module2.exports = {
      parse: function compoundSelector() {
        return this.createSingleNodeList(this.Selector());
      }
    };
  }
});

// node_modules/css-tree/lib/syntax/pseudo/index.js
var require_pseudo = __commonJS({
  "node_modules/css-tree/lib/syntax/pseudo/index.js"(exports2, module2) {
    module2.exports = {
      "dir": require_dir(),
      "has": require_has(),
      "lang": require_lang(),
      "matches": require_matches(),
      "not": require_not(),
      "nth-child": require_nth_child(),
      "nth-last-child": require_nth_last_child(),
      "nth-last-of-type": require_nth_last_of_type(),
      "nth-of-type": require_nth_of_type(),
      "slotted": require_slotted()
    };
  }
});

// node_modules/css-tree/lib/syntax/config/parser.js
var require_parser2 = __commonJS({
  "node_modules/css-tree/lib/syntax/config/parser.js"(exports2, module2) {
    module2.exports = {
      parseContext: {
        default: "StyleSheet",
        stylesheet: "StyleSheet",
        atrule: "Atrule",
        atrulePrelude: function(options) {
          return this.AtrulePrelude(options.atrule ? String(options.atrule) : null);
        },
        mediaQueryList: "MediaQueryList",
        mediaQuery: "MediaQuery",
        rule: "Rule",
        selectorList: "SelectorList",
        selector: "Selector",
        block: function() {
          return this.Block(true);
        },
        declarationList: "DeclarationList",
        declaration: "Declaration",
        value: "Value"
      },
      scope: require_scope(),
      atrule: require_atrule(),
      pseudo: require_pseudo(),
      node: require_node4()
    };
  }
});

// node_modules/css-tree/lib/syntax/config/walker.js
var require_walker = __commonJS({
  "node_modules/css-tree/lib/syntax/config/walker.js"(exports2, module2) {
    module2.exports = {
      node: require_node4()
    };
  }
});

// node_modules/css-tree/package.json
var require_package = __commonJS({
  "node_modules/css-tree/package.json"(exports2, module2) {
    module2.exports = {
      _args: [
        [
          "css-tree@1.1.3",
          "/home/runner/work/tailwindcss/tailwindcss"
        ]
      ],
      _from: "css-tree@1.1.3",
      _id: "css-tree@1.1.3",
      _inBundle: false,
      _integrity: "sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==",
      _location: "/css-tree",
      _phantomChildren: {},
      _requested: {
        type: "version",
        registry: true,
        raw: "css-tree@1.1.3",
        name: "css-tree",
        escapedName: "css-tree",
        rawSpec: "1.1.3",
        saveSpec: null,
        fetchSpec: "1.1.3"
      },
      _requiredBy: [
        "/csso",
        "/svgo"
      ],
      _resolved: "https://registry.npmjs.org/css-tree/-/css-tree-1.1.3.tgz",
      _spec: "1.1.3",
      _where: "/home/runner/work/tailwindcss/tailwindcss",
      author: {
        name: "Roman Dvornov",
        email: "rdvornov@gmail.com",
        url: "https://github.com/lahmatiy"
      },
      bugs: {
        url: "https://github.com/csstree/csstree/issues"
      },
      dependencies: {
        "mdn-data": "2.0.14",
        "source-map": "^0.6.1"
      },
      description: "A tool set for CSS: fast detailed parser (CSS \u2192 AST), walker (AST traversal), generator (AST \u2192 CSS) and lexer (validation and matching) based on specs and browser implementations",
      devDependencies: {
        "@rollup/plugin-commonjs": "^11.0.2",
        "@rollup/plugin-json": "^4.0.2",
        "@rollup/plugin-node-resolve": "^7.1.1",
        coveralls: "^3.0.9",
        eslint: "^6.8.0",
        "json-to-ast": "^2.1.0",
        mocha: "^6.2.3",
        nyc: "^14.1.1",
        rollup: "^1.32.1",
        "rollup-plugin-terser": "^5.3.0"
      },
      engines: {
        node: ">=8.0.0"
      },
      files: [
        "data",
        "dist",
        "lib"
      ],
      homepage: "https://github.com/csstree/csstree#readme",
      jsdelivr: "dist/csstree.min.js",
      keywords: [
        "css",
        "ast",
        "tokenizer",
        "parser",
        "walker",
        "lexer",
        "generator",
        "utils",
        "syntax",
        "validation"
      ],
      license: "MIT",
      main: "lib/index.js",
      name: "css-tree",
      repository: {
        type: "git",
        url: "git+https://github.com/csstree/csstree.git"
      },
      scripts: {
        build: "rollup --config",
        coverage: "nyc npm test",
        coveralls: "nyc report --reporter=text-lcov | coveralls",
        hydrogen: "node --trace-hydrogen --trace-phase=Z --trace-deopt --code-comments --hydrogen-track-positions --redirect-code-traces --redirect-code-traces-to=code.asm --trace_hydrogen_file=code.cfg --print-opt-code bin/parse --stat -o /dev/null",
        lint: "eslint data lib scripts test && node scripts/review-syntax-patch --lint && node scripts/update-docs --lint",
        "lint-and-test": "npm run lint && npm test",
        prepublishOnly: "npm run build",
        "review:syntax-patch": "node scripts/review-syntax-patch",
        test: "mocha --reporter progress",
        travis: "nyc npm run lint-and-test && npm run coveralls",
        "update:docs": "node scripts/update-docs"
      },
      unpkg: "dist/csstree.min.js",
      version: "1.1.3"
    };
  }
});

// node_modules/css-tree/lib/syntax/index.js
var require_syntax = __commonJS({
  "node_modules/css-tree/lib/syntax/index.js"(exports2, module2) {
    function merge() {
      var dest = {};
      for (var i = 0; i < arguments.length; i++) {
        var src = arguments[i];
        for (var key in src) {
          dest[key] = src[key];
        }
      }
      return dest;
    }
    module2.exports = require_create5().create(merge(require_lexer(), require_parser2(), require_walker()));
    module2.exports.version = require_package().version;
  }
});

// node_modules/css-tree/lib/index.js
var require_lib9 = __commonJS({
  "node_modules/css-tree/lib/index.js"(exports2, module2) {
    module2.exports = require_syntax();
  }
});

// node_modules/stable/stable.js
var require_stable = __commonJS({
  "node_modules/stable/stable.js"(exports2, module2) {
    (function(global2, factory) {
      typeof exports2 === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : global2.stable = factory();
    })(exports2, function() {
      "use strict";
      var stable = function(arr, comp) {
        return exec(arr.slice(), comp);
      };
      stable.inplace = function(arr, comp) {
        var result = exec(arr, comp);
        if (result !== arr) {
          pass(result, null, arr.length, arr);
        }
        return arr;
      };
      function exec(arr, comp) {
        if (typeof comp !== "function") {
          comp = function(a, b) {
            return String(a).localeCompare(b);
          };
        }
        var len = arr.length;
        if (len <= 1) {
          return arr;
        }
        var buffer = new Array(len);
        for (var chk = 1; chk < len; chk *= 2) {
          pass(arr, comp, chk, buffer);
          var tmp = arr;
          arr = buffer;
          buffer = tmp;
        }
        return arr;
      }
      var pass = function(arr, comp, chk, result) {
        var len = arr.length;
        var i = 0;
        var dbl = chk * 2;
        var l, r, e;
        var li, ri;
        for (l = 0; l < len; l += dbl) {
          r = l + chk;
          e = r + chk;
          if (r > len)
            r = len;
          if (e > len)
            e = len;
          li = l;
          ri = r;
          while (true) {
            if (li < r && ri < e) {
              if (comp(arr[li], arr[ri]) <= 0) {
                result[i++] = arr[li++];
              } else {
                result[i++] = arr[ri++];
              }
            } else if (li < r) {
              result[i++] = arr[li++];
            } else if (ri < e) {
              result[i++] = arr[ri++];
            } else {
              break;
            }
          }
        }
      };
      return stable;
    });
  }
});

// node_modules/csso/lib/restructure/prepare/specificity.js
var require_specificity = __commonJS({
  "node_modules/csso/lib/restructure/prepare/specificity.js"(exports2, module2) {
    module2.exports = function specificity(simpleSelector) {
      var A = 0;
      var B = 0;
      var C = 0;
      simpleSelector.children.each(function walk(node) {
        switch (node.type) {
          case "SelectorList":
          case "Selector":
            node.children.each(walk);
            break;
          case "IdSelector":
            A++;
            break;
          case "ClassSelector":
          case "AttributeSelector":
            B++;
            break;
          case "PseudoClassSelector":
            switch (node.name.toLowerCase()) {
              case "not":
                node.children.each(walk);
                break;
              case "before":
              case "after":
              case "first-line":
              case "first-letter":
                C++;
                break;
              default:
                B++;
            }
            break;
          case "PseudoElementSelector":
            C++;
            break;
          case "TypeSelector":
            if (node.name.charAt(node.name.length - 1) !== "*") {
              C++;
            }
            break;
        }
      });
      return [A, B, C];
    };
  }
});

// node_modules/svgo/lib/css-tools.js
var require_css_tools = __commonJS({
  "node_modules/svgo/lib/css-tools.js"(exports2, module2) {
    "use strict";
    var csstree = require_lib9();
    var List = csstree.List;
    var stable = require_stable();
    var specificity = require_specificity();
    function flattenToSelectors(cssAst) {
      var selectors = [];
      csstree.walk(cssAst, {
        visit: "Rule",
        enter: function(node) {
          if (node.type !== "Rule") {
            return;
          }
          var atrule = this.atrule;
          var rule = node;
          node.prelude.children.each(function(selectorNode, selectorItem) {
            var selector = {
              item: selectorItem,
              atrule,
              rule,
              pseudos: []
            };
            selectorNode.children.each(function(selectorChildNode, selectorChildItem, selectorChildList) {
              if (selectorChildNode.type === "PseudoClassSelector" || selectorChildNode.type === "PseudoElementSelector") {
                selector.pseudos.push({
                  item: selectorChildItem,
                  list: selectorChildList
                });
              }
            });
            selectors.push(selector);
          });
        }
      });
      return selectors;
    }
    function filterByMqs(selectors, useMqs) {
      return selectors.filter(function(selector) {
        if (selector.atrule === null) {
          return ~useMqs.indexOf("");
        }
        var mqName = selector.atrule.name;
        var mqStr = mqName;
        if (selector.atrule.expression && selector.atrule.expression.children.first().type === "MediaQueryList") {
          var mqExpr = csstree.generate(selector.atrule.expression);
          mqStr = [mqName, mqExpr].join(" ");
        }
        return ~useMqs.indexOf(mqStr);
      });
    }
    function filterByPseudos(selectors, usePseudos) {
      return selectors.filter(function(selector) {
        var pseudoSelectorsStr = csstree.generate({
          type: "Selector",
          children: new List().fromArray(selector.pseudos.map(function(pseudo) {
            return pseudo.item.data;
          }))
        });
        return ~usePseudos.indexOf(pseudoSelectorsStr);
      });
    }
    function cleanPseudos(selectors) {
      selectors.forEach(function(selector) {
        selector.pseudos.forEach(function(pseudo) {
          pseudo.list.remove(pseudo.item);
        });
      });
    }
    function compareSpecificity(aSpecificity, bSpecificity) {
      for (var i = 0; i < 4; i += 1) {
        if (aSpecificity[i] < bSpecificity[i]) {
          return -1;
        } else if (aSpecificity[i] > bSpecificity[i]) {
          return 1;
        }
      }
      return 0;
    }
    function compareSimpleSelectorNode(aSimpleSelectorNode, bSimpleSelectorNode) {
      var aSpecificity = specificity(aSimpleSelectorNode), bSpecificity = specificity(bSimpleSelectorNode);
      return compareSpecificity(aSpecificity, bSpecificity);
    }
    function _bySelectorSpecificity(selectorA, selectorB) {
      return compareSimpleSelectorNode(selectorA.item.data, selectorB.item.data);
    }
    function sortSelectors(selectors) {
      return stable(selectors, _bySelectorSpecificity);
    }
    function csstreeToStyleDeclaration(declaration) {
      var propertyName = declaration.property, propertyValue = csstree.generate(declaration.value), propertyPriority = declaration.important ? "important" : "";
      return {
        name: propertyName,
        value: propertyValue,
        priority: propertyPriority
      };
    }
    function getCssStr(elem) {
      if (elem.children.length > 0 && (elem.children[0].type === "text" || elem.children[0].type === "cdata")) {
        return elem.children[0].value;
      }
      return "";
    }
    function setCssStr(elem, css) {
      if (elem.children.length === 0) {
        elem.children.push({
          type: "text",
          value: ""
        });
      }
      if (elem.children[0].type !== "text" && elem.children[0].type !== "cdata") {
        return css;
      }
      elem.children[0].value = css;
      return css;
    }
    module2.exports.flattenToSelectors = flattenToSelectors;
    module2.exports.filterByMqs = filterByMqs;
    module2.exports.filterByPseudos = filterByPseudos;
    module2.exports.cleanPseudos = cleanPseudos;
    module2.exports.compareSpecificity = compareSpecificity;
    module2.exports.compareSimpleSelectorNode = compareSimpleSelectorNode;
    module2.exports.sortSelectors = sortSelectors;
    module2.exports.csstreeToStyleDeclaration = csstreeToStyleDeclaration;
    module2.exports.getCssStr = getCssStr;
    module2.exports.setCssStr = setCssStr;
  }
});

// node_modules/svgo/lib/svgo/css-style-declaration.js
var require_css_style_declaration = __commonJS({
  "node_modules/svgo/lib/svgo/css-style-declaration.js"(exports2, module2) {
    "use strict";
    var csstree = require_lib9();
    var csstools = require_css_tools();
    var CSSStyleDeclaration = function(node) {
      this.parentNode = node;
      this.properties = /* @__PURE__ */ new Map();
      this.hasSynced = false;
      this.styleValue = null;
      this.parseError = false;
      const value = node.attributes.style;
      if (value != null) {
        this.addStyleValueHandler();
        this.setStyleValue(value);
      }
    };
    CSSStyleDeclaration.prototype.addStyleValueHandler = function() {
      Object.defineProperty(this.parentNode.attributes, "style", {
        get: this.getStyleValue.bind(this),
        set: this.setStyleValue.bind(this),
        enumerable: true,
        configurable: true
      });
    };
    CSSStyleDeclaration.prototype.getStyleValue = function() {
      return this.getCssText();
    };
    CSSStyleDeclaration.prototype.setStyleValue = function(newValue) {
      this.properties.clear();
      this.styleValue = newValue;
      this.hasSynced = false;
    };
    CSSStyleDeclaration.prototype._loadCssText = function() {
      if (this.hasSynced) {
        return;
      }
      this.hasSynced = true;
      if (!this.styleValue || this.styleValue.length === 0) {
        return;
      }
      var inlineCssStr = this.styleValue;
      var declarations = {};
      try {
        declarations = csstree.parse(inlineCssStr, {
          context: "declarationList",
          parseValue: false
        });
      } catch (parseError) {
        this.parseError = parseError;
        return;
      }
      this.parseError = false;
      var self2 = this;
      declarations.children.each(function(declaration) {
        try {
          var styleDeclaration = csstools.csstreeToStyleDeclaration(declaration);
          self2.setProperty(styleDeclaration.name, styleDeclaration.value, styleDeclaration.priority);
        } catch (styleError) {
          if (styleError.message !== "Unknown node type: undefined") {
            self2.parseError = styleError;
          }
        }
      });
    };
    CSSStyleDeclaration.prototype.getCssText = function() {
      var properties = this.getProperties();
      if (this.parseError) {
        return this.styleValue;
      }
      var cssText = [];
      properties.forEach(function(property, propertyName) {
        var strImportant = property.priority === "important" ? "!important" : "";
        cssText.push(propertyName.trim() + ":" + property.value.trim() + strImportant);
      });
      return cssText.join(";");
    };
    CSSStyleDeclaration.prototype._handleParseError = function() {
      if (this.parseError) {
        console.warn("Warning: Parse error when parsing inline styles, style properties of this element cannot be used. The raw styles can still be get/set using .attr('style').value. Error details: " + this.parseError);
      }
    };
    CSSStyleDeclaration.prototype._getProperty = function(propertyName) {
      if (typeof propertyName === "undefined") {
        throw Error("1 argument required, but only 0 present.");
      }
      var properties = this.getProperties();
      this._handleParseError();
      var property = properties.get(propertyName.trim());
      return property;
    };
    CSSStyleDeclaration.prototype.getPropertyPriority = function(propertyName) {
      var property = this._getProperty(propertyName);
      return property ? property.priority : "";
    };
    CSSStyleDeclaration.prototype.getPropertyValue = function(propertyName) {
      var property = this._getProperty(propertyName);
      return property ? property.value : null;
    };
    CSSStyleDeclaration.prototype.item = function(index) {
      if (typeof index === "undefined") {
        throw Error("1 argument required, but only 0 present.");
      }
      var properties = this.getProperties();
      this._handleParseError();
      return Array.from(properties.keys())[index];
    };
    CSSStyleDeclaration.prototype.getProperties = function() {
      this._loadCssText();
      return this.properties;
    };
    CSSStyleDeclaration.prototype.removeProperty = function(propertyName) {
      if (typeof propertyName === "undefined") {
        throw Error("1 argument required, but only 0 present.");
      }
      this.addStyleValueHandler();
      var properties = this.getProperties();
      this._handleParseError();
      var oldValue = this.getPropertyValue(propertyName);
      properties.delete(propertyName.trim());
      return oldValue;
    };
    CSSStyleDeclaration.prototype.setProperty = function(propertyName, value, priority) {
      if (typeof propertyName === "undefined") {
        throw Error("propertyName argument required, but only not present.");
      }
      this.addStyleValueHandler();
      var properties = this.getProperties();
      this._handleParseError();
      var property = {
        value: value.trim(),
        priority: priority.trim()
      };
      properties.set(propertyName.trim(), property);
      return property;
    };
    module2.exports = CSSStyleDeclaration;
  }
});

// node_modules/svgo/lib/svgo/jsAPI.js
var require_jsAPI = __commonJS({
  "node_modules/svgo/lib/svgo/jsAPI.js"(exports2, module2) {
    "use strict";
    var { selectAll, selectOne, is } = require_lib8();
    var svgoCssSelectAdapter = require_css_select_adapter();
    var CSSClassList = require_css_class_list();
    var CSSStyleDeclaration = require_css_style_declaration();
    var parseName = (name) => {
      if (name == null) {
        return {
          prefix: "",
          local: ""
        };
      }
      if (name === "xmlns") {
        return {
          prefix: "xmlns",
          local: ""
        };
      }
      const chunks = name.split(":");
      if (chunks.length === 1) {
        return {
          prefix: "",
          local: chunks[0]
        };
      }
      return {
        prefix: chunks[0],
        local: chunks[1]
      };
    };
    var cssSelectOpts = {
      xmlMode: true,
      adapter: svgoCssSelectAdapter
    };
    var attrsHandler = {
      get: (attributes, name) => {
        if (attributes.hasOwnProperty(name)) {
          return {
            name,
            get value() {
              return attributes[name];
            },
            set value(value) {
              attributes[name] = value;
            }
          };
        }
      },
      set: (attributes, name, attr) => {
        attributes[name] = attr.value;
        return true;
      }
    };
    var JSAPI = function(data, parentNode) {
      Object.assign(this, data);
      if (this.type === "element") {
        if (this.attributes == null) {
          this.attributes = {};
        }
        if (this.children == null) {
          this.children = [];
        }
        Object.defineProperty(this, "class", {
          writable: true,
          configurable: true,
          value: new CSSClassList(this)
        });
        Object.defineProperty(this, "style", {
          writable: true,
          configurable: true,
          value: new CSSStyleDeclaration(this)
        });
        Object.defineProperty(this, "parentNode", {
          writable: true,
          value: parentNode
        });
        const element = this;
        Object.defineProperty(this, "attrs", {
          configurable: true,
          get() {
            return new Proxy(element.attributes, attrsHandler);
          },
          set(value) {
            const newAttributes = {};
            for (const attr of Object.values(value)) {
              newAttributes[attr.name] = attr.value;
            }
            element.attributes = newAttributes;
          }
        });
      }
    };
    module2.exports = JSAPI;
    JSAPI.prototype.clone = function() {
      const { children, ...nodeData } = this;
      const clonedNode = new JSAPI(JSON.parse(JSON.stringify(nodeData)), null);
      if (children) {
        clonedNode.children = children.map((child) => {
          const clonedChild = child.clone();
          clonedChild.parentNode = clonedNode;
          return clonedChild;
        });
      }
      return clonedNode;
    };
    JSAPI.prototype.isElem = function(param) {
      if (this.type !== "element") {
        return false;
      }
      if (param == null) {
        return true;
      }
      if (Array.isArray(param)) {
        return param.includes(this.name);
      }
      return this.name === param;
    };
    JSAPI.prototype.renameElem = function(name) {
      if (name && typeof name === "string")
        this.name = name;
      return this;
    };
    JSAPI.prototype.isEmpty = function() {
      return !this.children || !this.children.length;
    };
    JSAPI.prototype.closestElem = function(elemName) {
      var elem = this;
      while ((elem = elem.parentNode) && !elem.isElem(elemName))
        ;
      return elem;
    };
    JSAPI.prototype.spliceContent = function(start, n, insertion) {
      if (arguments.length < 2)
        return [];
      if (!Array.isArray(insertion))
        insertion = Array.apply(null, arguments).slice(2);
      insertion.forEach(function(inner) {
        inner.parentNode = this;
      }, this);
      return this.children.splice.apply(this.children, [start, n].concat(insertion));
    };
    JSAPI.prototype.hasAttr = function(name, val) {
      if (this.type !== "element") {
        return false;
      }
      if (Object.keys(this.attributes).length === 0) {
        return false;
      }
      if (name == null) {
        return true;
      }
      if (this.attributes.hasOwnProperty(name) === false) {
        return false;
      }
      if (val !== void 0) {
        return this.attributes[name] === val.toString();
      }
      return true;
    };
    JSAPI.prototype.hasAttrLocal = function(localName, val) {
      if (!this.attrs || !Object.keys(this.attrs).length)
        return false;
      if (!arguments.length)
        return !!this.attrs;
      var callback;
      switch (val != null && val.constructor && val.constructor.name) {
        case "Number":
        case "String":
          callback = stringValueTest;
          break;
        case "RegExp":
          callback = regexpValueTest;
          break;
        case "Function":
          callback = funcValueTest;
          break;
        default:
          callback = nameTest;
      }
      return this.someAttr(callback);
      function nameTest(attr) {
        const { local } = parseName(attr.name);
        return local === localName;
      }
      function stringValueTest(attr) {
        const { local } = parseName(attr.name);
        return local === localName && val == attr.value;
      }
      function regexpValueTest(attr) {
        const { local } = parseName(attr.name);
        return local === localName && val.test(attr.value);
      }
      function funcValueTest(attr) {
        const { local } = parseName(attr.name);
        return local === localName && val(attr.value);
      }
    };
    JSAPI.prototype.attr = function(name, val) {
      if (this.hasAttr(name, val)) {
        return this.attrs[name];
      }
    };
    JSAPI.prototype.computedAttr = function(name, val) {
      if (!arguments.length)
        return;
      for (var elem = this; elem && (!elem.hasAttr(name) || !elem.attributes[name]); elem = elem.parentNode)
        ;
      if (val != null) {
        return elem ? elem.hasAttr(name, val) : false;
      } else if (elem && elem.hasAttr(name)) {
        return elem.attributes[name];
      }
    };
    JSAPI.prototype.removeAttr = function(name, val) {
      if (this.type !== "element") {
        return false;
      }
      if (arguments.length === 0) {
        return false;
      }
      if (Array.isArray(name)) {
        for (const nameItem of name) {
          this.removeAttr(nameItem, val);
        }
        return false;
      }
      if (this.hasAttr(name, val) === false) {
        return false;
      }
      delete this.attributes[name];
      return true;
    };
    JSAPI.prototype.addAttr = function(attr) {
      attr = attr || {};
      if (attr.name === void 0)
        return false;
      this.attributes[attr.name] = attr.value;
      if (attr.name === "class") {
        this.class.addClassValueHandler();
      }
      if (attr.name === "style") {
        this.style.addStyleValueHandler();
      }
      return this.attrs[attr.name];
    };
    JSAPI.prototype.eachAttr = function(callback, context) {
      if (this.type !== "element") {
        return false;
      }
      if (callback == null) {
        return false;
      }
      for (const attr of Object.values(this.attrs)) {
        callback.call(context, attr);
      }
      return true;
    };
    JSAPI.prototype.someAttr = function(callback, context) {
      if (this.type !== "element") {
        return false;
      }
      for (const attr of Object.values(this.attrs)) {
        if (callback.call(context, attr))
          return true;
      }
      return false;
    };
    JSAPI.prototype.querySelectorAll = function(selectors) {
      var matchedEls = selectAll(selectors, this, cssSelectOpts);
      return matchedEls.length > 0 ? matchedEls : null;
    };
    JSAPI.prototype.querySelector = function(selectors) {
      return selectOne(selectors, this, cssSelectOpts);
    };
    JSAPI.prototype.matches = function(selector) {
      return is(this, selector, cssSelectOpts);
    };
  }
});

// node_modules/svgo/plugins/mergeStyles.js
var require_mergeStyles = __commonJS({
  "node_modules/svgo/plugins/mergeStyles.js"(exports2) {
    "use strict";
    var { visitSkip, detachNodeFromParent } = require_xast();
    var JSAPI = require_jsAPI();
    exports2.name = "mergeStyles";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "merge multiple style elements into one";
    exports2.fn = () => {
      let firstStyleElement = null;
      let collectedStyles = "";
      let styleContentType = "text";
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "foreignObject") {
              return visitSkip;
            }
            if (node.name !== "style") {
              return;
            }
            if (node.attributes.type != null && node.attributes.type !== "" && node.attributes.type !== "text/css") {
              return;
            }
            let css = "";
            for (const child of node.children) {
              if (child.type === "text") {
                css += child.value;
              }
              if (child.type === "cdata") {
                styleContentType = "cdata";
                css += child.value;
              }
            }
            if (css.trim().length === 0) {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (node.attributes.media == null) {
              collectedStyles += css;
            } else {
              collectedStyles += `@media ${node.attributes.media}{${css}}`;
              delete node.attributes.media;
            }
            if (firstStyleElement == null) {
              firstStyleElement = node;
            } else {
              detachNodeFromParent(node, parentNode);
              firstStyleElement.children = [
                new JSAPI({ type: styleContentType, value: collectedStyles }, firstStyleElement)
              ];
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/inlineStyles.js
var require_inlineStyles = __commonJS({
  "node_modules/svgo/plugins/inlineStyles.js"(exports2) {
    "use strict";
    var csstree = require_lib9();
    var specificity = require_specificity();
    var stable = require_stable();
    var {
      visitSkip,
      querySelectorAll,
      detachNodeFromParent
    } = require_xast();
    exports2.type = "visitor";
    exports2.name = "inlineStyles";
    exports2.active = true;
    exports2.description = "inline styles (additional options)";
    var compareSpecificity = (a, b) => {
      for (var i = 0; i < 4; i += 1) {
        if (a[i] < b[i]) {
          return -1;
        } else if (a[i] > b[i]) {
          return 1;
        }
      }
      return 0;
    };
    exports2.fn = (root, params) => {
      const {
        onlyMatchedOnce = true,
        removeMatchedSelectors = true,
        useMqs = ["", "screen"],
        usePseudos = [""]
      } = params;
      const styles = [];
      let selectors = [];
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "foreignObject") {
              return visitSkip;
            }
            if (node.name !== "style" || node.children.length === 0) {
              return;
            }
            if (node.attributes.type != null && node.attributes.type !== "" && node.attributes.type !== "text/css") {
              return;
            }
            let cssText = "";
            for (const child of node.children) {
              if (child.type === "text" || child.type === "cdata") {
                cssText += child.value;
              }
            }
            let cssAst = null;
            try {
              cssAst = csstree.parse(cssText, {
                parseValue: false,
                parseCustomProperty: false
              });
            } catch {
              return;
            }
            if (cssAst.type === "StyleSheet") {
              styles.push({ node, parentNode, cssAst });
            }
            csstree.walk(cssAst, {
              visit: "Selector",
              enter(node2, item) {
                const atrule = this.atrule;
                const rule = this.rule;
                if (rule == null) {
                  return;
                }
                let mq = "";
                if (atrule != null) {
                  mq = atrule.name;
                  if (atrule.prelude != null) {
                    mq += ` ${csstree.generate(atrule.prelude)}`;
                  }
                }
                if (useMqs.includes(mq) === false) {
                  return;
                }
                const pseudos = [];
                if (node2.type === "Selector") {
                  node2.children.each((childNode, childItem, childList) => {
                    if (childNode.type === "PseudoClassSelector" || childNode.type === "PseudoElementSelector") {
                      pseudos.push({ item: childItem, list: childList });
                    }
                  });
                }
                const pseudoSelectors = csstree.generate({
                  type: "Selector",
                  children: new csstree.List().fromArray(pseudos.map((pseudo) => pseudo.item.data))
                });
                if (usePseudos.includes(pseudoSelectors) === false) {
                  return;
                }
                for (const pseudo of pseudos) {
                  pseudo.list.remove(pseudo.item);
                }
                selectors.push({ node: node2, item, rule });
              }
            });
          }
        },
        root: {
          exit: () => {
            if (styles.length === 0) {
              return;
            }
            const sortedSelectors = stable(selectors, (a, b) => {
              const aSpecificity = specificity(a.item.data);
              const bSpecificity = specificity(b.item.data);
              return compareSpecificity(aSpecificity, bSpecificity);
            }).reverse();
            for (const selector of sortedSelectors) {
              const selectorText = csstree.generate(selector.item.data);
              const matchedElements = [];
              try {
                for (const node of querySelectorAll(root, selectorText)) {
                  if (node.type === "element") {
                    matchedElements.push(node);
                  }
                }
              } catch (selectError) {
                continue;
              }
              if (matchedElements.length === 0) {
                continue;
              }
              if (onlyMatchedOnce && matchedElements.length > 1) {
                continue;
              }
              for (const selectedEl of matchedElements) {
                const styleDeclarationList = csstree.parse(selectedEl.attributes.style == null ? "" : selectedEl.attributes.style, {
                  context: "declarationList",
                  parseValue: false
                });
                if (styleDeclarationList.type !== "DeclarationList") {
                  continue;
                }
                const styleDeclarationItems = /* @__PURE__ */ new Map();
                csstree.walk(styleDeclarationList, {
                  visit: "Declaration",
                  enter(node, item) {
                    styleDeclarationItems.set(node.property, item);
                  }
                });
                csstree.walk(selector.rule, {
                  visit: "Declaration",
                  enter(ruleDeclaration) {
                    const matchedItem = styleDeclarationItems.get(ruleDeclaration.property);
                    const ruleDeclarationItem = styleDeclarationList.children.createItem(ruleDeclaration);
                    if (matchedItem == null) {
                      styleDeclarationList.children.append(ruleDeclarationItem);
                    } else if (matchedItem.data.important !== true && ruleDeclaration.important === true) {
                      styleDeclarationList.children.replace(matchedItem, ruleDeclarationItem);
                      styleDeclarationItems.set(ruleDeclaration.property, ruleDeclarationItem);
                    }
                  }
                });
                selectedEl.attributes.style = csstree.generate(styleDeclarationList);
              }
              if (removeMatchedSelectors && matchedElements.length !== 0 && selector.rule.prelude.type === "SelectorList") {
                selector.rule.prelude.children.remove(selector.item);
              }
              selector.matchedElements = matchedElements;
            }
            if (removeMatchedSelectors === false) {
              return;
            }
            for (const selector of sortedSelectors) {
              if (selector.matchedElements == null) {
                continue;
              }
              if (onlyMatchedOnce && selector.matchedElements.length > 1) {
                continue;
              }
              for (const selectedEl of selector.matchedElements) {
                const classList = new Set(selectedEl.attributes.class == null ? null : selectedEl.attributes.class.split(" "));
                const firstSubSelector = selector.node.children.first();
                if (firstSubSelector != null && firstSubSelector.type === "ClassSelector") {
                  classList.delete(firstSubSelector.name);
                }
                if (classList.size === 0) {
                  delete selectedEl.attributes.class;
                } else {
                  selectedEl.attributes.class = Array.from(classList).join(" ");
                }
                if (firstSubSelector != null && firstSubSelector.type === "IdSelector") {
                  if (selectedEl.attributes.id === firstSubSelector.name) {
                    delete selectedEl.attributes.id;
                  }
                }
              }
            }
            for (const style of styles) {
              csstree.walk(style.cssAst, {
                visit: "Rule",
                enter: function(node, item, list) {
                  if (node.type === "Rule" && node.prelude.type === "SelectorList" && node.prelude.children.isEmpty()) {
                    list.remove(item);
                  }
                }
              });
              if (style.cssAst.children.isEmpty()) {
                detachNodeFromParent(style.node, style.parentNode);
              } else {
                const firstChild = style.node.children[0];
                if (firstChild.type === "text" || firstChild.type === "cdata") {
                  firstChild.value = csstree.generate(style.cssAst);
                }
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/csso/lib/usage.js
var require_usage = __commonJS({
  "node_modules/csso/lib/usage.js"(exports2, module2) {
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    function buildMap(list, caseInsensitive) {
      var map = /* @__PURE__ */ Object.create(null);
      if (!Array.isArray(list)) {
        return null;
      }
      for (var i = 0; i < list.length; i++) {
        var name = list[i];
        if (caseInsensitive) {
          name = name.toLowerCase();
        }
        map[name] = true;
      }
      return map;
    }
    function buildList(data) {
      if (!data) {
        return null;
      }
      var tags = buildMap(data.tags, true);
      var ids = buildMap(data.ids);
      var classes = buildMap(data.classes);
      if (tags === null && ids === null && classes === null) {
        return null;
      }
      return {
        tags,
        ids,
        classes
      };
    }
    function buildIndex(data) {
      var scopes = false;
      if (data.scopes && Array.isArray(data.scopes)) {
        scopes = /* @__PURE__ */ Object.create(null);
        for (var i = 0; i < data.scopes.length; i++) {
          var list = data.scopes[i];
          if (!list || !Array.isArray(list)) {
            throw new Error("Wrong usage format");
          }
          for (var j = 0; j < list.length; j++) {
            var name = list[j];
            if (hasOwnProperty2.call(scopes, name)) {
              throw new Error("Class can't be used for several scopes: " + name);
            }
            scopes[name] = i + 1;
          }
        }
      }
      return {
        whitelist: buildList(data),
        blacklist: buildList(data.blacklist),
        scopes
      };
    }
    module2.exports = {
      buildIndex
    };
  }
});

// node_modules/csso/lib/clean/utils.js
var require_utils4 = __commonJS({
  "node_modules/csso/lib/clean/utils.js"(exports2, module2) {
    module2.exports = {
      hasNoChildren: function(node) {
        return !node || !node.children || node.children.isEmpty();
      },
      isNodeChildrenList: function(node, list) {
        return node !== null && node.children === list;
      }
    };
  }
});

// node_modules/csso/lib/clean/Atrule.js
var require_Atrule2 = __commonJS({
  "node_modules/csso/lib/clean/Atrule.js"(exports2, module2) {
    var resolveKeyword = require_lib9().keyword;
    var { hasNoChildren } = require_utils4();
    module2.exports = function cleanAtrule(node, item, list) {
      if (node.block) {
        if (this.stylesheet !== null) {
          this.stylesheet.firstAtrulesAllowed = false;
        }
        if (hasNoChildren(node.block)) {
          list.remove(item);
          return;
        }
      }
      switch (node.name) {
        case "charset":
          if (hasNoChildren(node.prelude)) {
            list.remove(item);
            return;
          }
          if (item.prev) {
            list.remove(item);
            return;
          }
          break;
        case "import":
          if (this.stylesheet === null || !this.stylesheet.firstAtrulesAllowed) {
            list.remove(item);
            return;
          }
          list.prevUntil(item.prev, function(rule) {
            if (rule.type === "Atrule") {
              if (rule.name === "import" || rule.name === "charset") {
                return;
              }
            }
            this.root.firstAtrulesAllowed = false;
            list.remove(item);
            return true;
          }, this);
          break;
        default:
          var name = resolveKeyword(node.name).basename;
          if (name === "keyframes" || name === "media" || name === "supports") {
            if (hasNoChildren(node.prelude) || hasNoChildren(node.block)) {
              list.remove(item);
            }
          }
      }
    };
  }
});

// node_modules/csso/lib/clean/Comment.js
var require_Comment2 = __commonJS({
  "node_modules/csso/lib/clean/Comment.js"(exports2, module2) {
    module2.exports = function cleanComment(data, item, list) {
      list.remove(item);
    };
  }
});

// node_modules/csso/lib/clean/Declaration.js
var require_Declaration2 = __commonJS({
  "node_modules/csso/lib/clean/Declaration.js"(exports2, module2) {
    var property = require_lib9().property;
    module2.exports = function cleanDeclartion(node, item, list) {
      if (node.value.children && node.value.children.isEmpty()) {
        list.remove(item);
        return;
      }
      if (property(node.property).custom) {
        if (/\S/.test(node.value.value)) {
          node.value.value = node.value.value.trim();
        }
      }
    };
  }
});

// node_modules/csso/lib/clean/Raw.js
var require_Raw2 = __commonJS({
  "node_modules/csso/lib/clean/Raw.js"(exports2, module2) {
    var { isNodeChildrenList } = require_utils4();
    module2.exports = function cleanRaw(node, item, list) {
      if (isNodeChildrenList(this.stylesheet, list) || isNodeChildrenList(this.block, list)) {
        list.remove(item);
      }
    };
  }
});

// node_modules/csso/lib/clean/Rule.js
var require_Rule2 = __commonJS({
  "node_modules/csso/lib/clean/Rule.js"(exports2, module2) {
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    var walk = require_lib9().walk;
    var { hasNoChildren } = require_utils4();
    function cleanUnused(selectorList, usageData) {
      selectorList.children.each(function(selector, item, list) {
        var shouldRemove = false;
        walk(selector, function(node) {
          if (this.selector === null || this.selector === selectorList) {
            switch (node.type) {
              case "SelectorList":
                if (this.function === null || this.function.name.toLowerCase() !== "not") {
                  if (cleanUnused(node, usageData)) {
                    shouldRemove = true;
                  }
                }
                break;
              case "ClassSelector":
                if (usageData.whitelist !== null && usageData.whitelist.classes !== null && !hasOwnProperty2.call(usageData.whitelist.classes, node.name)) {
                  shouldRemove = true;
                }
                if (usageData.blacklist !== null && usageData.blacklist.classes !== null && hasOwnProperty2.call(usageData.blacklist.classes, node.name)) {
                  shouldRemove = true;
                }
                break;
              case "IdSelector":
                if (usageData.whitelist !== null && usageData.whitelist.ids !== null && !hasOwnProperty2.call(usageData.whitelist.ids, node.name)) {
                  shouldRemove = true;
                }
                if (usageData.blacklist !== null && usageData.blacklist.ids !== null && hasOwnProperty2.call(usageData.blacklist.ids, node.name)) {
                  shouldRemove = true;
                }
                break;
              case "TypeSelector":
                if (node.name.charAt(node.name.length - 1) !== "*") {
                  if (usageData.whitelist !== null && usageData.whitelist.tags !== null && !hasOwnProperty2.call(usageData.whitelist.tags, node.name.toLowerCase())) {
                    shouldRemove = true;
                  }
                  if (usageData.blacklist !== null && usageData.blacklist.tags !== null && hasOwnProperty2.call(usageData.blacklist.tags, node.name.toLowerCase())) {
                    shouldRemove = true;
                  }
                }
                break;
            }
          }
        });
        if (shouldRemove) {
          list.remove(item);
        }
      });
      return selectorList.children.isEmpty();
    }
    module2.exports = function cleanRule(node, item, list, options) {
      if (hasNoChildren(node.prelude) || hasNoChildren(node.block)) {
        list.remove(item);
        return;
      }
      var usageData = options.usage;
      if (usageData && (usageData.whitelist !== null || usageData.blacklist !== null)) {
        cleanUnused(node.prelude, usageData);
        if (hasNoChildren(node.prelude)) {
          list.remove(item);
          return;
        }
      }
    };
  }
});

// node_modules/csso/lib/clean/TypeSelector.js
var require_TypeSelector2 = __commonJS({
  "node_modules/csso/lib/clean/TypeSelector.js"(exports2, module2) {
    module2.exports = function cleanTypeSelector(node, item, list) {
      var name = item.data.name;
      if (name !== "*") {
        return;
      }
      var nextType = item.next && item.next.data.type;
      if (nextType === "IdSelector" || nextType === "ClassSelector" || nextType === "AttributeSelector" || nextType === "PseudoClassSelector" || nextType === "PseudoElementSelector") {
        list.remove(item);
      }
    };
  }
});

// node_modules/csso/lib/clean/WhiteSpace.js
var require_WhiteSpace2 = __commonJS({
  "node_modules/csso/lib/clean/WhiteSpace.js"(exports2, module2) {
    var { isNodeChildrenList } = require_utils4();
    function isSafeOperator(node) {
      return node.type === "Operator" && node.value !== "+" && node.value !== "-";
    }
    module2.exports = function cleanWhitespace(node, item, list) {
      if (item.next === null || item.prev === null) {
        list.remove(item);
        return;
      }
      if (isNodeChildrenList(this.stylesheet, list) || isNodeChildrenList(this.block, list)) {
        list.remove(item);
        return;
      }
      if (item.next.data.type === "WhiteSpace") {
        list.remove(item);
        return;
      }
      if (isSafeOperator(item.prev.data) || isSafeOperator(item.next.data)) {
        list.remove(item);
        return;
      }
    };
  }
});

// node_modules/csso/lib/clean/index.js
var require_clean = __commonJS({
  "node_modules/csso/lib/clean/index.js"(exports2, module2) {
    var walk = require_lib9().walk;
    var handlers = {
      Atrule: require_Atrule2(),
      Comment: require_Comment2(),
      Declaration: require_Declaration2(),
      Raw: require_Raw2(),
      Rule: require_Rule2(),
      TypeSelector: require_TypeSelector2(),
      WhiteSpace: require_WhiteSpace2()
    };
    module2.exports = function(ast, options) {
      walk(ast, {
        leave: function(node, item, list) {
          if (handlers.hasOwnProperty(node.type)) {
            handlers[node.type].call(this, node, item, list, options);
          }
        }
      });
    };
  }
});

// node_modules/csso/lib/replace/atrule/keyframes.js
var require_keyframes = __commonJS({
  "node_modules/csso/lib/replace/atrule/keyframes.js"(exports2, module2) {
    module2.exports = function(node) {
      node.block.children.each(function(rule) {
        rule.prelude.children.each(function(simpleselector) {
          simpleselector.children.each(function(data, item) {
            if (data.type === "Percentage" && data.value === "100") {
              item.data = {
                type: "TypeSelector",
                loc: data.loc,
                name: "to"
              };
            } else if (data.type === "TypeSelector" && data.name === "from") {
              item.data = {
                type: "Percentage",
                loc: data.loc,
                value: "0"
              };
            }
          });
        });
      });
    };
  }
});

// node_modules/csso/lib/replace/Atrule.js
var require_Atrule3 = __commonJS({
  "node_modules/csso/lib/replace/Atrule.js"(exports2, module2) {
    var resolveKeyword = require_lib9().keyword;
    var compressKeyframes = require_keyframes();
    module2.exports = function(node) {
      if (resolveKeyword(node.name).basename === "keyframes") {
        compressKeyframes(node);
      }
    };
  }
});

// node_modules/csso/lib/replace/AttributeSelector.js
var require_AttributeSelector2 = __commonJS({
  "node_modules/csso/lib/replace/AttributeSelector.js"(exports2, module2) {
    var escapesRx = /\\([0-9A-Fa-f]{1,6})(\r\n|[ \t\n\f\r])?|\\./g;
    var blockUnquoteRx = /^(-?\d|--)|[\u0000-\u002c\u002e\u002f\u003A-\u0040\u005B-\u005E\u0060\u007B-\u009f]/;
    function canUnquote(value) {
      if (value === "" || value === "-") {
        return;
      }
      value = value.replace(escapesRx, "a");
      return !blockUnquoteRx.test(value);
    }
    module2.exports = function(node) {
      var attrValue = node.value;
      if (!attrValue || attrValue.type !== "String") {
        return;
      }
      var unquotedValue = attrValue.value.replace(/^(.)(.*)\1$/, "$2");
      if (canUnquote(unquotedValue)) {
        node.value = {
          type: "Identifier",
          loc: attrValue.loc,
          name: unquotedValue
        };
      }
    };
  }
});

// node_modules/csso/lib/replace/property/font.js
var require_font = __commonJS({
  "node_modules/csso/lib/replace/property/font.js"(exports2, module2) {
    module2.exports = function compressFont(node) {
      var list = node.children;
      list.eachRight(function(node2, item) {
        if (node2.type === "Identifier") {
          if (node2.name === "bold") {
            item.data = {
              type: "Number",
              loc: node2.loc,
              value: "700"
            };
          } else if (node2.name === "normal") {
            var prev = item.prev;
            if (prev && prev.data.type === "Operator" && prev.data.value === "/") {
              this.remove(prev);
            }
            this.remove(item);
          } else if (node2.name === "medium") {
            var next = item.next;
            if (!next || next.data.type !== "Operator") {
              this.remove(item);
            }
          }
        }
      });
      list.each(function(node2, item) {
        if (node2.type === "WhiteSpace") {
          if (!item.prev || !item.next || item.next.data.type === "WhiteSpace") {
            this.remove(item);
          }
        }
      });
      if (list.isEmpty()) {
        list.insert(list.createItem({
          type: "Identifier",
          name: "normal"
        }));
      }
    };
  }
});

// node_modules/csso/lib/replace/property/font-weight.js
var require_font_weight = __commonJS({
  "node_modules/csso/lib/replace/property/font-weight.js"(exports2, module2) {
    module2.exports = function compressFontWeight(node) {
      var value = node.children.head.data;
      if (value.type === "Identifier") {
        switch (value.name) {
          case "normal":
            node.children.head.data = {
              type: "Number",
              loc: value.loc,
              value: "400"
            };
            break;
          case "bold":
            node.children.head.data = {
              type: "Number",
              loc: value.loc,
              value: "700"
            };
            break;
        }
      }
    };
  }
});

// node_modules/csso/lib/replace/property/background.js
var require_background = __commonJS({
  "node_modules/csso/lib/replace/property/background.js"(exports2, module2) {
    var List = require_lib9().List;
    module2.exports = function compressBackground(node) {
      function lastType() {
        if (buffer.length) {
          return buffer[buffer.length - 1].type;
        }
      }
      function flush() {
        if (lastType() === "WhiteSpace") {
          buffer.pop();
        }
        if (!buffer.length) {
          buffer.unshift({
            type: "Number",
            loc: null,
            value: "0"
          }, {
            type: "WhiteSpace",
            value: " "
          }, {
            type: "Number",
            loc: null,
            value: "0"
          });
        }
        newValue.push.apply(newValue, buffer);
        buffer = [];
      }
      var newValue = [];
      var buffer = [];
      node.children.each(function(node2) {
        if (node2.type === "Operator" && node2.value === ",") {
          flush();
          newValue.push(node2);
          return;
        }
        if (node2.type === "Identifier") {
          if (node2.name === "transparent" || node2.name === "none" || node2.name === "repeat" || node2.name === "scroll") {
            return;
          }
        }
        if (node2.type === "WhiteSpace" && (!buffer.length || lastType() === "WhiteSpace")) {
          return;
        }
        buffer.push(node2);
      });
      flush();
      node.children = new List().fromArray(newValue);
    };
  }
});

// node_modules/csso/lib/replace/property/border.js
var require_border = __commonJS({
  "node_modules/csso/lib/replace/property/border.js"(exports2, module2) {
    function removeItemAndRedundantWhiteSpace(list, item) {
      var prev = item.prev;
      var next = item.next;
      if (next !== null) {
        if (next.data.type === "WhiteSpace" && (prev === null || prev.data.type === "WhiteSpace")) {
          list.remove(next);
        }
      } else if (prev !== null && prev.data.type === "WhiteSpace") {
        list.remove(prev);
      }
      list.remove(item);
    }
    module2.exports = function compressBorder(node) {
      node.children.each(function(node2, item, list) {
        if (node2.type === "Identifier" && node2.name.toLowerCase() === "none") {
          if (list.head === list.tail) {
            item.data = {
              type: "Number",
              loc: node2.loc,
              value: "0"
            };
          } else {
            removeItemAndRedundantWhiteSpace(list, item);
          }
        }
      });
    };
  }
});

// node_modules/csso/lib/replace/Value.js
var require_Value2 = __commonJS({
  "node_modules/csso/lib/replace/Value.js"(exports2, module2) {
    var resolveName = require_lib9().property;
    var handlers = {
      "font": require_font(),
      "font-weight": require_font_weight(),
      "background": require_background(),
      "border": require_border(),
      "outline": require_border()
    };
    module2.exports = function compressValue(node) {
      if (!this.declaration) {
        return;
      }
      var property = resolveName(this.declaration.property);
      if (handlers.hasOwnProperty(property.basename)) {
        handlers[property.basename](node);
      }
    };
  }
});

// node_modules/csso/lib/replace/Number.js
var require_Number2 = __commonJS({
  "node_modules/csso/lib/replace/Number.js"(exports2, module2) {
    var OMIT_PLUSSIGN = /^(?:\+|(-))?0*(\d*)(?:\.0*|(\.\d*?)0*)?$/;
    var KEEP_PLUSSIGN = /^([\+\-])?0*(\d*)(?:\.0*|(\.\d*?)0*)?$/;
    var unsafeToRemovePlusSignAfter = {
      Dimension: true,
      Hash: true,
      Identifier: true,
      Number: true,
      Raw: true,
      UnicodeRange: true
    };
    function packNumber(value, item) {
      var regexp = item && item.prev !== null && unsafeToRemovePlusSignAfter.hasOwnProperty(item.prev.data.type) ? KEEP_PLUSSIGN : OMIT_PLUSSIGN;
      value = String(value).replace(regexp, "$1$2$3");
      if (value === "" || value === "-") {
        value = "0";
      }
      return value;
    }
    module2.exports = function(node, item) {
      node.value = packNumber(node.value, item);
    };
    module2.exports.pack = packNumber;
  }
});

// node_modules/csso/lib/replace/Dimension.js
var require_Dimension2 = __commonJS({
  "node_modules/csso/lib/replace/Dimension.js"(exports2, module2) {
    var packNumber = require_Number2().pack;
    var MATH_FUNCTIONS = {
      "calc": true,
      "min": true,
      "max": true,
      "clamp": true
    };
    var LENGTH_UNIT = {
      "px": true,
      "mm": true,
      "cm": true,
      "in": true,
      "pt": true,
      "pc": true,
      "em": true,
      "ex": true,
      "ch": true,
      "rem": true,
      "vh": true,
      "vw": true,
      "vmin": true,
      "vmax": true,
      "vm": true
    };
    module2.exports = function compressDimension(node, item) {
      var value = packNumber(node.value, item);
      node.value = value;
      if (value === "0" && this.declaration !== null && this.atrulePrelude === null) {
        var unit = node.unit.toLowerCase();
        if (!LENGTH_UNIT.hasOwnProperty(unit)) {
          return;
        }
        if (this.declaration.property === "-ms-flex" || this.declaration.property === "flex") {
          return;
        }
        if (this.function && MATH_FUNCTIONS.hasOwnProperty(this.function.name)) {
          return;
        }
        item.data = {
          type: "Number",
          loc: node.loc,
          value
        };
      }
    };
  }
});

// node_modules/csso/lib/replace/Percentage.js
var require_Percentage2 = __commonJS({
  "node_modules/csso/lib/replace/Percentage.js"(exports2, module2) {
    var lexer = require_lib9().lexer;
    var packNumber = require_Number2().pack;
    var blacklist = /* @__PURE__ */ new Set([
      "width",
      "min-width",
      "max-width",
      "height",
      "min-height",
      "max-height",
      "flex",
      "-ms-flex"
    ]);
    module2.exports = function compressPercentage(node, item) {
      node.value = packNumber(node.value, item);
      if (node.value === "0" && this.declaration && !blacklist.has(this.declaration.property)) {
        item.data = {
          type: "Number",
          loc: node.loc,
          value: node.value
        };
        if (!lexer.matchDeclaration(this.declaration).isType(item.data, "length")) {
          item.data = node;
        }
      }
    };
  }
});

// node_modules/csso/lib/replace/String.js
var require_String2 = __commonJS({
  "node_modules/csso/lib/replace/String.js"(exports2, module2) {
    module2.exports = function(node) {
      var value = node.value;
      value = value.replace(/\\(\r\n|\r|\n|\f)/g, "");
      node.value = value;
    };
  }
});

// node_modules/csso/lib/replace/Url.js
var require_Url2 = __commonJS({
  "node_modules/csso/lib/replace/Url.js"(exports2, module2) {
    var UNICODE = "\\\\[0-9a-f]{1,6}(\\r\\n|[ \\n\\r\\t\\f])?";
    var ESCAPE = "(" + UNICODE + "|\\\\[^\\n\\r\\f0-9a-fA-F])";
    var NONPRINTABLE = "\0\b\v-\x7F";
    var SAFE_URL = new RegExp("^(" + ESCAPE + `|[^"'\\(\\)\\\\\\s` + NONPRINTABLE + "])*$", "i");
    module2.exports = function(node) {
      var value = node.value;
      if (value.type !== "String") {
        return;
      }
      var quote = value.value[0];
      var url = value.value.substr(1, value.value.length - 2);
      url = url.replace(/\\\\/g, "/");
      if (SAFE_URL.test(url)) {
        node.value = {
          type: "Raw",
          loc: node.value.loc,
          value: url
        };
      } else {
        node.value.value = url.indexOf('"') === -1 ? '"' + url + '"' : quote + url + quote;
      }
    };
  }
});

// node_modules/csso/lib/replace/color.js
var require_color = __commonJS({
  "node_modules/csso/lib/replace/color.js"(exports2, module2) {
    var lexer = require_lib9().lexer;
    var packNumber = require_Number2().pack;
    var NAME_TO_HEX = {
      "aliceblue": "f0f8ff",
      "antiquewhite": "faebd7",
      "aqua": "0ff",
      "aquamarine": "7fffd4",
      "azure": "f0ffff",
      "beige": "f5f5dc",
      "bisque": "ffe4c4",
      "black": "000",
      "blanchedalmond": "ffebcd",
      "blue": "00f",
      "blueviolet": "8a2be2",
      "brown": "a52a2a",
      "burlywood": "deb887",
      "cadetblue": "5f9ea0",
      "chartreuse": "7fff00",
      "chocolate": "d2691e",
      "coral": "ff7f50",
      "cornflowerblue": "6495ed",
      "cornsilk": "fff8dc",
      "crimson": "dc143c",
      "cyan": "0ff",
      "darkblue": "00008b",
      "darkcyan": "008b8b",
      "darkgoldenrod": "b8860b",
      "darkgray": "a9a9a9",
      "darkgrey": "a9a9a9",
      "darkgreen": "006400",
      "darkkhaki": "bdb76b",
      "darkmagenta": "8b008b",
      "darkolivegreen": "556b2f",
      "darkorange": "ff8c00",
      "darkorchid": "9932cc",
      "darkred": "8b0000",
      "darksalmon": "e9967a",
      "darkseagreen": "8fbc8f",
      "darkslateblue": "483d8b",
      "darkslategray": "2f4f4f",
      "darkslategrey": "2f4f4f",
      "darkturquoise": "00ced1",
      "darkviolet": "9400d3",
      "deeppink": "ff1493",
      "deepskyblue": "00bfff",
      "dimgray": "696969",
      "dimgrey": "696969",
      "dodgerblue": "1e90ff",
      "firebrick": "b22222",
      "floralwhite": "fffaf0",
      "forestgreen": "228b22",
      "fuchsia": "f0f",
      "gainsboro": "dcdcdc",
      "ghostwhite": "f8f8ff",
      "gold": "ffd700",
      "goldenrod": "daa520",
      "gray": "808080",
      "grey": "808080",
      "green": "008000",
      "greenyellow": "adff2f",
      "honeydew": "f0fff0",
      "hotpink": "ff69b4",
      "indianred": "cd5c5c",
      "indigo": "4b0082",
      "ivory": "fffff0",
      "khaki": "f0e68c",
      "lavender": "e6e6fa",
      "lavenderblush": "fff0f5",
      "lawngreen": "7cfc00",
      "lemonchiffon": "fffacd",
      "lightblue": "add8e6",
      "lightcoral": "f08080",
      "lightcyan": "e0ffff",
      "lightgoldenrodyellow": "fafad2",
      "lightgray": "d3d3d3",
      "lightgrey": "d3d3d3",
      "lightgreen": "90ee90",
      "lightpink": "ffb6c1",
      "lightsalmon": "ffa07a",
      "lightseagreen": "20b2aa",
      "lightskyblue": "87cefa",
      "lightslategray": "789",
      "lightslategrey": "789",
      "lightsteelblue": "b0c4de",
      "lightyellow": "ffffe0",
      "lime": "0f0",
      "limegreen": "32cd32",
      "linen": "faf0e6",
      "magenta": "f0f",
      "maroon": "800000",
      "mediumaquamarine": "66cdaa",
      "mediumblue": "0000cd",
      "mediumorchid": "ba55d3",
      "mediumpurple": "9370db",
      "mediumseagreen": "3cb371",
      "mediumslateblue": "7b68ee",
      "mediumspringgreen": "00fa9a",
      "mediumturquoise": "48d1cc",
      "mediumvioletred": "c71585",
      "midnightblue": "191970",
      "mintcream": "f5fffa",
      "mistyrose": "ffe4e1",
      "moccasin": "ffe4b5",
      "navajowhite": "ffdead",
      "navy": "000080",
      "oldlace": "fdf5e6",
      "olive": "808000",
      "olivedrab": "6b8e23",
      "orange": "ffa500",
      "orangered": "ff4500",
      "orchid": "da70d6",
      "palegoldenrod": "eee8aa",
      "palegreen": "98fb98",
      "paleturquoise": "afeeee",
      "palevioletred": "db7093",
      "papayawhip": "ffefd5",
      "peachpuff": "ffdab9",
      "peru": "cd853f",
      "pink": "ffc0cb",
      "plum": "dda0dd",
      "powderblue": "b0e0e6",
      "purple": "800080",
      "rebeccapurple": "639",
      "red": "f00",
      "rosybrown": "bc8f8f",
      "royalblue": "4169e1",
      "saddlebrown": "8b4513",
      "salmon": "fa8072",
      "sandybrown": "f4a460",
      "seagreen": "2e8b57",
      "seashell": "fff5ee",
      "sienna": "a0522d",
      "silver": "c0c0c0",
      "skyblue": "87ceeb",
      "slateblue": "6a5acd",
      "slategray": "708090",
      "slategrey": "708090",
      "snow": "fffafa",
      "springgreen": "00ff7f",
      "steelblue": "4682b4",
      "tan": "d2b48c",
      "teal": "008080",
      "thistle": "d8bfd8",
      "tomato": "ff6347",
      "turquoise": "40e0d0",
      "violet": "ee82ee",
      "wheat": "f5deb3",
      "white": "fff",
      "whitesmoke": "f5f5f5",
      "yellow": "ff0",
      "yellowgreen": "9acd32"
    };
    var HEX_TO_NAME = {
      "800000": "maroon",
      "800080": "purple",
      "808000": "olive",
      "808080": "gray",
      "00ffff": "cyan",
      "f0ffff": "azure",
      "f5f5dc": "beige",
      "ffe4c4": "bisque",
      "000000": "black",
      "0000ff": "blue",
      "a52a2a": "brown",
      "ff7f50": "coral",
      "ffd700": "gold",
      "008000": "green",
      "4b0082": "indigo",
      "fffff0": "ivory",
      "f0e68c": "khaki",
      "00ff00": "lime",
      "faf0e6": "linen",
      "000080": "navy",
      "ffa500": "orange",
      "da70d6": "orchid",
      "cd853f": "peru",
      "ffc0cb": "pink",
      "dda0dd": "plum",
      "f00": "red",
      "ff0000": "red",
      "fa8072": "salmon",
      "a0522d": "sienna",
      "c0c0c0": "silver",
      "fffafa": "snow",
      "d2b48c": "tan",
      "008080": "teal",
      "ff6347": "tomato",
      "ee82ee": "violet",
      "f5deb3": "wheat",
      "ffffff": "white",
      "ffff00": "yellow"
    };
    function hueToRgb(p, q, t) {
      if (t < 0) {
        t += 1;
      }
      if (t > 1) {
        t -= 1;
      }
      if (t < 1 / 6) {
        return p + (q - p) * 6 * t;
      }
      if (t < 1 / 2) {
        return q;
      }
      if (t < 2 / 3) {
        return p + (q - p) * (2 / 3 - t) * 6;
      }
      return p;
    }
    function hslToRgb(h, s, l, a) {
      var r;
      var g;
      var b;
      if (s === 0) {
        r = g = b = l;
      } else {
        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
        var p = 2 * l - q;
        r = hueToRgb(p, q, h + 1 / 3);
        g = hueToRgb(p, q, h);
        b = hueToRgb(p, q, h - 1 / 3);
      }
      return [
        Math.round(r * 255),
        Math.round(g * 255),
        Math.round(b * 255),
        a
      ];
    }
    function toHex(value) {
      value = value.toString(16);
      return value.length === 1 ? "0" + value : value;
    }
    function parseFunctionArgs(functionArgs, count, rgb) {
      var cursor = functionArgs.head;
      var args = [];
      var wasValue = false;
      while (cursor !== null) {
        var node = cursor.data;
        var type = node.type;
        switch (type) {
          case "Number":
          case "Percentage":
            if (wasValue) {
              return;
            }
            wasValue = true;
            args.push({
              type,
              value: Number(node.value)
            });
            break;
          case "Operator":
            if (node.value === ",") {
              if (!wasValue) {
                return;
              }
              wasValue = false;
            } else if (wasValue || node.value !== "+") {
              return;
            }
            break;
          default:
            return;
        }
        cursor = cursor.next;
      }
      if (args.length !== count) {
        return;
      }
      if (args.length === 4) {
        if (args[3].type !== "Number") {
          return;
        }
        args[3].type = "Alpha";
      }
      if (rgb) {
        if (args[0].type !== args[1].type || args[0].type !== args[2].type) {
          return;
        }
      } else {
        if (args[0].type !== "Number" || args[1].type !== "Percentage" || args[2].type !== "Percentage") {
          return;
        }
        args[0].type = "Angle";
      }
      return args.map(function(arg) {
        var value = Math.max(0, arg.value);
        switch (arg.type) {
          case "Number":
            value = Math.min(value, 255);
            break;
          case "Percentage":
            value = Math.min(value, 100) / 100;
            if (!rgb) {
              return value;
            }
            value = 255 * value;
            break;
          case "Angle":
            return (value % 360 + 360) % 360 / 360;
          case "Alpha":
            return Math.min(value, 1);
        }
        return Math.round(value);
      });
    }
    function compressFunction(node, item, list) {
      var functionName = node.name;
      var args;
      if (functionName === "rgba" || functionName === "hsla") {
        args = parseFunctionArgs(node.children, 4, functionName === "rgba");
        if (!args) {
          return;
        }
        if (functionName === "hsla") {
          args = hslToRgb.apply(null, args);
          node.name = "rgba";
        }
        if (args[3] === 0) {
          var scopeFunctionName = this.function && this.function.name;
          if (args[0] === 0 && args[1] === 0 && args[2] === 0 || !/^(?:to|from|color-stop)$|gradient$/i.test(scopeFunctionName)) {
            item.data = {
              type: "Identifier",
              loc: node.loc,
              name: "transparent"
            };
            return;
          }
        }
        if (args[3] !== 1) {
          node.children.each(function(node2, item2, list2) {
            if (node2.type === "Operator") {
              if (node2.value !== ",") {
                list2.remove(item2);
              }
              return;
            }
            item2.data = {
              type: "Number",
              loc: node2.loc,
              value: packNumber(args.shift(), null)
            };
          });
          return;
        }
        functionName = "rgb";
      }
      if (functionName === "hsl") {
        args = args || parseFunctionArgs(node.children, 3, false);
        if (!args) {
          return;
        }
        args = hslToRgb.apply(null, args);
        functionName = "rgb";
      }
      if (functionName === "rgb") {
        args = args || parseFunctionArgs(node.children, 3, true);
        if (!args) {
          return;
        }
        var next = item.next;
        if (next && next.data.type !== "WhiteSpace") {
          list.insert(list.createItem({
            type: "WhiteSpace",
            value: " "
          }), next);
        }
        item.data = {
          type: "Hash",
          loc: node.loc,
          value: toHex(args[0]) + toHex(args[1]) + toHex(args[2])
        };
        compressHex(item.data, item);
      }
    }
    function compressIdent(node, item) {
      if (this.declaration === null) {
        return;
      }
      var color = node.name.toLowerCase();
      if (NAME_TO_HEX.hasOwnProperty(color) && lexer.matchDeclaration(this.declaration).isType(node, "color")) {
        var hex = NAME_TO_HEX[color];
        if (hex.length + 1 <= color.length) {
          item.data = {
            type: "Hash",
            loc: node.loc,
            value: hex
          };
        } else {
          if (color === "grey") {
            color = "gray";
          }
          node.name = color;
        }
      }
    }
    function compressHex(node, item) {
      var color = node.value.toLowerCase();
      if (color.length === 6 && color[0] === color[1] && color[2] === color[3] && color[4] === color[5]) {
        color = color[0] + color[2] + color[4];
      }
      if (HEX_TO_NAME[color]) {
        item.data = {
          type: "Identifier",
          loc: node.loc,
          name: HEX_TO_NAME[color]
        };
      } else {
        node.value = color;
      }
    }
    module2.exports = {
      compressFunction,
      compressIdent,
      compressHex
    };
  }
});

// node_modules/csso/lib/replace/index.js
var require_replace = __commonJS({
  "node_modules/csso/lib/replace/index.js"(exports2, module2) {
    var walk = require_lib9().walk;
    var handlers = {
      Atrule: require_Atrule3(),
      AttributeSelector: require_AttributeSelector2(),
      Value: require_Value2(),
      Dimension: require_Dimension2(),
      Percentage: require_Percentage2(),
      Number: require_Number2(),
      String: require_String2(),
      Url: require_Url2(),
      Hash: require_color().compressHex,
      Identifier: require_color().compressIdent,
      Function: require_color().compressFunction
    };
    module2.exports = function(ast) {
      walk(ast, {
        leave: function(node, item, list) {
          if (handlers.hasOwnProperty(node.type)) {
            handlers[node.type].call(this, node, item, list);
          }
        }
      });
    };
  }
});

// node_modules/csso/lib/restructure/prepare/createDeclarationIndexer.js
var require_createDeclarationIndexer = __commonJS({
  "node_modules/csso/lib/restructure/prepare/createDeclarationIndexer.js"(exports2, module2) {
    var generate = require_lib9().generate;
    function Index() {
      this.seed = 0;
      this.map = /* @__PURE__ */ Object.create(null);
    }
    Index.prototype.resolve = function(str) {
      var index = this.map[str];
      if (!index) {
        index = ++this.seed;
        this.map[str] = index;
      }
      return index;
    };
    module2.exports = function createDeclarationIndexer() {
      var ids = new Index();
      return function markDeclaration(node) {
        var id = generate(node);
        node.id = ids.resolve(id);
        node.length = id.length;
        node.fingerprint = null;
        return node;
      };
    };
  }
});

// node_modules/csso/lib/restructure/prepare/processSelector.js
var require_processSelector = __commonJS({
  "node_modules/csso/lib/restructure/prepare/processSelector.js"(exports2, module2) {
    var generate = require_lib9().generate;
    var specificity = require_specificity();
    var nonFreezePseudoElements = {
      "first-letter": true,
      "first-line": true,
      "after": true,
      "before": true
    };
    var nonFreezePseudoClasses = {
      "link": true,
      "visited": true,
      "hover": true,
      "active": true,
      "first-letter": true,
      "first-line": true,
      "after": true,
      "before": true
    };
    module2.exports = function freeze(node, usageData) {
      var pseudos = /* @__PURE__ */ Object.create(null);
      var hasPseudo = false;
      node.prelude.children.each(function(simpleSelector) {
        var tagName = "*";
        var scope = 0;
        simpleSelector.children.each(function(node2) {
          switch (node2.type) {
            case "ClassSelector":
              if (usageData && usageData.scopes) {
                var classScope = usageData.scopes[node2.name] || 0;
                if (scope !== 0 && classScope !== scope) {
                  throw new Error("Selector can't has classes from different scopes: " + generate(simpleSelector));
                }
                scope = classScope;
              }
              break;
            case "PseudoClassSelector":
              var name = node2.name.toLowerCase();
              if (!nonFreezePseudoClasses.hasOwnProperty(name)) {
                pseudos[":" + name] = true;
                hasPseudo = true;
              }
              break;
            case "PseudoElementSelector":
              var name = node2.name.toLowerCase();
              if (!nonFreezePseudoElements.hasOwnProperty(name)) {
                pseudos["::" + name] = true;
                hasPseudo = true;
              }
              break;
            case "TypeSelector":
              tagName = node2.name.toLowerCase();
              break;
            case "AttributeSelector":
              if (node2.flags) {
                pseudos["[" + node2.flags.toLowerCase() + "]"] = true;
                hasPseudo = true;
              }
              break;
            case "WhiteSpace":
            case "Combinator":
              tagName = "*";
              break;
          }
        });
        simpleSelector.compareMarker = specificity(simpleSelector).toString();
        simpleSelector.id = null;
        simpleSelector.id = generate(simpleSelector);
        if (scope) {
          simpleSelector.compareMarker += ":" + scope;
        }
        if (tagName !== "*") {
          simpleSelector.compareMarker += "," + tagName;
        }
      });
      node.pseudoSignature = hasPseudo && Object.keys(pseudos).sort().join(",");
    };
  }
});

// node_modules/csso/lib/restructure/prepare/index.js
var require_prepare = __commonJS({
  "node_modules/csso/lib/restructure/prepare/index.js"(exports2, module2) {
    var resolveKeyword = require_lib9().keyword;
    var walk = require_lib9().walk;
    var generate = require_lib9().generate;
    var createDeclarationIndexer = require_createDeclarationIndexer();
    var processSelector = require_processSelector();
    module2.exports = function prepare(ast, options) {
      var markDeclaration = createDeclarationIndexer();
      walk(ast, {
        visit: "Rule",
        enter: function processRule(node) {
          node.block.children.each(markDeclaration);
          processSelector(node, options.usage);
        }
      });
      walk(ast, {
        visit: "Atrule",
        enter: function(node) {
          if (node.prelude) {
            node.prelude.id = null;
            node.prelude.id = generate(node.prelude);
          }
          if (resolveKeyword(node.name).basename === "keyframes") {
            node.block.avoidRulesMerge = true;
            node.block.children.each(function(rule) {
              rule.prelude.children.each(function(simpleselector) {
                simpleselector.compareMarker = simpleselector.id;
              });
            });
          }
        }
      });
      return {
        declaration: markDeclaration
      };
    };
  }
});

// node_modules/csso/lib/restructure/1-mergeAtrule.js
var require_mergeAtrule = __commonJS({
  "node_modules/csso/lib/restructure/1-mergeAtrule.js"(exports2, module2) {
    var List = require_lib9().List;
    var resolveKeyword = require_lib9().keyword;
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    var walk = require_lib9().walk;
    function addRuleToMap(map, item, list, single) {
      var node = item.data;
      var name = resolveKeyword(node.name).basename;
      var id = node.name.toLowerCase() + "/" + (node.prelude ? node.prelude.id : null);
      if (!hasOwnProperty2.call(map, name)) {
        map[name] = /* @__PURE__ */ Object.create(null);
      }
      if (single) {
        delete map[name][id];
      }
      if (!hasOwnProperty2.call(map[name], id)) {
        map[name][id] = new List();
      }
      map[name][id].append(list.remove(item));
    }
    function relocateAtrules(ast, options) {
      var collected = /* @__PURE__ */ Object.create(null);
      var topInjectPoint = null;
      ast.children.each(function(node, item, list) {
        if (node.type === "Atrule") {
          var name = resolveKeyword(node.name).basename;
          switch (name) {
            case "keyframes":
              addRuleToMap(collected, item, list, true);
              return;
            case "media":
              if (options.forceMediaMerge) {
                addRuleToMap(collected, item, list, false);
                return;
              }
              break;
          }
          if (topInjectPoint === null && name !== "charset" && name !== "import") {
            topInjectPoint = item;
          }
        } else {
          if (topInjectPoint === null) {
            topInjectPoint = item;
          }
        }
      });
      for (var atrule in collected) {
        for (var id in collected[atrule]) {
          ast.children.insertList(collected[atrule][id], atrule === "media" ? null : topInjectPoint);
        }
      }
    }
    function isMediaRule(node) {
      return node.type === "Atrule" && node.name === "media";
    }
    function processAtrule(node, item, list) {
      if (!isMediaRule(node)) {
        return;
      }
      var prev = item.prev && item.prev.data;
      if (!prev || !isMediaRule(prev)) {
        return;
      }
      if (node.prelude && prev.prelude && node.prelude.id === prev.prelude.id) {
        prev.block.children.appendList(node.block.children);
        list.remove(item);
      }
    }
    module2.exports = function rejoinAtrule(ast, options) {
      relocateAtrules(ast, options);
      walk(ast, {
        visit: "Atrule",
        reverse: true,
        enter: processAtrule
      });
    };
  }
});

// node_modules/csso/lib/restructure/utils.js
var require_utils5 = __commonJS({
  "node_modules/csso/lib/restructure/utils.js"(exports2, module2) {
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    function isEqualSelectors(a, b) {
      var cursor1 = a.head;
      var cursor2 = b.head;
      while (cursor1 !== null && cursor2 !== null && cursor1.data.id === cursor2.data.id) {
        cursor1 = cursor1.next;
        cursor2 = cursor2.next;
      }
      return cursor1 === null && cursor2 === null;
    }
    function isEqualDeclarations(a, b) {
      var cursor1 = a.head;
      var cursor2 = b.head;
      while (cursor1 !== null && cursor2 !== null && cursor1.data.id === cursor2.data.id) {
        cursor1 = cursor1.next;
        cursor2 = cursor2.next;
      }
      return cursor1 === null && cursor2 === null;
    }
    function compareDeclarations(declarations1, declarations2) {
      var result = {
        eq: [],
        ne1: [],
        ne2: [],
        ne2overrided: []
      };
      var fingerprints = /* @__PURE__ */ Object.create(null);
      var declarations2hash = /* @__PURE__ */ Object.create(null);
      for (var cursor = declarations2.head; cursor; cursor = cursor.next) {
        declarations2hash[cursor.data.id] = true;
      }
      for (var cursor = declarations1.head; cursor; cursor = cursor.next) {
        var data = cursor.data;
        if (data.fingerprint) {
          fingerprints[data.fingerprint] = data.important;
        }
        if (declarations2hash[data.id]) {
          declarations2hash[data.id] = false;
          result.eq.push(data);
        } else {
          result.ne1.push(data);
        }
      }
      for (var cursor = declarations2.head; cursor; cursor = cursor.next) {
        var data = cursor.data;
        if (declarations2hash[data.id]) {
          if (!hasOwnProperty2.call(fingerprints, data.fingerprint) || !fingerprints[data.fingerprint] && data.important) {
            result.ne2.push(data);
          }
          result.ne2overrided.push(data);
        }
      }
      return result;
    }
    function addSelectors(dest, source) {
      source.each(function(sourceData) {
        var newStr = sourceData.id;
        var cursor = dest.head;
        while (cursor) {
          var nextStr = cursor.data.id;
          if (nextStr === newStr) {
            return;
          }
          if (nextStr > newStr) {
            break;
          }
          cursor = cursor.next;
        }
        dest.insert(dest.createItem(sourceData), cursor);
      });
      return dest;
    }
    function hasSimilarSelectors(selectors1, selectors2) {
      var cursor1 = selectors1.head;
      while (cursor1 !== null) {
        var cursor2 = selectors2.head;
        while (cursor2 !== null) {
          if (cursor1.data.compareMarker === cursor2.data.compareMarker) {
            return true;
          }
          cursor2 = cursor2.next;
        }
        cursor1 = cursor1.next;
      }
      return false;
    }
    function unsafeToSkipNode(node) {
      switch (node.type) {
        case "Rule":
          return hasSimilarSelectors(node.prelude.children, this);
        case "Atrule":
          if (node.block) {
            return node.block.children.some(unsafeToSkipNode, this);
          }
          break;
        case "Declaration":
          return false;
      }
      return true;
    }
    module2.exports = {
      isEqualSelectors,
      isEqualDeclarations,
      compareDeclarations,
      addSelectors,
      hasSimilarSelectors,
      unsafeToSkipNode
    };
  }
});

// node_modules/csso/lib/restructure/2-initialMergeRuleset.js
var require_initialMergeRuleset = __commonJS({
  "node_modules/csso/lib/restructure/2-initialMergeRuleset.js"(exports2, module2) {
    var walk = require_lib9().walk;
    var utils = require_utils5();
    function processRule(node, item, list) {
      var selectors = node.prelude.children;
      var declarations = node.block.children;
      list.prevUntil(item.prev, function(prev) {
        if (prev.type !== "Rule") {
          return utils.unsafeToSkipNode.call(selectors, prev);
        }
        var prevSelectors = prev.prelude.children;
        var prevDeclarations = prev.block.children;
        if (node.pseudoSignature === prev.pseudoSignature) {
          if (utils.isEqualSelectors(prevSelectors, selectors)) {
            prevDeclarations.appendList(declarations);
            list.remove(item);
            return true;
          }
          if (utils.isEqualDeclarations(declarations, prevDeclarations)) {
            utils.addSelectors(prevSelectors, selectors);
            list.remove(item);
            return true;
          }
        }
        return utils.hasSimilarSelectors(selectors, prevSelectors);
      });
    }
    module2.exports = function initialMergeRule(ast) {
      walk(ast, {
        visit: "Rule",
        enter: processRule
      });
    };
  }
});

// node_modules/csso/lib/restructure/3-disjoinRuleset.js
var require_disjoinRuleset = __commonJS({
  "node_modules/csso/lib/restructure/3-disjoinRuleset.js"(exports2, module2) {
    var List = require_lib9().List;
    var walk = require_lib9().walk;
    function processRule(node, item, list) {
      var selectors = node.prelude.children;
      while (selectors.head !== selectors.tail) {
        var newSelectors = new List();
        newSelectors.insert(selectors.remove(selectors.head));
        list.insert(list.createItem({
          type: "Rule",
          loc: node.loc,
          prelude: {
            type: "SelectorList",
            loc: node.prelude.loc,
            children: newSelectors
          },
          block: {
            type: "Block",
            loc: node.block.loc,
            children: node.block.children.copy()
          },
          pseudoSignature: node.pseudoSignature
        }), item);
      }
    }
    module2.exports = function disjoinRule(ast) {
      walk(ast, {
        visit: "Rule",
        reverse: true,
        enter: processRule
      });
    };
  }
});

// node_modules/csso/lib/restructure/4-restructShorthand.js
var require_restructShorthand = __commonJS({
  "node_modules/csso/lib/restructure/4-restructShorthand.js"(exports2, module2) {
    var List = require_lib9().List;
    var generate = require_lib9().generate;
    var walk = require_lib9().walk;
    var REPLACE = 1;
    var REMOVE = 2;
    var TOP = 0;
    var RIGHT = 1;
    var BOTTOM = 2;
    var LEFT = 3;
    var SIDES = ["top", "right", "bottom", "left"];
    var SIDE = {
      "margin-top": "top",
      "margin-right": "right",
      "margin-bottom": "bottom",
      "margin-left": "left",
      "padding-top": "top",
      "padding-right": "right",
      "padding-bottom": "bottom",
      "padding-left": "left",
      "border-top-color": "top",
      "border-right-color": "right",
      "border-bottom-color": "bottom",
      "border-left-color": "left",
      "border-top-width": "top",
      "border-right-width": "right",
      "border-bottom-width": "bottom",
      "border-left-width": "left",
      "border-top-style": "top",
      "border-right-style": "right",
      "border-bottom-style": "bottom",
      "border-left-style": "left"
    };
    var MAIN_PROPERTY = {
      "margin": "margin",
      "margin-top": "margin",
      "margin-right": "margin",
      "margin-bottom": "margin",
      "margin-left": "margin",
      "padding": "padding",
      "padding-top": "padding",
      "padding-right": "padding",
      "padding-bottom": "padding",
      "padding-left": "padding",
      "border-color": "border-color",
      "border-top-color": "border-color",
      "border-right-color": "border-color",
      "border-bottom-color": "border-color",
      "border-left-color": "border-color",
      "border-width": "border-width",
      "border-top-width": "border-width",
      "border-right-width": "border-width",
      "border-bottom-width": "border-width",
      "border-left-width": "border-width",
      "border-style": "border-style",
      "border-top-style": "border-style",
      "border-right-style": "border-style",
      "border-bottom-style": "border-style",
      "border-left-style": "border-style"
    };
    function TRBL(name) {
      this.name = name;
      this.loc = null;
      this.iehack = void 0;
      this.sides = {
        "top": null,
        "right": null,
        "bottom": null,
        "left": null
      };
    }
    TRBL.prototype.getValueSequence = function(declaration, count) {
      var values = [];
      var iehack = "";
      var hasBadValues = declaration.value.type !== "Value" || declaration.value.children.some(function(child) {
        var special = false;
        switch (child.type) {
          case "Identifier":
            switch (child.name) {
              case "\\0":
              case "\\9":
                iehack = child.name;
                return;
              case "inherit":
              case "initial":
              case "unset":
              case "revert":
                special = child.name;
                break;
            }
            break;
          case "Dimension":
            switch (child.unit) {
              case "rem":
              case "vw":
              case "vh":
              case "vmin":
              case "vmax":
              case "vm":
                special = child.unit;
                break;
            }
            break;
          case "Hash":
          case "Number":
          case "Percentage":
            break;
          case "Function":
            if (child.name === "var") {
              return true;
            }
            special = child.name;
            break;
          case "WhiteSpace":
            return false;
          default:
            return true;
        }
        values.push({
          node: child,
          special,
          important: declaration.important
        });
      });
      if (hasBadValues || values.length > count) {
        return false;
      }
      if (typeof this.iehack === "string" && this.iehack !== iehack) {
        return false;
      }
      this.iehack = iehack;
      return values;
    };
    TRBL.prototype.canOverride = function(side, value) {
      var currentValue = this.sides[side];
      return !currentValue || value.important && !currentValue.important;
    };
    TRBL.prototype.add = function(name, declaration) {
      function attemptToAdd() {
        var sides = this.sides;
        var side = SIDE[name];
        if (side) {
          if (side in sides === false) {
            return false;
          }
          var values = this.getValueSequence(declaration, 1);
          if (!values || !values.length) {
            return false;
          }
          for (var key in sides) {
            if (sides[key] !== null && sides[key].special !== values[0].special) {
              return false;
            }
          }
          if (!this.canOverride(side, values[0])) {
            return true;
          }
          sides[side] = values[0];
          return true;
        } else if (name === this.name) {
          var values = this.getValueSequence(declaration, 4);
          if (!values || !values.length) {
            return false;
          }
          switch (values.length) {
            case 1:
              values[RIGHT] = values[TOP];
              values[BOTTOM] = values[TOP];
              values[LEFT] = values[TOP];
              break;
            case 2:
              values[BOTTOM] = values[TOP];
              values[LEFT] = values[RIGHT];
              break;
            case 3:
              values[LEFT] = values[RIGHT];
              break;
          }
          for (var i = 0; i < 4; i++) {
            for (var key in sides) {
              if (sides[key] !== null && sides[key].special !== values[i].special) {
                return false;
              }
            }
          }
          for (var i = 0; i < 4; i++) {
            if (this.canOverride(SIDES[i], values[i])) {
              sides[SIDES[i]] = values[i];
            }
          }
          return true;
        }
      }
      if (!attemptToAdd.call(this)) {
        return false;
      }
      if (!this.loc) {
        this.loc = declaration.loc;
      }
      return true;
    };
    TRBL.prototype.isOkToMinimize = function() {
      var top = this.sides.top;
      var right = this.sides.right;
      var bottom = this.sides.bottom;
      var left = this.sides.left;
      if (top && right && bottom && left) {
        var important = top.important + right.important + bottom.important + left.important;
        return important === 0 || important === 4;
      }
      return false;
    };
    TRBL.prototype.getValue = function() {
      var result = new List();
      var sides = this.sides;
      var values = [
        sides.top,
        sides.right,
        sides.bottom,
        sides.left
      ];
      var stringValues = [
        generate(sides.top.node),
        generate(sides.right.node),
        generate(sides.bottom.node),
        generate(sides.left.node)
      ];
      if (stringValues[LEFT] === stringValues[RIGHT]) {
        values.pop();
        if (stringValues[BOTTOM] === stringValues[TOP]) {
          values.pop();
          if (stringValues[RIGHT] === stringValues[TOP]) {
            values.pop();
          }
        }
      }
      for (var i = 0; i < values.length; i++) {
        if (i) {
          result.appendData({ type: "WhiteSpace", value: " " });
        }
        result.appendData(values[i].node);
      }
      if (this.iehack) {
        result.appendData({ type: "WhiteSpace", value: " " });
        result.appendData({
          type: "Identifier",
          loc: null,
          name: this.iehack
        });
      }
      return {
        type: "Value",
        loc: null,
        children: result
      };
    };
    TRBL.prototype.getDeclaration = function() {
      return {
        type: "Declaration",
        loc: this.loc,
        important: this.sides.top.important,
        property: this.name,
        value: this.getValue()
      };
    };
    function processRule(rule, shorts, shortDeclarations, lastShortSelector) {
      var declarations = rule.block.children;
      var selector = rule.prelude.children.first().id;
      rule.block.children.eachRight(function(declaration, item) {
        var property = declaration.property;
        if (!MAIN_PROPERTY.hasOwnProperty(property)) {
          return;
        }
        var key = MAIN_PROPERTY[property];
        var shorthand;
        var operation;
        if (!lastShortSelector || selector === lastShortSelector) {
          if (key in shorts) {
            operation = REMOVE;
            shorthand = shorts[key];
          }
        }
        if (!shorthand || !shorthand.add(property, declaration)) {
          operation = REPLACE;
          shorthand = new TRBL(key);
          if (!shorthand.add(property, declaration)) {
            lastShortSelector = null;
            return;
          }
        }
        shorts[key] = shorthand;
        shortDeclarations.push({
          operation,
          block: declarations,
          item,
          shorthand
        });
        lastShortSelector = selector;
      });
      return lastShortSelector;
    }
    function processShorthands(shortDeclarations, markDeclaration) {
      shortDeclarations.forEach(function(item) {
        var shorthand = item.shorthand;
        if (!shorthand.isOkToMinimize()) {
          return;
        }
        if (item.operation === REPLACE) {
          item.item.data = markDeclaration(shorthand.getDeclaration());
        } else {
          item.block.remove(item.item);
        }
      });
    }
    module2.exports = function restructBlock(ast, indexer) {
      var stylesheetMap = {};
      var shortDeclarations = [];
      walk(ast, {
        visit: "Rule",
        reverse: true,
        enter: function(node) {
          var stylesheet = this.block || this.stylesheet;
          var ruleId = (node.pseudoSignature || "") + "|" + node.prelude.children.first().id;
          var ruleMap;
          var shorts;
          if (!stylesheetMap.hasOwnProperty(stylesheet.id)) {
            ruleMap = {
              lastShortSelector: null
            };
            stylesheetMap[stylesheet.id] = ruleMap;
          } else {
            ruleMap = stylesheetMap[stylesheet.id];
          }
          if (ruleMap.hasOwnProperty(ruleId)) {
            shorts = ruleMap[ruleId];
          } else {
            shorts = {};
            ruleMap[ruleId] = shorts;
          }
          ruleMap.lastShortSelector = processRule.call(this, node, shorts, shortDeclarations, ruleMap.lastShortSelector);
        }
      });
      processShorthands(shortDeclarations, indexer.declaration);
    };
  }
});

// node_modules/csso/lib/restructure/6-restructBlock.js
var require_restructBlock = __commonJS({
  "node_modules/csso/lib/restructure/6-restructBlock.js"(exports2, module2) {
    var resolveProperty = require_lib9().property;
    var resolveKeyword = require_lib9().keyword;
    var walk = require_lib9().walk;
    var generate = require_lib9().generate;
    var fingerprintId = 1;
    var dontRestructure = {
      "src": 1
    };
    var DONT_MIX_VALUE = {
      "display": /table|ruby|flex|-(flex)?box$|grid|contents|run-in/i,
      "text-align": /^(start|end|match-parent|justify-all)$/i
    };
    var SAFE_VALUES = {
      cursor: [
        "auto",
        "crosshair",
        "default",
        "move",
        "text",
        "wait",
        "help",
        "n-resize",
        "e-resize",
        "s-resize",
        "w-resize",
        "ne-resize",
        "nw-resize",
        "se-resize",
        "sw-resize",
        "pointer",
        "progress",
        "not-allowed",
        "no-drop",
        "vertical-text",
        "all-scroll",
        "col-resize",
        "row-resize"
      ],
      overflow: [
        "hidden",
        "visible",
        "scroll",
        "auto"
      ],
      position: [
        "static",
        "relative",
        "absolute",
        "fixed"
      ]
    };
    var NEEDLESS_TABLE = {
      "border-width": ["border"],
      "border-style": ["border"],
      "border-color": ["border"],
      "border-top": ["border"],
      "border-right": ["border"],
      "border-bottom": ["border"],
      "border-left": ["border"],
      "border-top-width": ["border-top", "border-width", "border"],
      "border-right-width": ["border-right", "border-width", "border"],
      "border-bottom-width": ["border-bottom", "border-width", "border"],
      "border-left-width": ["border-left", "border-width", "border"],
      "border-top-style": ["border-top", "border-style", "border"],
      "border-right-style": ["border-right", "border-style", "border"],
      "border-bottom-style": ["border-bottom", "border-style", "border"],
      "border-left-style": ["border-left", "border-style", "border"],
      "border-top-color": ["border-top", "border-color", "border"],
      "border-right-color": ["border-right", "border-color", "border"],
      "border-bottom-color": ["border-bottom", "border-color", "border"],
      "border-left-color": ["border-left", "border-color", "border"],
      "margin-top": ["margin"],
      "margin-right": ["margin"],
      "margin-bottom": ["margin"],
      "margin-left": ["margin"],
      "padding-top": ["padding"],
      "padding-right": ["padding"],
      "padding-bottom": ["padding"],
      "padding-left": ["padding"],
      "font-style": ["font"],
      "font-variant": ["font"],
      "font-weight": ["font"],
      "font-size": ["font"],
      "font-family": ["font"],
      "list-style-type": ["list-style"],
      "list-style-position": ["list-style"],
      "list-style-image": ["list-style"]
    };
    function getPropertyFingerprint(propertyName, declaration, fingerprints) {
      var realName = resolveProperty(propertyName).basename;
      if (realName === "background") {
        return propertyName + ":" + generate(declaration.value);
      }
      var declarationId = declaration.id;
      var fingerprint = fingerprints[declarationId];
      if (!fingerprint) {
        switch (declaration.value.type) {
          case "Value":
            var vendorId = "";
            var iehack = "";
            var special = {};
            var raw = false;
            declaration.value.children.each(function walk2(node) {
              switch (node.type) {
                case "Value":
                case "Brackets":
                case "Parentheses":
                  node.children.each(walk2);
                  break;
                case "Raw":
                  raw = true;
                  break;
                case "Identifier":
                  var name = node.name;
                  if (!vendorId) {
                    vendorId = resolveKeyword(name).vendor;
                  }
                  if (/\\[09]/.test(name)) {
                    iehack = RegExp.lastMatch;
                  }
                  if (SAFE_VALUES.hasOwnProperty(realName)) {
                    if (SAFE_VALUES[realName].indexOf(name) === -1) {
                      special[name] = true;
                    }
                  } else if (DONT_MIX_VALUE.hasOwnProperty(realName)) {
                    if (DONT_MIX_VALUE[realName].test(name)) {
                      special[name] = true;
                    }
                  }
                  break;
                case "Function":
                  var name = node.name;
                  if (!vendorId) {
                    vendorId = resolveKeyword(name).vendor;
                  }
                  if (name === "rect") {
                    var hasComma = node.children.some(function(node2) {
                      return node2.type === "Operator" && node2.value === ",";
                    });
                    if (!hasComma) {
                      name = "rect-backward";
                    }
                  }
                  special[name + "()"] = true;
                  node.children.each(walk2);
                  break;
                case "Dimension":
                  var unit = node.unit;
                  if (/\\[09]/.test(unit)) {
                    iehack = RegExp.lastMatch;
                  }
                  switch (unit) {
                    case "rem":
                    case "vw":
                    case "vh":
                    case "vmin":
                    case "vmax":
                    case "vm":
                      special[unit] = true;
                      break;
                  }
                  break;
              }
            });
            fingerprint = raw ? "!" + fingerprintId++ : "!" + Object.keys(special).sort() + "|" + iehack + vendorId;
            break;
          case "Raw":
            fingerprint = "!" + declaration.value.value;
            break;
          default:
            fingerprint = generate(declaration.value);
        }
        fingerprints[declarationId] = fingerprint;
      }
      return propertyName + fingerprint;
    }
    function needless(props, declaration, fingerprints) {
      var property = resolveProperty(declaration.property);
      if (NEEDLESS_TABLE.hasOwnProperty(property.basename)) {
        var table = NEEDLESS_TABLE[property.basename];
        for (var i = 0; i < table.length; i++) {
          var ppre = getPropertyFingerprint(property.prefix + table[i], declaration, fingerprints);
          var prev = props.hasOwnProperty(ppre) ? props[ppre] : null;
          if (prev && (!declaration.important || prev.item.data.important)) {
            return prev;
          }
        }
      }
    }
    function processRule(rule, item, list, props, fingerprints) {
      var declarations = rule.block.children;
      declarations.eachRight(function(declaration, declarationItem) {
        var property = declaration.property;
        var fingerprint = getPropertyFingerprint(property, declaration, fingerprints);
        var prev = props[fingerprint];
        if (prev && !dontRestructure.hasOwnProperty(property)) {
          if (declaration.important && !prev.item.data.important) {
            props[fingerprint] = {
              block: declarations,
              item: declarationItem
            };
            prev.block.remove(prev.item);
          } else {
            declarations.remove(declarationItem);
          }
        } else {
          var prev = needless(props, declaration, fingerprints);
          if (prev) {
            declarations.remove(declarationItem);
          } else {
            declaration.fingerprint = fingerprint;
            props[fingerprint] = {
              block: declarations,
              item: declarationItem
            };
          }
        }
      });
      if (declarations.isEmpty()) {
        list.remove(item);
      }
    }
    module2.exports = function restructBlock(ast) {
      var stylesheetMap = {};
      var fingerprints = /* @__PURE__ */ Object.create(null);
      walk(ast, {
        visit: "Rule",
        reverse: true,
        enter: function(node, item, list) {
          var stylesheet = this.block || this.stylesheet;
          var ruleId = (node.pseudoSignature || "") + "|" + node.prelude.children.first().id;
          var ruleMap;
          var props;
          if (!stylesheetMap.hasOwnProperty(stylesheet.id)) {
            ruleMap = {};
            stylesheetMap[stylesheet.id] = ruleMap;
          } else {
            ruleMap = stylesheetMap[stylesheet.id];
          }
          if (ruleMap.hasOwnProperty(ruleId)) {
            props = ruleMap[ruleId];
          } else {
            props = {};
            ruleMap[ruleId] = props;
          }
          processRule.call(this, node, item, list, props, fingerprints);
        }
      });
    };
  }
});

// node_modules/csso/lib/restructure/7-mergeRuleset.js
var require_mergeRuleset = __commonJS({
  "node_modules/csso/lib/restructure/7-mergeRuleset.js"(exports2, module2) {
    var walk = require_lib9().walk;
    var utils = require_utils5();
    function processRule(node, item, list) {
      var selectors = node.prelude.children;
      var declarations = node.block.children;
      var nodeCompareMarker = selectors.first().compareMarker;
      var skippedCompareMarkers = {};
      list.nextUntil(item.next, function(next, nextItem) {
        if (next.type !== "Rule") {
          return utils.unsafeToSkipNode.call(selectors, next);
        }
        if (node.pseudoSignature !== next.pseudoSignature) {
          return true;
        }
        var nextFirstSelector = next.prelude.children.head;
        var nextDeclarations = next.block.children;
        var nextCompareMarker = nextFirstSelector.data.compareMarker;
        if (nextCompareMarker in skippedCompareMarkers) {
          return true;
        }
        if (selectors.head === selectors.tail) {
          if (selectors.first().id === nextFirstSelector.data.id) {
            declarations.appendList(nextDeclarations);
            list.remove(nextItem);
            return;
          }
        }
        if (utils.isEqualDeclarations(declarations, nextDeclarations)) {
          var nextStr = nextFirstSelector.data.id;
          selectors.some(function(data, item2) {
            var curStr = data.id;
            if (nextStr < curStr) {
              selectors.insert(nextFirstSelector, item2);
              return true;
            }
            if (!item2.next) {
              selectors.insert(nextFirstSelector);
              return true;
            }
          });
          list.remove(nextItem);
          return;
        }
        if (nextCompareMarker === nodeCompareMarker) {
          return true;
        }
        skippedCompareMarkers[nextCompareMarker] = true;
      });
    }
    module2.exports = function mergeRule(ast) {
      walk(ast, {
        visit: "Rule",
        enter: processRule
      });
    };
  }
});

// node_modules/csso/lib/restructure/8-restructRuleset.js
var require_restructRuleset = __commonJS({
  "node_modules/csso/lib/restructure/8-restructRuleset.js"(exports2, module2) {
    var List = require_lib9().List;
    var walk = require_lib9().walk;
    var utils = require_utils5();
    function calcSelectorLength(list) {
      var length = 0;
      list.each(function(data) {
        length += data.id.length + 1;
      });
      return length - 1;
    }
    function calcDeclarationsLength(tokens) {
      var length = 0;
      for (var i = 0; i < tokens.length; i++) {
        length += tokens[i].length;
      }
      return length + tokens.length - 1;
    }
    function processRule(node, item, list) {
      var avoidRulesMerge = this.block !== null ? this.block.avoidRulesMerge : false;
      var selectors = node.prelude.children;
      var block = node.block;
      var disallowDownMarkers = /* @__PURE__ */ Object.create(null);
      var allowMergeUp = true;
      var allowMergeDown = true;
      list.prevUntil(item.prev, function(prev, prevItem) {
        var prevBlock = prev.block;
        var prevType = prev.type;
        if (prevType !== "Rule") {
          var unsafe = utils.unsafeToSkipNode.call(selectors, prev);
          if (!unsafe && prevType === "Atrule" && prevBlock) {
            walk(prevBlock, {
              visit: "Rule",
              enter: function(node2) {
                node2.prelude.children.each(function(data) {
                  disallowDownMarkers[data.compareMarker] = true;
                });
              }
            });
          }
          return unsafe;
        }
        var prevSelectors = prev.prelude.children;
        if (node.pseudoSignature !== prev.pseudoSignature) {
          return true;
        }
        allowMergeDown = !prevSelectors.some(function(selector) {
          return selector.compareMarker in disallowDownMarkers;
        });
        if (!allowMergeDown && !allowMergeUp) {
          return true;
        }
        if (allowMergeUp && utils.isEqualSelectors(prevSelectors, selectors)) {
          prevBlock.children.appendList(block.children);
          list.remove(item);
          return true;
        }
        var diff = utils.compareDeclarations(block.children, prevBlock.children);
        if (diff.eq.length) {
          if (!diff.ne1.length && !diff.ne2.length) {
            if (allowMergeDown) {
              utils.addSelectors(selectors, prevSelectors);
              list.remove(prevItem);
            }
            return true;
          } else if (!avoidRulesMerge) {
            if (diff.ne1.length && !diff.ne2.length) {
              var selectorLength = calcSelectorLength(selectors);
              var blockLength = calcDeclarationsLength(diff.eq);
              if (allowMergeUp && selectorLength < blockLength) {
                utils.addSelectors(prevSelectors, selectors);
                block.children = new List().fromArray(diff.ne1);
              }
            } else if (!diff.ne1.length && diff.ne2.length) {
              var selectorLength = calcSelectorLength(prevSelectors);
              var blockLength = calcDeclarationsLength(diff.eq);
              if (allowMergeDown && selectorLength < blockLength) {
                utils.addSelectors(selectors, prevSelectors);
                prevBlock.children = new List().fromArray(diff.ne2);
              }
            } else {
              var newSelector = {
                type: "SelectorList",
                loc: null,
                children: utils.addSelectors(prevSelectors.copy(), selectors)
              };
              var newBlockLength = calcSelectorLength(newSelector.children) + 2;
              var blockLength = calcDeclarationsLength(diff.eq);
              if (blockLength >= newBlockLength) {
                var newItem = list.createItem({
                  type: "Rule",
                  loc: null,
                  prelude: newSelector,
                  block: {
                    type: "Block",
                    loc: null,
                    children: new List().fromArray(diff.eq)
                  },
                  pseudoSignature: node.pseudoSignature
                });
                block.children = new List().fromArray(diff.ne1);
                prevBlock.children = new List().fromArray(diff.ne2overrided);
                if (allowMergeUp) {
                  list.insert(newItem, prevItem);
                } else {
                  list.insert(newItem, item);
                }
                return true;
              }
            }
          }
        }
        if (allowMergeUp) {
          allowMergeUp = !prevSelectors.some(function(prevSelector) {
            return selectors.some(function(selector) {
              return selector.compareMarker === prevSelector.compareMarker;
            });
          });
        }
        prevSelectors.each(function(data) {
          disallowDownMarkers[data.compareMarker] = true;
        });
      });
    }
    module2.exports = function restructRule(ast) {
      walk(ast, {
        visit: "Rule",
        reverse: true,
        enter: processRule
      });
    };
  }
});

// node_modules/csso/lib/restructure/index.js
var require_restructure = __commonJS({
  "node_modules/csso/lib/restructure/index.js"(exports2, module2) {
    var prepare = require_prepare();
    var mergeAtrule = require_mergeAtrule();
    var initialMergeRuleset = require_initialMergeRuleset();
    var disjoinRuleset = require_disjoinRuleset();
    var restructShorthand = require_restructShorthand();
    var restructBlock = require_restructBlock();
    var mergeRuleset = require_mergeRuleset();
    var restructRuleset = require_restructRuleset();
    module2.exports = function(ast, options) {
      var indexer = prepare(ast, options);
      options.logger("prepare", ast);
      mergeAtrule(ast, options);
      options.logger("mergeAtrule", ast);
      initialMergeRuleset(ast);
      options.logger("initialMergeRuleset", ast);
      disjoinRuleset(ast);
      options.logger("disjoinRuleset", ast);
      restructShorthand(ast, indexer);
      options.logger("restructShorthand", ast);
      restructBlock(ast);
      options.logger("restructBlock", ast);
      mergeRuleset(ast);
      options.logger("mergeRuleset", ast);
      restructRuleset(ast);
      options.logger("restructRuleset", ast);
    };
  }
});

// node_modules/csso/lib/compress.js
var require_compress = __commonJS({
  "node_modules/csso/lib/compress.js"(exports2, module2) {
    var List = require_lib9().List;
    var clone = require_lib9().clone;
    var usageUtils = require_usage();
    var clean = require_clean();
    var replace = require_replace();
    var restructure = require_restructure();
    var walk = require_lib9().walk;
    function readChunk(children, specialComments) {
      var buffer = new List();
      var nonSpaceTokenInBuffer = false;
      var protectedComment;
      children.nextUntil(children.head, function(node, item, list) {
        if (node.type === "Comment") {
          if (!specialComments || node.value.charAt(0) !== "!") {
            list.remove(item);
            return;
          }
          if (nonSpaceTokenInBuffer || protectedComment) {
            return true;
          }
          list.remove(item);
          protectedComment = node;
          return;
        }
        if (node.type !== "WhiteSpace") {
          nonSpaceTokenInBuffer = true;
        }
        buffer.insert(list.remove(item));
      });
      return {
        comment: protectedComment,
        stylesheet: {
          type: "StyleSheet",
          loc: null,
          children: buffer
        }
      };
    }
    function compressChunk(ast, firstAtrulesAllowed, num, options) {
      options.logger("Compress block #" + num, null, true);
      var seed = 1;
      if (ast.type === "StyleSheet") {
        ast.firstAtrulesAllowed = firstAtrulesAllowed;
        ast.id = seed++;
      }
      walk(ast, {
        visit: "Atrule",
        enter: function markScopes(node) {
          if (node.block !== null) {
            node.block.id = seed++;
          }
        }
      });
      options.logger("init", ast);
      clean(ast, options);
      options.logger("clean", ast);
      replace(ast, options);
      options.logger("replace", ast);
      if (options.restructuring) {
        restructure(ast, options);
      }
      return ast;
    }
    function getCommentsOption(options) {
      var comments = "comments" in options ? options.comments : "exclamation";
      if (typeof comments === "boolean") {
        comments = comments ? "exclamation" : false;
      } else if (comments !== "exclamation" && comments !== "first-exclamation") {
        comments = false;
      }
      return comments;
    }
    function getRestructureOption(options) {
      if ("restructure" in options) {
        return options.restructure;
      }
      return "restructuring" in options ? options.restructuring : true;
    }
    function wrapBlock(block) {
      return new List().appendData({
        type: "Rule",
        loc: null,
        prelude: {
          type: "SelectorList",
          loc: null,
          children: new List().appendData({
            type: "Selector",
            loc: null,
            children: new List().appendData({
              type: "TypeSelector",
              loc: null,
              name: "x"
            })
          })
        },
        block
      });
    }
    module2.exports = function compress(ast, options) {
      ast = ast || { type: "StyleSheet", loc: null, children: new List() };
      options = options || {};
      var compressOptions = {
        logger: typeof options.logger === "function" ? options.logger : function() {
        },
        restructuring: getRestructureOption(options),
        forceMediaMerge: Boolean(options.forceMediaMerge),
        usage: options.usage ? usageUtils.buildIndex(options.usage) : false
      };
      var specialComments = getCommentsOption(options);
      var firstAtrulesAllowed = true;
      var input;
      var output = new List();
      var chunk;
      var chunkNum = 1;
      var chunkChildren;
      if (options.clone) {
        ast = clone(ast);
      }
      if (ast.type === "StyleSheet") {
        input = ast.children;
        ast.children = output;
      } else {
        input = wrapBlock(ast);
      }
      do {
        chunk = readChunk(input, Boolean(specialComments));
        compressChunk(chunk.stylesheet, firstAtrulesAllowed, chunkNum++, compressOptions);
        chunkChildren = chunk.stylesheet.children;
        if (chunk.comment) {
          if (!output.isEmpty()) {
            output.insert(List.createItem({
              type: "Raw",
              value: "\n"
            }));
          }
          output.insert(List.createItem(chunk.comment));
          if (!chunkChildren.isEmpty()) {
            output.insert(List.createItem({
              type: "Raw",
              value: "\n"
            }));
          }
        }
        if (firstAtrulesAllowed && !chunkChildren.isEmpty()) {
          var lastRule = chunkChildren.last();
          if (lastRule.type !== "Atrule" || lastRule.name !== "import" && lastRule.name !== "charset") {
            firstAtrulesAllowed = false;
          }
        }
        if (specialComments !== "exclamation") {
          specialComments = false;
        }
        output.appendList(chunkChildren);
      } while (!input.isEmpty());
      return {
        ast
      };
    };
  }
});

// node_modules/csso/package.json
var require_package2 = __commonJS({
  "node_modules/csso/package.json"(exports2, module2) {
    module2.exports = {
      _args: [
        [
          "csso@4.2.0",
          "/home/runner/work/tailwindcss/tailwindcss"
        ]
      ],
      _from: "csso@4.2.0",
      _id: "csso@4.2.0",
      _inBundle: false,
      _integrity: "sha512-wvlcdIbf6pwKEk7vHj8/Bkc0B4ylXZruLvOgs9doS5eOsOpuodOV2zJChSpkp+pRpYQLQMeF04nr3Z68Sta9jA==",
      _location: "/csso",
      _phantomChildren: {},
      _requested: {
        type: "version",
        registry: true,
        raw: "csso@4.2.0",
        name: "csso",
        escapedName: "csso",
        rawSpec: "4.2.0",
        saveSpec: null,
        fetchSpec: "4.2.0"
      },
      _requiredBy: [
        "/svgo"
      ],
      _resolved: "https://registry.npmjs.org/csso/-/csso-4.2.0.tgz",
      _spec: "4.2.0",
      _where: "/home/runner/work/tailwindcss/tailwindcss",
      author: {
        name: "Sergey Kryzhanovsky",
        email: "skryzhanovsky@ya.ru",
        url: "https://github.com/afelix"
      },
      browser: {
        "css-tree": "css-tree/dist/csstree.min.js"
      },
      bugs: {
        url: "https://github.com/css/csso/issues"
      },
      dependencies: {
        "css-tree": "^1.1.2"
      },
      description: "CSS minifier with structural optimisations",
      devDependencies: {
        "@rollup/plugin-commonjs": "^11.0.1",
        "@rollup/plugin-json": "^4.0.1",
        "@rollup/plugin-node-resolve": "^7.0.0",
        coveralls: "^3.0.11",
        eslint: "^6.8.0",
        mocha: "^7.1.1",
        nyc: "^15.0.0",
        rollup: "^1.29.0",
        "source-map": "^0.6.1",
        terser: "^4.6.3"
      },
      engines: {
        node: ">=8.0.0"
      },
      files: [
        "dist",
        "lib"
      ],
      homepage: "https://github.com/css/csso",
      keywords: [
        "css",
        "compress",
        "minifier",
        "minify",
        "optimise",
        "optimisation",
        "csstree"
      ],
      license: "MIT",
      main: "./lib/index",
      maintainers: [
        {
          name: "Roman Dvornov",
          email: "rdvornov@gmail.com"
        }
      ],
      name: "csso",
      repository: {
        type: "git",
        url: "git+https://github.com/css/csso.git"
      },
      scripts: {
        build: "rollup --config && terser dist/csso.js --compress --mangle -o dist/csso.min.js",
        coverage: "nyc npm test",
        coveralls: "nyc report --reporter=text-lcov | coveralls",
        hydrogen: "node --trace-hydrogen --trace-phase=Z --trace-deopt --code-comments --hydrogen-track-positions --redirect-code-traces --redirect-code-traces-to=code.asm --trace_hydrogen_file=code.cfg --print-opt-code bin/csso --stat -o /dev/null",
        lint: "eslint lib test",
        "lint-and-test": "npm run lint && npm test",
        prepublishOnly: "npm run build",
        test: "mocha --reporter dot",
        travis: "nyc npm run lint-and-test && npm run coveralls"
      },
      version: "4.2.0"
    };
  }
});

// node_modules/csso/lib/index.js
var require_lib10 = __commonJS({
  "node_modules/csso/lib/index.js"(exports2, module2) {
    var csstree = require_lib9();
    var parse = csstree.parse;
    var compress = require_compress();
    var generate = csstree.generate;
    function debugOutput(name, options, startTime, data) {
      if (options.debug) {
        console.error("## " + name + " done in %d ms\n", Date.now() - startTime);
      }
      return data;
    }
    function createDefaultLogger(level) {
      var lastDebug;
      return function logger(title, ast) {
        var line = title;
        if (ast) {
          line = "[" + ((Date.now() - lastDebug) / 1e3).toFixed(3) + "s] " + line;
        }
        if (level > 1 && ast) {
          var css = generate(ast);
          if (level === 2 && css.length > 256) {
            css = css.substr(0, 256) + "...";
          }
          line += "\n  " + css + "\n";
        }
        console.error(line);
        lastDebug = Date.now();
      };
    }
    function copy(obj) {
      var result = {};
      for (var key in obj) {
        result[key] = obj[key];
      }
      return result;
    }
    function buildCompressOptions(options) {
      options = copy(options);
      if (typeof options.logger !== "function" && options.debug) {
        options.logger = createDefaultLogger(options.debug);
      }
      return options;
    }
    function runHandler(ast, options, handlers) {
      if (!Array.isArray(handlers)) {
        handlers = [handlers];
      }
      handlers.forEach(function(fn) {
        fn(ast, options);
      });
    }
    function minify(context, source, options) {
      options = options || {};
      var filename = options.filename || "<unknown>";
      var result;
      var ast = debugOutput("parsing", options, Date.now(), parse(source, {
        context,
        filename,
        positions: Boolean(options.sourceMap)
      }));
      if (options.beforeCompress) {
        debugOutput("beforeCompress", options, Date.now(), runHandler(ast, options, options.beforeCompress));
      }
      var compressResult = debugOutput("compress", options, Date.now(), compress(ast, buildCompressOptions(options)));
      if (options.afterCompress) {
        debugOutput("afterCompress", options, Date.now(), runHandler(compressResult, options, options.afterCompress));
      }
      if (options.sourceMap) {
        result = debugOutput("generate(sourceMap: true)", options, Date.now(), function() {
          var tmp = generate(compressResult.ast, { sourceMap: true });
          tmp.map._file = filename;
          tmp.map.setSourceContent(filename, source);
          return tmp;
        }());
      } else {
        result = debugOutput("generate", options, Date.now(), {
          css: generate(compressResult.ast),
          map: null
        });
      }
      return result;
    }
    function minifyStylesheet(source, options) {
      return minify("stylesheet", source, options);
    }
    function minifyBlock(source, options) {
      return minify("declarationList", source, options);
    }
    module2.exports = {
      version: require_package2().version,
      minify: minifyStylesheet,
      minifyBlock,
      syntax: Object.assign({
        compress
      }, csstree)
    };
  }
});

// node_modules/svgo/plugins/minifyStyles.js
var require_minifyStyles = __commonJS({
  "node_modules/svgo/plugins/minifyStyles.js"(exports2) {
    "use strict";
    var csso = require_lib10();
    exports2.type = "visitor";
    exports2.name = "minifyStyles";
    exports2.active = true;
    exports2.description = "minifies styles and removes unused styles based on usage data";
    exports2.fn = (_root, { usage, ...params }) => {
      let enableTagsUsage = true;
      let enableIdsUsage = true;
      let enableClassesUsage = true;
      let forceUsageDeoptimized = false;
      if (typeof usage === "boolean") {
        enableTagsUsage = usage;
        enableIdsUsage = usage;
        enableClassesUsage = usage;
      } else if (usage) {
        enableTagsUsage = usage.tags == null ? true : usage.tags;
        enableIdsUsage = usage.ids == null ? true : usage.ids;
        enableClassesUsage = usage.classes == null ? true : usage.classes;
        forceUsageDeoptimized = usage.force == null ? false : usage.force;
      }
      const styleElements = [];
      const elementsWithStyleAttributes = [];
      let deoptimized = false;
      const tagsUsage = /* @__PURE__ */ new Set();
      const idsUsage = /* @__PURE__ */ new Set();
      const classesUsage = /* @__PURE__ */ new Set();
      return {
        element: {
          enter: (node) => {
            if (node.name === "script") {
              deoptimized = true;
            }
            for (const name of Object.keys(node.attributes)) {
              if (name.startsWith("on")) {
                deoptimized = true;
              }
            }
            tagsUsage.add(node.name);
            if (node.attributes.id != null) {
              idsUsage.add(node.attributes.id);
            }
            if (node.attributes.class != null) {
              for (const className of node.attributes.class.split(/\s+/)) {
                classesUsage.add(className);
              }
            }
            if (node.name === "style" && node.children.length !== 0) {
              styleElements.push(node);
            } else if (node.attributes.style != null) {
              elementsWithStyleAttributes.push(node);
            }
          }
        },
        root: {
          exit: () => {
            const cssoUsage = {};
            if (deoptimized === false || forceUsageDeoptimized === true) {
              if (enableTagsUsage && tagsUsage.size !== 0) {
                cssoUsage.tags = Array.from(tagsUsage);
              }
              if (enableIdsUsage && idsUsage.size !== 0) {
                cssoUsage.ids = Array.from(idsUsage);
              }
              if (enableClassesUsage && classesUsage.size !== 0) {
                cssoUsage.classes = Array.from(classesUsage);
              }
            }
            for (const node of styleElements) {
              if (node.children[0].type === "text" || node.children[0].type === "cdata") {
                const cssText = node.children[0].value;
                const minified = csso.minify(cssText, {
                  ...params,
                  usage: cssoUsage
                }).css;
                if (cssText.indexOf(">") >= 0 || cssText.indexOf("<") >= 0) {
                  node.children[0].type = "cdata";
                  node.children[0].value = minified;
                } else {
                  node.children[0].type = "text";
                  node.children[0].value = minified;
                }
              }
            }
            for (const node of elementsWithStyleAttributes) {
              const elemStyle = node.attributes.style;
              node.attributes.style = csso.minifyBlock(elemStyle, {
                ...params
              }).css;
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/cleanupIDs.js
var require_cleanupIDs = __commonJS({
  "node_modules/svgo/plugins/cleanupIDs.js"(exports2) {
    "use strict";
    var { visitSkip } = require_xast();
    var { referencesProps } = require_collections();
    exports2.type = "visitor";
    exports2.name = "cleanupIDs";
    exports2.active = true;
    exports2.description = "removes unused IDs and minifies used";
    var regReferencesUrl = /\burl\(("|')?#(.+?)\1\)/;
    var regReferencesHref = /^#(.+?)$/;
    var regReferencesBegin = /(\w+)\./;
    var generateIDchars = [
      "a",
      "b",
      "c",
      "d",
      "e",
      "f",
      "g",
      "h",
      "i",
      "j",
      "k",
      "l",
      "m",
      "n",
      "o",
      "p",
      "q",
      "r",
      "s",
      "t",
      "u",
      "v",
      "w",
      "x",
      "y",
      "z",
      "A",
      "B",
      "C",
      "D",
      "E",
      "F",
      "G",
      "H",
      "I",
      "J",
      "K",
      "L",
      "M",
      "N",
      "O",
      "P",
      "Q",
      "R",
      "S",
      "T",
      "U",
      "V",
      "W",
      "X",
      "Y",
      "Z"
    ];
    var maxIDindex = generateIDchars.length - 1;
    var hasStringPrefix = (string, prefixes) => {
      for (const prefix of prefixes) {
        if (string.startsWith(prefix)) {
          return true;
        }
      }
      return false;
    };
    var generateID = (currentID) => {
      if (currentID == null) {
        return [0];
      }
      currentID[currentID.length - 1] += 1;
      for (let i = currentID.length - 1; i > 0; i--) {
        if (currentID[i] > maxIDindex) {
          currentID[i] = 0;
          if (currentID[i - 1] !== void 0) {
            currentID[i - 1]++;
          }
        }
      }
      if (currentID[0] > maxIDindex) {
        currentID[0] = 0;
        currentID.unshift(0);
      }
      return currentID;
    };
    var getIDstring = (arr, prefix) => {
      return prefix + arr.map((i) => generateIDchars[i]).join("");
    };
    exports2.fn = (_root, params) => {
      const {
        remove = true,
        minify = true,
        prefix = "",
        preserve = [],
        preservePrefixes = [],
        force = false
      } = params;
      const preserveIDs = new Set(Array.isArray(preserve) ? preserve : preserve ? [preserve] : []);
      const preserveIDPrefixes = Array.isArray(preservePrefixes) ? preservePrefixes : preservePrefixes ? [preservePrefixes] : [];
      const nodeById = /* @__PURE__ */ new Map();
      const referencesById = /* @__PURE__ */ new Map();
      let deoptimized = false;
      return {
        element: {
          enter: (node) => {
            if (force == false) {
              if ((node.name === "style" || node.name === "script") && node.children.length !== 0) {
                deoptimized = true;
                return;
              }
              if (node.name === "svg") {
                let hasDefsOnly = true;
                for (const child of node.children) {
                  if (child.type !== "element" || child.name !== "defs") {
                    hasDefsOnly = false;
                    break;
                  }
                }
                if (hasDefsOnly) {
                  return visitSkip;
                }
              }
            }
            for (const [name, value] of Object.entries(node.attributes)) {
              if (name === "id") {
                const id = value;
                if (nodeById.has(id)) {
                  delete node.attributes.id;
                } else {
                  nodeById.set(id, node);
                }
              } else {
                let id = null;
                if (referencesProps.includes(name)) {
                  const match = value.match(regReferencesUrl);
                  if (match != null) {
                    id = match[2];
                  }
                }
                if (name === "href" || name.endsWith(":href")) {
                  const match = value.match(regReferencesHref);
                  if (match != null) {
                    id = match[1];
                  }
                }
                if (name === "begin") {
                  const match = value.match(regReferencesBegin);
                  if (match != null) {
                    id = match[1];
                  }
                }
                if (id != null) {
                  let refs = referencesById.get(id);
                  if (refs == null) {
                    refs = [];
                    referencesById.set(id, refs);
                  }
                  refs.push({ element: node, name, value });
                }
              }
            }
          }
        },
        root: {
          exit: () => {
            if (deoptimized) {
              return;
            }
            const isIdPreserved = (id) => preserveIDs.has(id) || hasStringPrefix(id, preserveIDPrefixes);
            let currentID = null;
            for (const [id, refs] of referencesById) {
              const node = nodeById.get(id);
              if (node != null) {
                if (minify && isIdPreserved(id) === false) {
                  let currentIDString = null;
                  do {
                    currentID = generateID(currentID);
                    currentIDString = getIDstring(currentID, prefix);
                  } while (isIdPreserved(currentIDString));
                  node.attributes.id = currentIDString;
                  for (const { element, name, value } of refs) {
                    if (value.includes("#")) {
                      element.attributes[name] = value.replace(`#${id}`, `#${currentIDString}`);
                    } else {
                      element.attributes[name] = value.replace(`${id}.`, `${currentIDString}.`);
                    }
                  }
                }
                nodeById.delete(id);
              }
            }
            if (remove) {
              for (const [id, node] of nodeById) {
                if (isIdPreserved(id) === false) {
                  delete node.attributes.id;
                }
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeUselessDefs.js
var require_removeUselessDefs = __commonJS({
  "node_modules/svgo/plugins/removeUselessDefs.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    var { elemsGroups } = require_collections();
    exports2.type = "visitor";
    exports2.name = "removeUselessDefs";
    exports2.active = true;
    exports2.description = "removes elements in <defs> without id";
    exports2.fn = () => {
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "defs") {
              const usefulNodes = [];
              collectUsefulNodes(node, usefulNodes);
              if (usefulNodes.length === 0) {
                detachNodeFromParent(node, parentNode);
              }
              for (const usefulNode of usefulNodes) {
                usefulNode.parentNode = node;
              }
              node.children = usefulNodes;
            } else if (elemsGroups.nonRendering.includes(node.name) && node.attributes.id == null) {
              detachNodeFromParent(node, parentNode);
            }
          }
        }
      };
    };
    var collectUsefulNodes = (node, usefulNodes) => {
      for (const child of node.children) {
        if (child.type === "element") {
          if (child.attributes.id != null || child.name === "style") {
            usefulNodes.push(child);
          } else {
            collectUsefulNodes(child, usefulNodes);
          }
        }
      }
    };
  }
});

// node_modules/svgo/lib/svgo/tools.js
var require_tools = __commonJS({
  "node_modules/svgo/lib/svgo/tools.js"(exports2) {
    "use strict";
    exports2.encodeSVGDatauri = (str, type) => {
      var prefix = "data:image/svg+xml";
      if (!type || type === "base64") {
        prefix += ";base64,";
        str = prefix + Buffer.from(str).toString("base64");
      } else if (type === "enc") {
        str = prefix + "," + encodeURIComponent(str);
      } else if (type === "unenc") {
        str = prefix + "," + str;
      }
      return str;
    };
    exports2.decodeSVGDatauri = (str) => {
      var regexp = /data:image\/svg\+xml(;charset=[^;,]*)?(;base64)?,(.*)/;
      var match = regexp.exec(str);
      if (!match)
        return str;
      var data = match[3];
      if (match[2]) {
        str = Buffer.from(data, "base64").toString("utf8");
      } else if (data.charAt(0) === "%") {
        str = decodeURIComponent(data);
      } else if (data.charAt(0) === "<") {
        str = data;
      }
      return str;
    };
    exports2.cleanupOutData = (data, params, command) => {
      let str = "";
      let delimiter;
      let prev;
      data.forEach((item, i) => {
        delimiter = " ";
        if (i == 0)
          delimiter = "";
        if (params.noSpaceAfterFlags && (command == "A" || command == "a")) {
          var pos = i % 7;
          if (pos == 4 || pos == 5)
            delimiter = "";
        }
        const itemStr = params.leadingZero ? removeLeadingZero(item) : item.toString();
        if (params.negativeExtraSpace && delimiter != "" && (item < 0 || itemStr.charAt(0) === "." && prev % 1 !== 0)) {
          delimiter = "";
        }
        prev = item;
        str += delimiter + itemStr;
      });
      return str;
    };
    var removeLeadingZero = (num) => {
      var strNum = num.toString();
      if (0 < num && num < 1 && strNum.charAt(0) === "0") {
        strNum = strNum.slice(1);
      } else if (-1 < num && num < 0 && strNum.charAt(1) === "0") {
        strNum = strNum.charAt(0) + strNum.slice(2);
      }
      return strNum;
    };
    exports2.removeLeadingZero = removeLeadingZero;
  }
});

// node_modules/svgo/plugins/cleanupNumericValues.js
var require_cleanupNumericValues = __commonJS({
  "node_modules/svgo/plugins/cleanupNumericValues.js"(exports2) {
    "use strict";
    var { removeLeadingZero } = require_tools();
    exports2.name = "cleanupNumericValues";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "rounds numeric values to the fixed precision, removes default \u2018px\u2019 units";
    var regNumericValues = /^([-+]?\d*\.?\d+([eE][-+]?\d+)?)(px|pt|pc|mm|cm|m|in|ft|em|ex|%)?$/;
    var absoluteLengths = {
      cm: 96 / 2.54,
      mm: 96 / 25.4,
      in: 96,
      pt: 4 / 3,
      pc: 16,
      px: 1
    };
    exports2.fn = (_root, params) => {
      const {
        floatPrecision = 3,
        leadingZero = true,
        defaultPx = true,
        convertToPx = true
      } = params;
      return {
        element: {
          enter: (node) => {
            if (node.attributes.viewBox != null) {
              const nums = node.attributes.viewBox.split(/\s,?\s*|,\s*/g);
              node.attributes.viewBox = nums.map((value) => {
                const num = Number(value);
                return Number.isNaN(num) ? value : Number(num.toFixed(floatPrecision));
              }).join(" ");
            }
            for (const [name, value] of Object.entries(node.attributes)) {
              if (name === "version") {
                continue;
              }
              const match = value.match(regNumericValues);
              if (match) {
                let num = Number(Number(match[1]).toFixed(floatPrecision));
                let matchedUnit = match[3] || "";
                let units = matchedUnit;
                if (convertToPx && units !== "" && units in absoluteLengths) {
                  const pxNum = Number((absoluteLengths[units] * Number(match[1])).toFixed(floatPrecision));
                  if (pxNum.toString().length < match[0].length) {
                    num = pxNum;
                    units = "px";
                  }
                }
                let str;
                if (leadingZero) {
                  str = removeLeadingZero(num);
                } else {
                  str = num.toString();
                }
                if (defaultPx && units === "px") {
                  units = "";
                }
                node.attributes[name] = str + units;
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/convertColors.js
var require_convertColors = __commonJS({
  "node_modules/svgo/plugins/convertColors.js"(exports2) {
    "use strict";
    var collections = require_collections();
    exports2.type = "visitor";
    exports2.name = "convertColors";
    exports2.active = true;
    exports2.description = "converts colors: rgb() to #rrggbb and #rrggbb to #rgb";
    var rNumber = "([+-]?(?:\\d*\\.\\d+|\\d+\\.?)%?)";
    var rComma = "\\s*,\\s*";
    var regRGB = new RegExp("^rgb\\(\\s*" + rNumber + rComma + rNumber + rComma + rNumber + "\\s*\\)$");
    var regHEX = /^#(([a-fA-F0-9])\2){3}$/;
    var convertRgbToHex = ([r, g, b]) => {
      const hexNumber = (256 + r << 8 | g) << 8 | b;
      return "#" + hexNumber.toString(16).slice(1).toUpperCase();
    };
    exports2.fn = (_root, params) => {
      const {
        currentColor = false,
        names2hex = true,
        rgb2hex = true,
        shorthex = true,
        shortname = true
      } = params;
      return {
        element: {
          enter: (node) => {
            for (const [name, value] of Object.entries(node.attributes)) {
              if (collections.colorsProps.includes(name)) {
                let val = value;
                if (currentColor) {
                  let matched;
                  if (typeof currentColor === "string") {
                    matched = val === currentColor;
                  } else if (currentColor instanceof RegExp) {
                    matched = currentColor.exec(val) != null;
                  } else {
                    matched = val !== "none";
                  }
                  if (matched) {
                    val = "currentColor";
                  }
                }
                if (names2hex) {
                  const colorName = val.toLowerCase();
                  if (collections.colorsNames[colorName] != null) {
                    val = collections.colorsNames[colorName];
                  }
                }
                if (rgb2hex) {
                  let match = val.match(regRGB);
                  if (match != null) {
                    let nums = match.slice(1, 4).map((m) => {
                      let n;
                      if (m.indexOf("%") > -1) {
                        n = Math.round(parseFloat(m) * 2.55);
                      } else {
                        n = Number(m);
                      }
                      return Math.max(0, Math.min(n, 255));
                    });
                    val = convertRgbToHex(nums);
                  }
                }
                if (shorthex) {
                  let match = val.match(regHEX);
                  if (match != null) {
                    val = "#" + match[0][1] + match[0][3] + match[0][5];
                  }
                }
                if (shortname) {
                  const colorName = val.toLowerCase();
                  if (collections.colorsShortNames[colorName] != null) {
                    val = collections.colorsShortNames[colorName];
                  }
                }
                node.attributes[name] = val;
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/lib/style.js
var require_style = __commonJS({
  "node_modules/svgo/lib/style.js"(exports2) {
    "use strict";
    var stable = require_stable();
    var csstree = require_lib9();
    var specificity = require_specificity();
    var { visit, matches } = require_xast();
    var {
      attrsGroups,
      inheritableAttrs,
      presentationNonInheritableGroupAttrs
    } = require_collections();
    var csstreeWalkSkip = csstree.walk.skip;
    var parseRule = (ruleNode, dynamic) => {
      let selectors;
      let selectorsSpecificity;
      const declarations = [];
      csstree.walk(ruleNode, (cssNode) => {
        if (cssNode.type === "SelectorList") {
          selectorsSpecificity = specificity(cssNode);
          const newSelectorsNode = csstree.clone(cssNode);
          csstree.walk(newSelectorsNode, (pseudoClassNode, item, list) => {
            if (pseudoClassNode.type === "PseudoClassSelector") {
              dynamic = true;
              list.remove(item);
            }
          });
          selectors = csstree.generate(newSelectorsNode);
          return csstreeWalkSkip;
        }
        if (cssNode.type === "Declaration") {
          declarations.push({
            name: cssNode.property,
            value: csstree.generate(cssNode.value),
            important: cssNode.important === true
          });
          return csstreeWalkSkip;
        }
      });
      if (selectors == null || selectorsSpecificity == null) {
        throw Error("assert");
      }
      return {
        dynamic,
        selectors,
        specificity: selectorsSpecificity,
        declarations
      };
    };
    var parseStylesheet = (css, dynamic) => {
      const rules = [];
      const ast = csstree.parse(css, {
        parseValue: false,
        parseAtrulePrelude: false
      });
      csstree.walk(ast, (cssNode) => {
        if (cssNode.type === "Rule") {
          rules.push(parseRule(cssNode, dynamic || false));
          return csstreeWalkSkip;
        }
        if (cssNode.type === "Atrule") {
          if (cssNode.name === "keyframes") {
            return csstreeWalkSkip;
          }
          csstree.walk(cssNode, (ruleNode) => {
            if (ruleNode.type === "Rule") {
              rules.push(parseRule(ruleNode, dynamic || true));
              return csstreeWalkSkip;
            }
          });
          return csstreeWalkSkip;
        }
      });
      return rules;
    };
    var parseStyleDeclarations = (css) => {
      const declarations = [];
      const ast = csstree.parse(css, {
        context: "declarationList",
        parseValue: false
      });
      csstree.walk(ast, (cssNode) => {
        if (cssNode.type === "Declaration") {
          declarations.push({
            name: cssNode.property,
            value: csstree.generate(cssNode.value),
            important: cssNode.important === true
          });
        }
      });
      return declarations;
    };
    var computeOwnStyle = (stylesheet, node) => {
      const computedStyle = {};
      const importantStyles = /* @__PURE__ */ new Map();
      for (const [name, value] of Object.entries(node.attributes)) {
        if (attrsGroups.presentation.includes(name)) {
          computedStyle[name] = { type: "static", inherited: false, value };
          importantStyles.set(name, false);
        }
      }
      for (const { selectors, declarations, dynamic } of stylesheet.rules) {
        if (matches(node, selectors)) {
          for (const { name, value, important } of declarations) {
            const computed = computedStyle[name];
            if (computed && computed.type === "dynamic") {
              continue;
            }
            if (dynamic) {
              computedStyle[name] = { type: "dynamic", inherited: false };
              continue;
            }
            if (computed == null || important === true || importantStyles.get(name) === false) {
              computedStyle[name] = { type: "static", inherited: false, value };
              importantStyles.set(name, important);
            }
          }
        }
      }
      const styleDeclarations = node.attributes.style == null ? [] : parseStyleDeclarations(node.attributes.style);
      for (const { name, value, important } of styleDeclarations) {
        const computed = computedStyle[name];
        if (computed && computed.type === "dynamic") {
          continue;
        }
        if (computed == null || important === true || importantStyles.get(name) === false) {
          computedStyle[name] = { type: "static", inherited: false, value };
          importantStyles.set(name, important);
        }
      }
      return computedStyle;
    };
    var compareSpecificity = (a, b) => {
      for (var i = 0; i < 4; i += 1) {
        if (a[i] < b[i]) {
          return -1;
        } else if (a[i] > b[i]) {
          return 1;
        }
      }
      return 0;
    };
    var collectStylesheet = (root) => {
      const rules = [];
      const parents = /* @__PURE__ */ new Map();
      visit(root, {
        element: {
          enter: (node, parentNode) => {
            parents.set(node, parentNode);
            if (node.name === "style") {
              const dynamic = node.attributes.media != null && node.attributes.media !== "all";
              if (node.attributes.type == null || node.attributes.type === "" || node.attributes.type === "text/css") {
                const children = node.children;
                for (const child of children) {
                  if (child.type === "text" || child.type === "cdata") {
                    rules.push(...parseStylesheet(child.value, dynamic));
                  }
                }
              }
            }
          }
        }
      });
      stable.inplace(rules, (a, b) => compareSpecificity(a.specificity, b.specificity));
      return { rules, parents };
    };
    exports2.collectStylesheet = collectStylesheet;
    var computeStyle = (stylesheet, node) => {
      const { parents } = stylesheet;
      const computedStyles = computeOwnStyle(stylesheet, node);
      let parent = parents.get(node);
      while (parent != null && parent.type !== "root") {
        const inheritedStyles = computeOwnStyle(stylesheet, parent);
        for (const [name, computed] of Object.entries(inheritedStyles)) {
          if (computedStyles[name] == null && inheritableAttrs.includes(name) === true && presentationNonInheritableGroupAttrs.includes(name) === false) {
            computedStyles[name] = { ...computed, inherited: true };
          }
        }
        parent = parents.get(parent);
      }
      return computedStyles;
    };
    exports2.computeStyle = computeStyle;
  }
});

// node_modules/svgo/plugins/removeUnknownsAndDefaults.js
var require_removeUnknownsAndDefaults = __commonJS({
  "node_modules/svgo/plugins/removeUnknownsAndDefaults.js"(exports2) {
    "use strict";
    var { visitSkip, detachNodeFromParent } = require_xast();
    var { collectStylesheet, computeStyle } = require_style();
    var {
      elems,
      attrsGroups,
      elemsGroups,
      attrsGroupsDefaults,
      presentationNonInheritableGroupAttrs
    } = require_collections();
    exports2.type = "visitor";
    exports2.name = "removeUnknownsAndDefaults";
    exports2.active = true;
    exports2.description = "removes unknown elements content and attributes, removes attrs with default values";
    var allowedChildrenPerElement = /* @__PURE__ */ new Map();
    var allowedAttributesPerElement = /* @__PURE__ */ new Map();
    var attributesDefaultsPerElement = /* @__PURE__ */ new Map();
    for (const [name, config] of Object.entries(elems)) {
      const allowedChildren = /* @__PURE__ */ new Set();
      if (config.content) {
        for (const elementName of config.content) {
          allowedChildren.add(elementName);
        }
      }
      if (config.contentGroups) {
        for (const contentGroupName of config.contentGroups) {
          const elemsGroup = elemsGroups[contentGroupName];
          if (elemsGroup) {
            for (const elementName of elemsGroup) {
              allowedChildren.add(elementName);
            }
          }
        }
      }
      const allowedAttributes = /* @__PURE__ */ new Set();
      if (config.attrs) {
        for (const attrName of config.attrs) {
          allowedAttributes.add(attrName);
        }
      }
      const attributesDefaults = /* @__PURE__ */ new Map();
      if (config.defaults) {
        for (const [attrName, defaultValue] of Object.entries(config.defaults)) {
          attributesDefaults.set(attrName, defaultValue);
        }
      }
      for (const attrsGroupName of config.attrsGroups) {
        const attrsGroup = attrsGroups[attrsGroupName];
        if (attrsGroup) {
          for (const attrName of attrsGroup) {
            allowedAttributes.add(attrName);
          }
        }
        const groupDefaults = attrsGroupsDefaults[attrsGroupName];
        if (groupDefaults) {
          for (const [attrName, defaultValue] of Object.entries(groupDefaults)) {
            attributesDefaults.set(attrName, defaultValue);
          }
        }
      }
      allowedChildrenPerElement.set(name, allowedChildren);
      allowedAttributesPerElement.set(name, allowedAttributes);
      attributesDefaultsPerElement.set(name, attributesDefaults);
    }
    exports2.fn = (root, params) => {
      const {
        unknownContent = true,
        unknownAttrs = true,
        defaultAttrs = true,
        uselessOverrides = true,
        keepDataAttrs = true,
        keepAriaAttrs = true,
        keepRoleAttr = false
      } = params;
      const stylesheet = collectStylesheet(root);
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name.includes(":")) {
              return;
            }
            if (node.name === "foreignObject") {
              return visitSkip;
            }
            if (unknownContent && parentNode.type === "element") {
              const allowedChildren = allowedChildrenPerElement.get(parentNode.name);
              if (allowedChildren == null || allowedChildren.size === 0) {
                if (allowedChildrenPerElement.get(node.name) == null) {
                  detachNodeFromParent(node, parentNode);
                  return;
                }
              } else {
                if (allowedChildren.has(node.name) === false) {
                  detachNodeFromParent(node, parentNode);
                  return;
                }
              }
            }
            const allowedAttributes = allowedAttributesPerElement.get(node.name);
            const attributesDefaults = attributesDefaultsPerElement.get(node.name);
            const computedParentStyle = parentNode.type === "element" ? computeStyle(stylesheet, parentNode) : null;
            for (const [name, value] of Object.entries(node.attributes)) {
              if (keepDataAttrs && name.startsWith("data-")) {
                continue;
              }
              if (keepAriaAttrs && name.startsWith("aria-")) {
                continue;
              }
              if (keepRoleAttr && name === "role") {
                continue;
              }
              if (name === "xmlns") {
                continue;
              }
              if (name.includes(":")) {
                const [prefix] = name.split(":");
                if (prefix !== "xml" && prefix !== "xlink") {
                  continue;
                }
              }
              if (unknownAttrs && allowedAttributes && allowedAttributes.has(name) === false) {
                delete node.attributes[name];
              }
              if (defaultAttrs && node.attributes.id == null && attributesDefaults && attributesDefaults.get(name) === value) {
                if (computedParentStyle == null || computedParentStyle[name] == null) {
                  delete node.attributes[name];
                }
              }
              if (uselessOverrides && node.attributes.id == null) {
                const style = computedParentStyle == null ? null : computedParentStyle[name];
                if (presentationNonInheritableGroupAttrs.includes(name) === false && style != null && style.type === "static" && style.value === value) {
                  delete node.attributes[name];
                }
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeNonInheritableGroupAttrs.js
var require_removeNonInheritableGroupAttrs = __commonJS({
  "node_modules/svgo/plugins/removeNonInheritableGroupAttrs.js"(exports2) {
    "use strict";
    exports2.name = "removeNonInheritableGroupAttrs";
    exports2.type = "perItem";
    exports2.active = true;
    exports2.description = "removes non-inheritable group\u2019s presentational attributes";
    var {
      inheritableAttrs,
      attrsGroups,
      presentationNonInheritableGroupAttrs
    } = require_collections();
    exports2.fn = function(item) {
      if (item.type === "element" && item.name === "g") {
        for (const name of Object.keys(item.attributes)) {
          if (attrsGroups.presentation.includes(name) === true && inheritableAttrs.includes(name) === false && presentationNonInheritableGroupAttrs.includes(name) === false) {
            delete item.attributes[name];
          }
        }
      }
    };
  }
});

// node_modules/svgo/plugins/removeUselessStrokeAndFill.js
var require_removeUselessStrokeAndFill = __commonJS({
  "node_modules/svgo/plugins/removeUselessStrokeAndFill.js"(exports2) {
    "use strict";
    var { visit, visitSkip, detachNodeFromParent } = require_xast();
    var { collectStylesheet, computeStyle } = require_style();
    var { elemsGroups } = require_collections();
    exports2.type = "visitor";
    exports2.name = "removeUselessStrokeAndFill";
    exports2.active = true;
    exports2.description = "removes useless stroke and fill attributes";
    exports2.fn = (root, params) => {
      const {
        stroke: removeStroke = true,
        fill: removeFill = true,
        removeNone = false
      } = params;
      let hasStyleOrScript = false;
      visit(root, {
        element: {
          enter: (node) => {
            if (node.name === "style" || node.name === "script") {
              hasStyleOrScript = true;
            }
          }
        }
      });
      if (hasStyleOrScript) {
        return null;
      }
      const stylesheet = collectStylesheet(root);
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.attributes.id != null) {
              return visitSkip;
            }
            if (elemsGroups.shape.includes(node.name) == false) {
              return;
            }
            const computedStyle = computeStyle(stylesheet, node);
            const stroke = computedStyle.stroke;
            const strokeOpacity = computedStyle["stroke-opacity"];
            const strokeWidth = computedStyle["stroke-width"];
            const markerEnd = computedStyle["marker-end"];
            const fill = computedStyle.fill;
            const fillOpacity = computedStyle["fill-opacity"];
            const computedParentStyle = parentNode.type === "element" ? computeStyle(stylesheet, parentNode) : null;
            const parentStroke = computedParentStyle == null ? null : computedParentStyle.stroke;
            if (removeStroke) {
              if (stroke == null || stroke.type === "static" && stroke.value == "none" || strokeOpacity != null && strokeOpacity.type === "static" && strokeOpacity.value === "0" || strokeWidth != null && strokeWidth.type === "static" && strokeWidth.value === "0") {
                if (strokeWidth != null && strokeWidth.type === "static" && strokeWidth.value === "0" || markerEnd == null) {
                  for (const name of Object.keys(node.attributes)) {
                    if (name.startsWith("stroke")) {
                      delete node.attributes[name];
                    }
                  }
                  if (parentStroke != null && parentStroke.type === "static" && parentStroke.value !== "none") {
                    node.attributes.stroke = "none";
                  }
                }
              }
            }
            if (removeFill) {
              if (fill != null && fill.type === "static" && fill.value === "none" || fillOpacity != null && fillOpacity.type === "static" && fillOpacity.value === "0") {
                for (const name of Object.keys(node.attributes)) {
                  if (name.startsWith("fill-")) {
                    delete node.attributes[name];
                  }
                }
                if (fill == null || fill.type === "static" && fill.value !== "none") {
                  node.attributes.fill = "none";
                }
              }
            }
            if (removeNone) {
              if ((stroke == null || node.attributes.stroke === "none") && (fill != null && fill.type === "static" && fill.value === "none" || node.attributes.fill === "none")) {
                detachNodeFromParent(node, parentNode);
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeViewBox.js
var require_removeViewBox = __commonJS({
  "node_modules/svgo/plugins/removeViewBox.js"(exports2) {
    "use strict";
    exports2.type = "visitor";
    exports2.name = "removeViewBox";
    exports2.active = true;
    exports2.description = "removes viewBox attribute when possible";
    var viewBoxElems = ["svg", "pattern", "symbol"];
    exports2.fn = () => {
      return {
        element: {
          enter: (node, parentNode) => {
            if (viewBoxElems.includes(node.name) && node.attributes.viewBox != null && node.attributes.width != null && node.attributes.height != null) {
              if (node.name === "svg" && parentNode.type !== "root") {
                return;
              }
              const nums = node.attributes.viewBox.split(/[ ,]+/g);
              if (nums[0] === "0" && nums[1] === "0" && node.attributes.width.replace(/px$/, "") === nums[2] && node.attributes.height.replace(/px$/, "") === nums[3]) {
                delete node.attributes.viewBox;
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/cleanupEnableBackground.js
var require_cleanupEnableBackground = __commonJS({
  "node_modules/svgo/plugins/cleanupEnableBackground.js"(exports2) {
    "use strict";
    var { visit } = require_xast();
    exports2.type = "visitor";
    exports2.name = "cleanupEnableBackground";
    exports2.active = true;
    exports2.description = "remove or cleanup enable-background attribute when possible";
    exports2.fn = (root) => {
      const regEnableBackground = /^new\s0\s0\s([-+]?\d*\.?\d+([eE][-+]?\d+)?)\s([-+]?\d*\.?\d+([eE][-+]?\d+)?)$/;
      let hasFilter = false;
      visit(root, {
        element: {
          enter: (node) => {
            if (node.name === "filter") {
              hasFilter = true;
            }
          }
        }
      });
      return {
        element: {
          enter: (node) => {
            if (node.attributes["enable-background"] == null) {
              return;
            }
            if (hasFilter) {
              if ((node.name === "svg" || node.name === "mask" || node.name === "pattern") && node.attributes.width != null && node.attributes.height != null) {
                const match = node.attributes["enable-background"].match(regEnableBackground);
                if (match != null && node.attributes.width === match[1] && node.attributes.height === match[3]) {
                  if (node.name === "svg") {
                    delete node.attributes["enable-background"];
                  } else {
                    node.attributes["enable-background"] = "new";
                  }
                }
              }
            } else {
              delete node.attributes["enable-background"];
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/lib/path.js
var require_path = __commonJS({
  "node_modules/svgo/lib/path.js"(exports2) {
    "use strict";
    var argsCountPerCommand = {
      M: 2,
      m: 2,
      Z: 0,
      z: 0,
      L: 2,
      l: 2,
      H: 1,
      h: 1,
      V: 1,
      v: 1,
      C: 6,
      c: 6,
      S: 4,
      s: 4,
      Q: 4,
      q: 4,
      T: 2,
      t: 2,
      A: 7,
      a: 7
    };
    var isCommand = (c) => {
      return c in argsCountPerCommand;
    };
    var isWsp = (c) => {
      const codePoint = c.codePointAt(0);
      return codePoint === 32 || codePoint === 9 || codePoint === 13 || codePoint === 10;
    };
    var isDigit = (c) => {
      const codePoint = c.codePointAt(0);
      if (codePoint == null) {
        return false;
      }
      return 48 <= codePoint && codePoint <= 57;
    };
    var readNumber = (string, cursor) => {
      let i = cursor;
      let value = "";
      let state = "none";
      for (; i < string.length; i += 1) {
        const c = string[i];
        if (c === "+" || c === "-") {
          if (state === "none") {
            state = "sign";
            value += c;
            continue;
          }
          if (state === "e") {
            state = "exponent_sign";
            value += c;
            continue;
          }
        }
        if (isDigit(c)) {
          if (state === "none" || state === "sign" || state === "whole") {
            state = "whole";
            value += c;
            continue;
          }
          if (state === "decimal_point" || state === "decimal") {
            state = "decimal";
            value += c;
            continue;
          }
          if (state === "e" || state === "exponent_sign" || state === "exponent") {
            state = "exponent";
            value += c;
            continue;
          }
        }
        if (c === ".") {
          if (state === "none" || state === "sign" || state === "whole") {
            state = "decimal_point";
            value += c;
            continue;
          }
        }
        if (c === "E" || c == "e") {
          if (state === "whole" || state === "decimal_point" || state === "decimal") {
            state = "e";
            value += c;
            continue;
          }
        }
        break;
      }
      const number = Number.parseFloat(value);
      if (Number.isNaN(number)) {
        return [cursor, null];
      } else {
        return [i - 1, number];
      }
    };
    var parsePathData = (string) => {
      const pathData = [];
      let command = null;
      let args = [];
      let argsCount = 0;
      let canHaveComma = false;
      let hadComma = false;
      for (let i = 0; i < string.length; i += 1) {
        const c = string.charAt(i);
        if (isWsp(c)) {
          continue;
        }
        if (canHaveComma && c === ",") {
          if (hadComma) {
            break;
          }
          hadComma = true;
          continue;
        }
        if (isCommand(c)) {
          if (hadComma) {
            return pathData;
          }
          if (command == null) {
            if (c !== "M" && c !== "m") {
              return pathData;
            }
          } else {
            if (args.length !== 0) {
              return pathData;
            }
          }
          command = c;
          args = [];
          argsCount = argsCountPerCommand[command];
          canHaveComma = false;
          if (argsCount === 0) {
            pathData.push({ command, args });
          }
          continue;
        }
        if (command == null) {
          return pathData;
        }
        let newCursor = i;
        let number = null;
        if (command === "A" || command === "a") {
          const position = args.length;
          if (position === 0 || position === 1) {
            if (c !== "+" && c !== "-") {
              [newCursor, number] = readNumber(string, i);
            }
          }
          if (position === 2 || position === 5 || position === 6) {
            [newCursor, number] = readNumber(string, i);
          }
          if (position === 3 || position === 4) {
            if (c === "0") {
              number = 0;
            }
            if (c === "1") {
              number = 1;
            }
          }
        } else {
          [newCursor, number] = readNumber(string, i);
        }
        if (number == null) {
          return pathData;
        }
        args.push(number);
        canHaveComma = true;
        hadComma = false;
        i = newCursor;
        if (args.length === argsCount) {
          pathData.push({ command, args });
          if (command === "M") {
            command = "L";
          }
          if (command === "m") {
            command = "l";
          }
          args = [];
        }
      }
      return pathData;
    };
    exports2.parsePathData = parsePathData;
    var stringifyNumber = (number, precision) => {
      if (precision != null) {
        const ratio = 10 ** precision;
        number = Math.round(number * ratio) / ratio;
      }
      return number.toString().replace(/^0\./, ".").replace(/^-0\./, "-.");
    };
    var stringifyArgs = (command, args, precision, disableSpaceAfterFlags) => {
      let result = "";
      let prev = "";
      for (let i = 0; i < args.length; i += 1) {
        const number = args[i];
        const numberString = stringifyNumber(number, precision);
        if (disableSpaceAfterFlags && (command === "A" || command === "a") && (i % 7 === 4 || i % 7 === 5)) {
          result += numberString;
        } else if (i === 0 || numberString.startsWith("-")) {
          result += numberString;
        } else if (prev.includes(".") && numberString.startsWith(".")) {
          result += numberString;
        } else {
          result += ` ${numberString}`;
        }
        prev = numberString;
      }
      return result;
    };
    var stringifyPathData = ({ pathData, precision, disableSpaceAfterFlags }) => {
      let combined = [];
      for (let i = 0; i < pathData.length; i += 1) {
        const { command, args } = pathData[i];
        if (i === 0) {
          combined.push({ command, args });
        } else {
          const last = combined[combined.length - 1];
          if (i === 1) {
            if (command === "L") {
              last.command = "M";
            }
            if (command === "l") {
              last.command = "m";
            }
          }
          if (last.command === command && last.command !== "M" && last.command !== "m" || last.command === "M" && command === "L" || last.command === "m" && command === "l") {
            last.args = [...last.args, ...args];
          } else {
            combined.push({ command, args });
          }
        }
      }
      let result = "";
      for (const { command, args } of combined) {
        result += command + stringifyArgs(command, args, precision, disableSpaceAfterFlags);
      }
      return result;
    };
    exports2.stringifyPathData = stringifyPathData;
  }
});

// node_modules/svgo/plugins/removeHiddenElems.js
var require_removeHiddenElems = __commonJS({
  "node_modules/svgo/plugins/removeHiddenElems.js"(exports2) {
    "use strict";
    var {
      querySelector,
      closestByName,
      detachNodeFromParent
    } = require_xast();
    var { collectStylesheet, computeStyle } = require_style();
    var { parsePathData } = require_path();
    exports2.name = "removeHiddenElems";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "removes hidden elements (zero sized, with absent attributes)";
    exports2.fn = (root, params) => {
      const {
        isHidden = true,
        displayNone = true,
        opacity0 = true,
        circleR0 = true,
        ellipseRX0 = true,
        ellipseRY0 = true,
        rectWidth0 = true,
        rectHeight0 = true,
        patternWidth0 = true,
        patternHeight0 = true,
        imageWidth0 = true,
        imageHeight0 = true,
        pathEmptyD = true,
        polylineEmptyPoints = true,
        polygonEmptyPoints = true
      } = params;
      const stylesheet = collectStylesheet(root);
      return {
        element: {
          enter: (node, parentNode) => {
            const computedStyle = computeStyle(stylesheet, node);
            if (isHidden && computedStyle.visibility && computedStyle.visibility.type === "static" && computedStyle.visibility.value === "hidden" && querySelector(node, "[visibility=visible]") == null) {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (displayNone && computedStyle.display && computedStyle.display.type === "static" && computedStyle.display.value === "none" && node.name !== "marker") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (opacity0 && computedStyle.opacity && computedStyle.opacity.type === "static" && computedStyle.opacity.value === "0" && closestByName(node, "clipPath") == null) {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (circleR0 && node.name === "circle" && node.children.length === 0 && node.attributes.r === "0") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (ellipseRX0 && node.name === "ellipse" && node.children.length === 0 && node.attributes.rx === "0") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (ellipseRY0 && node.name === "ellipse" && node.children.length === 0 && node.attributes.ry === "0") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (rectWidth0 && node.name === "rect" && node.children.length === 0 && node.attributes.width === "0") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (rectHeight0 && rectWidth0 && node.name === "rect" && node.children.length === 0 && node.attributes.height === "0") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (patternWidth0 && node.name === "pattern" && node.attributes.width === "0") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (patternHeight0 && node.name === "pattern" && node.attributes.height === "0") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (imageWidth0 && node.name === "image" && node.attributes.width === "0") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (imageHeight0 && node.name === "image" && node.attributes.height === "0") {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (pathEmptyD && node.name === "path") {
              if (node.attributes.d == null) {
                detachNodeFromParent(node, parentNode);
                return;
              }
              const pathData = parsePathData(node.attributes.d);
              if (pathData.length === 0) {
                detachNodeFromParent(node, parentNode);
                return;
              }
              if (pathData.length === 1 && computedStyle["marker-start"] == null && computedStyle["marker-end"] == null) {
                detachNodeFromParent(node, parentNode);
                return;
              }
              return;
            }
            if (polylineEmptyPoints && node.name === "polyline" && node.attributes.points == null) {
              detachNodeFromParent(node, parentNode);
              return;
            }
            if (polygonEmptyPoints && node.name === "polygon" && node.attributes.points == null) {
              detachNodeFromParent(node, parentNode);
              return;
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeEmptyText.js
var require_removeEmptyText = __commonJS({
  "node_modules/svgo/plugins/removeEmptyText.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeEmptyText";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "removes empty <text> elements";
    exports2.fn = (root, params) => {
      const { text = true, tspan = true, tref = true } = params;
      return {
        element: {
          enter: (node, parentNode) => {
            if (text && node.name === "text" && node.children.length === 0) {
              detachNodeFromParent(node, parentNode);
            }
            if (tspan && node.name === "tspan" && node.children.length === 0) {
              detachNodeFromParent(node, parentNode);
            }
            if (tref && node.name === "tref" && node.attributes["xlink:href"] == null) {
              detachNodeFromParent(node, parentNode);
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/convertShapeToPath.js
var require_convertShapeToPath = __commonJS({
  "node_modules/svgo/plugins/convertShapeToPath.js"(exports2) {
    "use strict";
    var { stringifyPathData } = require_path();
    var { detachNodeFromParent } = require_xast();
    exports2.name = "convertShapeToPath";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "converts basic shapes to more compact path form";
    var regNumber = /[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
    exports2.fn = (root, params) => {
      const { convertArcs = false, floatPrecision: precision } = params;
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "rect" && node.attributes.width != null && node.attributes.height != null && node.attributes.rx == null && node.attributes.ry == null) {
              const x = Number(node.attributes.x || "0");
              const y = Number(node.attributes.y || "0");
              const width = Number(node.attributes.width);
              const height = Number(node.attributes.height);
              if (Number.isNaN(x - y + width - height))
                return;
              const pathData = [
                { command: "M", args: [x, y] },
                { command: "H", args: [x + width] },
                { command: "V", args: [y + height] },
                { command: "H", args: [x] },
                { command: "z", args: [] }
              ];
              node.name = "path";
              node.attributes.d = stringifyPathData({ pathData, precision });
              delete node.attributes.x;
              delete node.attributes.y;
              delete node.attributes.width;
              delete node.attributes.height;
            }
            if (node.name === "line") {
              const x1 = Number(node.attributes.x1 || "0");
              const y1 = Number(node.attributes.y1 || "0");
              const x2 = Number(node.attributes.x2 || "0");
              const y2 = Number(node.attributes.y2 || "0");
              if (Number.isNaN(x1 - y1 + x2 - y2))
                return;
              const pathData = [
                { command: "M", args: [x1, y1] },
                { command: "L", args: [x2, y2] }
              ];
              node.name = "path";
              node.attributes.d = stringifyPathData({ pathData, precision });
              delete node.attributes.x1;
              delete node.attributes.y1;
              delete node.attributes.x2;
              delete node.attributes.y2;
            }
            if ((node.name === "polyline" || node.name === "polygon") && node.attributes.points != null) {
              const coords = (node.attributes.points.match(regNumber) || []).map(Number);
              if (coords.length < 4) {
                detachNodeFromParent(node, parentNode);
                return;
              }
              const pathData = [];
              for (let i = 0; i < coords.length; i += 2) {
                pathData.push({
                  command: i === 0 ? "M" : "L",
                  args: coords.slice(i, i + 2)
                });
              }
              if (node.name === "polygon") {
                pathData.push({ command: "z", args: [] });
              }
              node.name = "path";
              node.attributes.d = stringifyPathData({ pathData, precision });
              delete node.attributes.points;
            }
            if (node.name === "circle" && convertArcs) {
              const cx = Number(node.attributes.cx || "0");
              const cy = Number(node.attributes.cy || "0");
              const r = Number(node.attributes.r || "0");
              if (Number.isNaN(cx - cy + r)) {
                return;
              }
              const pathData = [
                { command: "M", args: [cx, cy - r] },
                { command: "A", args: [r, r, 0, 1, 0, cx, cy + r] },
                { command: "A", args: [r, r, 0, 1, 0, cx, cy - r] },
                { command: "z", args: [] }
              ];
              node.name = "path";
              node.attributes.d = stringifyPathData({ pathData, precision });
              delete node.attributes.cx;
              delete node.attributes.cy;
              delete node.attributes.r;
            }
            if (node.name === "ellipse" && convertArcs) {
              const ecx = Number(node.attributes.cx || "0");
              const ecy = Number(node.attributes.cy || "0");
              const rx = Number(node.attributes.rx || "0");
              const ry = Number(node.attributes.ry || "0");
              if (Number.isNaN(ecx - ecy + rx - ry)) {
                return;
              }
              const pathData = [
                { command: "M", args: [ecx, ecy - ry] },
                { command: "A", args: [rx, ry, 0, 1, 0, ecx, ecy + ry] },
                { command: "A", args: [rx, ry, 0, 1, 0, ecx, ecy - ry] },
                { command: "z", args: [] }
              ];
              node.name = "path";
              node.attributes.d = stringifyPathData({ pathData, precision });
              delete node.attributes.cx;
              delete node.attributes.cy;
              delete node.attributes.rx;
              delete node.attributes.ry;
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/convertEllipseToCircle.js
var require_convertEllipseToCircle = __commonJS({
  "node_modules/svgo/plugins/convertEllipseToCircle.js"(exports2) {
    "use strict";
    exports2.name = "convertEllipseToCircle";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "converts non-eccentric <ellipse>s to <circle>s";
    exports2.fn = () => {
      return {
        element: {
          enter: (node) => {
            if (node.name === "ellipse") {
              const rx = node.attributes.rx || "0";
              const ry = node.attributes.ry || "0";
              if (rx === ry || rx === "auto" || ry === "auto") {
                node.name = "circle";
                const radius = rx === "auto" ? ry : rx;
                delete node.attributes.rx;
                delete node.attributes.ry;
                node.attributes.r = radius;
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/moveElemsAttrsToGroup.js
var require_moveElemsAttrsToGroup = __commonJS({
  "node_modules/svgo/plugins/moveElemsAttrsToGroup.js"(exports2) {
    "use strict";
    var { visit } = require_xast();
    var { inheritableAttrs, pathElems } = require_collections();
    exports2.type = "visitor";
    exports2.name = "moveElemsAttrsToGroup";
    exports2.active = true;
    exports2.description = "Move common attributes of group children to the group";
    exports2.fn = (root) => {
      let deoptimizedWithStyles = false;
      visit(root, {
        element: {
          enter: (node) => {
            if (node.name === "style") {
              deoptimizedWithStyles = true;
            }
          }
        }
      });
      return {
        element: {
          exit: (node) => {
            if (node.name !== "g" || node.children.length <= 1) {
              return;
            }
            if (deoptimizedWithStyles) {
              return;
            }
            const commonAttributes = /* @__PURE__ */ new Map();
            let initial = true;
            let everyChildIsPath = true;
            for (const child of node.children) {
              if (child.type === "element") {
                if (pathElems.includes(child.name) === false) {
                  everyChildIsPath = false;
                }
                if (initial) {
                  initial = false;
                  for (const [name, value] of Object.entries(child.attributes)) {
                    if (inheritableAttrs.includes(name)) {
                      commonAttributes.set(name, value);
                    }
                  }
                } else {
                  for (const [name, value] of commonAttributes) {
                    if (child.attributes[name] !== value) {
                      commonAttributes.delete(name);
                    }
                  }
                }
              }
            }
            if (node.attributes["clip-path"] != null || node.attributes.mask != null) {
              commonAttributes.delete("transform");
            }
            if (everyChildIsPath) {
              commonAttributes.delete("transform");
            }
            for (const [name, value] of commonAttributes) {
              if (name === "transform") {
                if (node.attributes.transform != null) {
                  node.attributes.transform = `${node.attributes.transform} ${value}`;
                } else {
                  node.attributes.transform = value;
                }
              } else {
                node.attributes[name] = value;
              }
            }
            for (const child of node.children) {
              if (child.type === "element") {
                for (const [name] of commonAttributes) {
                  delete child.attributes[name];
                }
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/moveGroupAttrsToElems.js
var require_moveGroupAttrsToElems = __commonJS({
  "node_modules/svgo/plugins/moveGroupAttrsToElems.js"(exports2) {
    "use strict";
    var { pathElems, referencesProps } = require_collections();
    exports2.name = "moveGroupAttrsToElems";
    exports2.type = "perItem";
    exports2.active = true;
    exports2.description = "moves some group attributes to the content elements";
    var pathElemsWithGroupsAndText = [...pathElems, "g", "text"];
    exports2.fn = function(item) {
      if (item.type === "element" && item.name === "g" && item.children.length !== 0 && item.attributes.transform != null && Object.entries(item.attributes).some(([name, value]) => referencesProps.includes(name) && value.includes("url(")) === false && item.children.every((inner) => pathElemsWithGroupsAndText.includes(inner.name) && inner.attributes.id == null)) {
        for (const inner of item.children) {
          const value = item.attributes.transform;
          if (inner.attributes.transform != null) {
            inner.attributes.transform = value + " " + inner.attributes.transform;
          } else {
            inner.attributes.transform = value;
          }
        }
        delete item.attributes.transform;
      }
    };
  }
});

// node_modules/svgo/plugins/collapseGroups.js
var require_collapseGroups = __commonJS({
  "node_modules/svgo/plugins/collapseGroups.js"(exports2) {
    "use strict";
    var { inheritableAttrs, elemsGroups } = require_collections();
    exports2.type = "visitor";
    exports2.name = "collapseGroups";
    exports2.active = true;
    exports2.description = "collapses useless groups";
    var hasAnimatedAttr = (node, name) => {
      if (node.type === "element") {
        if (elemsGroups.animation.includes(node.name) && node.attributes.attributeName === name) {
          return true;
        }
        for (const child of node.children) {
          if (hasAnimatedAttr(child, name)) {
            return true;
          }
        }
      }
      return false;
    };
    exports2.fn = () => {
      return {
        element: {
          exit: (node, parentNode) => {
            if (parentNode.type === "root" || parentNode.name === "switch") {
              return;
            }
            if (node.name !== "g" || node.children.length === 0) {
              return;
            }
            if (Object.keys(node.attributes).length !== 0 && node.children.length === 1) {
              const firstChild = node.children[0];
              if (firstChild.type === "element" && firstChild.attributes.id == null && node.attributes.filter == null && (node.attributes.class == null || firstChild.attributes.class == null) && (node.attributes["clip-path"] == null && node.attributes.mask == null || firstChild.name === "g" && node.attributes.transform == null && firstChild.attributes.transform == null)) {
                for (const [name, value] of Object.entries(node.attributes)) {
                  if (hasAnimatedAttr(firstChild, name)) {
                    return;
                  }
                  if (firstChild.attributes[name] == null) {
                    firstChild.attributes[name] = value;
                  } else if (name === "transform") {
                    firstChild.attributes[name] = value + " " + firstChild.attributes[name];
                  } else if (firstChild.attributes[name] === "inherit") {
                    firstChild.attributes[name] = value;
                  } else if (inheritableAttrs.includes(name) === false && firstChild.attributes[name] !== value) {
                    return;
                  }
                  delete node.attributes[name];
                }
              }
            }
            if (Object.keys(node.attributes).length === 0) {
              for (const child of node.children) {
                if (child.type === "element" && elemsGroups.animation.includes(child.name)) {
                  return;
                }
              }
              const index = parentNode.children.indexOf(node);
              parentNode.children.splice(index, 1, ...node.children);
              for (const child of node.children) {
                child.parentNode = parentNode;
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/_path.js
var require_path2 = __commonJS({
  "node_modules/svgo/plugins/_path.js"(exports2) {
    "use strict";
    var { parsePathData, stringifyPathData } = require_path();
    var prevCtrlPoint;
    var path2js = (path) => {
      if (path.pathJS)
        return path.pathJS;
      const pathData = [];
      const newPathData = parsePathData(path.attributes.d);
      for (const { command, args } of newPathData) {
        pathData.push({ command, args });
      }
      if (pathData.length && pathData[0].command == "m") {
        pathData[0].command = "M";
      }
      path.pathJS = pathData;
      return pathData;
    };
    exports2.path2js = path2js;
    var convertRelativeToAbsolute = (data) => {
      const newData = [];
      let start = [0, 0];
      let cursor = [0, 0];
      for (let { command, args } of data) {
        args = args.slice();
        if (command === "m") {
          args[0] += cursor[0];
          args[1] += cursor[1];
          command = "M";
        }
        if (command === "M") {
          cursor[0] = args[0];
          cursor[1] = args[1];
          start[0] = cursor[0];
          start[1] = cursor[1];
        }
        if (command === "h") {
          args[0] += cursor[0];
          command = "H";
        }
        if (command === "H") {
          cursor[0] = args[0];
        }
        if (command === "v") {
          args[0] += cursor[1];
          command = "V";
        }
        if (command === "V") {
          cursor[1] = args[0];
        }
        if (command === "l") {
          args[0] += cursor[0];
          args[1] += cursor[1];
          command = "L";
        }
        if (command === "L") {
          cursor[0] = args[0];
          cursor[1] = args[1];
        }
        if (command === "c") {
          args[0] += cursor[0];
          args[1] += cursor[1];
          args[2] += cursor[0];
          args[3] += cursor[1];
          args[4] += cursor[0];
          args[5] += cursor[1];
          command = "C";
        }
        if (command === "C") {
          cursor[0] = args[4];
          cursor[1] = args[5];
        }
        if (command === "s") {
          args[0] += cursor[0];
          args[1] += cursor[1];
          args[2] += cursor[0];
          args[3] += cursor[1];
          command = "S";
        }
        if (command === "S") {
          cursor[0] = args[2];
          cursor[1] = args[3];
        }
        if (command === "q") {
          args[0] += cursor[0];
          args[1] += cursor[1];
          args[2] += cursor[0];
          args[3] += cursor[1];
          command = "Q";
        }
        if (command === "Q") {
          cursor[0] = args[2];
          cursor[1] = args[3];
        }
        if (command === "t") {
          args[0] += cursor[0];
          args[1] += cursor[1];
          command = "T";
        }
        if (command === "T") {
          cursor[0] = args[0];
          cursor[1] = args[1];
        }
        if (command === "a") {
          args[5] += cursor[0];
          args[6] += cursor[1];
          command = "A";
        }
        if (command === "A") {
          cursor[0] = args[5];
          cursor[1] = args[6];
        }
        if (command === "z" || command === "Z") {
          cursor[0] = start[0];
          cursor[1] = start[1];
          command = "z";
        }
        newData.push({ command, args });
      }
      return newData;
    };
    exports2.js2path = function(path, data, params) {
      path.pathJS = data;
      const pathData = [];
      for (const item of data) {
        if (pathData.length !== 0 && (item.command === "M" || item.command === "m")) {
          const last = pathData[pathData.length - 1];
          if (last.command === "M" || last.command === "m") {
            pathData.pop();
          }
        }
        pathData.push({
          command: item.command,
          args: item.args
        });
      }
      path.attributes.d = stringifyPathData({
        pathData,
        precision: params.floatPrecision,
        disableSpaceAfterFlags: params.noSpaceAfterFlags
      });
    };
    function set(dest, source) {
      dest[0] = source[source.length - 2];
      dest[1] = source[source.length - 1];
      return dest;
    }
    exports2.intersects = function(path1, path2) {
      const points1 = gatherPoints(convertRelativeToAbsolute(path1));
      const points2 = gatherPoints(convertRelativeToAbsolute(path2));
      if (points1.maxX <= points2.minX || points2.maxX <= points1.minX || points1.maxY <= points2.minY || points2.maxY <= points1.minY || points1.list.every((set1) => {
        return points2.list.every((set2) => {
          return set1.list[set1.maxX][0] <= set2.list[set2.minX][0] || set2.list[set2.maxX][0] <= set1.list[set1.minX][0] || set1.list[set1.maxY][1] <= set2.list[set2.minY][1] || set2.list[set2.maxY][1] <= set1.list[set1.minY][1];
        });
      }))
        return false;
      const hullNest1 = points1.list.map(convexHull);
      const hullNest2 = points2.list.map(convexHull);
      return hullNest1.some(function(hull1) {
        if (hull1.list.length < 3)
          return false;
        return hullNest2.some(function(hull2) {
          if (hull2.list.length < 3)
            return false;
          var simplex = [getSupport(hull1, hull2, [1, 0])], direction = minus(simplex[0]);
          var iterations = 1e4;
          while (true) {
            if (iterations-- == 0) {
              console.error("Error: infinite loop while processing mergePaths plugin.");
              return true;
            }
            simplex.push(getSupport(hull1, hull2, direction));
            if (dot(direction, simplex[simplex.length - 1]) <= 0)
              return false;
            if (processSimplex(simplex, direction))
              return true;
          }
        });
      });
      function getSupport(a, b, direction) {
        return sub(supportPoint(a, direction), supportPoint(b, minus(direction)));
      }
      function supportPoint(polygon, direction) {
        var index = direction[1] >= 0 ? direction[0] < 0 ? polygon.maxY : polygon.maxX : direction[0] < 0 ? polygon.minX : polygon.minY, max = -Infinity, value;
        while ((value = dot(polygon.list[index], direction)) > max) {
          max = value;
          index = ++index % polygon.list.length;
        }
        return polygon.list[(index || polygon.list.length) - 1];
      }
    };
    function processSimplex(simplex, direction) {
      if (simplex.length == 2) {
        let a = simplex[1], b = simplex[0], AO = minus(simplex[1]), AB = sub(b, a);
        if (dot(AO, AB) > 0) {
          set(direction, orth(AB, a));
        } else {
          set(direction, AO);
          simplex.shift();
        }
      } else {
        let a = simplex[2], b = simplex[1], c = simplex[0], AB = sub(b, a), AC = sub(c, a), AO = minus(a), ACB = orth(AB, AC), ABC = orth(AC, AB);
        if (dot(ACB, AO) > 0) {
          if (dot(AB, AO) > 0) {
            set(direction, ACB);
            simplex.shift();
          } else {
            set(direction, AO);
            simplex.splice(0, 2);
          }
        } else if (dot(ABC, AO) > 0) {
          if (dot(AC, AO) > 0) {
            set(direction, ABC);
            simplex.splice(1, 1);
          } else {
            set(direction, AO);
            simplex.splice(0, 2);
          }
        } else
          return true;
      }
      return false;
    }
    function minus(v) {
      return [-v[0], -v[1]];
    }
    function sub(v1, v2) {
      return [v1[0] - v2[0], v1[1] - v2[1]];
    }
    function dot(v1, v2) {
      return v1[0] * v2[0] + v1[1] * v2[1];
    }
    function orth(v, from) {
      var o = [-v[1], v[0]];
      return dot(o, minus(from)) < 0 ? minus(o) : o;
    }
    function gatherPoints(pathData) {
      const points = { list: [], minX: 0, minY: 0, maxX: 0, maxY: 0 };
      const addPoint = (path, point) => {
        if (!path.list.length || point[1] > path.list[path.maxY][1]) {
          path.maxY = path.list.length;
          points.maxY = points.list.length ? Math.max(point[1], points.maxY) : point[1];
        }
        if (!path.list.length || point[0] > path.list[path.maxX][0]) {
          path.maxX = path.list.length;
          points.maxX = points.list.length ? Math.max(point[0], points.maxX) : point[0];
        }
        if (!path.list.length || point[1] < path.list[path.minY][1]) {
          path.minY = path.list.length;
          points.minY = points.list.length ? Math.min(point[1], points.minY) : point[1];
        }
        if (!path.list.length || point[0] < path.list[path.minX][0]) {
          path.minX = path.list.length;
          points.minX = points.list.length ? Math.min(point[0], points.minX) : point[0];
        }
        path.list.push(point);
      };
      for (let i = 0; i < pathData.length; i += 1) {
        const pathDataItem = pathData[i];
        let subPath = points.list.length === 0 ? { list: [], minX: 0, minY: 0, maxX: 0, maxY: 0 } : points.list[points.list.length - 1];
        let prev = i === 0 ? null : pathData[i - 1];
        let basePoint = subPath.list.length === 0 ? null : subPath.list[subPath.list.length - 1];
        let data = pathDataItem.args;
        let ctrlPoint = basePoint;
        const toAbsolute = (n, i2) => n + (basePoint == null ? 0 : basePoint[i2 % 2]);
        switch (pathDataItem.command) {
          case "M":
            subPath = { list: [], minX: 0, minY: 0, maxX: 0, maxY: 0 };
            points.list.push(subPath);
            break;
          case "H":
            if (basePoint != null) {
              addPoint(subPath, [data[0], basePoint[1]]);
            }
            break;
          case "V":
            if (basePoint != null) {
              addPoint(subPath, [basePoint[0], data[0]]);
            }
            break;
          case "Q":
            addPoint(subPath, data.slice(0, 2));
            prevCtrlPoint = [data[2] - data[0], data[3] - data[1]];
            break;
          case "T":
            if (basePoint != null && prev != null && (prev.command == "Q" || prev.command == "T")) {
              ctrlPoint = [
                basePoint[0] + prevCtrlPoint[0],
                basePoint[1] + prevCtrlPoint[1]
              ];
              addPoint(subPath, ctrlPoint);
              prevCtrlPoint = [data[0] - ctrlPoint[0], data[1] - ctrlPoint[1]];
            }
            break;
          case "C":
            if (basePoint != null) {
              addPoint(subPath, [
                0.5 * (basePoint[0] + data[0]),
                0.5 * (basePoint[1] + data[1])
              ]);
            }
            addPoint(subPath, [
              0.5 * (data[0] + data[2]),
              0.5 * (data[1] + data[3])
            ]);
            addPoint(subPath, [
              0.5 * (data[2] + data[4]),
              0.5 * (data[3] + data[5])
            ]);
            prevCtrlPoint = [data[4] - data[2], data[5] - data[3]];
            break;
          case "S":
            if (basePoint != null && prev != null && (prev.command == "C" || prev.command == "S")) {
              addPoint(subPath, [
                basePoint[0] + 0.5 * prevCtrlPoint[0],
                basePoint[1] + 0.5 * prevCtrlPoint[1]
              ]);
              ctrlPoint = [
                basePoint[0] + prevCtrlPoint[0],
                basePoint[1] + prevCtrlPoint[1]
              ];
            }
            if (ctrlPoint != null) {
              addPoint(subPath, [
                0.5 * (ctrlPoint[0] + data[0]),
                0.5 * (ctrlPoint[1] + data[1])
              ]);
            }
            addPoint(subPath, [
              0.5 * (data[0] + data[2]),
              0.5 * (data[1] + data[3])
            ]);
            prevCtrlPoint = [data[2] - data[0], data[3] - data[1]];
            break;
          case "A":
            if (basePoint != null) {
              var curves = a2c.apply(0, basePoint.concat(data));
              for (var cData; (cData = curves.splice(0, 6).map(toAbsolute)).length; ) {
                if (basePoint != null) {
                  addPoint(subPath, [
                    0.5 * (basePoint[0] + cData[0]),
                    0.5 * (basePoint[1] + cData[1])
                  ]);
                }
                addPoint(subPath, [
                  0.5 * (cData[0] + cData[2]),
                  0.5 * (cData[1] + cData[3])
                ]);
                addPoint(subPath, [
                  0.5 * (cData[2] + cData[4]),
                  0.5 * (cData[3] + cData[5])
                ]);
                if (curves.length)
                  addPoint(subPath, basePoint = cData.slice(-2));
              }
            }
            break;
        }
        if (data.length >= 2)
          addPoint(subPath, data.slice(-2));
      }
      return points;
    }
    function convexHull(points) {
      points.list.sort(function(a, b) {
        return a[0] == b[0] ? a[1] - b[1] : a[0] - b[0];
      });
      var lower = [], minY = 0, bottom = 0;
      for (let i = 0; i < points.list.length; i++) {
        while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], points.list[i]) <= 0) {
          lower.pop();
        }
        if (points.list[i][1] < points.list[minY][1]) {
          minY = i;
          bottom = lower.length;
        }
        lower.push(points.list[i]);
      }
      var upper = [], maxY = points.list.length - 1, top = 0;
      for (let i = points.list.length; i--; ) {
        while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], points.list[i]) <= 0) {
          upper.pop();
        }
        if (points.list[i][1] > points.list[maxY][1]) {
          maxY = i;
          top = upper.length;
        }
        upper.push(points.list[i]);
      }
      upper.pop();
      lower.pop();
      const hullList = lower.concat(upper);
      const hull = {
        list: hullList,
        minX: 0,
        maxX: lower.length,
        minY: bottom,
        maxY: (lower.length + top) % hullList.length
      };
      return hull;
    }
    function cross(o, a, b) {
      return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
    }
    var a2c = (x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) => {
      const _120 = Math.PI * 120 / 180;
      const rad = Math.PI / 180 * (+angle || 0);
      let res = [];
      const rotateX = (x3, y3, rad2) => {
        return x3 * Math.cos(rad2) - y3 * Math.sin(rad2);
      };
      const rotateY = (x3, y3, rad2) => {
        return x3 * Math.sin(rad2) + y3 * Math.cos(rad2);
      };
      if (!recursive) {
        x1 = rotateX(x1, y1, -rad);
        y1 = rotateY(x1, y1, -rad);
        x2 = rotateX(x2, y2, -rad);
        y2 = rotateY(x2, y2, -rad);
        var x = (x1 - x2) / 2, y = (y1 - y2) / 2;
        var h = x * x / (rx * rx) + y * y / (ry * ry);
        if (h > 1) {
          h = Math.sqrt(h);
          rx = h * rx;
          ry = h * ry;
        }
        var rx2 = rx * rx;
        var ry2 = ry * ry;
        var k = (large_arc_flag == sweep_flag ? -1 : 1) * Math.sqrt(Math.abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x)));
        var cx = k * rx * y / ry + (x1 + x2) / 2;
        var cy = k * -ry * x / rx + (y1 + y2) / 2;
        var f1 = Math.asin(Number(((y1 - cy) / ry).toFixed(9)));
        var f2 = Math.asin(Number(((y2 - cy) / ry).toFixed(9)));
        f1 = x1 < cx ? Math.PI - f1 : f1;
        f2 = x2 < cx ? Math.PI - f2 : f2;
        f1 < 0 && (f1 = Math.PI * 2 + f1);
        f2 < 0 && (f2 = Math.PI * 2 + f2);
        if (sweep_flag && f1 > f2) {
          f1 = f1 - Math.PI * 2;
        }
        if (!sweep_flag && f2 > f1) {
          f2 = f2 - Math.PI * 2;
        }
      } else {
        f1 = recursive[0];
        f2 = recursive[1];
        cx = recursive[2];
        cy = recursive[3];
      }
      var df = f2 - f1;
      if (Math.abs(df) > _120) {
        var f2old = f2, x2old = x2, y2old = y2;
        f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
        x2 = cx + rx * Math.cos(f2);
        y2 = cy + ry * Math.sin(f2);
        res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [
          f2,
          f2old,
          cx,
          cy
        ]);
      }
      df = f2 - f1;
      var c1 = Math.cos(f1), s1 = Math.sin(f1), c2 = Math.cos(f2), s2 = Math.sin(f2), t = Math.tan(df / 4), hx = 4 / 3 * rx * t, hy = 4 / 3 * ry * t, m = [
        -hx * s1,
        hy * c1,
        x2 + hx * s2 - x1,
        y2 - hy * c2 - y1,
        x2 - x1,
        y2 - y1
      ];
      if (recursive) {
        return m.concat(res);
      } else {
        res = m.concat(res);
        var newres = [];
        for (var i = 0, n = res.length; i < n; i++) {
          newres[i] = i % 2 ? rotateY(res[i - 1], res[i], rad) : rotateX(res[i], res[i + 1], rad);
        }
        return newres;
      }
    };
  }
});

// node_modules/svgo/plugins/_transforms.js
var require_transforms = __commonJS({
  "node_modules/svgo/plugins/_transforms.js"(exports2) {
    "use strict";
    var regTransformTypes = /matrix|translate|scale|rotate|skewX|skewY/;
    var regTransformSplit = /\s*(matrix|translate|scale|rotate|skewX|skewY)\s*\(\s*(.+?)\s*\)[\s,]*/;
    var regNumericValues = /[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
    exports2.transform2js = (transformString) => {
      const transforms = [];
      let current = null;
      for (const item of transformString.split(regTransformSplit)) {
        var num;
        if (item) {
          if (regTransformTypes.test(item)) {
            current = { name: item, data: [] };
            transforms.push(current);
          } else {
            while (num = regNumericValues.exec(item)) {
              num = Number(num);
              if (current != null) {
                current.data.push(num);
              }
            }
          }
        }
      }
      return current == null || current.data.length == 0 ? [] : transforms;
    };
    exports2.transformsMultiply = (transforms) => {
      const matrixData = transforms.map((transform) => {
        if (transform.name === "matrix") {
          return transform.data;
        }
        return transformToMatrix(transform);
      });
      const matrixTransform = {
        name: "matrix",
        data: matrixData.length > 0 ? matrixData.reduce(multiplyTransformMatrices) : []
      };
      return matrixTransform;
    };
    var mth = {
      rad: (deg) => {
        return deg * Math.PI / 180;
      },
      deg: (rad) => {
        return rad * 180 / Math.PI;
      },
      cos: (deg) => {
        return Math.cos(mth.rad(deg));
      },
      acos: (val, floatPrecision) => {
        return Number(mth.deg(Math.acos(val)).toFixed(floatPrecision));
      },
      sin: (deg) => {
        return Math.sin(mth.rad(deg));
      },
      asin: (val, floatPrecision) => {
        return Number(mth.deg(Math.asin(val)).toFixed(floatPrecision));
      },
      tan: (deg) => {
        return Math.tan(mth.rad(deg));
      },
      atan: (val, floatPrecision) => {
        return Number(mth.deg(Math.atan(val)).toFixed(floatPrecision));
      }
    };
    exports2.matrixToTransform = (transform, params) => {
      let floatPrecision = params.floatPrecision;
      let data = transform.data;
      let transforms = [];
      let sx = Number(Math.hypot(data[0], data[1]).toFixed(params.transformPrecision));
      let sy = Number(((data[0] * data[3] - data[1] * data[2]) / sx).toFixed(params.transformPrecision));
      let colsSum = data[0] * data[2] + data[1] * data[3];
      let rowsSum = data[0] * data[1] + data[2] * data[3];
      let scaleBefore = rowsSum != 0 || sx == sy;
      if (data[4] || data[5]) {
        transforms.push({
          name: "translate",
          data: data.slice(4, data[5] ? 6 : 5)
        });
      }
      if (!data[1] && data[2]) {
        transforms.push({
          name: "skewX",
          data: [mth.atan(data[2] / sy, floatPrecision)]
        });
      } else if (data[1] && !data[2]) {
        transforms.push({
          name: "skewY",
          data: [mth.atan(data[1] / data[0], floatPrecision)]
        });
        sx = data[0];
        sy = data[3];
      } else if (!colsSum || sx == 1 && sy == 1 || !scaleBefore) {
        if (!scaleBefore) {
          sx = (data[0] < 0 ? -1 : 1) * Math.hypot(data[0], data[2]);
          sy = (data[3] < 0 ? -1 : 1) * Math.hypot(data[1], data[3]);
          transforms.push({ name: "scale", data: [sx, sy] });
        }
        var angle = Math.min(Math.max(-1, data[0] / sx), 1), rotate = [
          mth.acos(angle, floatPrecision) * ((scaleBefore ? 1 : sy) * data[1] < 0 ? -1 : 1)
        ];
        if (rotate[0])
          transforms.push({ name: "rotate", data: rotate });
        if (rowsSum && colsSum)
          transforms.push({
            name: "skewX",
            data: [mth.atan(colsSum / (sx * sx), floatPrecision)]
          });
        if (rotate[0] && (data[4] || data[5])) {
          transforms.shift();
          var cos = data[0] / sx, sin = data[1] / (scaleBefore ? sx : sy), x = data[4] * (scaleBefore ? 1 : sy), y = data[5] * (scaleBefore ? 1 : sx), denom = (Math.pow(1 - cos, 2) + Math.pow(sin, 2)) * (scaleBefore ? 1 : sx * sy);
          rotate.push(((1 - cos) * x - sin * y) / denom);
          rotate.push(((1 - cos) * y + sin * x) / denom);
        }
      } else if (data[1] || data[2]) {
        return [transform];
      }
      if (scaleBefore && (sx != 1 || sy != 1) || !transforms.length)
        transforms.push({
          name: "scale",
          data: sx == sy ? [sx] : [sx, sy]
        });
      return transforms;
    };
    var transformToMatrix = (transform) => {
      if (transform.name === "matrix") {
        return transform.data;
      }
      switch (transform.name) {
        case "translate":
          return [1, 0, 0, 1, transform.data[0], transform.data[1] || 0];
        case "scale":
          return [
            transform.data[0],
            0,
            0,
            transform.data[1] || transform.data[0],
            0,
            0
          ];
        case "rotate":
          var cos = mth.cos(transform.data[0]), sin = mth.sin(transform.data[0]), cx = transform.data[1] || 0, cy = transform.data[2] || 0;
          return [
            cos,
            sin,
            -sin,
            cos,
            (1 - cos) * cx + sin * cy,
            (1 - cos) * cy - sin * cx
          ];
        case "skewX":
          return [1, 0, mth.tan(transform.data[0]), 1, 0, 0];
        case "skewY":
          return [1, mth.tan(transform.data[0]), 0, 1, 0, 0];
        default:
          throw Error(`Unknown transform ${transform.name}`);
      }
    };
    exports2.transformArc = (cursor, arc, transform) => {
      const x = arc[5] - cursor[0];
      const y = arc[6] - cursor[1];
      let a = arc[0];
      let b = arc[1];
      const rot = arc[2] * Math.PI / 180;
      const cos = Math.cos(rot);
      const sin = Math.sin(rot);
      if (a > 0 && b > 0) {
        let h = Math.pow(x * cos + y * sin, 2) / (4 * a * a) + Math.pow(y * cos - x * sin, 2) / (4 * b * b);
        if (h > 1) {
          h = Math.sqrt(h);
          a *= h;
          b *= h;
        }
      }
      const ellipse = [a * cos, a * sin, -b * sin, b * cos, 0, 0];
      const m = multiplyTransformMatrices(transform, ellipse);
      const lastCol = m[2] * m[2] + m[3] * m[3];
      const squareSum = m[0] * m[0] + m[1] * m[1] + lastCol;
      const root = Math.hypot(m[0] - m[3], m[1] + m[2]) * Math.hypot(m[0] + m[3], m[1] - m[2]);
      if (!root) {
        arc[0] = arc[1] = Math.sqrt(squareSum / 2);
        arc[2] = 0;
      } else {
        const majorAxisSqr = (squareSum + root) / 2;
        const minorAxisSqr = (squareSum - root) / 2;
        const major = Math.abs(majorAxisSqr - lastCol) > 1e-6;
        const sub = (major ? majorAxisSqr : minorAxisSqr) - lastCol;
        const rowsSum = m[0] * m[2] + m[1] * m[3];
        const term1 = m[0] * sub + m[2] * rowsSum;
        const term2 = m[1] * sub + m[3] * rowsSum;
        arc[0] = Math.sqrt(majorAxisSqr);
        arc[1] = Math.sqrt(minorAxisSqr);
        arc[2] = ((major ? term2 < 0 : term1 > 0) ? -1 : 1) * Math.acos((major ? term1 : term2) / Math.hypot(term1, term2)) * 180 / Math.PI;
      }
      if (transform[0] < 0 !== transform[3] < 0) {
        arc[4] = 1 - arc[4];
      }
      return arc;
    };
    var multiplyTransformMatrices = (a, b) => {
      return [
        a[0] * b[0] + a[2] * b[1],
        a[1] * b[0] + a[3] * b[1],
        a[0] * b[2] + a[2] * b[3],
        a[1] * b[2] + a[3] * b[3],
        a[0] * b[4] + a[2] * b[5] + a[4],
        a[1] * b[4] + a[3] * b[5] + a[5]
      ];
    };
  }
});

// node_modules/svgo/plugins/_applyTransforms.js
var require_applyTransforms = __commonJS({
  "node_modules/svgo/plugins/_applyTransforms.js"(exports2) {
    "use strict";
    var {
      transformsMultiply,
      transform2js,
      transformArc
    } = require_transforms();
    var { removeLeadingZero } = require_tools();
    var { referencesProps, attrsGroupsDefaults } = require_collections();
    var regNumericValues = /[-+]?(\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
    var defaultStrokeWidth = attrsGroupsDefaults.presentation["stroke-width"];
    var applyTransforms = (elem, pathData, params) => {
      if (elem.attributes.transform == null || elem.attributes.transform === "" || elem.attributes.style != null || Object.entries(elem.attributes).some(([name, value]) => referencesProps.includes(name) && value.includes("url("))) {
        return;
      }
      const matrix = transformsMultiply(transform2js(elem.attributes.transform));
      const stroke = elem.computedAttr("stroke");
      const id = elem.computedAttr("id");
      const transformPrecision = params.transformPrecision;
      if (stroke && stroke != "none") {
        if (!params.applyTransformsStroked || (matrix.data[0] != matrix.data[3] || matrix.data[1] != -matrix.data[2]) && (matrix.data[0] != -matrix.data[3] || matrix.data[1] != matrix.data[2]))
          return;
        if (id) {
          let idElem = elem;
          let hasStrokeWidth = false;
          do {
            if (idElem.attributes["stroke-width"]) {
              hasStrokeWidth = true;
            }
          } while (idElem.attributes.id !== id && !hasStrokeWidth && (idElem = idElem.parentNode));
          if (!hasStrokeWidth)
            return;
        }
        const scale = +Math.sqrt(matrix.data[0] * matrix.data[0] + matrix.data[1] * matrix.data[1]).toFixed(transformPrecision);
        if (scale !== 1) {
          const strokeWidth = elem.computedAttr("stroke-width") || defaultStrokeWidth;
          if (elem.attributes["vector-effect"] == null || elem.attributes["vector-effect"] !== "non-scaling-stroke") {
            if (elem.attributes["stroke-width"] != null) {
              elem.attributes["stroke-width"] = elem.attributes["stroke-width"].trim().replace(regNumericValues, (num) => removeLeadingZero(num * scale));
            } else {
              elem.attributes["stroke-width"] = strokeWidth.replace(regNumericValues, (num) => removeLeadingZero(num * scale));
            }
            if (elem.attributes["stroke-dashoffset"] != null) {
              elem.attributes["stroke-dashoffset"] = elem.attributes["stroke-dashoffset"].trim().replace(regNumericValues, (num) => removeLeadingZero(num * scale));
            }
            if (elem.attributes["stroke-dasharray"] != null) {
              elem.attributes["stroke-dasharray"] = elem.attributes["stroke-dasharray"].trim().replace(regNumericValues, (num) => removeLeadingZero(num * scale));
            }
          }
        }
      } else if (id) {
        return;
      }
      applyMatrixToPathData(pathData, matrix.data);
      delete elem.attributes.transform;
      return;
    };
    exports2.applyTransforms = applyTransforms;
    var transformAbsolutePoint = (matrix, x, y) => {
      const newX = matrix[0] * x + matrix[2] * y + matrix[4];
      const newY = matrix[1] * x + matrix[3] * y + matrix[5];
      return [newX, newY];
    };
    var transformRelativePoint = (matrix, x, y) => {
      const newX = matrix[0] * x + matrix[2] * y;
      const newY = matrix[1] * x + matrix[3] * y;
      return [newX, newY];
    };
    var applyMatrixToPathData = (pathData, matrix) => {
      const start = [0, 0];
      const cursor = [0, 0];
      for (const pathItem of pathData) {
        let { command, args } = pathItem;
        if (command === "M") {
          cursor[0] = args[0];
          cursor[1] = args[1];
          start[0] = cursor[0];
          start[1] = cursor[1];
          const [x, y] = transformAbsolutePoint(matrix, args[0], args[1]);
          args[0] = x;
          args[1] = y;
        }
        if (command === "m") {
          cursor[0] += args[0];
          cursor[1] += args[1];
          start[0] = cursor[0];
          start[1] = cursor[1];
          const [x, y] = transformRelativePoint(matrix, args[0], args[1]);
          args[0] = x;
          args[1] = y;
        }
        if (command === "H") {
          command = "L";
          args = [args[0], cursor[1]];
        }
        if (command === "h") {
          command = "l";
          args = [args[0], 0];
        }
        if (command === "V") {
          command = "L";
          args = [cursor[0], args[0]];
        }
        if (command === "v") {
          command = "l";
          args = [0, args[0]];
        }
        if (command === "L") {
          cursor[0] = args[0];
          cursor[1] = args[1];
          const [x, y] = transformAbsolutePoint(matrix, args[0], args[1]);
          args[0] = x;
          args[1] = y;
        }
        if (command === "l") {
          cursor[0] += args[0];
          cursor[1] += args[1];
          const [x, y] = transformRelativePoint(matrix, args[0], args[1]);
          args[0] = x;
          args[1] = y;
        }
        if (command === "C") {
          cursor[0] = args[4];
          cursor[1] = args[5];
          const [x1, y1] = transformAbsolutePoint(matrix, args[0], args[1]);
          const [x2, y2] = transformAbsolutePoint(matrix, args[2], args[3]);
          const [x, y] = transformAbsolutePoint(matrix, args[4], args[5]);
          args[0] = x1;
          args[1] = y1;
          args[2] = x2;
          args[3] = y2;
          args[4] = x;
          args[5] = y;
        }
        if (command === "c") {
          cursor[0] += args[4];
          cursor[1] += args[5];
          const [x1, y1] = transformRelativePoint(matrix, args[0], args[1]);
          const [x2, y2] = transformRelativePoint(matrix, args[2], args[3]);
          const [x, y] = transformRelativePoint(matrix, args[4], args[5]);
          args[0] = x1;
          args[1] = y1;
          args[2] = x2;
          args[3] = y2;
          args[4] = x;
          args[5] = y;
        }
        if (command === "S") {
          cursor[0] = args[2];
          cursor[1] = args[3];
          const [x2, y2] = transformAbsolutePoint(matrix, args[0], args[1]);
          const [x, y] = transformAbsolutePoint(matrix, args[2], args[3]);
          args[0] = x2;
          args[1] = y2;
          args[2] = x;
          args[3] = y;
        }
        if (command === "s") {
          cursor[0] += args[2];
          cursor[1] += args[3];
          const [x2, y2] = transformRelativePoint(matrix, args[0], args[1]);
          const [x, y] = transformRelativePoint(matrix, args[2], args[3]);
          args[0] = x2;
          args[1] = y2;
          args[2] = x;
          args[3] = y;
        }
        if (command === "Q") {
          cursor[0] = args[2];
          cursor[1] = args[3];
          const [x1, y1] = transformAbsolutePoint(matrix, args[0], args[1]);
          const [x, y] = transformAbsolutePoint(matrix, args[2], args[3]);
          args[0] = x1;
          args[1] = y1;
          args[2] = x;
          args[3] = y;
        }
        if (command === "q") {
          cursor[0] += args[2];
          cursor[1] += args[3];
          const [x1, y1] = transformRelativePoint(matrix, args[0], args[1]);
          const [x, y] = transformRelativePoint(matrix, args[2], args[3]);
          args[0] = x1;
          args[1] = y1;
          args[2] = x;
          args[3] = y;
        }
        if (command === "T") {
          cursor[0] = args[0];
          cursor[1] = args[1];
          const [x, y] = transformAbsolutePoint(matrix, args[0], args[1]);
          args[0] = x;
          args[1] = y;
        }
        if (command === "t") {
          cursor[0] += args[0];
          cursor[1] += args[1];
          const [x, y] = transformRelativePoint(matrix, args[0], args[1]);
          args[0] = x;
          args[1] = y;
        }
        if (command === "A") {
          transformArc(cursor, args, matrix);
          cursor[0] = args[5];
          cursor[1] = args[6];
          if (Math.abs(args[2]) > 80) {
            const a = args[0];
            const rotation = args[2];
            args[0] = args[1];
            args[1] = a;
            args[2] = rotation + (rotation > 0 ? -90 : 90);
          }
          const [x, y] = transformAbsolutePoint(matrix, args[5], args[6]);
          args[5] = x;
          args[6] = y;
        }
        if (command === "a") {
          transformArc([0, 0], args, matrix);
          cursor[0] += args[5];
          cursor[1] += args[6];
          if (Math.abs(args[2]) > 80) {
            const a = args[0];
            const rotation = args[2];
            args[0] = args[1];
            args[1] = a;
            args[2] = rotation + (rotation > 0 ? -90 : 90);
          }
          const [x, y] = transformRelativePoint(matrix, args[5], args[6]);
          args[5] = x;
          args[6] = y;
        }
        if (command === "z" || command === "Z") {
          cursor[0] = start[0];
          cursor[1] = start[1];
        }
        pathItem.command = command;
        pathItem.args = args;
      }
    };
  }
});

// node_modules/svgo/plugins/convertPathData.js
var require_convertPathData = __commonJS({
  "node_modules/svgo/plugins/convertPathData.js"(exports2) {
    "use strict";
    var { collectStylesheet, computeStyle } = require_style();
    var { pathElems } = require_collections();
    var { path2js, js2path } = require_path2();
    var { applyTransforms } = require_applyTransforms();
    var { cleanupOutData } = require_tools();
    exports2.name = "convertPathData";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "optimizes path data: writes in shorter form, applies transformations";
    exports2.params = {
      applyTransforms: true,
      applyTransformsStroked: true,
      makeArcs: {
        threshold: 2.5,
        tolerance: 0.5
      },
      straightCurves: true,
      lineShorthands: true,
      curveSmoothShorthands: true,
      floatPrecision: 3,
      transformPrecision: 5,
      removeUseless: true,
      collapseRepeated: true,
      utilizeAbsolute: true,
      leadingZero: true,
      negativeExtraSpace: true,
      noSpaceAfterFlags: false,
      forceAbsolutePath: false
    };
    var roundData;
    var precision;
    var error;
    var arcThreshold;
    var arcTolerance;
    exports2.fn = (root, params) => {
      const stylesheet = collectStylesheet(root);
      return {
        element: {
          enter: (node) => {
            if (pathElems.includes(node.name) && node.attributes.d != null) {
              const computedStyle = computeStyle(stylesheet, node);
              precision = params.floatPrecision;
              error = precision !== false ? +Math.pow(0.1, precision).toFixed(precision) : 0.01;
              roundData = precision > 0 && precision < 20 ? strongRound : round;
              if (params.makeArcs) {
                arcThreshold = params.makeArcs.threshold;
                arcTolerance = params.makeArcs.tolerance;
              }
              const hasMarkerMid = computedStyle["marker-mid"] != null;
              const maybeHasStroke = computedStyle.stroke && (computedStyle.stroke.type === "dynamic" || computedStyle.stroke.value !== "none");
              const maybeHasLinecap = computedStyle["stroke-linecap"] && (computedStyle["stroke-linecap"].type === "dynamic" || computedStyle["stroke-linecap"].value !== "butt");
              const maybeHasStrokeAndLinecap = maybeHasStroke && maybeHasLinecap;
              var data = path2js(node);
              if (data.length) {
                if (params.applyTransforms) {
                  applyTransforms(node, data, params);
                }
                convertToRelative(data);
                data = filters(data, params, {
                  maybeHasStrokeAndLinecap,
                  hasMarkerMid
                });
                if (params.utilizeAbsolute) {
                  data = convertToMixed(data, params);
                }
                js2path(node, data, params);
              }
            }
          }
        }
      };
    };
    var convertToRelative = (pathData) => {
      let start = [0, 0];
      let cursor = [0, 0];
      let prevCoords = [0, 0];
      for (let i = 0; i < pathData.length; i += 1) {
        const pathItem = pathData[i];
        let { command, args } = pathItem;
        if (command === "m") {
          cursor[0] += args[0];
          cursor[1] += args[1];
          start[0] = cursor[0];
          start[1] = cursor[1];
        }
        if (command === "M") {
          if (i !== 0) {
            command = "m";
          }
          args[0] -= cursor[0];
          args[1] -= cursor[1];
          cursor[0] += args[0];
          cursor[1] += args[1];
          start[0] = cursor[0];
          start[1] = cursor[1];
        }
        if (command === "l") {
          cursor[0] += args[0];
          cursor[1] += args[1];
        }
        if (command === "L") {
          command = "l";
          args[0] -= cursor[0];
          args[1] -= cursor[1];
          cursor[0] += args[0];
          cursor[1] += args[1];
        }
        if (command === "h") {
          cursor[0] += args[0];
        }
        if (command === "H") {
          command = "h";
          args[0] -= cursor[0];
          cursor[0] += args[0];
        }
        if (command === "v") {
          cursor[1] += args[0];
        }
        if (command === "V") {
          command = "v";
          args[0] -= cursor[1];
          cursor[1] += args[0];
        }
        if (command === "c") {
          cursor[0] += args[4];
          cursor[1] += args[5];
        }
        if (command === "C") {
          command = "c";
          args[0] -= cursor[0];
          args[1] -= cursor[1];
          args[2] -= cursor[0];
          args[3] -= cursor[1];
          args[4] -= cursor[0];
          args[5] -= cursor[1];
          cursor[0] += args[4];
          cursor[1] += args[5];
        }
        if (command === "s") {
          cursor[0] += args[2];
          cursor[1] += args[3];
        }
        if (command === "S") {
          command = "s";
          args[0] -= cursor[0];
          args[1] -= cursor[1];
          args[2] -= cursor[0];
          args[3] -= cursor[1];
          cursor[0] += args[2];
          cursor[1] += args[3];
        }
        if (command === "q") {
          cursor[0] += args[2];
          cursor[1] += args[3];
        }
        if (command === "Q") {
          command = "q";
          args[0] -= cursor[0];
          args[1] -= cursor[1];
          args[2] -= cursor[0];
          args[3] -= cursor[1];
          cursor[0] += args[2];
          cursor[1] += args[3];
        }
        if (command === "t") {
          cursor[0] += args[0];
          cursor[1] += args[1];
        }
        if (command === "T") {
          command = "t";
          args[0] -= cursor[0];
          args[1] -= cursor[1];
          cursor[0] += args[0];
          cursor[1] += args[1];
        }
        if (command === "a") {
          cursor[0] += args[5];
          cursor[1] += args[6];
        }
        if (command === "A") {
          command = "a";
          args[5] -= cursor[0];
          args[6] -= cursor[1];
          cursor[0] += args[5];
          cursor[1] += args[6];
        }
        if (command === "Z" || command === "z") {
          cursor[0] = start[0];
          cursor[1] = start[1];
        }
        pathItem.command = command;
        pathItem.args = args;
        pathItem.base = prevCoords;
        pathItem.coords = [cursor[0], cursor[1]];
        prevCoords = pathItem.coords;
      }
      return pathData;
    };
    function filters(path, params, { maybeHasStrokeAndLinecap, hasMarkerMid }) {
      var stringify = data2Path.bind(null, params), relSubpoint = [0, 0], pathBase = [0, 0], prev = {};
      path = path.filter(function(item, index, path2) {
        let command = item.command;
        let data = item.args;
        let next = path2[index + 1];
        if (command !== "Z" && command !== "z") {
          var sdata = data, circle;
          if (command === "s") {
            sdata = [0, 0].concat(data);
            if (command === "c" || command === "s") {
              var pdata = prev.args, n = pdata.length;
              sdata[0] = pdata[n - 2] - pdata[n - 4];
              sdata[1] = pdata[n - 1] - pdata[n - 3];
            }
          }
          if (params.makeArcs && (command == "c" || command == "s") && isConvex(sdata) && (circle = findCircle(sdata))) {
            var r = roundData([circle.radius])[0], angle = findArcAngle(sdata, circle), sweep = sdata[5] * sdata[0] - sdata[4] * sdata[1] > 0 ? 1 : 0, arc = {
              command: "a",
              args: [r, r, 0, 0, sweep, sdata[4], sdata[5]],
              coords: item.coords.slice(),
              base: item.base
            }, output = [arc], relCenter = [
              circle.center[0] - sdata[4],
              circle.center[1] - sdata[5]
            ], relCircle = { center: relCenter, radius: circle.radius }, arcCurves = [item], hasPrev = 0, suffix = "", nextLonghand;
            if (prev.command == "c" && isConvex(prev.args) && isArcPrev(prev.args, circle) || prev.command == "a" && prev.sdata && isArcPrev(prev.sdata, circle)) {
              arcCurves.unshift(prev);
              arc.base = prev.base;
              arc.args[5] = arc.coords[0] - arc.base[0];
              arc.args[6] = arc.coords[1] - arc.base[1];
              var prevData = prev.command == "a" ? prev.sdata : prev.args;
              var prevAngle = findArcAngle(prevData, {
                center: [
                  prevData[4] + circle.center[0],
                  prevData[5] + circle.center[1]
                ],
                radius: circle.radius
              });
              angle += prevAngle;
              if (angle > Math.PI)
                arc.args[3] = 1;
              hasPrev = 1;
            }
            for (var j = index; (next = path2[++j]) && ~"cs".indexOf(next.command); ) {
              var nextData = next.args;
              if (next.command == "s") {
                nextLonghand = makeLonghand({ command: "s", args: next.args.slice() }, path2[j - 1].args);
                nextData = nextLonghand.args;
                nextLonghand.args = nextData.slice(0, 2);
                suffix = stringify([nextLonghand]);
              }
              if (isConvex(nextData) && isArc(nextData, relCircle)) {
                angle += findArcAngle(nextData, relCircle);
                if (angle - 2 * Math.PI > 1e-3)
                  break;
                if (angle > Math.PI)
                  arc.args[3] = 1;
                arcCurves.push(next);
                if (2 * Math.PI - angle > 1e-3) {
                  arc.coords = next.coords;
                  arc.args[5] = arc.coords[0] - arc.base[0];
                  arc.args[6] = arc.coords[1] - arc.base[1];
                } else {
                  arc.args[5] = 2 * (relCircle.center[0] - nextData[4]);
                  arc.args[6] = 2 * (relCircle.center[1] - nextData[5]);
                  arc.coords = [
                    arc.base[0] + arc.args[5],
                    arc.base[1] + arc.args[6]
                  ];
                  arc = {
                    command: "a",
                    args: [
                      r,
                      r,
                      0,
                      0,
                      sweep,
                      next.coords[0] - arc.coords[0],
                      next.coords[1] - arc.coords[1]
                    ],
                    coords: next.coords,
                    base: arc.coords
                  };
                  output.push(arc);
                  j++;
                  break;
                }
                relCenter[0] -= nextData[4];
                relCenter[1] -= nextData[5];
              } else
                break;
            }
            if ((stringify(output) + suffix).length < stringify(arcCurves).length) {
              if (path2[j] && path2[j].command == "s") {
                makeLonghand(path2[j], path2[j - 1].args);
              }
              if (hasPrev) {
                var prevArc = output.shift();
                roundData(prevArc.args);
                relSubpoint[0] += prevArc.args[5] - prev.args[prev.args.length - 2];
                relSubpoint[1] += prevArc.args[6] - prev.args[prev.args.length - 1];
                prev.command = "a";
                prev.args = prevArc.args;
                item.base = prev.coords = prevArc.coords;
              }
              arc = output.shift();
              if (arcCurves.length == 1) {
                item.sdata = sdata.slice();
              } else if (arcCurves.length - 1 - hasPrev > 0) {
                path2.splice.apply(path2, [index + 1, arcCurves.length - 1 - hasPrev].concat(output));
              }
              if (!arc)
                return false;
              command = "a";
              data = arc.args;
              item.coords = arc.coords;
            }
          }
          if (precision !== false) {
            if (command === "m" || command === "l" || command === "t" || command === "q" || command === "s" || command === "c") {
              for (var i = data.length; i--; ) {
                data[i] += item.base[i % 2] - relSubpoint[i % 2];
              }
            } else if (command == "h") {
              data[0] += item.base[0] - relSubpoint[0];
            } else if (command == "v") {
              data[0] += item.base[1] - relSubpoint[1];
            } else if (command == "a") {
              data[5] += item.base[0] - relSubpoint[0];
              data[6] += item.base[1] - relSubpoint[1];
            }
            roundData(data);
            if (command == "h")
              relSubpoint[0] += data[0];
            else if (command == "v")
              relSubpoint[1] += data[0];
            else {
              relSubpoint[0] += data[data.length - 2];
              relSubpoint[1] += data[data.length - 1];
            }
            roundData(relSubpoint);
            if (command === "M" || command === "m") {
              pathBase[0] = relSubpoint[0];
              pathBase[1] = relSubpoint[1];
            }
          }
          if (params.straightCurves) {
            if (command === "c" && isCurveStraightLine(data) || command === "s" && isCurveStraightLine(sdata)) {
              if (next && next.command == "s")
                makeLonghand(next, data);
              command = "l";
              data = data.slice(-2);
            } else if (command === "q" && isCurveStraightLine(data)) {
              if (next && next.command == "t")
                makeLonghand(next, data);
              command = "l";
              data = data.slice(-2);
            } else if (command === "t" && prev.command !== "q" && prev.command !== "t") {
              command = "l";
              data = data.slice(-2);
            } else if (command === "a" && (data[0] === 0 || data[1] === 0)) {
              command = "l";
              data = data.slice(-2);
            }
          }
          if (params.lineShorthands && command === "l") {
            if (data[1] === 0) {
              command = "h";
              data.pop();
            } else if (data[0] === 0) {
              command = "v";
              data.shift();
            }
          }
          if (params.collapseRepeated && hasMarkerMid === false && (command === "m" || command === "h" || command === "v") && prev.command && command == prev.command.toLowerCase() && (command != "h" && command != "v" || prev.args[0] >= 0 == data[0] >= 0)) {
            prev.args[0] += data[0];
            if (command != "h" && command != "v") {
              prev.args[1] += data[1];
            }
            prev.coords = item.coords;
            path2[index] = prev;
            return false;
          }
          if (params.curveSmoothShorthands && prev.command) {
            if (command === "c") {
              if (prev.command === "c" && data[0] === -(prev.args[2] - prev.args[4]) && data[1] === -(prev.args[3] - prev.args[5])) {
                command = "s";
                data = data.slice(2);
              } else if (prev.command === "s" && data[0] === -(prev.args[0] - prev.args[2]) && data[1] === -(prev.args[1] - prev.args[3])) {
                command = "s";
                data = data.slice(2);
              } else if (prev.command !== "c" && prev.command !== "s" && data[0] === 0 && data[1] === 0) {
                command = "s";
                data = data.slice(2);
              }
            } else if (command === "q") {
              if (prev.command === "q" && data[0] === prev.args[2] - prev.args[0] && data[1] === prev.args[3] - prev.args[1]) {
                command = "t";
                data = data.slice(2);
              } else if (prev.command === "t" && data[2] === prev.args[0] && data[3] === prev.args[1]) {
                command = "t";
                data = data.slice(2);
              }
            }
          }
          if (params.removeUseless && !maybeHasStrokeAndLinecap) {
            if ((command === "l" || command === "h" || command === "v" || command === "q" || command === "t" || command === "c" || command === "s") && data.every(function(i2) {
              return i2 === 0;
            })) {
              path2[index] = prev;
              return false;
            }
            if (command === "a" && data[5] === 0 && data[6] === 0) {
              path2[index] = prev;
              return false;
            }
          }
          item.command = command;
          item.args = data;
          prev = item;
        } else {
          relSubpoint[0] = pathBase[0];
          relSubpoint[1] = pathBase[1];
          if (prev.command === "Z" || prev.command === "z")
            return false;
          prev = item;
        }
        return true;
      });
      return path;
    }
    function convertToMixed(path, params) {
      var prev = path[0];
      path = path.filter(function(item, index) {
        if (index == 0)
          return true;
        if (item.command === "Z" || item.command === "z") {
          prev = item;
          return true;
        }
        var command = item.command, data = item.args, adata = data.slice();
        if (command === "m" || command === "l" || command === "t" || command === "q" || command === "s" || command === "c") {
          for (var i = adata.length; i--; ) {
            adata[i] += item.base[i % 2];
          }
        } else if (command == "h") {
          adata[0] += item.base[0];
        } else if (command == "v") {
          adata[0] += item.base[1];
        } else if (command == "a") {
          adata[5] += item.base[0];
          adata[6] += item.base[1];
        }
        roundData(adata);
        var absoluteDataStr = cleanupOutData(adata, params), relativeDataStr = cleanupOutData(data, params);
        if (params.forceAbsolutePath || absoluteDataStr.length < relativeDataStr.length && !(params.negativeExtraSpace && command == prev.command && prev.command.charCodeAt(0) > 96 && absoluteDataStr.length == relativeDataStr.length - 1 && (data[0] < 0 || /^0\./.test(data[0]) && prev.args[prev.args.length - 1] % 1))) {
          item.command = command.toUpperCase();
          item.args = adata;
        }
        prev = item;
        return true;
      });
      return path;
    }
    function isConvex(data) {
      var center = getIntersection([
        0,
        0,
        data[2],
        data[3],
        data[0],
        data[1],
        data[4],
        data[5]
      ]);
      return center && data[2] < center[0] == center[0] < 0 && data[3] < center[1] == center[1] < 0 && data[4] < center[0] == center[0] < data[0] && data[5] < center[1] == center[1] < data[1];
    }
    function getIntersection(coords) {
      var a1 = coords[1] - coords[3], b1 = coords[2] - coords[0], c1 = coords[0] * coords[3] - coords[2] * coords[1], a2 = coords[5] - coords[7], b2 = coords[6] - coords[4], c2 = coords[4] * coords[7] - coords[5] * coords[6], denom = a1 * b2 - a2 * b1;
      if (!denom)
        return;
      var cross = [(b1 * c2 - b2 * c1) / denom, (a1 * c2 - a2 * c1) / -denom];
      if (!isNaN(cross[0]) && !isNaN(cross[1]) && isFinite(cross[0]) && isFinite(cross[1])) {
        return cross;
      }
    }
    function strongRound(data) {
      for (var i = data.length; i-- > 0; ) {
        if (data[i].toFixed(precision) != data[i]) {
          var rounded = +data[i].toFixed(precision - 1);
          data[i] = +Math.abs(rounded - data[i]).toFixed(precision + 1) >= error ? +data[i].toFixed(precision) : rounded;
        }
      }
      return data;
    }
    function round(data) {
      for (var i = data.length; i-- > 0; ) {
        data[i] = Math.round(data[i]);
      }
      return data;
    }
    function isCurveStraightLine(data) {
      var i = data.length - 2, a = -data[i + 1], b = data[i], d = 1 / (a * a + b * b);
      if (i <= 1 || !isFinite(d))
        return false;
      while ((i -= 2) >= 0) {
        if (Math.sqrt(Math.pow(a * data[i] + b * data[i + 1], 2) * d) > error)
          return false;
      }
      return true;
    }
    function makeLonghand(item, data) {
      switch (item.command) {
        case "s":
          item.command = "c";
          break;
        case "t":
          item.command = "q";
          break;
      }
      item.args.unshift(data[data.length - 2] - data[data.length - 4], data[data.length - 1] - data[data.length - 3]);
      return item;
    }
    function getDistance(point1, point2) {
      return Math.hypot(point1[0] - point2[0], point1[1] - point2[1]);
    }
    function getCubicBezierPoint(curve, t) {
      var sqrT = t * t, cubT = sqrT * t, mt = 1 - t, sqrMt = mt * mt;
      return [
        3 * sqrMt * t * curve[0] + 3 * mt * sqrT * curve[2] + cubT * curve[4],
        3 * sqrMt * t * curve[1] + 3 * mt * sqrT * curve[3] + cubT * curve[5]
      ];
    }
    function findCircle(curve) {
      var midPoint = getCubicBezierPoint(curve, 1 / 2), m1 = [midPoint[0] / 2, midPoint[1] / 2], m2 = [(midPoint[0] + curve[4]) / 2, (midPoint[1] + curve[5]) / 2], center = getIntersection([
        m1[0],
        m1[1],
        m1[0] + m1[1],
        m1[1] - m1[0],
        m2[0],
        m2[1],
        m2[0] + (m2[1] - midPoint[1]),
        m2[1] - (m2[0] - midPoint[0])
      ]), radius = center && getDistance([0, 0], center), tolerance = Math.min(arcThreshold * error, arcTolerance * radius / 100);
      if (center && radius < 1e15 && [1 / 4, 3 / 4].every(function(point) {
        return Math.abs(getDistance(getCubicBezierPoint(curve, point), center) - radius) <= tolerance;
      }))
        return { center, radius };
    }
    function isArc(curve, circle) {
      var tolerance = Math.min(arcThreshold * error, arcTolerance * circle.radius / 100);
      return [0, 1 / 4, 1 / 2, 3 / 4, 1].every(function(point) {
        return Math.abs(getDistance(getCubicBezierPoint(curve, point), circle.center) - circle.radius) <= tolerance;
      });
    }
    function isArcPrev(curve, circle) {
      return isArc(curve, {
        center: [circle.center[0] + curve[4], circle.center[1] + curve[5]],
        radius: circle.radius
      });
    }
    function findArcAngle(curve, relCircle) {
      var x1 = -relCircle.center[0], y1 = -relCircle.center[1], x2 = curve[4] - relCircle.center[0], y2 = curve[5] - relCircle.center[1];
      return Math.acos((x1 * x2 + y1 * y2) / Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2)));
    }
    function data2Path(params, pathData) {
      return pathData.reduce(function(pathString, item) {
        var strData = "";
        if (item.args) {
          strData = cleanupOutData(roundData(item.args.slice()), params);
        }
        return pathString + item.command + strData;
      }, "");
    }
  }
});

// node_modules/svgo/plugins/convertTransform.js
var require_convertTransform = __commonJS({
  "node_modules/svgo/plugins/convertTransform.js"(exports2) {
    "use strict";
    var { cleanupOutData } = require_tools();
    var {
      transform2js,
      transformsMultiply,
      matrixToTransform
    } = require_transforms();
    exports2.type = "visitor";
    exports2.name = "convertTransform";
    exports2.active = true;
    exports2.description = "collapses multiple transformations and optimizes it";
    exports2.fn = (_root, params) => {
      const {
        convertToShorts: convertToShorts2 = true,
        degPrecision,
        floatPrecision = 3,
        transformPrecision = 5,
        matrixToTransform: matrixToTransform2 = true,
        shortTranslate = true,
        shortScale = true,
        shortRotate = true,
        removeUseless: removeUseless2 = true,
        collapseIntoOne = true,
        leadingZero = true,
        negativeExtraSpace = false
      } = params;
      const newParams = {
        convertToShorts: convertToShorts2,
        degPrecision,
        floatPrecision,
        transformPrecision,
        matrixToTransform: matrixToTransform2,
        shortTranslate,
        shortScale,
        shortRotate,
        removeUseless: removeUseless2,
        collapseIntoOne,
        leadingZero,
        negativeExtraSpace
      };
      return {
        element: {
          enter: (node) => {
            if (node.attributes.transform != null) {
              convertTransform(node, "transform", newParams);
            }
            if (node.attributes.gradientTransform != null) {
              convertTransform(node, "gradientTransform", newParams);
            }
            if (node.attributes.patternTransform != null) {
              convertTransform(node, "patternTransform", newParams);
            }
          }
        }
      };
    };
    var convertTransform = (item, attrName, params) => {
      let data = transform2js(item.attributes[attrName]);
      params = definePrecision(data, params);
      if (params.collapseIntoOne && data.length > 1) {
        data = [transformsMultiply(data)];
      }
      if (params.convertToShorts) {
        data = convertToShorts(data, params);
      } else {
        data.forEach((item2) => roundTransform(item2, params));
      }
      if (params.removeUseless) {
        data = removeUseless(data);
      }
      if (data.length) {
        item.attributes[attrName] = js2transform(data, params);
      } else {
        delete item.attributes[attrName];
      }
    };
    var definePrecision = (data, { ...newParams }) => {
      const matrixData = [];
      for (const item of data) {
        if (item.name == "matrix") {
          matrixData.push(...item.data.slice(0, 4));
        }
      }
      let significantDigits = newParams.transformPrecision;
      if (matrixData.length) {
        newParams.transformPrecision = Math.min(newParams.transformPrecision, Math.max.apply(Math, matrixData.map(floatDigits)) || newParams.transformPrecision);
        significantDigits = Math.max.apply(Math, matrixData.map((n) => n.toString().replace(/\D+/g, "").length));
      }
      if (newParams.degPrecision == null) {
        newParams.degPrecision = Math.max(0, Math.min(newParams.floatPrecision, significantDigits - 2));
      }
      return newParams;
    };
    var degRound = (data, params) => {
      if (params.degPrecision != null && params.degPrecision >= 1 && params.floatPrecision < 20) {
        return smartRound(params.degPrecision, data);
      } else {
        return round(data);
      }
    };
    var floatRound = (data, params) => {
      if (params.floatPrecision >= 1 && params.floatPrecision < 20) {
        return smartRound(params.floatPrecision, data);
      } else {
        return round(data);
      }
    };
    var transformRound = (data, params) => {
      if (params.transformPrecision >= 1 && params.floatPrecision < 20) {
        return smartRound(params.transformPrecision, data);
      } else {
        return round(data);
      }
    };
    var floatDigits = (n) => {
      const str = n.toString();
      return str.slice(str.indexOf(".")).length - 1;
    };
    var convertToShorts = (transforms, params) => {
      for (var i = 0; i < transforms.length; i++) {
        var transform = transforms[i];
        if (params.matrixToTransform && transform.name === "matrix") {
          var decomposed = matrixToTransform(transform, params);
          if (js2transform(decomposed, params).length <= js2transform([transform], params).length) {
            transforms.splice(i, 1, ...decomposed);
          }
          transform = transforms[i];
        }
        roundTransform(transform, params);
        if (params.shortTranslate && transform.name === "translate" && transform.data.length === 2 && !transform.data[1]) {
          transform.data.pop();
        }
        if (params.shortScale && transform.name === "scale" && transform.data.length === 2 && transform.data[0] === transform.data[1]) {
          transform.data.pop();
        }
        if (params.shortRotate && transforms[i - 2] && transforms[i - 2].name === "translate" && transforms[i - 1].name === "rotate" && transforms[i].name === "translate" && transforms[i - 2].data[0] === -transforms[i].data[0] && transforms[i - 2].data[1] === -transforms[i].data[1]) {
          transforms.splice(i - 2, 3, {
            name: "rotate",
            data: [
              transforms[i - 1].data[0],
              transforms[i - 2].data[0],
              transforms[i - 2].data[1]
            ]
          });
          i -= 2;
        }
      }
      return transforms;
    };
    var removeUseless = (transforms) => {
      return transforms.filter((transform) => {
        if (["translate", "rotate", "skewX", "skewY"].indexOf(transform.name) > -1 && (transform.data.length == 1 || transform.name == "rotate") && !transform.data[0] || transform.name == "translate" && !transform.data[0] && !transform.data[1] || transform.name == "scale" && transform.data[0] == 1 && (transform.data.length < 2 || transform.data[1] == 1) || transform.name == "matrix" && transform.data[0] == 1 && transform.data[3] == 1 && !(transform.data[1] || transform.data[2] || transform.data[4] || transform.data[5])) {
          return false;
        }
        return true;
      });
    };
    var js2transform = (transformJS, params) => {
      var transformString = "";
      transformJS.forEach((transform) => {
        roundTransform(transform, params);
        transformString += (transformString && " ") + transform.name + "(" + cleanupOutData(transform.data, params) + ")";
      });
      return transformString;
    };
    var roundTransform = (transform, params) => {
      switch (transform.name) {
        case "translate":
          transform.data = floatRound(transform.data, params);
          break;
        case "rotate":
          transform.data = [
            ...degRound(transform.data.slice(0, 1), params),
            ...floatRound(transform.data.slice(1), params)
          ];
          break;
        case "skewX":
        case "skewY":
          transform.data = degRound(transform.data, params);
          break;
        case "scale":
          transform.data = transformRound(transform.data, params);
          break;
        case "matrix":
          transform.data = [
            ...transformRound(transform.data.slice(0, 4), params),
            ...floatRound(transform.data.slice(4), params)
          ];
          break;
      }
      return transform;
    };
    var round = (data) => {
      return data.map(Math.round);
    };
    var smartRound = (precision, data) => {
      for (var i = data.length, tolerance = +Math.pow(0.1, precision).toFixed(precision); i--; ) {
        if (Number(data[i].toFixed(precision)) !== data[i]) {
          var rounded = +data[i].toFixed(precision - 1);
          data[i] = +Math.abs(rounded - data[i]).toFixed(precision + 1) >= tolerance ? +data[i].toFixed(precision) : rounded;
        }
      }
      return data;
    };
  }
});

// node_modules/svgo/plugins/removeEmptyAttrs.js
var require_removeEmptyAttrs = __commonJS({
  "node_modules/svgo/plugins/removeEmptyAttrs.js"(exports2) {
    "use strict";
    var { attrsGroups } = require_collections();
    exports2.type = "visitor";
    exports2.name = "removeEmptyAttrs";
    exports2.active = true;
    exports2.description = "removes empty attributes";
    exports2.fn = () => {
      return {
        element: {
          enter: (node) => {
            for (const [name, value] of Object.entries(node.attributes)) {
              if (value === "" && attrsGroups.conditionalProcessing.includes(name) === false) {
                delete node.attributes[name];
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeEmptyContainers.js
var require_removeEmptyContainers = __commonJS({
  "node_modules/svgo/plugins/removeEmptyContainers.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    var { elemsGroups } = require_collections();
    exports2.type = "visitor";
    exports2.name = "removeEmptyContainers";
    exports2.active = true;
    exports2.description = "removes empty container elements";
    exports2.fn = () => {
      return {
        element: {
          exit: (node, parentNode) => {
            if (node.name === "svg" || elemsGroups.container.includes(node.name) === false || node.children.length !== 0) {
              return;
            }
            if (node.name === "pattern" && Object.keys(node.attributes).length !== 0) {
              return;
            }
            if (node.name === "g" && node.attributes.filter != null) {
              return;
            }
            if (node.name === "mask" && node.attributes.id != null) {
              return;
            }
            detachNodeFromParent(node, parentNode);
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/mergePaths.js
var require_mergePaths = __commonJS({
  "node_modules/svgo/plugins/mergePaths.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    var { collectStylesheet, computeStyle } = require_style();
    var { path2js, js2path, intersects } = require_path2();
    exports2.type = "visitor";
    exports2.name = "mergePaths";
    exports2.active = true;
    exports2.description = "merges multiple paths in one if possible";
    exports2.fn = (root, params) => {
      const {
        force = false,
        floatPrecision,
        noSpaceAfterFlags = false
      } = params;
      const stylesheet = collectStylesheet(root);
      return {
        element: {
          enter: (node) => {
            let prevChild = null;
            for (const child of node.children) {
              if (prevChild == null || prevChild.type !== "element" || prevChild.name !== "path" || prevChild.children.length !== 0 || prevChild.attributes.d == null) {
                prevChild = child;
                continue;
              }
              if (child.type !== "element" || child.name !== "path" || child.children.length !== 0 || child.attributes.d == null) {
                prevChild = child;
                continue;
              }
              const computedStyle = computeStyle(stylesheet, child);
              if (computedStyle["marker-start"] || computedStyle["marker-mid"] || computedStyle["marker-end"]) {
                prevChild = child;
                continue;
              }
              const prevChildAttrs = Object.keys(prevChild.attributes);
              const childAttrs = Object.keys(child.attributes);
              let attributesAreEqual = prevChildAttrs.length === childAttrs.length;
              for (const name of childAttrs) {
                if (name !== "d") {
                  if (prevChild.attributes[name] == null || prevChild.attributes[name] !== child.attributes[name]) {
                    attributesAreEqual = false;
                  }
                }
              }
              const prevPathJS = path2js(prevChild);
              const curPathJS = path2js(child);
              if (attributesAreEqual && (force || !intersects(prevPathJS, curPathJS))) {
                js2path(prevChild, prevPathJS.concat(curPathJS), {
                  floatPrecision,
                  noSpaceAfterFlags
                });
                detachNodeFromParent(child, node);
                continue;
              }
              prevChild = child;
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeUnusedNS.js
var require_removeUnusedNS = __commonJS({
  "node_modules/svgo/plugins/removeUnusedNS.js"(exports2) {
    "use strict";
    exports2.type = "visitor";
    exports2.name = "removeUnusedNS";
    exports2.active = true;
    exports2.description = "removes unused namespaces declaration";
    exports2.fn = () => {
      const unusedNamespaces = /* @__PURE__ */ new Set();
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "svg" && parentNode.type === "root") {
              for (const name of Object.keys(node.attributes)) {
                if (name.startsWith("xmlns:")) {
                  const local = name.slice("xmlns:".length);
                  unusedNamespaces.add(local);
                }
              }
            }
            if (unusedNamespaces.size !== 0) {
              if (node.name.includes(":")) {
                const [ns] = node.name.split(":");
                if (unusedNamespaces.has(ns)) {
                  unusedNamespaces.delete(ns);
                }
              }
              for (const name of Object.keys(node.attributes)) {
                if (name.includes(":")) {
                  const [ns] = name.split(":");
                  unusedNamespaces.delete(ns);
                }
              }
            }
          },
          exit: (node, parentNode) => {
            if (node.name === "svg" && parentNode.type === "root") {
              for (const name of unusedNamespaces) {
                delete node.attributes[`xmlns:${name}`];
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/sortDefsChildren.js
var require_sortDefsChildren = __commonJS({
  "node_modules/svgo/plugins/sortDefsChildren.js"(exports2) {
    "use strict";
    exports2.type = "visitor";
    exports2.name = "sortDefsChildren";
    exports2.active = true;
    exports2.description = "Sorts children of <defs> to improve compression";
    exports2.fn = () => {
      return {
        element: {
          enter: (node) => {
            if (node.name === "defs") {
              const frequencies = /* @__PURE__ */ new Map();
              for (const child of node.children) {
                if (child.type === "element") {
                  const frequency = frequencies.get(child.name);
                  if (frequency == null) {
                    frequencies.set(child.name, 1);
                  } else {
                    frequencies.set(child.name, frequency + 1);
                  }
                }
              }
              node.children.sort((a, b) => {
                if (a.type !== "element" || b.type !== "element") {
                  return 0;
                }
                const aFrequency = frequencies.get(a.name);
                const bFrequency = frequencies.get(b.name);
                if (aFrequency != null && bFrequency != null) {
                  const frequencyComparison = bFrequency - aFrequency;
                  if (frequencyComparison !== 0) {
                    return frequencyComparison;
                  }
                }
                const lengthComparison = b.name.length - a.name.length;
                if (lengthComparison !== 0) {
                  return lengthComparison;
                }
                if (a.name !== b.name) {
                  return a.name > b.name ? -1 : 1;
                }
                return 0;
              });
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeTitle.js
var require_removeTitle = __commonJS({
  "node_modules/svgo/plugins/removeTitle.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeTitle";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "removes <title>";
    exports2.fn = () => {
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "title") {
              detachNodeFromParent(node, parentNode);
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeDesc.js
var require_removeDesc = __commonJS({
  "node_modules/svgo/plugins/removeDesc.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeDesc";
    exports2.type = "visitor";
    exports2.active = true;
    exports2.description = "removes <desc>";
    var standardDescs = /^(Created with|Created using)/;
    exports2.fn = (root, params) => {
      const { removeAny = true } = params;
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "desc") {
              if (removeAny || node.children.length === 0 || node.children[0].type === "text" && standardDescs.test(node.children[0].value)) {
                detachNodeFromParent(node, parentNode);
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/preset-default.js
var require_preset_default = __commonJS({
  "node_modules/svgo/plugins/preset-default.js"(exports2, module2) {
    "use strict";
    var { createPreset } = require_plugins();
    var removeDoctype = require_removeDoctype();
    var removeXMLProcInst = require_removeXMLProcInst();
    var removeComments = require_removeComments();
    var removeMetadata = require_removeMetadata();
    var removeEditorsNSData = require_removeEditorsNSData();
    var cleanupAttrs = require_cleanupAttrs();
    var mergeStyles = require_mergeStyles();
    var inlineStyles = require_inlineStyles();
    var minifyStyles = require_minifyStyles();
    var cleanupIDs = require_cleanupIDs();
    var removeUselessDefs = require_removeUselessDefs();
    var cleanupNumericValues = require_cleanupNumericValues();
    var convertColors = require_convertColors();
    var removeUnknownsAndDefaults = require_removeUnknownsAndDefaults();
    var removeNonInheritableGroupAttrs = require_removeNonInheritableGroupAttrs();
    var removeUselessStrokeAndFill = require_removeUselessStrokeAndFill();
    var removeViewBox = require_removeViewBox();
    var cleanupEnableBackground = require_cleanupEnableBackground();
    var removeHiddenElems = require_removeHiddenElems();
    var removeEmptyText = require_removeEmptyText();
    var convertShapeToPath = require_convertShapeToPath();
    var convertEllipseToCircle = require_convertEllipseToCircle();
    var moveElemsAttrsToGroup = require_moveElemsAttrsToGroup();
    var moveGroupAttrsToElems = require_moveGroupAttrsToElems();
    var collapseGroups = require_collapseGroups();
    var convertPathData = require_convertPathData();
    var convertTransform = require_convertTransform();
    var removeEmptyAttrs = require_removeEmptyAttrs();
    var removeEmptyContainers = require_removeEmptyContainers();
    var mergePaths = require_mergePaths();
    var removeUnusedNS = require_removeUnusedNS();
    var sortDefsChildren = require_sortDefsChildren();
    var removeTitle = require_removeTitle();
    var removeDesc = require_removeDesc();
    var presetDefault = createPreset({
      name: "presetDefault",
      plugins: [
        removeDoctype,
        removeXMLProcInst,
        removeComments,
        removeMetadata,
        removeEditorsNSData,
        cleanupAttrs,
        mergeStyles,
        inlineStyles,
        minifyStyles,
        cleanupIDs,
        removeUselessDefs,
        cleanupNumericValues,
        convertColors,
        removeUnknownsAndDefaults,
        removeNonInheritableGroupAttrs,
        removeUselessStrokeAndFill,
        removeViewBox,
        cleanupEnableBackground,
        removeHiddenElems,
        removeEmptyText,
        convertShapeToPath,
        convertEllipseToCircle,
        moveElemsAttrsToGroup,
        moveGroupAttrsToElems,
        collapseGroups,
        convertPathData,
        convertTransform,
        removeEmptyAttrs,
        removeEmptyContainers,
        mergePaths,
        removeUnusedNS,
        sortDefsChildren,
        removeTitle,
        removeDesc
      ]
    });
    module2.exports = presetDefault;
  }
});

// node_modules/svgo/plugins/addAttributesToSVGElement.js
var require_addAttributesToSVGElement = __commonJS({
  "node_modules/svgo/plugins/addAttributesToSVGElement.js"(exports2) {
    "use strict";
    exports2.name = "addAttributesToSVGElement";
    exports2.type = "visitor";
    exports2.active = false;
    exports2.description = "adds attributes to an outer <svg> element";
    var ENOCLS = `Error in plugin "addAttributesToSVGElement": absent parameters.
It should have a list of "attributes" or one "attribute".
Config example:

plugins: [
  {
    name: 'addAttributesToSVGElement',
    params: {
      attribute: "mySvg"
    }
  }
]

plugins: [
  {
    name: 'addAttributesToSVGElement',
    params: {
      attributes: ["mySvg", "size-big"]
    }
  }
]

plugins: [
  {
    name: 'addAttributesToSVGElement',
    params: {
      attributes: [
        {
          focusable: false
        },
        {
          'data-image': icon
        }
      ]
    }
  }
]
`;
    exports2.fn = (root, params) => {
      if (!Array.isArray(params.attributes) && !params.attribute) {
        console.error(ENOCLS);
        return null;
      }
      const attributes = params.attributes || [params.attribute];
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "svg" && parentNode.type === "root") {
              for (const attribute of attributes) {
                if (typeof attribute === "string") {
                  if (node.attributes[attribute] == null) {
                    node.attributes[attribute] = void 0;
                  }
                }
                if (typeof attribute === "object") {
                  for (const key of Object.keys(attribute)) {
                    if (node.attributes[key] == null) {
                      node.attributes[key] = attribute[key];
                    }
                  }
                }
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/addClassesToSVGElement.js
var require_addClassesToSVGElement = __commonJS({
  "node_modules/svgo/plugins/addClassesToSVGElement.js"(exports2) {
    "use strict";
    exports2.name = "addClassesToSVGElement";
    exports2.type = "visitor";
    exports2.active = false;
    exports2.description = "adds classnames to an outer <svg> element";
    var ENOCLS = `Error in plugin "addClassesToSVGElement": absent parameters.
It should have a list of classes in "classNames" or one "className".
Config example:

plugins: [
  {
    name: "addClassesToSVGElement",
    params: {
      className: "mySvg"
    }
  }
]

plugins: [
  {
    name: "addClassesToSVGElement",
    params: {
      classNames: ["mySvg", "size-big"]
    }
  }
]
`;
    exports2.fn = (root, params) => {
      if (!(Array.isArray(params.classNames) && params.classNames.some(String)) && !params.className) {
        console.error(ENOCLS);
        return null;
      }
      const classNames = params.classNames || [params.className];
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "svg" && parentNode.type === "root") {
              const classList = new Set(node.attributes.class == null ? null : node.attributes.class.split(" "));
              for (const className of classNames) {
                if (className != null) {
                  classList.add(className);
                }
              }
              node.attributes.class = Array.from(classList).join(" ");
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/cleanupListOfValues.js
var require_cleanupListOfValues = __commonJS({
  "node_modules/svgo/plugins/cleanupListOfValues.js"(exports2) {
    "use strict";
    var { removeLeadingZero } = require_tools();
    exports2.name = "cleanupListOfValues";
    exports2.type = "visitor";
    exports2.active = false;
    exports2.description = "rounds list of values to the fixed precision";
    var regNumericValues = /^([-+]?\d*\.?\d+([eE][-+]?\d+)?)(px|pt|pc|mm|cm|m|in|ft|em|ex|%)?$/;
    var regSeparator = /\s+,?\s*|,\s*/;
    var absoluteLengths = {
      cm: 96 / 2.54,
      mm: 96 / 25.4,
      in: 96,
      pt: 4 / 3,
      pc: 16,
      px: 1
    };
    exports2.fn = (_root, params) => {
      const {
        floatPrecision = 3,
        leadingZero = true,
        defaultPx = true,
        convertToPx = true
      } = params;
      const roundValues = (lists) => {
        const roundedList = [];
        for (const elem of lists.split(regSeparator)) {
          const match = elem.match(regNumericValues);
          const matchNew = elem.match(/new/);
          if (match) {
            let num = Number(Number(match[1]).toFixed(floatPrecision));
            let matchedUnit = match[3] || "";
            let units = matchedUnit;
            if (convertToPx && units && units in absoluteLengths) {
              const pxNum = Number((absoluteLengths[units] * Number(match[1])).toFixed(floatPrecision));
              if (pxNum.toString().length < match[0].length) {
                num = pxNum;
                units = "px";
              }
            }
            let str;
            if (leadingZero) {
              str = removeLeadingZero(num);
            } else {
              str = num.toString();
            }
            if (defaultPx && units === "px") {
              units = "";
            }
            roundedList.push(str + units);
          } else if (matchNew) {
            roundedList.push("new");
          } else if (elem) {
            roundedList.push(elem);
          }
        }
        return roundedList.join(" ");
      };
      return {
        element: {
          enter: (node) => {
            if (node.attributes.points != null) {
              node.attributes.points = roundValues(node.attributes.points);
            }
            if (node.attributes["enable-background"] != null) {
              node.attributes["enable-background"] = roundValues(node.attributes["enable-background"]);
            }
            if (node.attributes.viewBox != null) {
              node.attributes.viewBox = roundValues(node.attributes.viewBox);
            }
            if (node.attributes["stroke-dasharray"] != null) {
              node.attributes["stroke-dasharray"] = roundValues(node.attributes["stroke-dasharray"]);
            }
            if (node.attributes.dx != null) {
              node.attributes.dx = roundValues(node.attributes.dx);
            }
            if (node.attributes.dy != null) {
              node.attributes.dy = roundValues(node.attributes.dy);
            }
            if (node.attributes.x != null) {
              node.attributes.x = roundValues(node.attributes.x);
            }
            if (node.attributes.y != null) {
              node.attributes.y = roundValues(node.attributes.y);
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/convertStyleToAttrs.js
var require_convertStyleToAttrs = __commonJS({
  "node_modules/svgo/plugins/convertStyleToAttrs.js"(exports2) {
    "use strict";
    exports2.name = "convertStyleToAttrs";
    exports2.type = "perItem";
    exports2.active = false;
    exports2.description = "converts style to attributes";
    exports2.params = {
      keepImportant: false
    };
    var stylingProps = require_collections().attrsGroups.presentation;
    var rEscape = "\\\\(?:[0-9a-f]{1,6}\\s?|\\r\\n|.)";
    var rAttr = "\\s*(" + g("[^:;\\\\]", rEscape) + "*?)\\s*";
    var rSingleQuotes = "'(?:[^'\\n\\r\\\\]|" + rEscape + ")*?(?:'|$)";
    var rQuotes = '"(?:[^"\\n\\r\\\\]|' + rEscape + ')*?(?:"|$)';
    var rQuotedString = new RegExp("^" + g(rSingleQuotes, rQuotes) + "$");
    var rParenthesis = "\\(" + g(`[^'"()\\\\]+`, rEscape, rSingleQuotes, rQuotes) + "*?\\)";
    var rValue = "\\s*(" + g(`[^!'"();\\\\]+?`, rEscape, rSingleQuotes, rQuotes, rParenthesis, "[^;]*?") + "*?)";
    var rDeclEnd = "\\s*(?:;\\s*|$)";
    var rImportant = "(\\s*!important(?![-(\\w]))?";
    var regDeclarationBlock = new RegExp(rAttr + ":" + rValue + rImportant + rDeclEnd, "ig");
    var regStripComments = new RegExp(g(rEscape, rSingleQuotes, rQuotes, "/\\*[^]*?\\*/"), "ig");
    exports2.fn = function(item, params) {
      if (item.type === "element" && item.attributes.style != null) {
        let styles = [];
        const newAttributes = {};
        const styleValue = item.attributes.style.replace(regStripComments, (match) => {
          return match[0] == "/" ? "" : match[0] == "\\" && /[-g-z]/i.test(match[1]) ? match[1] : match;
        });
        regDeclarationBlock.lastIndex = 0;
        for (var rule; rule = regDeclarationBlock.exec(styleValue); ) {
          if (!params.keepImportant || !rule[3]) {
            styles.push([rule[1], rule[2]]);
          }
        }
        if (styles.length) {
          styles = styles.filter(function(style) {
            if (style[0]) {
              var prop = style[0].toLowerCase(), val = style[1];
              if (rQuotedString.test(val)) {
                val = val.slice(1, -1);
              }
              if (stylingProps.includes(prop)) {
                newAttributes[prop] = val;
                return false;
              }
            }
            return true;
          });
          Object.assign(item.attributes, newAttributes);
          if (styles.length) {
            item.attributes.style = styles.map((declaration) => declaration.join(":")).join(";");
          } else {
            delete item.attributes.style;
          }
        }
      }
    };
    function g() {
      return "(?:" + Array.prototype.join.call(arguments, "|") + ")";
    }
  }
});

// node_modules/svgo/plugins/prefixIds.js
var require_prefixIds = __commonJS({
  "node_modules/svgo/plugins/prefixIds.js"(exports2) {
    "use strict";
    var csstree = require_lib9();
    var { referencesProps } = require_collections();
    exports2.type = "visitor";
    exports2.name = "prefixIds";
    exports2.active = false;
    exports2.description = "prefix IDs";
    var getBasename = (path) => {
      const matched = path.match(/[/\\]?([^/\\]+)$/);
      if (matched) {
        return matched[1];
      }
      return "";
    };
    var escapeIdentifierName = (str) => {
      return str.replace(/[. ]/g, "_");
    };
    var unquote = (string) => {
      if (string.startsWith('"') && string.endsWith('"') || string.startsWith("'") && string.endsWith("'")) {
        return string.slice(1, -1);
      }
      return string;
    };
    var prefixId = (prefix, value) => {
      if (value.startsWith(prefix)) {
        return value;
      }
      return prefix + value;
    };
    var prefixReference = (prefix, value) => {
      if (value.startsWith("#")) {
        return "#" + prefixId(prefix, value.slice(1));
      }
      return null;
    };
    exports2.fn = (_root, params, info) => {
      const { delim = "__", prefixIds = true, prefixClassNames = true } = params;
      return {
        element: {
          enter: (node) => {
            let prefix = "prefix" + delim;
            if (typeof params.prefix === "function") {
              prefix = params.prefix(node, info) + delim;
            } else if (typeof params.prefix === "string") {
              prefix = params.prefix + delim;
            } else if (params.prefix === false) {
              prefix = "";
            } else if (info.path != null && info.path.length > 0) {
              prefix = escapeIdentifierName(getBasename(info.path)) + delim;
            }
            if (node.name === "style") {
              if (node.children.length === 0) {
                return;
              }
              let cssText = "";
              if (node.children[0].type === "text" || node.children[0].type === "cdata") {
                cssText = node.children[0].value;
              }
              let cssAst = null;
              try {
                cssAst = csstree.parse(cssText, {
                  parseValue: true,
                  parseCustomProperty: false
                });
              } catch {
                return;
              }
              csstree.walk(cssAst, (node2) => {
                if (prefixIds && node2.type === "IdSelector" || prefixClassNames && node2.type === "ClassSelector") {
                  node2.name = prefixId(prefix, node2.name);
                  return;
                }
                if (node2.type === "Url" && node2.value.value && node2.value.value.length > 0) {
                  const prefixed = prefixReference(prefix, unquote(node2.value.value));
                  if (prefixed != null) {
                    node2.value.value = prefixed;
                  }
                }
              });
              if (node.children[0].type === "text" || node.children[0].type === "cdata") {
                node.children[0].value = csstree.generate(cssAst);
              }
              return;
            }
            if (prefixIds && node.attributes.id != null && node.attributes.id.length !== 0) {
              node.attributes.id = prefixId(prefix, node.attributes.id);
            }
            if (prefixClassNames && node.attributes.class != null && node.attributes.class.length !== 0) {
              node.attributes.class = node.attributes.class.split(/\s+/).map((name) => prefixId(prefix, name)).join(" ");
            }
            for (const name of ["href", "xlink:href"]) {
              if (node.attributes[name] != null && node.attributes[name].length !== 0) {
                const prefixed = prefixReference(prefix, node.attributes[name]);
                if (prefixed != null) {
                  node.attributes[name] = prefixed;
                }
              }
            }
            for (const name of referencesProps) {
              if (node.attributes[name] != null && node.attributes[name].length !== 0) {
                node.attributes[name] = node.attributes[name].replace(/url\((.*?)\)/gi, (match, url) => {
                  const prefixed = prefixReference(prefix, url);
                  if (prefixed == null) {
                    return match;
                  }
                  return `url(${prefixed})`;
                });
              }
            }
            for (const name of ["begin", "end"]) {
              if (node.attributes[name] != null && node.attributes[name].length !== 0) {
                const parts = node.attributes[name].split(/\s*;\s+/).map((val) => {
                  if (val.endsWith(".end") || val.endsWith(".start")) {
                    const [id, postfix] = val.split(".");
                    return `${prefixId(prefix, id)}.${postfix}`;
                  }
                  return val;
                });
                node.attributes[name] = parts.join("; ");
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeAttributesBySelector.js
var require_removeAttributesBySelector = __commonJS({
  "node_modules/svgo/plugins/removeAttributesBySelector.js"(exports2) {
    "use strict";
    var { querySelectorAll } = require_xast();
    exports2.name = "removeAttributesBySelector";
    exports2.type = "visitor";
    exports2.active = false;
    exports2.description = "removes attributes of elements that match a css selector";
    exports2.fn = (root, params) => {
      const selectors = Array.isArray(params.selectors) ? params.selectors : [params];
      for (const { selector, attributes } of selectors) {
        const nodes = querySelectorAll(root, selector);
        for (const node of nodes) {
          if (node.type === "element") {
            if (Array.isArray(attributes)) {
              for (const name of attributes) {
                delete node.attributes[name];
              }
            } else {
              delete node.attributes[attributes];
            }
          }
        }
      }
      return {};
    };
  }
});

// node_modules/svgo/plugins/removeAttrs.js
var require_removeAttrs = __commonJS({
  "node_modules/svgo/plugins/removeAttrs.js"(exports2) {
    "use strict";
    exports2.name = "removeAttrs";
    exports2.type = "visitor";
    exports2.active = false;
    exports2.description = "removes specified attributes";
    var DEFAULT_SEPARATOR = ":";
    var ENOATTRS = `Warning: The plugin "removeAttrs" requires the "attrs" parameter.
It should have a pattern to remove, otherwise the plugin is a noop.
Config example:

plugins: [
  {
    name: "removeAttrs",
    params: {
      attrs: "(fill|stroke)"
    }
  }
]
`;
    exports2.fn = (root, params) => {
      if (typeof params.attrs == "undefined") {
        console.warn(ENOATTRS);
        return null;
      }
      const elemSeparator = typeof params.elemSeparator == "string" ? params.elemSeparator : DEFAULT_SEPARATOR;
      const preserveCurrentColor = typeof params.preserveCurrentColor == "boolean" ? params.preserveCurrentColor : false;
      const attrs = Array.isArray(params.attrs) ? params.attrs : [params.attrs];
      return {
        element: {
          enter: (node) => {
            for (let pattern of attrs) {
              if (pattern.includes(elemSeparator) === false) {
                pattern = [".*", elemSeparator, pattern, elemSeparator, ".*"].join("");
              } else if (pattern.split(elemSeparator).length < 3) {
                pattern = [pattern, elemSeparator, ".*"].join("");
              }
              const list = pattern.split(elemSeparator).map((value) => {
                if (value === "*") {
                  value = ".*";
                }
                return new RegExp(["^", value, "$"].join(""), "i");
              });
              if (list[0].test(node.name)) {
                for (const [name, value] of Object.entries(node.attributes)) {
                  const isFillCurrentColor = preserveCurrentColor && name == "fill" && value == "currentColor";
                  const isStrokeCurrentColor = preserveCurrentColor && name == "stroke" && value == "currentColor";
                  if (!isFillCurrentColor && !isStrokeCurrentColor && list[1].test(name) && list[2].test(value)) {
                    delete node.attributes[name];
                  }
                }
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeDimensions.js
var require_removeDimensions = __commonJS({
  "node_modules/svgo/plugins/removeDimensions.js"(exports2) {
    "use strict";
    exports2.name = "removeDimensions";
    exports2.type = "perItem";
    exports2.active = false;
    exports2.description = "removes width and height in presence of viewBox (opposite to removeViewBox, disable it first)";
    exports2.fn = function(item) {
      if (item.type === "element" && item.name === "svg") {
        if (item.attributes.viewBox != null) {
          delete item.attributes.width;
          delete item.attributes.height;
        } else if (item.attributes.width != null && item.attributes.height != null && Number.isNaN(Number(item.attributes.width)) === false && Number.isNaN(Number(item.attributes.height)) === false) {
          const width = Number(item.attributes.width);
          const height = Number(item.attributes.height);
          item.attributes.viewBox = `0 0 ${width} ${height}`;
          delete item.attributes.width;
          delete item.attributes.height;
        }
      }
    };
  }
});

// node_modules/svgo/plugins/removeElementsByAttr.js
var require_removeElementsByAttr = __commonJS({
  "node_modules/svgo/plugins/removeElementsByAttr.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeElementsByAttr";
    exports2.type = "visitor";
    exports2.active = false;
    exports2.description = "removes arbitrary elements by ID or className (disabled by default)";
    exports2.fn = (root, params) => {
      const ids = params.id == null ? [] : Array.isArray(params.id) ? params.id : [params.id];
      const classes = params.class == null ? [] : Array.isArray(params.class) ? params.class : [params.class];
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.attributes.id != null && ids.length !== 0) {
              if (ids.includes(node.attributes.id)) {
                detachNodeFromParent(node, parentNode);
              }
            }
            if (node.attributes.class && classes.length !== 0) {
              const classList = node.attributes.class.split(" ");
              for (const item of classes) {
                if (classList.includes(item)) {
                  detachNodeFromParent(node, parentNode);
                  break;
                }
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeOffCanvasPaths.js
var require_removeOffCanvasPaths = __commonJS({
  "node_modules/svgo/plugins/removeOffCanvasPaths.js"(exports2) {
    "use strict";
    var { visitSkip, detachNodeFromParent } = require_xast();
    var { parsePathData } = require_path();
    var { intersects } = require_path2();
    exports2.type = "visitor";
    exports2.name = "removeOffCanvasPaths";
    exports2.active = false;
    exports2.description = "removes elements that are drawn outside of the viewbox (disabled by default)";
    exports2.fn = () => {
      let viewBoxData = null;
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "svg" && parentNode.type === "root") {
              let viewBox = "";
              if (node.attributes.viewBox != null) {
                viewBox = node.attributes.viewBox;
              } else if (node.attributes.height != null && node.attributes.width != null) {
                viewBox = `0 0 ${node.attributes.width} ${node.attributes.height}`;
              }
              viewBox = viewBox.replace(/[,+]|px/g, " ").replace(/\s+/g, " ").replace(/^\s*|\s*$/g, "");
              const m = /^(-?\d*\.?\d+) (-?\d*\.?\d+) (\d*\.?\d+) (\d*\.?\d+)$/.exec(viewBox);
              if (m == null) {
                return;
              }
              const left = Number.parseFloat(m[1]);
              const top = Number.parseFloat(m[2]);
              const width = Number.parseFloat(m[3]);
              const height = Number.parseFloat(m[4]);
              viewBoxData = {
                left,
                top,
                right: left + width,
                bottom: top + height,
                width,
                height
              };
            }
            if (node.attributes.transform != null) {
              return visitSkip;
            }
            if (node.name === "path" && node.attributes.d != null && viewBoxData != null) {
              const pathData = parsePathData(node.attributes.d);
              let visible = false;
              for (const pathDataItem of pathData) {
                if (pathDataItem.command === "M") {
                  const [x, y] = pathDataItem.args;
                  if (x >= viewBoxData.left && x <= viewBoxData.right && y >= viewBoxData.top && y <= viewBoxData.bottom) {
                    visible = true;
                  }
                }
              }
              if (visible) {
                return;
              }
              if (pathData.length === 2) {
                pathData.push({ command: "z", args: [] });
              }
              const { left, top, width, height } = viewBoxData;
              const viewBoxPathData = [
                { command: "M", args: [left, top] },
                { command: "h", args: [width] },
                { command: "v", args: [height] },
                { command: "H", args: [left] },
                { command: "z", args: [] }
              ];
              if (intersects(viewBoxPathData, pathData) === false) {
                detachNodeFromParent(node, parentNode);
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeRasterImages.js
var require_removeRasterImages = __commonJS({
  "node_modules/svgo/plugins/removeRasterImages.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeRasterImages";
    exports2.type = "visitor";
    exports2.active = false;
    exports2.description = "removes raster images (disabled by default)";
    exports2.fn = () => {
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "image" && node.attributes["xlink:href"] != null && /(\.|image\/)(jpg|png|gif)/.test(node.attributes["xlink:href"])) {
              detachNodeFromParent(node, parentNode);
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeScriptElement.js
var require_removeScriptElement = __commonJS({
  "node_modules/svgo/plugins/removeScriptElement.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeScriptElement";
    exports2.type = "visitor";
    exports2.active = false;
    exports2.description = "removes <script> elements (disabled by default)";
    exports2.fn = () => {
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "script") {
              detachNodeFromParent(node, parentNode);
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeStyleElement.js
var require_removeStyleElement = __commonJS({
  "node_modules/svgo/plugins/removeStyleElement.js"(exports2) {
    "use strict";
    var { detachNodeFromParent } = require_xast();
    exports2.name = "removeStyleElement";
    exports2.type = "visitor";
    exports2.active = false;
    exports2.description = "removes <style> element (disabled by default)";
    exports2.fn = () => {
      return {
        element: {
          enter: (node, parentNode) => {
            if (node.name === "style") {
              detachNodeFromParent(node, parentNode);
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/removeXMLNS.js
var require_removeXMLNS = __commonJS({
  "node_modules/svgo/plugins/removeXMLNS.js"(exports2) {
    "use strict";
    exports2.name = "removeXMLNS";
    exports2.type = "perItem";
    exports2.active = false;
    exports2.description = "removes xmlns attribute (for inline svg, disabled by default)";
    exports2.fn = function(item) {
      if (item.type === "element" && item.name === "svg") {
        delete item.attributes.xmlns;
        delete item.attributes["xmlns:xlink"];
      }
    };
  }
});

// node_modules/svgo/plugins/reusePaths.js
var require_reusePaths = __commonJS({
  "node_modules/svgo/plugins/reusePaths.js"(exports2) {
    "use strict";
    var JSAPI = require_jsAPI();
    exports2.type = "visitor";
    exports2.name = "reusePaths";
    exports2.active = false;
    exports2.description = "Finds <path> elements with the same d, fill, and stroke, and converts them to <use> elements referencing a single <path> def.";
    exports2.fn = () => {
      const paths = /* @__PURE__ */ new Map();
      return {
        element: {
          enter: (node) => {
            if (node.name === "path" && node.attributes.d != null) {
              const d = node.attributes.d;
              const fill = node.attributes.fill || "";
              const stroke = node.attributes.stroke || "";
              const key = d + ";s:" + stroke + ";f:" + fill;
              let list = paths.get(key);
              if (list == null) {
                list = [];
                paths.set(key, list);
              }
              list.push(node);
            }
          },
          exit: (node, parentNode) => {
            if (node.name === "svg" && parentNode.type === "root") {
              const rawDefs = {
                type: "element",
                name: "defs",
                attributes: {},
                children: []
              };
              const defsTag = new JSAPI(rawDefs, node);
              let index = 0;
              for (const list of paths.values()) {
                if (list.length > 1) {
                  const rawPath = {
                    type: "element",
                    name: "path",
                    attributes: { ...list[0].attributes },
                    children: []
                  };
                  delete rawPath.attributes.transform;
                  let id;
                  if (rawPath.attributes.id == null) {
                    id = "reuse-" + index;
                    index += 1;
                    rawPath.attributes.id = id;
                  } else {
                    id = rawPath.attributes.id;
                    delete list[0].attributes.id;
                  }
                  const reusablePath = new JSAPI(rawPath, defsTag);
                  defsTag.children.push(reusablePath);
                  for (const pathNode of list) {
                    pathNode.name = "use";
                    pathNode.attributes["xlink:href"] = "#" + id;
                    delete pathNode.attributes.d;
                    delete pathNode.attributes.stroke;
                    delete pathNode.attributes.fill;
                  }
                }
              }
              if (defsTag.children.length !== 0) {
                if (node.attributes["xmlns:xlink"] == null) {
                  node.attributes["xmlns:xlink"] = "http://www.w3.org/1999/xlink";
                }
                node.children.unshift(defsTag);
              }
            }
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/sortAttrs.js
var require_sortAttrs = __commonJS({
  "node_modules/svgo/plugins/sortAttrs.js"(exports2) {
    "use strict";
    exports2.type = "visitor";
    exports2.name = "sortAttrs";
    exports2.active = false;
    exports2.description = "Sort element attributes for better compression";
    exports2.fn = (_root, params) => {
      const {
        order = [
          "id",
          "width",
          "height",
          "x",
          "x1",
          "x2",
          "y",
          "y1",
          "y2",
          "cx",
          "cy",
          "r",
          "fill",
          "stroke",
          "marker",
          "d",
          "points"
        ],
        xmlnsOrder = "front"
      } = params;
      const getNsPriority = (name) => {
        if (xmlnsOrder === "front") {
          if (name === "xmlns") {
            return 3;
          }
          if (name.startsWith("xmlns:")) {
            return 2;
          }
        }
        if (name.includes(":")) {
          return 1;
        }
        return 0;
      };
      const compareAttrs = ([aName], [bName]) => {
        const aPriority = getNsPriority(aName);
        const bPriority = getNsPriority(bName);
        const priorityNs = bPriority - aPriority;
        if (priorityNs !== 0) {
          return priorityNs;
        }
        const [aPart] = aName.split("-");
        const [bPart] = bName.split("-");
        if (aPart !== bPart) {
          const aInOrderFlag = order.includes(aPart) ? 1 : 0;
          const bInOrderFlag = order.includes(bPart) ? 1 : 0;
          if (aInOrderFlag === 1 && bInOrderFlag === 1) {
            return order.indexOf(aPart) - order.indexOf(bPart);
          }
          const priorityOrder = bInOrderFlag - aInOrderFlag;
          if (priorityOrder !== 0) {
            return priorityOrder;
          }
        }
        return aName < bName ? -1 : 1;
      };
      return {
        element: {
          enter: (node) => {
            const attrs = Object.entries(node.attributes);
            attrs.sort(compareAttrs);
            const sortedAttributes = {};
            for (const [name, value] of attrs) {
              sortedAttributes[name] = value;
            }
            node.attributes = sortedAttributes;
          }
        }
      };
    };
  }
});

// node_modules/svgo/plugins/plugins.js
var require_plugins2 = __commonJS({
  "node_modules/svgo/plugins/plugins.js"(exports2) {
    "use strict";
    exports2["preset-default"] = require_preset_default();
    exports2.addAttributesToSVGElement = require_addAttributesToSVGElement();
    exports2.addClassesToSVGElement = require_addClassesToSVGElement();
    exports2.cleanupAttrs = require_cleanupAttrs();
    exports2.cleanupEnableBackground = require_cleanupEnableBackground();
    exports2.cleanupIDs = require_cleanupIDs();
    exports2.cleanupListOfValues = require_cleanupListOfValues();
    exports2.cleanupNumericValues = require_cleanupNumericValues();
    exports2.collapseGroups = require_collapseGroups();
    exports2.convertColors = require_convertColors();
    exports2.convertEllipseToCircle = require_convertEllipseToCircle();
    exports2.convertPathData = require_convertPathData();
    exports2.convertShapeToPath = require_convertShapeToPath();
    exports2.convertStyleToAttrs = require_convertStyleToAttrs();
    exports2.convertTransform = require_convertTransform();
    exports2.mergeStyles = require_mergeStyles();
    exports2.inlineStyles = require_inlineStyles();
    exports2.mergePaths = require_mergePaths();
    exports2.minifyStyles = require_minifyStyles();
    exports2.moveElemsAttrsToGroup = require_moveElemsAttrsToGroup();
    exports2.moveGroupAttrsToElems = require_moveGroupAttrsToElems();
    exports2.prefixIds = require_prefixIds();
    exports2.removeAttributesBySelector = require_removeAttributesBySelector();
    exports2.removeAttrs = require_removeAttrs();
    exports2.removeComments = require_removeComments();
    exports2.removeDesc = require_removeDesc();
    exports2.removeDimensions = require_removeDimensions();
    exports2.removeDoctype = require_removeDoctype();
    exports2.removeEditorsNSData = require_removeEditorsNSData();
    exports2.removeElementsByAttr = require_removeElementsByAttr();
    exports2.removeEmptyAttrs = require_removeEmptyAttrs();
    exports2.removeEmptyContainers = require_removeEmptyContainers();
    exports2.removeEmptyText = require_removeEmptyText();
    exports2.removeHiddenElems = require_removeHiddenElems();
    exports2.removeMetadata = require_removeMetadata();
    exports2.removeNonInheritableGroupAttrs = require_removeNonInheritableGroupAttrs();
    exports2.removeOffCanvasPaths = require_removeOffCanvasPaths();
    exports2.removeRasterImages = require_removeRasterImages();
    exports2.removeScriptElement = require_removeScriptElement();
    exports2.removeStyleElement = require_removeStyleElement();
    exports2.removeTitle = require_removeTitle();
    exports2.removeUnknownsAndDefaults = require_removeUnknownsAndDefaults();
    exports2.removeUnusedNS = require_removeUnusedNS();
    exports2.removeUselessDefs = require_removeUselessDefs();
    exports2.removeUselessStrokeAndFill = require_removeUselessStrokeAndFill();
    exports2.removeViewBox = require_removeViewBox();
    exports2.removeXMLNS = require_removeXMLNS();
    exports2.removeXMLProcInst = require_removeXMLProcInst();
    exports2.reusePaths = require_reusePaths();
    exports2.sortAttrs = require_sortAttrs();
    exports2.sortDefsChildren = require_sortDefsChildren();
  }
});

// node_modules/svgo/lib/svgo/config.js
var require_config = __commonJS({
  "node_modules/svgo/lib/svgo/config.js"(exports2) {
    "use strict";
    var pluginsMap = require_plugins2();
    var pluginsOrder = [
      "removeDoctype",
      "removeXMLProcInst",
      "removeComments",
      "removeMetadata",
      "removeXMLNS",
      "removeEditorsNSData",
      "cleanupAttrs",
      "mergeStyles",
      "inlineStyles",
      "minifyStyles",
      "convertStyleToAttrs",
      "cleanupIDs",
      "prefixIds",
      "removeRasterImages",
      "removeUselessDefs",
      "cleanupNumericValues",
      "cleanupListOfValues",
      "convertColors",
      "removeUnknownsAndDefaults",
      "removeNonInheritableGroupAttrs",
      "removeUselessStrokeAndFill",
      "removeViewBox",
      "cleanupEnableBackground",
      "removeHiddenElems",
      "removeEmptyText",
      "convertShapeToPath",
      "convertEllipseToCircle",
      "moveElemsAttrsToGroup",
      "moveGroupAttrsToElems",
      "collapseGroups",
      "convertPathData",
      "convertTransform",
      "removeEmptyAttrs",
      "removeEmptyContainers",
      "mergePaths",
      "removeUnusedNS",
      "sortAttrs",
      "sortDefsChildren",
      "removeTitle",
      "removeDesc",
      "removeDimensions",
      "removeAttrs",
      "removeAttributesBySelector",
      "removeElementsByAttr",
      "addClassesToSVGElement",
      "removeStyleElement",
      "removeScriptElement",
      "addAttributesToSVGElement",
      "removeOffCanvasPaths",
      "reusePaths"
    ];
    var defaultPlugins = pluginsOrder.filter((name) => pluginsMap[name].active);
    exports2.defaultPlugins = defaultPlugins;
    var extendDefaultPlugins = (plugins) => {
      console.warn(`
"extendDefaultPlugins" utility is deprecated.
Use "preset-default" plugin with overrides instead.
For example:
{
  name: 'preset-default',
  params: {
    overrides: {
      // customize plugin options
      convertShapeToPath: {
        convertArcs: true
      },
      // disable plugins
      convertPathData: false
    }
  }
}
`);
      const extendedPlugins = pluginsOrder.map((name) => ({
        name,
        active: pluginsMap[name].active
      }));
      for (const plugin of plugins) {
        const resolvedPlugin = resolvePluginConfig(plugin);
        const index = pluginsOrder.indexOf(resolvedPlugin.name);
        if (index === -1) {
          extendedPlugins.push(plugin);
        } else {
          extendedPlugins[index] = plugin;
        }
      }
      return extendedPlugins;
    };
    exports2.extendDefaultPlugins = extendDefaultPlugins;
    var resolvePluginConfig = (plugin) => {
      let configParams = {};
      if (typeof plugin === "string") {
        const pluginConfig = pluginsMap[plugin];
        if (pluginConfig == null) {
          throw Error(`Unknown builtin plugin "${plugin}" specified.`);
        }
        return {
          ...pluginConfig,
          name: plugin,
          active: true,
          params: { ...pluginConfig.params, ...configParams }
        };
      }
      if (typeof plugin === "object" && plugin != null) {
        if (plugin.name == null) {
          throw Error(`Plugin name should be specified`);
        }
        if (plugin.fn) {
          return {
            active: true,
            ...plugin,
            params: { ...configParams, ...plugin.params }
          };
        } else {
          const pluginConfig = pluginsMap[plugin.name];
          if (pluginConfig == null) {
            throw Error(`Unknown builtin plugin "${plugin.name}" specified.`);
          }
          return {
            ...pluginConfig,
            active: true,
            ...plugin,
            params: { ...pluginConfig.params, ...configParams, ...plugin.params }
          };
        }
      }
      return null;
    };
    exports2.resolvePluginConfig = resolvePluginConfig;
  }
});

// node_modules/@trysound/sax/lib/sax.js
var require_sax = __commonJS({
  "node_modules/@trysound/sax/lib/sax.js"(exports2) {
    (function(sax) {
      sax.parser = function(strict, opt) {
        return new SAXParser(strict, opt);
      };
      sax.SAXParser = SAXParser;
      sax.MAX_BUFFER_LENGTH = 64 * 1024;
      var buffers = [
        "comment",
        "sgmlDecl",
        "textNode",
        "tagName",
        "doctype",
        "procInstName",
        "procInstBody",
        "entity",
        "attribName",
        "attribValue",
        "cdata",
        "script"
      ];
      sax.EVENTS = [
        "text",
        "processinginstruction",
        "sgmldeclaration",
        "doctype",
        "comment",
        "opentagstart",
        "attribute",
        "opentag",
        "closetag",
        "opencdata",
        "cdata",
        "closecdata",
        "error",
        "end",
        "ready",
        "script",
        "opennamespace",
        "closenamespace"
      ];
      function SAXParser(strict, opt) {
        if (!(this instanceof SAXParser)) {
          return new SAXParser(strict, opt);
        }
        var parser = this;
        clearBuffers(parser);
        parser.q = parser.c = "";
        parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH;
        parser.opt = opt || {};
        parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
        parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase";
        parser.tags = [];
        parser.closed = parser.closedRoot = parser.sawRoot = false;
        parser.tag = parser.error = null;
        parser.strict = !!strict;
        parser.noscript = !!(strict || parser.opt.noscript);
        parser.state = S.BEGIN;
        parser.strictEntities = parser.opt.strictEntities;
        parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES);
        parser.attribList = [];
        if (parser.opt.xmlns) {
          parser.ns = Object.create(rootNS);
        }
        parser.trackPosition = parser.opt.position !== false;
        if (parser.trackPosition) {
          parser.position = parser.line = parser.column = 0;
        }
        emit(parser, "onready");
      }
      if (!Object.create) {
        Object.create = function(o) {
          function F() {
          }
          F.prototype = o;
          var newf = new F();
          return newf;
        };
      }
      if (!Object.keys) {
        Object.keys = function(o) {
          var a = [];
          for (var i in o)
            if (o.hasOwnProperty(i))
              a.push(i);
          return a;
        };
      }
      function checkBufferLength(parser) {
        var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10);
        var maxActual = 0;
        for (var i = 0, l = buffers.length; i < l; i++) {
          var len = parser[buffers[i]].length;
          if (len > maxAllowed) {
            switch (buffers[i]) {
              case "textNode":
                closeText(parser);
                break;
              case "cdata":
                emitNode(parser, "oncdata", parser.cdata);
                parser.cdata = "";
                break;
              case "script":
                emitNode(parser, "onscript", parser.script);
                parser.script = "";
                break;
              default:
                error(parser, "Max buffer length exceeded: " + buffers[i]);
            }
          }
          maxActual = Math.max(maxActual, len);
        }
        var m = sax.MAX_BUFFER_LENGTH - maxActual;
        parser.bufferCheckPosition = m + parser.position;
      }
      function clearBuffers(parser) {
        for (var i = 0, l = buffers.length; i < l; i++) {
          parser[buffers[i]] = "";
        }
      }
      function flushBuffers(parser) {
        closeText(parser);
        if (parser.cdata !== "") {
          emitNode(parser, "oncdata", parser.cdata);
          parser.cdata = "";
        }
        if (parser.script !== "") {
          emitNode(parser, "onscript", parser.script);
          parser.script = "";
        }
      }
      SAXParser.prototype = {
        end: function() {
          end(this);
        },
        write,
        resume: function() {
          this.error = null;
          return this;
        },
        close: function() {
          return this.write(null);
        },
        flush: function() {
          flushBuffers(this);
        }
      };
      var CDATA = "[CDATA[";
      var DOCTYPE = "DOCTYPE";
      var XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
      var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
      var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE };
      var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
      var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
      var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
      var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
      function isWhitespace(c) {
        return c === " " || c === "\n" || c === "\r" || c === "	";
      }
      function isQuote(c) {
        return c === '"' || c === "'";
      }
      function isAttribEnd(c) {
        return c === ">" || isWhitespace(c);
      }
      function isMatch(regex, c) {
        return regex.test(c);
      }
      function notMatch(regex, c) {
        return !isMatch(regex, c);
      }
      var S = 0;
      sax.STATE = {
        BEGIN: S++,
        BEGIN_WHITESPACE: S++,
        TEXT: S++,
        TEXT_ENTITY: S++,
        OPEN_WAKA: S++,
        SGML_DECL: S++,
        SGML_DECL_QUOTED: S++,
        DOCTYPE: S++,
        DOCTYPE_QUOTED: S++,
        DOCTYPE_DTD: S++,
        DOCTYPE_DTD_QUOTED: S++,
        COMMENT_STARTING: S++,
        COMMENT: S++,
        COMMENT_ENDING: S++,
        COMMENT_ENDED: S++,
        CDATA: S++,
        CDATA_ENDING: S++,
        CDATA_ENDING_2: S++,
        PROC_INST: S++,
        PROC_INST_BODY: S++,
        PROC_INST_ENDING: S++,
        OPEN_TAG: S++,
        OPEN_TAG_SLASH: S++,
        ATTRIB: S++,
        ATTRIB_NAME: S++,
        ATTRIB_NAME_SAW_WHITE: S++,
        ATTRIB_VALUE: S++,
        ATTRIB_VALUE_QUOTED: S++,
        ATTRIB_VALUE_CLOSED: S++,
        ATTRIB_VALUE_UNQUOTED: S++,
        ATTRIB_VALUE_ENTITY_Q: S++,
        ATTRIB_VALUE_ENTITY_U: S++,
        CLOSE_TAG: S++,
        CLOSE_TAG_SAW_WHITE: S++,
        SCRIPT: S++,
        SCRIPT_ENDING: S++
      };
      sax.XML_ENTITIES = {
        "amp": "&",
        "gt": ">",
        "lt": "<",
        "quot": '"',
        "apos": "'"
      };
      sax.ENTITIES = {
        "amp": "&",
        "gt": ">",
        "lt": "<",
        "quot": '"',
        "apos": "'",
        "AElig": 198,
        "Aacute": 193,
        "Acirc": 194,
        "Agrave": 192,
        "Aring": 197,
        "Atilde": 195,
        "Auml": 196,
        "Ccedil": 199,
        "ETH": 208,
        "Eacute": 201,
        "Ecirc": 202,
        "Egrave": 200,
        "Euml": 203,
        "Iacute": 205,
        "Icirc": 206,
        "Igrave": 204,
        "Iuml": 207,
        "Ntilde": 209,
        "Oacute": 211,
        "Ocirc": 212,
        "Ograve": 210,
        "Oslash": 216,
        "Otilde": 213,
        "Ouml": 214,
        "THORN": 222,
        "Uacute": 218,
        "Ucirc": 219,
        "Ugrave": 217,
        "Uuml": 220,
        "Yacute": 221,
        "aacute": 225,
        "acirc": 226,
        "aelig": 230,
        "agrave": 224,
        "aring": 229,
        "atilde": 227,
        "auml": 228,
        "ccedil": 231,
        "eacute": 233,
        "ecirc": 234,
        "egrave": 232,
        "eth": 240,
        "euml": 235,
        "iacute": 237,
        "icirc": 238,
        "igrave": 236,
        "iuml": 239,
        "ntilde": 241,
        "oacute": 243,
        "ocirc": 244,
        "ograve": 242,
        "oslash": 248,
        "otilde": 245,
        "ouml": 246,
        "szlig": 223,
        "thorn": 254,
        "uacute": 250,
        "ucirc": 251,
        "ugrave": 249,
        "uuml": 252,
        "yacute": 253,
        "yuml": 255,
        "copy": 169,
        "reg": 174,
        "nbsp": 160,
        "iexcl": 161,
        "cent": 162,
        "pound": 163,
        "curren": 164,
        "yen": 165,
        "brvbar": 166,
        "sect": 167,
        "uml": 168,
        "ordf": 170,
        "laquo": 171,
        "not": 172,
        "shy": 173,
        "macr": 175,
        "deg": 176,
        "plusmn": 177,
        "sup1": 185,
        "sup2": 178,
        "sup3": 179,
        "acute": 180,
        "micro": 181,
        "para": 182,
        "middot": 183,
        "cedil": 184,
        "ordm": 186,
        "raquo": 187,
        "frac14": 188,
        "frac12": 189,
        "frac34": 190,
        "iquest": 191,
        "times": 215,
        "divide": 247,
        "OElig": 338,
        "oelig": 339,
        "Scaron": 352,
        "scaron": 353,
        "Yuml": 376,
        "fnof": 402,
        "circ": 710,
        "tilde": 732,
        "Alpha": 913,
        "Beta": 914,
        "Gamma": 915,
        "Delta": 916,
        "Epsilon": 917,
        "Zeta": 918,
        "Eta": 919,
        "Theta": 920,
        "Iota": 921,
        "Kappa": 922,
        "Lambda": 923,
        "Mu": 924,
        "Nu": 925,
        "Xi": 926,
        "Omicron": 927,
        "Pi": 928,
        "Rho": 929,
        "Sigma": 931,
        "Tau": 932,
        "Upsilon": 933,
        "Phi": 934,
        "Chi": 935,
        "Psi": 936,
        "Omega": 937,
        "alpha": 945,
        "beta": 946,
        "gamma": 947,
        "delta": 948,
        "epsilon": 949,
        "zeta": 950,
        "eta": 951,
        "theta": 952,
        "iota": 953,
        "kappa": 954,
        "lambda": 955,
        "mu": 956,
        "nu": 957,
        "xi": 958,
        "omicron": 959,
        "pi": 960,
        "rho": 961,
        "sigmaf": 962,
        "sigma": 963,
        "tau": 964,
        "upsilon": 965,
        "phi": 966,
        "chi": 967,
        "psi": 968,
        "omega": 969,
        "thetasym": 977,
        "upsih": 978,
        "piv": 982,
        "ensp": 8194,
        "emsp": 8195,
        "thinsp": 8201,
        "zwnj": 8204,
        "zwj": 8205,
        "lrm": 8206,
        "rlm": 8207,
        "ndash": 8211,
        "mdash": 8212,
        "lsquo": 8216,
        "rsquo": 8217,
        "sbquo": 8218,
        "ldquo": 8220,
        "rdquo": 8221,
        "bdquo": 8222,
        "dagger": 8224,
        "Dagger": 8225,
        "bull": 8226,
        "hellip": 8230,
        "permil": 8240,
        "prime": 8242,
        "Prime": 8243,
        "lsaquo": 8249,
        "rsaquo": 8250,
        "oline": 8254,
        "frasl": 8260,
        "euro": 8364,
        "image": 8465,
        "weierp": 8472,
        "real": 8476,
        "trade": 8482,
        "alefsym": 8501,
        "larr": 8592,
        "uarr": 8593,
        "rarr": 8594,
        "darr": 8595,
        "harr": 8596,
        "crarr": 8629,
        "lArr": 8656,
        "uArr": 8657,
        "rArr": 8658,
        "dArr": 8659,
        "hArr": 8660,
        "forall": 8704,
        "part": 8706,
        "exist": 8707,
        "empty": 8709,
        "nabla": 8711,
        "isin": 8712,
        "notin": 8713,
        "ni": 8715,
        "prod": 8719,
        "sum": 8721,
        "minus": 8722,
        "lowast": 8727,
        "radic": 8730,
        "prop": 8733,
        "infin": 8734,
        "ang": 8736,
        "and": 8743,
        "or": 8744,
        "cap": 8745,
        "cup": 8746,
        "int": 8747,
        "there4": 8756,
        "sim": 8764,
        "cong": 8773,
        "asymp": 8776,
        "ne": 8800,
        "equiv": 8801,
        "le": 8804,
        "ge": 8805,
        "sub": 8834,
        "sup": 8835,
        "nsub": 8836,
        "sube": 8838,
        "supe": 8839,
        "oplus": 8853,
        "otimes": 8855,
        "perp": 8869,
        "sdot": 8901,
        "lceil": 8968,
        "rceil": 8969,
        "lfloor": 8970,
        "rfloor": 8971,
        "lang": 9001,
        "rang": 9002,
        "loz": 9674,
        "spades": 9824,
        "clubs": 9827,
        "hearts": 9829,
        "diams": 9830
      };
      Object.keys(sax.ENTITIES).forEach(function(key) {
        var e = sax.ENTITIES[key];
        var s2 = typeof e === "number" ? String.fromCharCode(e) : e;
        sax.ENTITIES[key] = s2;
      });
      for (var s in sax.STATE) {
        sax.STATE[sax.STATE[s]] = s;
      }
      S = sax.STATE;
      function emit(parser, event, data) {
        parser[event] && parser[event](data);
      }
      function emitNode(parser, nodeType, data) {
        if (parser.textNode)
          closeText(parser);
        emit(parser, nodeType, data);
      }
      function closeText(parser) {
        parser.textNode = textopts(parser.opt, parser.textNode);
        if (parser.textNode)
          emit(parser, "ontext", parser.textNode);
        parser.textNode = "";
      }
      function textopts(opt, text) {
        if (opt.trim)
          text = text.trim();
        if (opt.normalize)
          text = text.replace(/\s+/g, " ");
        return text;
      }
      function error(parser, reason) {
        closeText(parser);
        const message = reason + "\nLine: " + parser.line + "\nColumn: " + parser.column + "\nChar: " + parser.c;
        const error2 = new Error(message);
        error2.reason = reason;
        error2.line = parser.line;
        error2.column = parser.column;
        parser.error = error2;
        emit(parser, "onerror", error2);
        return parser;
      }
      function end(parser) {
        if (parser.sawRoot && !parser.closedRoot)
          strictFail(parser, "Unclosed root tag");
        if (parser.state !== S.BEGIN && parser.state !== S.BEGIN_WHITESPACE && parser.state !== S.TEXT) {
          error(parser, "Unexpected end");
        }
        closeText(parser);
        parser.c = "";
        parser.closed = true;
        emit(parser, "onend");
        SAXParser.call(parser, parser.strict, parser.opt);
        return parser;
      }
      function strictFail(parser, message) {
        if (typeof parser !== "object" || !(parser instanceof SAXParser)) {
          throw new Error("bad call to strictFail");
        }
        if (parser.strict) {
          error(parser, message);
        }
      }
      function newTag(parser) {
        if (!parser.strict)
          parser.tagName = parser.tagName[parser.looseCase]();
        var parent = parser.tags[parser.tags.length - 1] || parser;
        var tag = parser.tag = { name: parser.tagName, attributes: {} };
        if (parser.opt.xmlns) {
          tag.ns = parent.ns;
        }
        parser.attribList.length = 0;
        emitNode(parser, "onopentagstart", tag);
      }
      function qname(name, attribute) {
        var i = name.indexOf(":");
        var qualName = i < 0 ? ["", name] : name.split(":");
        var prefix = qualName[0];
        var local = qualName[1];
        if (attribute && name === "xmlns") {
          prefix = "xmlns";
          local = "";
        }
        return { prefix, local };
      }
      function attrib(parser) {
        if (!parser.strict) {
          parser.attribName = parser.attribName[parser.looseCase]();
        }
        if (parser.attribList.indexOf(parser.attribName) !== -1 || parser.tag.attributes.hasOwnProperty(parser.attribName)) {
          parser.attribName = parser.attribValue = "";
          return;
        }
        if (parser.opt.xmlns) {
          var qn = qname(parser.attribName, true);
          var prefix = qn.prefix;
          var local = qn.local;
          if (prefix === "xmlns") {
            if (local === "xml" && parser.attribValue !== XML_NAMESPACE) {
              strictFail(parser, "xml: prefix must be bound to " + XML_NAMESPACE + "\nActual: " + parser.attribValue);
            } else if (local === "xmlns" && parser.attribValue !== XMLNS_NAMESPACE) {
              strictFail(parser, "xmlns: prefix must be bound to " + XMLNS_NAMESPACE + "\nActual: " + parser.attribValue);
            } else {
              var tag = parser.tag;
              var parent = parser.tags[parser.tags.length - 1] || parser;
              if (tag.ns === parent.ns) {
                tag.ns = Object.create(parent.ns);
              }
              tag.ns[local] = parser.attribValue;
            }
          }
          parser.attribList.push([parser.attribName, parser.attribValue]);
        } else {
          parser.tag.attributes[parser.attribName] = parser.attribValue;
          emitNode(parser, "onattribute", {
            name: parser.attribName,
            value: parser.attribValue
          });
        }
        parser.attribName = parser.attribValue = "";
      }
      function openTag(parser, selfClosing) {
        if (parser.opt.xmlns) {
          var tag = parser.tag;
          var qn = qname(parser.tagName);
          tag.prefix = qn.prefix;
          tag.local = qn.local;
          tag.uri = tag.ns[qn.prefix] || "";
          if (tag.prefix && !tag.uri) {
            strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(parser.tagName));
            tag.uri = qn.prefix;
          }
          var parent = parser.tags[parser.tags.length - 1] || parser;
          if (tag.ns && parent.ns !== tag.ns) {
            Object.keys(tag.ns).forEach(function(p) {
              emitNode(parser, "onopennamespace", {
                prefix: p,
                uri: tag.ns[p]
              });
            });
          }
          for (var i = 0, l = parser.attribList.length; i < l; i++) {
            var nv = parser.attribList[i];
            var name = nv[0];
            var value = nv[1];
            var qualName = qname(name, true);
            var prefix = qualName.prefix;
            var local = qualName.local;
            var uri = prefix === "" ? "" : tag.ns[prefix] || "";
            var a = {
              name,
              value,
              prefix,
              local,
              uri
            };
            if (prefix && prefix !== "xmlns" && !uri) {
              strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(prefix));
              a.uri = prefix;
            }
            parser.tag.attributes[name] = a;
            emitNode(parser, "onattribute", a);
          }
          parser.attribList.length = 0;
        }
        parser.tag.isSelfClosing = !!selfClosing;
        parser.sawRoot = true;
        parser.tags.push(parser.tag);
        emitNode(parser, "onopentag", parser.tag);
        if (!selfClosing) {
          if (!parser.noscript && parser.tagName.toLowerCase() === "script") {
            parser.state = S.SCRIPT;
          } else {
            parser.state = S.TEXT;
          }
          parser.tag = null;
          parser.tagName = "";
        }
        parser.attribName = parser.attribValue = "";
        parser.attribList.length = 0;
      }
      function closeTag(parser) {
        if (!parser.tagName) {
          strictFail(parser, "Weird empty close tag.");
          parser.textNode += "</>";
          parser.state = S.TEXT;
          return;
        }
        if (parser.script) {
          if (parser.tagName !== "script") {
            parser.script += "</" + parser.tagName + ">";
            parser.tagName = "";
            parser.state = S.SCRIPT;
            return;
          }
          emitNode(parser, "onscript", parser.script);
          parser.script = "";
        }
        var t = parser.tags.length;
        var tagName = parser.tagName;
        if (!parser.strict) {
          tagName = tagName[parser.looseCase]();
        }
        var closeTo = tagName;
        while (t--) {
          var close = parser.tags[t];
          if (close.name !== closeTo) {
            strictFail(parser, "Unexpected close tag");
          } else {
            break;
          }
        }
        if (t < 0) {
          strictFail(parser, "Unmatched closing tag: " + parser.tagName);
          parser.textNode += "</" + parser.tagName + ">";
          parser.state = S.TEXT;
          return;
        }
        parser.tagName = tagName;
        var s2 = parser.tags.length;
        while (s2-- > t) {
          var tag = parser.tag = parser.tags.pop();
          parser.tagName = parser.tag.name;
          emitNode(parser, "onclosetag", parser.tagName);
          var x = {};
          for (var i in tag.ns) {
            x[i] = tag.ns[i];
          }
          var parent = parser.tags[parser.tags.length - 1] || parser;
          if (parser.opt.xmlns && tag.ns !== parent.ns) {
            Object.keys(tag.ns).forEach(function(p) {
              var n = tag.ns[p];
              emitNode(parser, "onclosenamespace", { prefix: p, uri: n });
            });
          }
        }
        if (t === 0)
          parser.closedRoot = true;
        parser.tagName = parser.attribValue = parser.attribName = "";
        parser.attribList.length = 0;
        parser.state = S.TEXT;
      }
      function parseEntity(parser) {
        var entity = parser.entity;
        var entityLC = entity.toLowerCase();
        var num;
        var numStr = "";
        if (parser.ENTITIES[entity]) {
          return parser.ENTITIES[entity];
        }
        if (parser.ENTITIES[entityLC]) {
          return parser.ENTITIES[entityLC];
        }
        entity = entityLC;
        if (entity.charAt(0) === "#") {
          if (entity.charAt(1) === "x") {
            entity = entity.slice(2);
            num = parseInt(entity, 16);
            numStr = num.toString(16);
          } else {
            entity = entity.slice(1);
            num = parseInt(entity, 10);
            numStr = num.toString(10);
          }
        }
        entity = entity.replace(/^0+/, "");
        if (isNaN(num) || numStr.toLowerCase() !== entity) {
          strictFail(parser, "Invalid character entity");
          return "&" + parser.entity + ";";
        }
        return String.fromCodePoint(num);
      }
      function beginWhiteSpace(parser, c) {
        if (c === "<") {
          parser.state = S.OPEN_WAKA;
          parser.startTagPosition = parser.position;
        } else if (!isWhitespace(c)) {
          strictFail(parser, "Non-whitespace before first tag.");
          parser.textNode = c;
          parser.state = S.TEXT;
        }
      }
      function charAt(chunk, i) {
        var result = "";
        if (i < chunk.length) {
          result = chunk.charAt(i);
        }
        return result;
      }
      function write(chunk) {
        var parser = this;
        if (this.error) {
          throw this.error;
        }
        if (parser.closed) {
          return error(parser, "Cannot write after close. Assign an onready handler.");
        }
        if (chunk === null) {
          return end(parser);
        }
        if (typeof chunk === "object") {
          chunk = chunk.toString();
        }
        var i = 0;
        var c = "";
        while (true) {
          c = charAt(chunk, i++);
          parser.c = c;
          if (!c) {
            break;
          }
          if (parser.trackPosition) {
            parser.position++;
            if (c === "\n") {
              parser.line++;
              parser.column = 0;
            } else {
              parser.column++;
            }
          }
          switch (parser.state) {
            case S.BEGIN:
              parser.state = S.BEGIN_WHITESPACE;
              if (c === "\uFEFF") {
                continue;
              }
              beginWhiteSpace(parser, c);
              continue;
            case S.BEGIN_WHITESPACE:
              beginWhiteSpace(parser, c);
              continue;
            case S.TEXT:
              if (parser.sawRoot && !parser.closedRoot) {
                var starti = i - 1;
                while (c && c !== "<" && c !== "&") {
                  c = charAt(chunk, i++);
                  if (c && parser.trackPosition) {
                    parser.position++;
                    if (c === "\n") {
                      parser.line++;
                      parser.column = 0;
                    } else {
                      parser.column++;
                    }
                  }
                }
                parser.textNode += chunk.substring(starti, i - 1);
              }
              if (c === "<" && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
                parser.state = S.OPEN_WAKA;
                parser.startTagPosition = parser.position;
              } else {
                if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {
                  strictFail(parser, "Text data outside of root node.");
                }
                if (c === "&") {
                  parser.state = S.TEXT_ENTITY;
                } else {
                  parser.textNode += c;
                }
              }
              continue;
            case S.SCRIPT:
              if (c === "<") {
                parser.state = S.SCRIPT_ENDING;
              } else {
                parser.script += c;
              }
              continue;
            case S.SCRIPT_ENDING:
              if (c === "/") {
                parser.state = S.CLOSE_TAG;
              } else {
                parser.script += "<" + c;
                parser.state = S.SCRIPT;
              }
              continue;
            case S.OPEN_WAKA:
              if (c === "!") {
                parser.state = S.SGML_DECL;
                parser.sgmlDecl = "";
              } else if (isWhitespace(c)) {
              } else if (isMatch(nameStart, c)) {
                parser.state = S.OPEN_TAG;
                parser.tagName = c;
              } else if (c === "/") {
                parser.state = S.CLOSE_TAG;
                parser.tagName = "";
              } else if (c === "?") {
                parser.state = S.PROC_INST;
                parser.procInstName = parser.procInstBody = "";
              } else {
                strictFail(parser, "Unencoded <");
                if (parser.startTagPosition + 1 < parser.position) {
                  var pad = parser.position - parser.startTagPosition;
                  c = new Array(pad).join(" ") + c;
                }
                parser.textNode += "<" + c;
                parser.state = S.TEXT;
              }
              continue;
            case S.SGML_DECL:
              if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
                emitNode(parser, "onopencdata");
                parser.state = S.CDATA;
                parser.sgmlDecl = "";
                parser.cdata = "";
              } else if (parser.sgmlDecl + c === "--") {
                parser.state = S.COMMENT;
                parser.comment = "";
                parser.sgmlDecl = "";
              } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
                parser.state = S.DOCTYPE;
                if (parser.doctype || parser.sawRoot) {
                  strictFail(parser, "Inappropriately located doctype declaration");
                }
                parser.doctype = "";
                parser.sgmlDecl = "";
              } else if (c === ">") {
                emitNode(parser, "onsgmldeclaration", parser.sgmlDecl);
                parser.sgmlDecl = "";
                parser.state = S.TEXT;
              } else if (isQuote(c)) {
                parser.state = S.SGML_DECL_QUOTED;
                parser.sgmlDecl += c;
              } else {
                parser.sgmlDecl += c;
              }
              continue;
            case S.SGML_DECL_QUOTED:
              if (c === parser.q) {
                parser.state = S.SGML_DECL;
                parser.q = "";
              }
              parser.sgmlDecl += c;
              continue;
            case S.DOCTYPE:
              if (c === ">") {
                parser.state = S.TEXT;
                emitNode(parser, "ondoctype", parser.doctype);
                parser.doctype = true;
              } else {
                parser.doctype += c;
                if (c === "[") {
                  parser.state = S.DOCTYPE_DTD;
                } else if (isQuote(c)) {
                  parser.state = S.DOCTYPE_QUOTED;
                  parser.q = c;
                }
              }
              continue;
            case S.DOCTYPE_QUOTED:
              parser.doctype += c;
              if (c === parser.q) {
                parser.q = "";
                parser.state = S.DOCTYPE;
              }
              continue;
            case S.DOCTYPE_DTD:
              parser.doctype += c;
              if (c === "]") {
                parser.state = S.DOCTYPE;
              } else if (isQuote(c)) {
                parser.state = S.DOCTYPE_DTD_QUOTED;
                parser.q = c;
              }
              continue;
            case S.DOCTYPE_DTD_QUOTED:
              parser.doctype += c;
              if (c === parser.q) {
                parser.state = S.DOCTYPE_DTD;
                parser.q = "";
              }
              continue;
            case S.COMMENT:
              if (c === "-") {
                parser.state = S.COMMENT_ENDING;
              } else {
                parser.comment += c;
              }
              continue;
            case S.COMMENT_ENDING:
              if (c === "-") {
                parser.state = S.COMMENT_ENDED;
                parser.comment = textopts(parser.opt, parser.comment);
                if (parser.comment) {
                  emitNode(parser, "oncomment", parser.comment);
                }
                parser.comment = "";
              } else {
                parser.comment += "-" + c;
                parser.state = S.COMMENT;
              }
              continue;
            case S.COMMENT_ENDED:
              if (c !== ">") {
                strictFail(parser, "Malformed comment");
                parser.comment += "--" + c;
                parser.state = S.COMMENT;
              } else {
                parser.state = S.TEXT;
              }
              continue;
            case S.CDATA:
              if (c === "]") {
                parser.state = S.CDATA_ENDING;
              } else {
                parser.cdata += c;
              }
              continue;
            case S.CDATA_ENDING:
              if (c === "]") {
                parser.state = S.CDATA_ENDING_2;
              } else {
                parser.cdata += "]" + c;
                parser.state = S.CDATA;
              }
              continue;
            case S.CDATA_ENDING_2:
              if (c === ">") {
                if (parser.cdata) {
                  emitNode(parser, "oncdata", parser.cdata);
                }
                emitNode(parser, "onclosecdata");
                parser.cdata = "";
                parser.state = S.TEXT;
              } else if (c === "]") {
                parser.cdata += "]";
              } else {
                parser.cdata += "]]" + c;
                parser.state = S.CDATA;
              }
              continue;
            case S.PROC_INST:
              if (c === "?") {
                parser.state = S.PROC_INST_ENDING;
              } else if (isWhitespace(c)) {
                parser.state = S.PROC_INST_BODY;
              } else {
                parser.procInstName += c;
              }
              continue;
            case S.PROC_INST_BODY:
              if (!parser.procInstBody && isWhitespace(c)) {
                continue;
              } else if (c === "?") {
                parser.state = S.PROC_INST_ENDING;
              } else {
                parser.procInstBody += c;
              }
              continue;
            case S.PROC_INST_ENDING:
              if (c === ">") {
                emitNode(parser, "onprocessinginstruction", {
                  name: parser.procInstName,
                  body: parser.procInstBody
                });
                parser.procInstName = parser.procInstBody = "";
                parser.state = S.TEXT;
              } else {
                parser.procInstBody += "?" + c;
                parser.state = S.PROC_INST_BODY;
              }
              continue;
            case S.OPEN_TAG:
              if (isMatch(nameBody, c)) {
                parser.tagName += c;
              } else {
                newTag(parser);
                if (c === ">") {
                  openTag(parser);
                } else if (c === "/") {
                  parser.state = S.OPEN_TAG_SLASH;
                } else {
                  if (!isWhitespace(c)) {
                    strictFail(parser, "Invalid character in tag name");
                  }
                  parser.state = S.ATTRIB;
                }
              }
              continue;
            case S.OPEN_TAG_SLASH:
              if (c === ">") {
                openTag(parser, true);
                closeTag(parser);
              } else {
                strictFail(parser, "Forward-slash in opening tag not followed by >");
                parser.state = S.ATTRIB;
              }
              continue;
            case S.ATTRIB:
              if (isWhitespace(c)) {
                continue;
              } else if (c === ">") {
                openTag(parser);
              } else if (c === "/") {
                parser.state = S.OPEN_TAG_SLASH;
              } else if (isMatch(nameStart, c)) {
                parser.attribName = c;
                parser.attribValue = "";
                parser.state = S.ATTRIB_NAME;
              } else {
                strictFail(parser, "Invalid attribute name");
              }
              continue;
            case S.ATTRIB_NAME:
              if (c === "=") {
                parser.state = S.ATTRIB_VALUE;
              } else if (c === ">") {
                strictFail(parser, "Attribute without value");
                parser.attribValue = parser.attribName;
                attrib(parser);
                openTag(parser);
              } else if (isWhitespace(c)) {
                parser.state = S.ATTRIB_NAME_SAW_WHITE;
              } else if (isMatch(nameBody, c)) {
                parser.attribName += c;
              } else {
                strictFail(parser, "Invalid attribute name");
              }
              continue;
            case S.ATTRIB_NAME_SAW_WHITE:
              if (c === "=") {
                parser.state = S.ATTRIB_VALUE;
              } else if (isWhitespace(c)) {
                continue;
              } else {
                strictFail(parser, "Attribute without value");
                parser.tag.attributes[parser.attribName] = "";
                parser.attribValue = "";
                emitNode(parser, "onattribute", {
                  name: parser.attribName,
                  value: ""
                });
                parser.attribName = "";
                if (c === ">") {
                  openTag(parser);
                } else if (isMatch(nameStart, c)) {
                  parser.attribName = c;
                  parser.state = S.ATTRIB_NAME;
                } else {
                  strictFail(parser, "Invalid attribute name");
                  parser.state = S.ATTRIB;
                }
              }
              continue;
            case S.ATTRIB_VALUE:
              if (isWhitespace(c)) {
                continue;
              } else if (isQuote(c)) {
                parser.q = c;
                parser.state = S.ATTRIB_VALUE_QUOTED;
              } else {
                strictFail(parser, "Unquoted attribute value");
                parser.state = S.ATTRIB_VALUE_UNQUOTED;
                parser.attribValue = c;
              }
              continue;
            case S.ATTRIB_VALUE_QUOTED:
              if (c !== parser.q) {
                if (c === "&") {
                  parser.state = S.ATTRIB_VALUE_ENTITY_Q;
                } else {
                  parser.attribValue += c;
                }
                continue;
              }
              attrib(parser);
              parser.q = "";
              parser.state = S.ATTRIB_VALUE_CLOSED;
              continue;
            case S.ATTRIB_VALUE_CLOSED:
              if (isWhitespace(c)) {
                parser.state = S.ATTRIB;
              } else if (c === ">") {
                openTag(parser);
              } else if (c === "/") {
                parser.state = S.OPEN_TAG_SLASH;
              } else if (isMatch(nameStart, c)) {
                strictFail(parser, "No whitespace between attributes");
                parser.attribName = c;
                parser.attribValue = "";
                parser.state = S.ATTRIB_NAME;
              } else {
                strictFail(parser, "Invalid attribute name");
              }
              continue;
            case S.ATTRIB_VALUE_UNQUOTED:
              if (!isAttribEnd(c)) {
                if (c === "&") {
                  parser.state = S.ATTRIB_VALUE_ENTITY_U;
                } else {
                  parser.attribValue += c;
                }
                continue;
              }
              attrib(parser);
              if (c === ">") {
                openTag(parser);
              } else {
                parser.state = S.ATTRIB;
              }
              continue;
            case S.CLOSE_TAG:
              if (!parser.tagName) {
                if (isWhitespace(c)) {
                  continue;
                } else if (notMatch(nameStart, c)) {
                  if (parser.script) {
                    parser.script += "</" + c;
                    parser.state = S.SCRIPT;
                  } else {
                    strictFail(parser, "Invalid tagname in closing tag.");
                  }
                } else {
                  parser.tagName = c;
                }
              } else if (c === ">") {
                closeTag(parser);
              } else if (isMatch(nameBody, c)) {
                parser.tagName += c;
              } else if (parser.script) {
                parser.script += "</" + parser.tagName;
                parser.tagName = "";
                parser.state = S.SCRIPT;
              } else {
                if (!isWhitespace(c)) {
                  strictFail(parser, "Invalid tagname in closing tag");
                }
                parser.state = S.CLOSE_TAG_SAW_WHITE;
              }
              continue;
            case S.CLOSE_TAG_SAW_WHITE:
              if (isWhitespace(c)) {
                continue;
              }
              if (c === ">") {
                closeTag(parser);
              } else {
                strictFail(parser, "Invalid characters in closing tag");
              }
              continue;
            case S.TEXT_ENTITY:
            case S.ATTRIB_VALUE_ENTITY_Q:
            case S.ATTRIB_VALUE_ENTITY_U:
              var returnState;
              var buffer;
              switch (parser.state) {
                case S.TEXT_ENTITY:
                  returnState = S.TEXT;
                  buffer = "textNode";
                  break;
                case S.ATTRIB_VALUE_ENTITY_Q:
                  returnState = S.ATTRIB_VALUE_QUOTED;
                  buffer = "attribValue";
                  break;
                case S.ATTRIB_VALUE_ENTITY_U:
                  returnState = S.ATTRIB_VALUE_UNQUOTED;
                  buffer = "attribValue";
                  break;
              }
              if (c === ";") {
                var parsedEntity = parseEntity(parser);
                if (parser.state === S.TEXT_ENTITY && !sax.ENTITIES[parser.entity] && parsedEntity !== "&" + parser.entity + ";") {
                  chunk = chunk.slice(0, i) + parsedEntity + chunk.slice(i);
                } else {
                  parser[buffer] += parsedEntity;
                }
                parser.entity = "";
                parser.state = returnState;
              } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
                parser.entity += c;
              } else {
                strictFail(parser, "Invalid character in entity name");
                parser[buffer] += "&" + parser.entity + c;
                parser.entity = "";
                parser.state = returnState;
              }
              continue;
            default:
              throw new Error(parser, "Unknown state: " + parser.state);
          }
        }
        if (parser.position >= parser.bufferCheckPosition) {
          checkBufferLength(parser);
        }
        return parser;
      }
    })(typeof exports2 === "undefined" ? exports2.sax = {} : exports2);
  }
});

// node_modules/svgo/lib/parser.js
var require_parser3 = __commonJS({
  "node_modules/svgo/lib/parser.js"(exports2) {
    "use strict";
    var SAX = require_sax();
    var JSAPI = require_jsAPI();
    var { textElems } = require_collections();
    var SvgoParserError = class extends Error {
      constructor(message, line, column, source, file) {
        super(message);
        this.name = "SvgoParserError";
        this.message = `${file || "<input>"}:${line}:${column}: ${message}`;
        this.reason = message;
        this.line = line;
        this.column = column;
        this.source = source;
        if (Error.captureStackTrace) {
          Error.captureStackTrace(this, SvgoParserError);
        }
      }
      toString() {
        const lines = this.source.split(/\r?\n/);
        const startLine = Math.max(this.line - 3, 0);
        const endLine = Math.min(this.line + 2, lines.length);
        const lineNumberWidth = String(endLine).length;
        const startColumn = Math.max(this.column - 54, 0);
        const endColumn = Math.max(this.column + 20, 80);
        const code = lines.slice(startLine, endLine).map((line, index) => {
          const lineSlice = line.slice(startColumn, endColumn);
          let ellipsisPrefix = "";
          let ellipsisSuffix = "";
          if (startColumn !== 0) {
            ellipsisPrefix = startColumn > line.length - 1 ? " " : "\u2026";
          }
          if (endColumn < line.length - 1) {
            ellipsisSuffix = "\u2026";
          }
          const number = startLine + 1 + index;
          const gutter = ` ${number.toString().padStart(lineNumberWidth)} | `;
          if (number === this.line) {
            const gutterSpacing = gutter.replace(/[^|]/g, " ");
            const lineSpacing = (ellipsisPrefix + line.slice(startColumn, this.column - 1)).replace(/[^\t]/g, " ");
            const spacing = gutterSpacing + lineSpacing;
            return `>${gutter}${ellipsisPrefix}${lineSlice}${ellipsisSuffix}
 ${spacing}^`;
          }
          return ` ${gutter}${ellipsisPrefix}${lineSlice}${ellipsisSuffix}`;
        }).join("\n");
        return `${this.name}: ${this.message}

${code}
`;
      }
    };
    var entityDeclaration = /<!ENTITY\s+(\S+)\s+(?:'([^']+)'|"([^"]+)")\s*>/g;
    var config = {
      strict: true,
      trim: false,
      normalize: false,
      lowercase: true,
      xmlns: true,
      position: true
    };
    var parseSvg = (data, from) => {
      const sax = SAX.parser(config.strict, config);
      const root = new JSAPI({ type: "root", children: [] });
      let current = root;
      const stack = [root];
      const pushToContent = (node) => {
        const wrapped = new JSAPI(node, current);
        current.children.push(wrapped);
        return wrapped;
      };
      sax.ondoctype = (doctype) => {
        const node = {
          type: "doctype",
          name: "svg",
          data: {
            doctype
          }
        };
        pushToContent(node);
        const subsetStart = doctype.indexOf("[");
        if (subsetStart >= 0) {
          entityDeclaration.lastIndex = subsetStart;
          let entityMatch = entityDeclaration.exec(data);
          while (entityMatch != null) {
            sax.ENTITIES[entityMatch[1]] = entityMatch[2] || entityMatch[3];
            entityMatch = entityDeclaration.exec(data);
          }
        }
      };
      sax.onprocessinginstruction = (data2) => {
        const node = {
          type: "instruction",
          name: data2.name,
          value: data2.body
        };
        pushToContent(node);
      };
      sax.oncomment = (comment) => {
        const node = {
          type: "comment",
          value: comment.trim()
        };
        pushToContent(node);
      };
      sax.oncdata = (cdata) => {
        const node = {
          type: "cdata",
          value: cdata
        };
        pushToContent(node);
      };
      sax.onopentag = (data2) => {
        let element = {
          type: "element",
          name: data2.name,
          attributes: {},
          children: []
        };
        for (const [name, attr] of Object.entries(data2.attributes)) {
          element.attributes[name] = attr.value;
        }
        element = pushToContent(element);
        current = element;
        stack.push(element);
      };
      sax.ontext = (text) => {
        if (current.type === "element") {
          if (textElems.includes(current.name)) {
            const node = {
              type: "text",
              value: text
            };
            pushToContent(node);
          } else if (/\S/.test(text)) {
            const node = {
              type: "text",
              value: text.trim()
            };
            pushToContent(node);
          }
        }
      };
      sax.onclosetag = () => {
        stack.pop();
        current = stack[stack.length - 1];
      };
      sax.onerror = (e) => {
        const error = new SvgoParserError(e.reason, e.line + 1, e.column, data, from);
        if (e.message.indexOf("Unexpected end") === -1) {
          throw error;
        }
      };
      sax.write(data).close();
      return root;
    };
    exports2.parseSvg = parseSvg;
  }
});

// node_modules/svgo/lib/stringifier.js
var require_stringifier2 = __commonJS({
  "node_modules/svgo/lib/stringifier.js"(exports2) {
    "use strict";
    var { textElems } = require_collections();
    var encodeEntity = (char) => {
      return entities[char];
    };
    var defaults = {
      doctypeStart: "<!DOCTYPE",
      doctypeEnd: ">",
      procInstStart: "<?",
      procInstEnd: "?>",
      tagOpenStart: "<",
      tagOpenEnd: ">",
      tagCloseStart: "</",
      tagCloseEnd: ">",
      tagShortStart: "<",
      tagShortEnd: "/>",
      attrStart: '="',
      attrEnd: '"',
      commentStart: "<!--",
      commentEnd: "-->",
      cdataStart: "<![CDATA[",
      cdataEnd: "]]>",
      textStart: "",
      textEnd: "",
      indent: 4,
      regEntities: /[&'"<>]/g,
      regValEntities: /[&"<>]/g,
      encodeEntity,
      pretty: false,
      useShortTags: true,
      eol: "lf",
      finalNewline: false
    };
    var entities = {
      "&": "&amp;",
      "'": "&apos;",
      '"': "&quot;",
      ">": "&gt;",
      "<": "&lt;"
    };
    var stringifySvg = (data, userOptions = {}) => {
      const config = { ...defaults, ...userOptions };
      const indent = config.indent;
      let newIndent = "    ";
      if (typeof indent === "number" && Number.isNaN(indent) === false) {
        newIndent = indent < 0 ? "	" : " ".repeat(indent);
      } else if (typeof indent === "string") {
        newIndent = indent;
      }
      const state = {
        width: void 0,
        height: void 0,
        indent: newIndent,
        textContext: null,
        indentLevel: 0
      };
      const eol = config.eol === "crlf" ? "\r\n" : "\n";
      if (config.pretty) {
        config.doctypeEnd += eol;
        config.procInstEnd += eol;
        config.commentEnd += eol;
        config.cdataEnd += eol;
        config.tagShortEnd += eol;
        config.tagOpenEnd += eol;
        config.tagCloseEnd += eol;
        config.textEnd += eol;
      }
      let svg = stringifyNode(data, config, state);
      if (config.finalNewline && svg.length > 0 && svg[svg.length - 1] !== "\n") {
        svg += eol;
      }
      return {
        data: svg,
        info: {
          width: state.width,
          height: state.height
        }
      };
    };
    exports2.stringifySvg = stringifySvg;
    var stringifyNode = (data, config, state) => {
      let svg = "";
      state.indentLevel += 1;
      for (const item of data.children) {
        if (item.type === "element") {
          svg += stringifyElement(item, config, state);
        }
        if (item.type === "text") {
          svg += stringifyText(item, config, state);
        }
        if (item.type === "doctype") {
          svg += stringifyDoctype(item, config);
        }
        if (item.type === "instruction") {
          svg += stringifyInstruction(item, config);
        }
        if (item.type === "comment") {
          svg += stringifyComment(item, config);
        }
        if (item.type === "cdata") {
          svg += stringifyCdata(item, config, state);
        }
      }
      state.indentLevel -= 1;
      return svg;
    };
    var createIndent = (config, state) => {
      let indent = "";
      if (config.pretty && state.textContext == null) {
        indent = state.indent.repeat(state.indentLevel - 1);
      }
      return indent;
    };
    var stringifyDoctype = (node, config) => {
      return config.doctypeStart + node.data.doctype + config.doctypeEnd;
    };
    var stringifyInstruction = (node, config) => {
      return config.procInstStart + node.name + " " + node.value + config.procInstEnd;
    };
    var stringifyComment = (node, config) => {
      return config.commentStart + node.value + config.commentEnd;
    };
    var stringifyCdata = (node, config, state) => {
      return createIndent(config, state) + config.cdataStart + node.value + config.cdataEnd;
    };
    var stringifyElement = (node, config, state) => {
      if (node.name === "svg" && node.attributes.width != null && node.attributes.height != null) {
        state.width = node.attributes.width;
        state.height = node.attributes.height;
      }
      if (node.children.length === 0) {
        if (config.useShortTags) {
          return createIndent(config, state) + config.tagShortStart + node.name + stringifyAttributes(node, config) + config.tagShortEnd;
        } else {
          return createIndent(config, state) + config.tagShortStart + node.name + stringifyAttributes(node, config) + config.tagOpenEnd + config.tagCloseStart + node.name + config.tagCloseEnd;
        }
      } else {
        let tagOpenStart = config.tagOpenStart;
        let tagOpenEnd = config.tagOpenEnd;
        let tagCloseStart = config.tagCloseStart;
        let tagCloseEnd = config.tagCloseEnd;
        let openIndent = createIndent(config, state);
        let closeIndent = createIndent(config, state);
        if (state.textContext) {
          tagOpenStart = defaults.tagOpenStart;
          tagOpenEnd = defaults.tagOpenEnd;
          tagCloseStart = defaults.tagCloseStart;
          tagCloseEnd = defaults.tagCloseEnd;
          openIndent = "";
        } else if (textElems.includes(node.name)) {
          tagOpenEnd = defaults.tagOpenEnd;
          tagCloseStart = defaults.tagCloseStart;
          closeIndent = "";
          state.textContext = node;
        }
        const children = stringifyNode(node, config, state);
        if (state.textContext === node) {
          state.textContext = null;
        }
        return openIndent + tagOpenStart + node.name + stringifyAttributes(node, config) + tagOpenEnd + children + closeIndent + tagCloseStart + node.name + tagCloseEnd;
      }
    };
    var stringifyAttributes = (node, config) => {
      let attrs = "";
      for (const [name, value] of Object.entries(node.attributes)) {
        if (value !== void 0) {
          const encodedValue = value.toString().replace(config.regValEntities, config.encodeEntity);
          attrs += " " + name + config.attrStart + encodedValue + config.attrEnd;
        } else {
          attrs += " " + name;
        }
      }
      return attrs;
    };
    var stringifyText = (node, config, state) => {
      return createIndent(config, state) + config.textStart + node.value.replace(config.regEntities, config.encodeEntity) + (state.textContext ? "" : config.textEnd);
    };
  }
});

// node_modules/svgo/lib/svgo.js
var require_svgo = __commonJS({
  "node_modules/svgo/lib/svgo.js"(exports2) {
    "use strict";
    var {
      defaultPlugins,
      resolvePluginConfig,
      extendDefaultPlugins
    } = require_config();
    var { parseSvg } = require_parser3();
    var { stringifySvg } = require_stringifier2();
    var { invokePlugins } = require_plugins();
    var JSAPI = require_jsAPI();
    var { encodeSVGDatauri } = require_tools();
    exports2.extendDefaultPlugins = extendDefaultPlugins;
    var optimize = (input, config) => {
      if (config == null) {
        config = {};
      }
      if (typeof config !== "object") {
        throw Error("Config should be an object");
      }
      const maxPassCount = config.multipass ? 10 : 1;
      let prevResultSize = Number.POSITIVE_INFINITY;
      let svgjs = null;
      const info = {};
      if (config.path != null) {
        info.path = config.path;
      }
      for (let i = 0; i < maxPassCount; i += 1) {
        info.multipassCount = i;
        try {
          svgjs = parseSvg(input, config.path);
        } catch (error) {
          return { error: error.toString(), modernError: error };
        }
        if (svgjs.error != null) {
          if (config.path != null) {
            svgjs.path = config.path;
          }
          return svgjs;
        }
        const plugins = config.plugins || defaultPlugins;
        if (Array.isArray(plugins) === false) {
          throw Error("Invalid plugins list. Provided 'plugins' in config should be an array.");
        }
        const resolvedPlugins = plugins.map(resolvePluginConfig);
        const globalOverrides = {};
        if (config.floatPrecision != null) {
          globalOverrides.floatPrecision = config.floatPrecision;
        }
        svgjs = invokePlugins(svgjs, info, resolvedPlugins, null, globalOverrides);
        svgjs = stringifySvg(svgjs, config.js2svg);
        if (svgjs.data.length < prevResultSize) {
          input = svgjs.data;
          prevResultSize = svgjs.data.length;
        } else {
          if (config.datauri) {
            svgjs.data = encodeSVGDatauri(svgjs.data, config.datauri);
          }
          if (config.path != null) {
            svgjs.path = config.path;
          }
          return svgjs;
        }
      }
      return svgjs;
    };
    exports2.optimize = optimize;
    var createContentItem = (data) => {
      return new JSAPI(data);
    };
    exports2.createContentItem = createContentItem;
  }
});

// node_modules/svgo/lib/svgo-node.js
var require_svgo_node = __commonJS({
  "node_modules/svgo/lib/svgo-node.js"(exports2) {
    "use strict";
    var os = require("os");
    var fs = require("fs");
    var { pathToFileURL } = require("url");
    var path = require("path");
    var {
      extendDefaultPlugins,
      optimize: optimizeAgnostic,
      createContentItem
    } = require_svgo();
    exports2.extendDefaultPlugins = extendDefaultPlugins;
    exports2.createContentItem = createContentItem;
    var importConfig = async (configFile) => {
      let config;
      if (configFile.endsWith(".cjs")) {
        config = require(configFile);
      } else {
        try {
          const { default: imported } = await import(pathToFileURL(configFile));
          config = imported;
        } catch (importError) {
          try {
            config = require(configFile);
          } catch (requireError) {
            if (requireError.code === "ERR_REQUIRE_ESM") {
              throw importError;
            } else {
              throw requireError;
            }
          }
        }
      }
      if (config == null || typeof config !== "object" || Array.isArray(config)) {
        throw Error(`Invalid config file "${configFile}"`);
      }
      return config;
    };
    var isFile = async (file) => {
      try {
        const stats = await fs.promises.stat(file);
        return stats.isFile();
      } catch {
        return false;
      }
    };
    var loadConfig = async (configFile, cwd = process.cwd()) => {
      if (configFile != null) {
        if (path.isAbsolute(configFile)) {
          return await importConfig(configFile);
        } else {
          return await importConfig(path.join(cwd, configFile));
        }
      }
      let dir = cwd;
      while (true) {
        const js = path.join(dir, "svgo.config.js");
        if (await isFile(js)) {
          return await importConfig(js);
        }
        const mjs = path.join(dir, "svgo.config.mjs");
        if (await isFile(mjs)) {
          return await importConfig(mjs);
        }
        const cjs = path.join(dir, "svgo.config.cjs");
        if (await isFile(cjs)) {
          return await importConfig(cjs);
        }
        const parent = path.dirname(dir);
        if (dir === parent) {
          return null;
        }
        dir = parent;
      }
    };
    exports2.loadConfig = loadConfig;
    var optimize = (input, config) => {
      if (config == null) {
        config = {};
      }
      if (typeof config !== "object") {
        throw Error("Config should be an object");
      }
      return optimizeAgnostic(input, {
        ...config,
        js2svg: {
          eol: os.EOL === "\r\n" ? "crlf" : "lf",
          ...config.js2svg
        }
      });
    };
    exports2.optimize = optimize;
  }
});

// node_modules/postcss-svgo/src/lib/url.js
var require_url2 = __commonJS({
  "node_modules/postcss-svgo/src/lib/url.js"(exports2, module2) {
    "use strict";
    function encode(data) {
      return data.replace(/"/g, "'").replace(/%/g, "%25").replace(/</g, "%3C").replace(/>/g, "%3E").replace(/&/g, "%26").replace(/#/g, "%23").replace(/\s+/g, " ");
    }
    var decode = decodeURIComponent;
    module2.exports = { encode, decode };
  }
});

// node_modules/postcss-svgo/src/index.js
var require_src6 = __commonJS({
  "node_modules/postcss-svgo/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var { optimize } = require_svgo_node();
    var { encode, decode } = require_url2();
    var PLUGIN = "postcss-svgo";
    var dataURI = /data:image\/svg\+xml(;((charset=)?utf-8|base64))?,/i;
    var dataURIBase64 = /data:image\/svg\+xml;base64,/i;
    var escapedQuotes = /\b([\w-]+)\s*=\s*\\"([\S\s]+?)\\"/g;
    function minifySVG(input, opts) {
      let svg = input;
      let decodedUri, isUriEncoded;
      try {
        decodedUri = decode(input);
        isUriEncoded = decodedUri !== input;
      } catch (e) {
        isUriEncoded = false;
      }
      if (isUriEncoded) {
        svg = decodedUri;
      }
      if (opts.encode !== void 0) {
        isUriEncoded = opts.encode;
      }
      svg = svg.replace(escapedQuotes, '$1="$2"');
      const result = optimize(svg, opts);
      if (result.error) {
        throw new Error(result.error);
      }
      return {
        result: result.data,
        isUriEncoded
      };
    }
    function minify(decl, opts, postcssResult) {
      const parsed = valueParser(decl.value);
      const minified = parsed.walk((node) => {
        if (node.type !== "function" || node.value.toLowerCase() !== "url" || !node.nodes.length) {
          return;
        }
        let { value, quote } = node.nodes[0];
        let optimizedValue;
        try {
          if (dataURIBase64.test(value)) {
            const url = new URL(value);
            const base64String = `${url.protocol}${url.pathname}`.replace(dataURI, "");
            const svg = Buffer.from(base64String, "base64").toString("utf8");
            const { result } = minifySVG(svg, opts);
            const data = Buffer.from(result).toString("base64");
            optimizedValue = "data:image/svg+xml;base64," + data + url.hash;
          } else if (dataURI.test(value)) {
            const svg = value.replace(dataURI, "");
            const { result, isUriEncoded } = minifySVG(svg, opts);
            let data = isUriEncoded ? encode(result) : result;
            data = data.replace(/#/g, "%23");
            optimizedValue = "data:image/svg+xml;charset=utf-8," + data;
            quote = isUriEncoded ? '"' : "'";
          } else {
            return;
          }
        } catch (error) {
          decl.warn(postcssResult, `${error}`);
          return;
        }
        node.nodes[0] = Object.assign({}, node.nodes[0], {
          value: optimizedValue,
          quote,
          type: "string",
          before: "",
          after: ""
        });
        return false;
      });
      decl.value = minified.toString();
    }
    function pluginCreator(opts = {}) {
      return {
        postcssPlugin: PLUGIN,
        OnceExit(css, { result }) {
          css.walkDecls((decl) => {
            if (!dataURI.test(decl.value)) {
              return;
            }
            minify(decl, opts, result);
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-reduce-transforms/src/index.js
var require_src7 = __commonJS({
  "node_modules/postcss-reduce-transforms/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    function getValues(list, node, index) {
      if (index % 2 === 0) {
        let value = NaN;
        if (node.type === "function" && (node.value === "var" || node.value === "env") && node.nodes.length === 1) {
          value = valueParser.stringify(node.nodes);
        } else if (node.type === "word") {
          value = parseFloat(node.value);
        }
        return [...list, value];
      }
      return list;
    }
    function matrix3d(node, values) {
      if (values.length !== 16) {
        return;
      }
      if (values[15] && values[2] === 0 && values[3] === 0 && values[6] === 0 && values[7] === 0 && values[8] === 0 && values[9] === 0 && values[10] === 1 && values[11] === 0 && values[14] === 0 && values[15] === 1) {
        const { nodes } = node;
        node.value = "matrix";
        node.nodes = [
          nodes[0],
          nodes[1],
          nodes[2],
          nodes[3],
          nodes[8],
          nodes[9],
          nodes[10],
          nodes[11],
          nodes[24],
          nodes[25],
          nodes[26]
        ];
      }
    }
    var rotate3dMappings = /* @__PURE__ */ new Map([
      [[1, 0, 0].toString(), "rotateX"],
      [[0, 1, 0].toString(), "rotateY"],
      [[0, 0, 1].toString(), "rotate"]
    ]);
    function rotate3d(node, values) {
      if (values.length !== 4) {
        return;
      }
      const { nodes } = node;
      const match = rotate3dMappings.get(values.slice(0, 3).toString());
      if (match) {
        node.value = match;
        node.nodes = [nodes[6]];
      }
    }
    function rotateZ(node, values) {
      if (values.length !== 1) {
        return;
      }
      node.value = "rotate";
    }
    function scale(node, values) {
      if (values.length !== 2) {
        return;
      }
      const { nodes } = node;
      const [first, second] = values;
      if (first === second) {
        node.nodes = [nodes[0]];
        return;
      }
      if (second === 1) {
        node.value = "scaleX";
        node.nodes = [nodes[0]];
        return;
      }
      if (first === 1) {
        node.value = "scaleY";
        node.nodes = [nodes[2]];
        return;
      }
    }
    function scale3d(node, values) {
      if (values.length !== 3) {
        return;
      }
      const { nodes } = node;
      const [first, second, third] = values;
      if (second === 1 && third === 1) {
        node.value = "scaleX";
        node.nodes = [nodes[0]];
        return;
      }
      if (first === 1 && third === 1) {
        node.value = "scaleY";
        node.nodes = [nodes[2]];
        return;
      }
      if (first === 1 && second === 1) {
        node.value = "scaleZ";
        node.nodes = [nodes[4]];
        return;
      }
    }
    function translate(node, values) {
      if (values.length !== 2) {
        return;
      }
      const { nodes } = node;
      if (values[1] === 0) {
        node.nodes = [nodes[0]];
        return;
      }
      if (values[0] === 0) {
        node.value = "translateY";
        node.nodes = [nodes[2]];
        return;
      }
    }
    function translate3d(node, values) {
      if (values.length !== 3) {
        return;
      }
      const { nodes } = node;
      if (values[0] === 0 && values[1] === 0) {
        node.value = "translateZ";
        node.nodes = [nodes[4]];
      }
    }
    var reducers = /* @__PURE__ */ new Map([
      ["matrix3d", matrix3d],
      ["rotate3d", rotate3d],
      ["rotateZ", rotateZ],
      ["scale", scale],
      ["scale3d", scale3d],
      ["translate", translate],
      ["translate3d", translate3d]
    ]);
    function normalizeReducerName(name) {
      const lowerCasedName = name.toLowerCase();
      if (lowerCasedName === "rotatez") {
        return "rotateZ";
      }
      return lowerCasedName;
    }
    function reduce(node) {
      if (node.type === "function") {
        const normalizedReducerName = normalizeReducerName(node.value);
        const reducer = reducers.get(normalizedReducerName);
        if (reducer !== void 0) {
          reducer(node, node.nodes.reduce(getValues, []));
        }
      }
      return false;
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-reduce-transforms",
        prepare() {
          const cache = /* @__PURE__ */ new Map();
          return {
            OnceExit(css) {
              css.walkDecls(/transform$/i, (decl) => {
                const value = decl.value;
                if (!value) {
                  return;
                }
                if (cache.has(value)) {
                  decl.value = cache.get(value);
                  return;
                }
                const result = valueParser(value).walk(reduce).toString();
                decl.value = result;
                cache.set(value, result);
              });
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-convert-values/src/lib/convert.js
var require_convert = __commonJS({
  "node_modules/postcss-convert-values/src/lib/convert.js"(exports2, module2) {
    "use strict";
    var lengthConv = /* @__PURE__ */ new Map([
      ["in", 96],
      ["px", 1],
      ["pt", 4 / 3],
      ["pc", 16]
    ]);
    var timeConv = /* @__PURE__ */ new Map([
      ["s", 1e3],
      ["ms", 1]
    ]);
    var angleConv = /* @__PURE__ */ new Map([
      ["turn", 360],
      ["deg", 1]
    ]);
    function dropLeadingZero(number) {
      const value = String(number);
      if (number % 1) {
        if (value[0] === "0") {
          return value.slice(1);
        }
        if (value[0] === "-" && value[1] === "0") {
          return "-" + value.slice(2);
        }
      }
      return value;
    }
    function transform(number, originalUnit, conversions) {
      let conversionUnits = [...conversions.keys()].filter((u) => {
        return originalUnit !== u;
      });
      const base = number * conversions.get(originalUnit);
      return conversionUnits.map((u) => dropLeadingZero(base / conversions.get(u)) + u).reduce((a, b) => a.length < b.length ? a : b);
    }
    module2.exports = function(number, unit, { time, length, angle }) {
      let value = dropLeadingZero(number) + (unit ? unit : "");
      let converted;
      const lowerCaseUnit = unit.toLowerCase();
      if (length !== false && lengthConv.has(lowerCaseUnit)) {
        converted = transform(number, lowerCaseUnit, lengthConv);
      }
      if (time !== false && timeConv.has(lowerCaseUnit)) {
        converted = transform(number, lowerCaseUnit, timeConv);
      }
      if (angle !== false && angleConv.has(lowerCaseUnit)) {
        converted = transform(number, lowerCaseUnit, angleConv);
      }
      if (converted && converted.length < value.length) {
        value = converted;
      }
      return value;
    };
  }
});

// node_modules/postcss-convert-values/src/index.js
var require_src8 = __commonJS({
  "node_modules/postcss-convert-values/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var browserslist = require_browserslist();
    var convert = require_convert();
    var LENGTH_UNITS = /* @__PURE__ */ new Set([
      "em",
      "ex",
      "ch",
      "rem",
      "vw",
      "vh",
      "vmin",
      "vmax",
      "cm",
      "mm",
      "q",
      "in",
      "pt",
      "pc",
      "px"
    ]);
    var notALength = /* @__PURE__ */ new Set([
      "descent-override",
      "ascent-override",
      "font-stretch",
      "size-adjust",
      "line-gap-override"
    ]);
    var keepWhenZero = /* @__PURE__ */ new Set([
      "stroke-dashoffset",
      "stroke-width",
      "line-height"
    ]);
    var keepZeroPercent = /* @__PURE__ */ new Set(["max-height", "height", "min-width"]);
    function stripLeadingDot(item) {
      if (item.charCodeAt(0) === ".".charCodeAt(0)) {
        return item.slice(1);
      } else {
        return item;
      }
    }
    function parseWord(node, opts, keepZeroUnit) {
      const pair = valueParser.unit(node.value);
      if (pair) {
        const num = Number(pair.number);
        const u = stripLeadingDot(pair.unit);
        if (num === 0) {
          node.value = 0 + (keepZeroUnit || !LENGTH_UNITS.has(u.toLowerCase()) && u !== "%" ? u : "");
        } else {
          node.value = convert(num, u, opts);
          if (typeof opts.precision === "number" && u.toLowerCase() === "px" && pair.number.includes(".")) {
            const precision = Math.pow(10, opts.precision);
            node.value = Math.round(parseFloat(node.value) * precision) / precision + u;
          }
        }
      }
    }
    function clampOpacity(node) {
      const pair = valueParser.unit(node.value);
      if (!pair) {
        return;
      }
      let num = Number(pair.number);
      if (num > 1) {
        node.value = pair.unit === "%" ? num + pair.unit : 1 + pair.unit;
      } else if (num < 0) {
        node.value = 0 + pair.unit;
      }
    }
    function shouldKeepZeroUnit(decl, browsers) {
      const { parent } = decl;
      const lowerCasedProp = decl.prop.toLowerCase();
      return decl.value.includes("%") && keepZeroPercent.has(lowerCasedProp) && browsers.includes("ie 11") || parent && parent.parent && parent.parent.type === "atrule" && parent.parent.name.toLowerCase() === "keyframes" && lowerCasedProp === "stroke-dasharray" || keepWhenZero.has(lowerCasedProp);
    }
    function transform(opts, browsers, decl) {
      const lowerCasedProp = decl.prop.toLowerCase();
      if (lowerCasedProp.includes("flex") || lowerCasedProp.indexOf("--") === 0 || notALength.has(lowerCasedProp)) {
        return;
      }
      decl.value = valueParser(decl.value).walk((node) => {
        const lowerCasedValue = node.value.toLowerCase();
        if (node.type === "word") {
          parseWord(node, opts, shouldKeepZeroUnit(decl, browsers));
          if (lowerCasedProp === "opacity" || lowerCasedProp === "shape-image-threshold") {
            clampOpacity(node);
          }
        } else if (node.type === "function") {
          if (lowerCasedValue === "calc" || lowerCasedValue === "min" || lowerCasedValue === "max" || lowerCasedValue === "clamp" || lowerCasedValue === "hsl" || lowerCasedValue === "hsla") {
            valueParser.walk(node.nodes, (n) => {
              if (n.type === "word") {
                parseWord(n, opts, true);
              }
            });
            return false;
          }
          if (lowerCasedValue === "url") {
            return false;
          }
        }
      }).toString();
    }
    var plugin = "postcss-convert-values";
    function pluginCreator(opts = { precision: false }) {
      const browsers = browserslist(null, {
        stats: opts.stats,
        path: __dirname,
        env: opts.env
      });
      return {
        postcssPlugin: plugin,
        OnceExit(css) {
          css.walkDecls((decl) => transform(opts, browsers, decl));
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-selector-parser/dist/util/unesc.js
var require_unesc = __commonJS({
  "node_modules/postcss-selector-parser/dist/util/unesc.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = unesc;
    function gobbleHex(str) {
      var lower = str.toLowerCase();
      var hex = "";
      var spaceTerminated = false;
      for (var i = 0; i < 6 && lower[i] !== void 0; i++) {
        var code = lower.charCodeAt(i);
        var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
        spaceTerminated = code === 32;
        if (!valid) {
          break;
        }
        hex += lower[i];
      }
      if (hex.length === 0) {
        return void 0;
      }
      var codePoint = parseInt(hex, 16);
      var isSurrogate = codePoint >= 55296 && codePoint <= 57343;
      if (isSurrogate || codePoint === 0 || codePoint > 1114111) {
        return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)];
      }
      return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
    }
    var CONTAINS_ESCAPE = /\\/;
    function unesc(str) {
      var needToProcess = CONTAINS_ESCAPE.test(str);
      if (!needToProcess) {
        return str;
      }
      var ret = "";
      for (var i = 0; i < str.length; i++) {
        if (str[i] === "\\") {
          var gobbled = gobbleHex(str.slice(i + 1, i + 7));
          if (gobbled !== void 0) {
            ret += gobbled[0];
            i += gobbled[1];
            continue;
          }
          if (str[i + 1] === "\\") {
            ret += "\\";
            i++;
            continue;
          }
          if (str.length === i + 1) {
            ret += str[i];
          }
          continue;
        }
        ret += str[i];
      }
      return ret;
    }
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/util/getProp.js
var require_getProp = __commonJS({
  "node_modules/postcss-selector-parser/dist/util/getProp.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = getProp;
    function getProp(obj) {
      for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        props[_key - 1] = arguments[_key];
      }
      while (props.length > 0) {
        var prop = props.shift();
        if (!obj[prop]) {
          return void 0;
        }
        obj = obj[prop];
      }
      return obj;
    }
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/util/ensureObject.js
var require_ensureObject = __commonJS({
  "node_modules/postcss-selector-parser/dist/util/ensureObject.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = ensureObject;
    function ensureObject(obj) {
      for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        props[_key - 1] = arguments[_key];
      }
      while (props.length > 0) {
        var prop = props.shift();
        if (!obj[prop]) {
          obj[prop] = {};
        }
        obj = obj[prop];
      }
    }
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/util/stripComments.js
var require_stripComments = __commonJS({
  "node_modules/postcss-selector-parser/dist/util/stripComments.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = stripComments;
    function stripComments(str) {
      var s = "";
      var commentStart = str.indexOf("/*");
      var lastEnd = 0;
      while (commentStart >= 0) {
        s = s + str.slice(lastEnd, commentStart);
        var commentEnd = str.indexOf("*/", commentStart + 2);
        if (commentEnd < 0) {
          return s;
        }
        lastEnd = commentEnd + 2;
        commentStart = str.indexOf("/*", lastEnd);
      }
      s = s + str.slice(lastEnd);
      return s;
    }
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/util/index.js
var require_util3 = __commonJS({
  "node_modules/postcss-selector-parser/dist/util/index.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.stripComments = exports2.ensureObject = exports2.getProp = exports2.unesc = void 0;
    var _unesc = _interopRequireDefault(require_unesc());
    exports2.unesc = _unesc["default"];
    var _getProp = _interopRequireDefault(require_getProp());
    exports2.getProp = _getProp["default"];
    var _ensureObject = _interopRequireDefault(require_ensureObject());
    exports2.ensureObject = _ensureObject["default"];
    var _stripComments = _interopRequireDefault(require_stripComments());
    exports2.stripComments = _stripComments["default"];
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
  }
});

// node_modules/postcss-selector-parser/dist/selectors/node.js
var require_node5 = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/node.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _util = require_util3();
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor)
          descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps)
        _defineProperties(Constructor.prototype, protoProps);
      if (staticProps)
        _defineProperties(Constructor, staticProps);
      return Constructor;
    }
    var cloneNode = function cloneNode2(obj, parent) {
      if (typeof obj !== "object" || obj === null) {
        return obj;
      }
      var cloned = new obj.constructor();
      for (var i in obj) {
        if (!obj.hasOwnProperty(i)) {
          continue;
        }
        var value = obj[i];
        var type = typeof value;
        if (i === "parent" && type === "object") {
          if (parent) {
            cloned[i] = parent;
          }
        } else if (value instanceof Array) {
          cloned[i] = value.map(function(j) {
            return cloneNode2(j, cloned);
          });
        } else {
          cloned[i] = cloneNode2(value, cloned);
        }
      }
      return cloned;
    };
    var Node = /* @__PURE__ */ function() {
      function Node2(opts) {
        if (opts === void 0) {
          opts = {};
        }
        Object.assign(this, opts);
        this.spaces = this.spaces || {};
        this.spaces.before = this.spaces.before || "";
        this.spaces.after = this.spaces.after || "";
      }
      var _proto = Node2.prototype;
      _proto.remove = function remove() {
        if (this.parent) {
          this.parent.removeChild(this);
        }
        this.parent = void 0;
        return this;
      };
      _proto.replaceWith = function replaceWith() {
        if (this.parent) {
          for (var index in arguments) {
            this.parent.insertBefore(this, arguments[index]);
          }
          this.remove();
        }
        return this;
      };
      _proto.next = function next() {
        return this.parent.at(this.parent.index(this) + 1);
      };
      _proto.prev = function prev() {
        return this.parent.at(this.parent.index(this) - 1);
      };
      _proto.clone = function clone(overrides) {
        if (overrides === void 0) {
          overrides = {};
        }
        var cloned = cloneNode(this);
        for (var name in overrides) {
          cloned[name] = overrides[name];
        }
        return cloned;
      };
      _proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
        if (!this.raws) {
          this.raws = {};
        }
        var originalValue = this[name];
        var originalEscaped = this.raws[name];
        this[name] = originalValue + value;
        if (originalEscaped || valueEscaped !== value) {
          this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
        } else {
          delete this.raws[name];
        }
      };
      _proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
        if (!this.raws) {
          this.raws = {};
        }
        this[name] = value;
        this.raws[name] = valueEscaped;
      };
      _proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
        this[name] = value;
        if (this.raws) {
          delete this.raws[name];
        }
      };
      _proto.isAtPosition = function isAtPosition(line, column) {
        if (this.source && this.source.start && this.source.end) {
          if (this.source.start.line > line) {
            return false;
          }
          if (this.source.end.line < line) {
            return false;
          }
          if (this.source.start.line === line && this.source.start.column > column) {
            return false;
          }
          if (this.source.end.line === line && this.source.end.column < column) {
            return false;
          }
          return true;
        }
        return void 0;
      };
      _proto.stringifyProperty = function stringifyProperty(name) {
        return this.raws && this.raws[name] || this[name];
      };
      _proto.valueToString = function valueToString() {
        return String(this.stringifyProperty("value"));
      };
      _proto.toString = function toString() {
        return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join("");
      };
      _createClass(Node2, [{
        key: "rawSpaceBefore",
        get: function get() {
          var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
          if (rawSpace === void 0) {
            rawSpace = this.spaces && this.spaces.before;
          }
          return rawSpace || "";
        },
        set: function set(raw) {
          (0, _util.ensureObject)(this, "raws", "spaces");
          this.raws.spaces.before = raw;
        }
      }, {
        key: "rawSpaceAfter",
        get: function get() {
          var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
          if (rawSpace === void 0) {
            rawSpace = this.spaces.after;
          }
          return rawSpace || "";
        },
        set: function set(raw) {
          (0, _util.ensureObject)(this, "raws", "spaces");
          this.raws.spaces.after = raw;
        }
      }]);
      return Node2;
    }();
    exports2["default"] = Node;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/types.js
var require_types2 = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/types.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.UNIVERSAL = exports2.ATTRIBUTE = exports2.CLASS = exports2.COMBINATOR = exports2.COMMENT = exports2.ID = exports2.NESTING = exports2.PSEUDO = exports2.ROOT = exports2.SELECTOR = exports2.STRING = exports2.TAG = void 0;
    var TAG = "tag";
    exports2.TAG = TAG;
    var STRING = "string";
    exports2.STRING = STRING;
    var SELECTOR = "selector";
    exports2.SELECTOR = SELECTOR;
    var ROOT = "root";
    exports2.ROOT = ROOT;
    var PSEUDO = "pseudo";
    exports2.PSEUDO = PSEUDO;
    var NESTING = "nesting";
    exports2.NESTING = NESTING;
    var ID = "id";
    exports2.ID = ID;
    var COMMENT = "comment";
    exports2.COMMENT = COMMENT;
    var COMBINATOR = "combinator";
    exports2.COMBINATOR = COMBINATOR;
    var CLASS = "class";
    exports2.CLASS = CLASS;
    var ATTRIBUTE = "attribute";
    exports2.ATTRIBUTE = ATTRIBUTE;
    var UNIVERSAL = "universal";
    exports2.UNIVERSAL = UNIVERSAL;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/container.js
var require_container2 = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/container.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _node = _interopRequireDefault(require_node5());
    var types = _interopRequireWildcard(require_types2());
    function _getRequireWildcardCache() {
      if (typeof WeakMap !== "function")
        return null;
      var cache = /* @__PURE__ */ new WeakMap();
      _getRequireWildcardCache = function _getRequireWildcardCache2() {
        return cache;
      };
      return cache;
    }
    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      }
      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
        return { "default": obj };
      }
      var cache = _getRequireWildcardCache();
      if (cache && cache.has(obj)) {
        return cache.get(obj);
      }
      var newObj = {};
      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
      for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
          if (desc && (desc.get || desc.set)) {
            Object.defineProperty(newObj, key, desc);
          } else {
            newObj[key] = obj[key];
          }
        }
      }
      newObj["default"] = obj;
      if (cache) {
        cache.set(obj, newObj);
      }
      return newObj;
    }
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _createForOfIteratorHelperLoose(o, allowArrayLike) {
      var it;
      if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
        if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
          if (it)
            o = it;
          var i = 0;
          return function() {
            if (i >= o.length)
              return { done: true };
            return { done: false, value: o[i++] };
          };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      it = o[Symbol.iterator]();
      return it.next.bind(it);
    }
    function _unsupportedIterableToArray(o, minLen) {
      if (!o)
        return;
      if (typeof o === "string")
        return _arrayLikeToArray(o, minLen);
      var n = Object.prototype.toString.call(o).slice(8, -1);
      if (n === "Object" && o.constructor)
        n = o.constructor.name;
      if (n === "Map" || n === "Set")
        return Array.from(o);
      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
        return _arrayLikeToArray(o, minLen);
    }
    function _arrayLikeToArray(arr, len) {
      if (len == null || len > arr.length)
        len = arr.length;
      for (var i = 0, arr2 = new Array(len); i < len; i++) {
        arr2[i] = arr[i];
      }
      return arr2;
    }
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor)
          descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps)
        _defineProperties(Constructor.prototype, protoProps);
      if (staticProps)
        _defineProperties(Constructor, staticProps);
      return Constructor;
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Container = /* @__PURE__ */ function(_Node) {
      _inheritsLoose(Container2, _Node);
      function Container2(opts) {
        var _this;
        _this = _Node.call(this, opts) || this;
        if (!_this.nodes) {
          _this.nodes = [];
        }
        return _this;
      }
      var _proto = Container2.prototype;
      _proto.append = function append(selector) {
        selector.parent = this;
        this.nodes.push(selector);
        return this;
      };
      _proto.prepend = function prepend(selector) {
        selector.parent = this;
        this.nodes.unshift(selector);
        return this;
      };
      _proto.at = function at(index) {
        return this.nodes[index];
      };
      _proto.index = function index(child) {
        if (typeof child === "number") {
          return child;
        }
        return this.nodes.indexOf(child);
      };
      _proto.removeChild = function removeChild(child) {
        child = this.index(child);
        this.at(child).parent = void 0;
        this.nodes.splice(child, 1);
        var index;
        for (var id in this.indexes) {
          index = this.indexes[id];
          if (index >= child) {
            this.indexes[id] = index - 1;
          }
        }
        return this;
      };
      _proto.removeAll = function removeAll() {
        for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done; ) {
          var node = _step.value;
          node.parent = void 0;
        }
        this.nodes = [];
        return this;
      };
      _proto.empty = function empty() {
        return this.removeAll();
      };
      _proto.insertAfter = function insertAfter(oldNode, newNode) {
        newNode.parent = this;
        var oldIndex = this.index(oldNode);
        this.nodes.splice(oldIndex + 1, 0, newNode);
        newNode.parent = this;
        var index;
        for (var id in this.indexes) {
          index = this.indexes[id];
          if (oldIndex <= index) {
            this.indexes[id] = index + 1;
          }
        }
        return this;
      };
      _proto.insertBefore = function insertBefore(oldNode, newNode) {
        newNode.parent = this;
        var oldIndex = this.index(oldNode);
        this.nodes.splice(oldIndex, 0, newNode);
        newNode.parent = this;
        var index;
        for (var id in this.indexes) {
          index = this.indexes[id];
          if (index <= oldIndex) {
            this.indexes[id] = index + 1;
          }
        }
        return this;
      };
      _proto._findChildAtPosition = function _findChildAtPosition(line, col) {
        var found = void 0;
        this.each(function(node) {
          if (node.atPosition) {
            var foundChild = node.atPosition(line, col);
            if (foundChild) {
              found = foundChild;
              return false;
            }
          } else if (node.isAtPosition(line, col)) {
            found = node;
            return false;
          }
        });
        return found;
      };
      _proto.atPosition = function atPosition(line, col) {
        if (this.isAtPosition(line, col)) {
          return this._findChildAtPosition(line, col) || this;
        } else {
          return void 0;
        }
      };
      _proto._inferEndPosition = function _inferEndPosition() {
        if (this.last && this.last.source && this.last.source.end) {
          this.source = this.source || {};
          this.source.end = this.source.end || {};
          Object.assign(this.source.end, this.last.source.end);
        }
      };
      _proto.each = function each(callback) {
        if (!this.lastEach) {
          this.lastEach = 0;
        }
        if (!this.indexes) {
          this.indexes = {};
        }
        this.lastEach++;
        var id = this.lastEach;
        this.indexes[id] = 0;
        if (!this.length) {
          return void 0;
        }
        var index, result;
        while (this.indexes[id] < this.length) {
          index = this.indexes[id];
          result = callback(this.at(index), index);
          if (result === false) {
            break;
          }
          this.indexes[id] += 1;
        }
        delete this.indexes[id];
        if (result === false) {
          return false;
        }
      };
      _proto.walk = function walk(callback) {
        return this.each(function(node, i) {
          var result = callback(node, i);
          if (result !== false && node.length) {
            result = node.walk(callback);
          }
          if (result === false) {
            return false;
          }
        });
      };
      _proto.walkAttributes = function walkAttributes(callback) {
        var _this2 = this;
        return this.walk(function(selector) {
          if (selector.type === types.ATTRIBUTE) {
            return callback.call(_this2, selector);
          }
        });
      };
      _proto.walkClasses = function walkClasses(callback) {
        var _this3 = this;
        return this.walk(function(selector) {
          if (selector.type === types.CLASS) {
            return callback.call(_this3, selector);
          }
        });
      };
      _proto.walkCombinators = function walkCombinators(callback) {
        var _this4 = this;
        return this.walk(function(selector) {
          if (selector.type === types.COMBINATOR) {
            return callback.call(_this4, selector);
          }
        });
      };
      _proto.walkComments = function walkComments(callback) {
        var _this5 = this;
        return this.walk(function(selector) {
          if (selector.type === types.COMMENT) {
            return callback.call(_this5, selector);
          }
        });
      };
      _proto.walkIds = function walkIds(callback) {
        var _this6 = this;
        return this.walk(function(selector) {
          if (selector.type === types.ID) {
            return callback.call(_this6, selector);
          }
        });
      };
      _proto.walkNesting = function walkNesting(callback) {
        var _this7 = this;
        return this.walk(function(selector) {
          if (selector.type === types.NESTING) {
            return callback.call(_this7, selector);
          }
        });
      };
      _proto.walkPseudos = function walkPseudos(callback) {
        var _this8 = this;
        return this.walk(function(selector) {
          if (selector.type === types.PSEUDO) {
            return callback.call(_this8, selector);
          }
        });
      };
      _proto.walkTags = function walkTags(callback) {
        var _this9 = this;
        return this.walk(function(selector) {
          if (selector.type === types.TAG) {
            return callback.call(_this9, selector);
          }
        });
      };
      _proto.walkUniversals = function walkUniversals(callback) {
        var _this10 = this;
        return this.walk(function(selector) {
          if (selector.type === types.UNIVERSAL) {
            return callback.call(_this10, selector);
          }
        });
      };
      _proto.split = function split(callback) {
        var _this11 = this;
        var current = [];
        return this.reduce(function(memo, node, index) {
          var split2 = callback.call(_this11, node);
          current.push(node);
          if (split2) {
            memo.push(current);
            current = [];
          } else if (index === _this11.length - 1) {
            memo.push(current);
          }
          return memo;
        }, []);
      };
      _proto.map = function map(callback) {
        return this.nodes.map(callback);
      };
      _proto.reduce = function reduce(callback, memo) {
        return this.nodes.reduce(callback, memo);
      };
      _proto.every = function every(callback) {
        return this.nodes.every(callback);
      };
      _proto.some = function some(callback) {
        return this.nodes.some(callback);
      };
      _proto.filter = function filter(callback) {
        return this.nodes.filter(callback);
      };
      _proto.sort = function sort(callback) {
        return this.nodes.sort(callback);
      };
      _proto.toString = function toString() {
        return this.map(String).join("");
      };
      _createClass(Container2, [{
        key: "first",
        get: function get() {
          return this.at(0);
        }
      }, {
        key: "last",
        get: function get() {
          return this.at(this.length - 1);
        }
      }, {
        key: "length",
        get: function get() {
          return this.nodes.length;
        }
      }]);
      return Container2;
    }(_node["default"]);
    exports2["default"] = Container;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/root.js
var require_root2 = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/root.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _container = _interopRequireDefault(require_container2());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor)
          descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps)
        _defineProperties(Constructor.prototype, protoProps);
      if (staticProps)
        _defineProperties(Constructor, staticProps);
      return Constructor;
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Root = /* @__PURE__ */ function(_Container) {
      _inheritsLoose(Root2, _Container);
      function Root2(opts) {
        var _this;
        _this = _Container.call(this, opts) || this;
        _this.type = _types.ROOT;
        return _this;
      }
      var _proto = Root2.prototype;
      _proto.toString = function toString() {
        var str = this.reduce(function(memo, selector) {
          memo.push(String(selector));
          return memo;
        }, []).join(",");
        return this.trailingComma ? str + "," : str;
      };
      _proto.error = function error(message, options) {
        if (this._error) {
          return this._error(message, options);
        } else {
          return new Error(message);
        }
      };
      _createClass(Root2, [{
        key: "errorGenerator",
        set: function set(handler) {
          this._error = handler;
        }
      }]);
      return Root2;
    }(_container["default"]);
    exports2["default"] = Root;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/selector.js
var require_selector3 = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/selector.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _container = _interopRequireDefault(require_container2());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Selector = /* @__PURE__ */ function(_Container) {
      _inheritsLoose(Selector2, _Container);
      function Selector2(opts) {
        var _this;
        _this = _Container.call(this, opts) || this;
        _this.type = _types.SELECTOR;
        return _this;
      }
      return Selector2;
    }(_container["default"]);
    exports2["default"] = Selector;
    module2.exports = exports2.default;
  }
});

// node_modules/cssesc/cssesc.js
var require_cssesc = __commonJS({
  "node_modules/cssesc/cssesc.js"(exports2, module2) {
    "use strict";
    var object = {};
    var hasOwnProperty2 = object.hasOwnProperty;
    var merge = function merge2(options, defaults) {
      if (!options) {
        return defaults;
      }
      var result = {};
      for (var key in defaults) {
        result[key] = hasOwnProperty2.call(options, key) ? options[key] : defaults[key];
      }
      return result;
    };
    var regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
    var regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
    var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
    var cssesc = function cssesc2(string, options) {
      options = merge(options, cssesc2.options);
      if (options.quotes != "single" && options.quotes != "double") {
        options.quotes = "single";
      }
      var quote = options.quotes == "double" ? '"' : "'";
      var isIdentifier = options.isIdentifier;
      var firstChar = string.charAt(0);
      var output = "";
      var counter = 0;
      var length = string.length;
      while (counter < length) {
        var character = string.charAt(counter++);
        var codePoint = character.charCodeAt();
        var value = void 0;
        if (codePoint < 32 || codePoint > 126) {
          if (codePoint >= 55296 && codePoint <= 56319 && counter < length) {
            var extra = string.charCodeAt(counter++);
            if ((extra & 64512) == 56320) {
              codePoint = ((codePoint & 1023) << 10) + (extra & 1023) + 65536;
            } else {
              counter--;
            }
          }
          value = "\\" + codePoint.toString(16).toUpperCase() + " ";
        } else {
          if (options.escapeEverything) {
            if (regexAnySingleEscape.test(character)) {
              value = "\\" + character;
            } else {
              value = "\\" + codePoint.toString(16).toUpperCase() + " ";
            }
          } else if (/[\t\n\f\r\x0B]/.test(character)) {
            value = "\\" + codePoint.toString(16).toUpperCase() + " ";
          } else if (character == "\\" || !isIdentifier && (character == '"' && quote == character || character == "'" && quote == character) || isIdentifier && regexSingleEscape.test(character)) {
            value = "\\" + character;
          } else {
            value = character;
          }
        }
        output += value;
      }
      if (isIdentifier) {
        if (/^-[-\d]/.test(output)) {
          output = "\\-" + output.slice(1);
        } else if (/\d/.test(firstChar)) {
          output = "\\3" + firstChar + " " + output.slice(1);
        }
      }
      output = output.replace(regexExcessiveSpaces, function($0, $1, $2) {
        if ($1 && $1.length % 2) {
          return $0;
        }
        return ($1 || "") + $2;
      });
      if (!isIdentifier && options.wrap) {
        return quote + output + quote;
      }
      return output;
    };
    cssesc.options = {
      "escapeEverything": false,
      "isIdentifier": false,
      "quotes": "single",
      "wrap": false
    };
    cssesc.version = "3.0.0";
    module2.exports = cssesc;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/className.js
var require_className = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/className.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _cssesc = _interopRequireDefault(require_cssesc());
    var _util = require_util3();
    var _node = _interopRequireDefault(require_node5());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor)
          descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps)
        _defineProperties(Constructor.prototype, protoProps);
      if (staticProps)
        _defineProperties(Constructor, staticProps);
      return Constructor;
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var ClassName = /* @__PURE__ */ function(_Node) {
      _inheritsLoose(ClassName2, _Node);
      function ClassName2(opts) {
        var _this;
        _this = _Node.call(this, opts) || this;
        _this.type = _types.CLASS;
        _this._constructed = true;
        return _this;
      }
      var _proto = ClassName2.prototype;
      _proto.valueToString = function valueToString() {
        return "." + _Node.prototype.valueToString.call(this);
      };
      _createClass(ClassName2, [{
        key: "value",
        get: function get() {
          return this._value;
        },
        set: function set(v) {
          if (this._constructed) {
            var escaped = (0, _cssesc["default"])(v, {
              isIdentifier: true
            });
            if (escaped !== v) {
              (0, _util.ensureObject)(this, "raws");
              this.raws.value = escaped;
            } else if (this.raws) {
              delete this.raws.value;
            }
          }
          this._value = v;
        }
      }]);
      return ClassName2;
    }(_node["default"]);
    exports2["default"] = ClassName;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/comment.js
var require_comment2 = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/comment.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _node = _interopRequireDefault(require_node5());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Comment = /* @__PURE__ */ function(_Node) {
      _inheritsLoose(Comment2, _Node);
      function Comment2(opts) {
        var _this;
        _this = _Node.call(this, opts) || this;
        _this.type = _types.COMMENT;
        return _this;
      }
      return Comment2;
    }(_node["default"]);
    exports2["default"] = Comment;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/id.js
var require_id = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/id.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _node = _interopRequireDefault(require_node5());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var ID = /* @__PURE__ */ function(_Node) {
      _inheritsLoose(ID2, _Node);
      function ID2(opts) {
        var _this;
        _this = _Node.call(this, opts) || this;
        _this.type = _types.ID;
        return _this;
      }
      var _proto = ID2.prototype;
      _proto.valueToString = function valueToString() {
        return "#" + _Node.prototype.valueToString.call(this);
      };
      return ID2;
    }(_node["default"]);
    exports2["default"] = ID;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/namespace.js
var require_namespace = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/namespace.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _cssesc = _interopRequireDefault(require_cssesc());
    var _util = require_util3();
    var _node = _interopRequireDefault(require_node5());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor)
          descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps)
        _defineProperties(Constructor.prototype, protoProps);
      if (staticProps)
        _defineProperties(Constructor, staticProps);
      return Constructor;
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Namespace = /* @__PURE__ */ function(_Node) {
      _inheritsLoose(Namespace2, _Node);
      function Namespace2() {
        return _Node.apply(this, arguments) || this;
      }
      var _proto = Namespace2.prototype;
      _proto.qualifiedName = function qualifiedName(value) {
        if (this.namespace) {
          return this.namespaceString + "|" + value;
        } else {
          return value;
        }
      };
      _proto.valueToString = function valueToString() {
        return this.qualifiedName(_Node.prototype.valueToString.call(this));
      };
      _createClass(Namespace2, [{
        key: "namespace",
        get: function get() {
          return this._namespace;
        },
        set: function set(namespace) {
          if (namespace === true || namespace === "*" || namespace === "&") {
            this._namespace = namespace;
            if (this.raws) {
              delete this.raws.namespace;
            }
            return;
          }
          var escaped = (0, _cssesc["default"])(namespace, {
            isIdentifier: true
          });
          this._namespace = namespace;
          if (escaped !== namespace) {
            (0, _util.ensureObject)(this, "raws");
            this.raws.namespace = escaped;
          } else if (this.raws) {
            delete this.raws.namespace;
          }
        }
      }, {
        key: "ns",
        get: function get() {
          return this._namespace;
        },
        set: function set(namespace) {
          this.namespace = namespace;
        }
      }, {
        key: "namespaceString",
        get: function get() {
          if (this.namespace) {
            var ns = this.stringifyProperty("namespace");
            if (ns === true) {
              return "";
            } else {
              return ns;
            }
          } else {
            return "";
          }
        }
      }]);
      return Namespace2;
    }(_node["default"]);
    exports2["default"] = Namespace;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/tag.js
var require_tag = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/tag.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _namespace = _interopRequireDefault(require_namespace());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Tag = /* @__PURE__ */ function(_Namespace) {
      _inheritsLoose(Tag2, _Namespace);
      function Tag2(opts) {
        var _this;
        _this = _Namespace.call(this, opts) || this;
        _this.type = _types.TAG;
        return _this;
      }
      return Tag2;
    }(_namespace["default"]);
    exports2["default"] = Tag;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/string.js
var require_string = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/string.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _node = _interopRequireDefault(require_node5());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var String2 = /* @__PURE__ */ function(_Node) {
      _inheritsLoose(String3, _Node);
      function String3(opts) {
        var _this;
        _this = _Node.call(this, opts) || this;
        _this.type = _types.STRING;
        return _this;
      }
      return String3;
    }(_node["default"]);
    exports2["default"] = String2;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/pseudo.js
var require_pseudo2 = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/pseudo.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _container = _interopRequireDefault(require_container2());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Pseudo = /* @__PURE__ */ function(_Container) {
      _inheritsLoose(Pseudo2, _Container);
      function Pseudo2(opts) {
        var _this;
        _this = _Container.call(this, opts) || this;
        _this.type = _types.PSEUDO;
        return _this;
      }
      var _proto = Pseudo2.prototype;
      _proto.toString = function toString() {
        var params = this.length ? "(" + this.map(String).join(",") + ")" : "";
        return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join("");
      };
      return Pseudo2;
    }(_container["default"]);
    exports2["default"] = Pseudo;
    module2.exports = exports2.default;
  }
});

// node_modules/util-deprecate/node.js
var require_node6 = __commonJS({
  "node_modules/util-deprecate/node.js"(exports2, module2) {
    module2.exports = require("util").deprecate;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/attribute.js
var require_attribute = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/attribute.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.unescapeValue = unescapeValue;
    exports2["default"] = void 0;
    var _cssesc = _interopRequireDefault(require_cssesc());
    var _unesc = _interopRequireDefault(require_unesc());
    var _namespace = _interopRequireDefault(require_namespace());
    var _types = require_types2();
    var _CSSESC_QUOTE_OPTIONS;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor)
          descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps)
        _defineProperties(Constructor.prototype, protoProps);
      if (staticProps)
        _defineProperties(Constructor, staticProps);
      return Constructor;
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var deprecate = require_node6();
    var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
    var warnOfDeprecatedValueAssignment = deprecate(function() {
    }, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.");
    var warnOfDeprecatedQuotedAssignment = deprecate(function() {
    }, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
    var warnOfDeprecatedConstructor = deprecate(function() {
    }, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
    function unescapeValue(value) {
      var deprecatedUsage = false;
      var quoteMark = null;
      var unescaped = value;
      var m = unescaped.match(WRAPPED_IN_QUOTES);
      if (m) {
        quoteMark = m[1];
        unescaped = m[2];
      }
      unescaped = (0, _unesc["default"])(unescaped);
      if (unescaped !== value) {
        deprecatedUsage = true;
      }
      return {
        deprecatedUsage,
        unescaped,
        quoteMark
      };
    }
    function handleDeprecatedContructorOpts(opts) {
      if (opts.quoteMark !== void 0) {
        return opts;
      }
      if (opts.value === void 0) {
        return opts;
      }
      warnOfDeprecatedConstructor();
      var _unescapeValue = unescapeValue(opts.value), quoteMark = _unescapeValue.quoteMark, unescaped = _unescapeValue.unescaped;
      if (!opts.raws) {
        opts.raws = {};
      }
      if (opts.raws.value === void 0) {
        opts.raws.value = opts.value;
      }
      opts.value = unescaped;
      opts.quoteMark = quoteMark;
      return opts;
    }
    var Attribute = /* @__PURE__ */ function(_Namespace) {
      _inheritsLoose(Attribute2, _Namespace);
      function Attribute2(opts) {
        var _this;
        if (opts === void 0) {
          opts = {};
        }
        _this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
        _this.type = _types.ATTRIBUTE;
        _this.raws = _this.raws || {};
        Object.defineProperty(_this.raws, "unquoted", {
          get: deprecate(function() {
            return _this.value;
          }, "attr.raws.unquoted is deprecated. Call attr.value instead."),
          set: deprecate(function() {
            return _this.value;
          }, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
        });
        _this._constructed = true;
        return _this;
      }
      var _proto = Attribute2.prototype;
      _proto.getQuotedValue = function getQuotedValue(options) {
        if (options === void 0) {
          options = {};
        }
        var quoteMark = this._determineQuoteMark(options);
        var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
        var escaped = (0, _cssesc["default"])(this._value, cssescopts);
        return escaped;
      };
      _proto._determineQuoteMark = function _determineQuoteMark(options) {
        return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
      };
      _proto.setValue = function setValue(value, options) {
        if (options === void 0) {
          options = {};
        }
        this._value = value;
        this._quoteMark = this._determineQuoteMark(options);
        this._syncRawValue();
      };
      _proto.smartQuoteMark = function smartQuoteMark(options) {
        var v = this.value;
        var numSingleQuotes = v.replace(/[^']/g, "").length;
        var numDoubleQuotes = v.replace(/[^"]/g, "").length;
        if (numSingleQuotes + numDoubleQuotes === 0) {
          var escaped = (0, _cssesc["default"])(v, {
            isIdentifier: true
          });
          if (escaped === v) {
            return Attribute2.NO_QUOTE;
          } else {
            var pref = this.preferredQuoteMark(options);
            if (pref === Attribute2.NO_QUOTE) {
              var quote = this.quoteMark || options.quoteMark || Attribute2.DOUBLE_QUOTE;
              var opts = CSSESC_QUOTE_OPTIONS[quote];
              var quoteValue = (0, _cssesc["default"])(v, opts);
              if (quoteValue.length < escaped.length) {
                return quote;
              }
            }
            return pref;
          }
        } else if (numDoubleQuotes === numSingleQuotes) {
          return this.preferredQuoteMark(options);
        } else if (numDoubleQuotes < numSingleQuotes) {
          return Attribute2.DOUBLE_QUOTE;
        } else {
          return Attribute2.SINGLE_QUOTE;
        }
      };
      _proto.preferredQuoteMark = function preferredQuoteMark(options) {
        var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
        if (quoteMark === void 0) {
          quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
        }
        if (quoteMark === void 0) {
          quoteMark = Attribute2.DOUBLE_QUOTE;
        }
        return quoteMark;
      };
      _proto._syncRawValue = function _syncRawValue() {
        var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
        if (rawValue === this._value) {
          if (this.raws) {
            delete this.raws.value;
          }
        } else {
          this.raws.value = rawValue;
        }
      };
      _proto._handleEscapes = function _handleEscapes(prop, value) {
        if (this._constructed) {
          var escaped = (0, _cssesc["default"])(value, {
            isIdentifier: true
          });
          if (escaped !== value) {
            this.raws[prop] = escaped;
          } else {
            delete this.raws[prop];
          }
        }
      };
      _proto._spacesFor = function _spacesFor(name) {
        var attrSpaces = {
          before: "",
          after: ""
        };
        var spaces = this.spaces[name] || {};
        var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
        return Object.assign(attrSpaces, spaces, rawSpaces);
      };
      _proto._stringFor = function _stringFor(name, spaceName, concat) {
        if (spaceName === void 0) {
          spaceName = name;
        }
        if (concat === void 0) {
          concat = defaultAttrConcat;
        }
        var attrSpaces = this._spacesFor(spaceName);
        return concat(this.stringifyProperty(name), attrSpaces);
      };
      _proto.offsetOf = function offsetOf(name) {
        var count = 1;
        var attributeSpaces = this._spacesFor("attribute");
        count += attributeSpaces.before.length;
        if (name === "namespace" || name === "ns") {
          return this.namespace ? count : -1;
        }
        if (name === "attributeNS") {
          return count;
        }
        count += this.namespaceString.length;
        if (this.namespace) {
          count += 1;
        }
        if (name === "attribute") {
          return count;
        }
        count += this.stringifyProperty("attribute").length;
        count += attributeSpaces.after.length;
        var operatorSpaces = this._spacesFor("operator");
        count += operatorSpaces.before.length;
        var operator = this.stringifyProperty("operator");
        if (name === "operator") {
          return operator ? count : -1;
        }
        count += operator.length;
        count += operatorSpaces.after.length;
        var valueSpaces = this._spacesFor("value");
        count += valueSpaces.before.length;
        var value = this.stringifyProperty("value");
        if (name === "value") {
          return value ? count : -1;
        }
        count += value.length;
        count += valueSpaces.after.length;
        var insensitiveSpaces = this._spacesFor("insensitive");
        count += insensitiveSpaces.before.length;
        if (name === "insensitive") {
          return this.insensitive ? count : -1;
        }
        return -1;
      };
      _proto.toString = function toString() {
        var _this2 = this;
        var selector = [this.rawSpaceBefore, "["];
        selector.push(this._stringFor("qualifiedAttribute", "attribute"));
        if (this.operator && (this.value || this.value === "")) {
          selector.push(this._stringFor("operator"));
          selector.push(this._stringFor("value"));
          selector.push(this._stringFor("insensitiveFlag", "insensitive", function(attrValue, attrSpaces) {
            if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) {
              attrSpaces.before = " ";
            }
            return defaultAttrConcat(attrValue, attrSpaces);
          }));
        }
        selector.push("]");
        selector.push(this.rawSpaceAfter);
        return selector.join("");
      };
      _createClass(Attribute2, [{
        key: "quoted",
        get: function get() {
          var qm = this.quoteMark;
          return qm === "'" || qm === '"';
        },
        set: function set(value) {
          warnOfDeprecatedQuotedAssignment();
        }
      }, {
        key: "quoteMark",
        get: function get() {
          return this._quoteMark;
        },
        set: function set(quoteMark) {
          if (!this._constructed) {
            this._quoteMark = quoteMark;
            return;
          }
          if (this._quoteMark !== quoteMark) {
            this._quoteMark = quoteMark;
            this._syncRawValue();
          }
        }
      }, {
        key: "qualifiedAttribute",
        get: function get() {
          return this.qualifiedName(this.raws.attribute || this.attribute);
        }
      }, {
        key: "insensitiveFlag",
        get: function get() {
          return this.insensitive ? "i" : "";
        }
      }, {
        key: "value",
        get: function get() {
          return this._value;
        },
        set: function set(v) {
          if (this._constructed) {
            var _unescapeValue2 = unescapeValue(v), deprecatedUsage = _unescapeValue2.deprecatedUsage, unescaped = _unescapeValue2.unescaped, quoteMark = _unescapeValue2.quoteMark;
            if (deprecatedUsage) {
              warnOfDeprecatedValueAssignment();
            }
            if (unescaped === this._value && quoteMark === this._quoteMark) {
              return;
            }
            this._value = unescaped;
            this._quoteMark = quoteMark;
            this._syncRawValue();
          } else {
            this._value = v;
          }
        }
      }, {
        key: "attribute",
        get: function get() {
          return this._attribute;
        },
        set: function set(name) {
          this._handleEscapes("attribute", name);
          this._attribute = name;
        }
      }]);
      return Attribute2;
    }(_namespace["default"]);
    exports2["default"] = Attribute;
    Attribute.NO_QUOTE = null;
    Attribute.SINGLE_QUOTE = "'";
    Attribute.DOUBLE_QUOTE = '"';
    var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = {
      "'": {
        quotes: "single",
        wrap: true
      },
      '"': {
        quotes: "double",
        wrap: true
      }
    }, _CSSESC_QUOTE_OPTIONS[null] = {
      isIdentifier: true
    }, _CSSESC_QUOTE_OPTIONS);
    function defaultAttrConcat(attrValue, attrSpaces) {
      return "" + attrSpaces.before + attrValue + attrSpaces.after;
    }
  }
});

// node_modules/postcss-selector-parser/dist/selectors/universal.js
var require_universal = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/universal.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _namespace = _interopRequireDefault(require_namespace());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Universal = /* @__PURE__ */ function(_Namespace) {
      _inheritsLoose(Universal2, _Namespace);
      function Universal2(opts) {
        var _this;
        _this = _Namespace.call(this, opts) || this;
        _this.type = _types.UNIVERSAL;
        _this.value = "*";
        return _this;
      }
      return Universal2;
    }(_namespace["default"]);
    exports2["default"] = Universal;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/combinator.js
var require_combinator = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/combinator.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _node = _interopRequireDefault(require_node5());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Combinator = /* @__PURE__ */ function(_Node) {
      _inheritsLoose(Combinator2, _Node);
      function Combinator2(opts) {
        var _this;
        _this = _Node.call(this, opts) || this;
        _this.type = _types.COMBINATOR;
        return _this;
      }
      return Combinator2;
    }(_node["default"]);
    exports2["default"] = Combinator;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/nesting.js
var require_nesting = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/nesting.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _node = _interopRequireDefault(require_node5());
    var _types = require_types2();
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    var Nesting = /* @__PURE__ */ function(_Node) {
      _inheritsLoose(Nesting2, _Node);
      function Nesting2(opts) {
        var _this;
        _this = _Node.call(this, opts) || this;
        _this.type = _types.NESTING;
        _this.value = "&";
        return _this;
      }
      return Nesting2;
    }(_node["default"]);
    exports2["default"] = Nesting;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/sortAscending.js
var require_sortAscending = __commonJS({
  "node_modules/postcss-selector-parser/dist/sortAscending.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = sortAscending;
    function sortAscending(list) {
      return list.sort(function(a, b) {
        return a - b;
      });
    }
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/tokenTypes.js
var require_tokenTypes = __commonJS({
  "node_modules/postcss-selector-parser/dist/tokenTypes.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.combinator = exports2.word = exports2.comment = exports2.str = exports2.tab = exports2.newline = exports2.feed = exports2.cr = exports2.backslash = exports2.bang = exports2.slash = exports2.doubleQuote = exports2.singleQuote = exports2.space = exports2.greaterThan = exports2.pipe = exports2.equals = exports2.plus = exports2.caret = exports2.tilde = exports2.dollar = exports2.closeSquare = exports2.openSquare = exports2.closeParenthesis = exports2.openParenthesis = exports2.semicolon = exports2.colon = exports2.comma = exports2.at = exports2.asterisk = exports2.ampersand = void 0;
    var ampersand = 38;
    exports2.ampersand = ampersand;
    var asterisk = 42;
    exports2.asterisk = asterisk;
    var at = 64;
    exports2.at = at;
    var comma = 44;
    exports2.comma = comma;
    var colon = 58;
    exports2.colon = colon;
    var semicolon = 59;
    exports2.semicolon = semicolon;
    var openParenthesis = 40;
    exports2.openParenthesis = openParenthesis;
    var closeParenthesis = 41;
    exports2.closeParenthesis = closeParenthesis;
    var openSquare = 91;
    exports2.openSquare = openSquare;
    var closeSquare = 93;
    exports2.closeSquare = closeSquare;
    var dollar = 36;
    exports2.dollar = dollar;
    var tilde = 126;
    exports2.tilde = tilde;
    var caret = 94;
    exports2.caret = caret;
    var plus = 43;
    exports2.plus = plus;
    var equals = 61;
    exports2.equals = equals;
    var pipe = 124;
    exports2.pipe = pipe;
    var greaterThan = 62;
    exports2.greaterThan = greaterThan;
    var space = 32;
    exports2.space = space;
    var singleQuote = 39;
    exports2.singleQuote = singleQuote;
    var doubleQuote = 34;
    exports2.doubleQuote = doubleQuote;
    var slash = 47;
    exports2.slash = slash;
    var bang = 33;
    exports2.bang = bang;
    var backslash = 92;
    exports2.backslash = backslash;
    var cr = 13;
    exports2.cr = cr;
    var feed = 12;
    exports2.feed = feed;
    var newline = 10;
    exports2.newline = newline;
    var tab = 9;
    exports2.tab = tab;
    var str = singleQuote;
    exports2.str = str;
    var comment = -1;
    exports2.comment = comment;
    var word = -2;
    exports2.word = word;
    var combinator = -3;
    exports2.combinator = combinator;
  }
});

// node_modules/postcss-selector-parser/dist/tokenize.js
var require_tokenize2 = __commonJS({
  "node_modules/postcss-selector-parser/dist/tokenize.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = tokenize;
    exports2.FIELDS = void 0;
    var t = _interopRequireWildcard(require_tokenTypes());
    var _unescapable;
    var _wordDelimiters;
    function _getRequireWildcardCache() {
      if (typeof WeakMap !== "function")
        return null;
      var cache = /* @__PURE__ */ new WeakMap();
      _getRequireWildcardCache = function _getRequireWildcardCache2() {
        return cache;
      };
      return cache;
    }
    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      }
      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
        return { "default": obj };
      }
      var cache = _getRequireWildcardCache();
      if (cache && cache.has(obj)) {
        return cache.get(obj);
      }
      var newObj = {};
      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
      for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
          if (desc && (desc.get || desc.set)) {
            Object.defineProperty(newObj, key, desc);
          } else {
            newObj[key] = obj[key];
          }
        }
      }
      newObj["default"] = obj;
      if (cache) {
        cache.set(obj, newObj);
      }
      return newObj;
    }
    var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
    var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters);
    var hex = {};
    var hexChars = "0123456789abcdefABCDEF";
    for (i = 0; i < hexChars.length; i++) {
      hex[hexChars.charCodeAt(i)] = true;
    }
    var i;
    function consumeWord(css, start) {
      var next = start;
      var code;
      do {
        code = css.charCodeAt(next);
        if (wordDelimiters[code]) {
          return next - 1;
        } else if (code === t.backslash) {
          next = consumeEscape(css, next) + 1;
        } else {
          next++;
        }
      } while (next < css.length);
      return next - 1;
    }
    function consumeEscape(css, start) {
      var next = start;
      var code = css.charCodeAt(next + 1);
      if (unescapable[code]) {
      } else if (hex[code]) {
        var hexDigits = 0;
        do {
          next++;
          hexDigits++;
          code = css.charCodeAt(next + 1);
        } while (hex[code] && hexDigits < 6);
        if (hexDigits < 6 && code === t.space) {
          next++;
        }
      } else {
        next++;
      }
      return next;
    }
    var FIELDS = {
      TYPE: 0,
      START_LINE: 1,
      START_COL: 2,
      END_LINE: 3,
      END_COL: 4,
      START_POS: 5,
      END_POS: 6
    };
    exports2.FIELDS = FIELDS;
    function tokenize(input) {
      var tokens = [];
      var css = input.css.valueOf();
      var _css = css, length = _css.length;
      var offset = -1;
      var line = 1;
      var start = 0;
      var end = 0;
      var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
      function unclosed(what, fix) {
        if (input.safe) {
          css += fix;
          next = css.length - 1;
        } else {
          throw input.error("Unclosed " + what, line, start - offset, start);
        }
      }
      while (start < length) {
        code = css.charCodeAt(start);
        if (code === t.newline) {
          offset = start;
          line += 1;
        }
        switch (code) {
          case t.space:
          case t.tab:
          case t.newline:
          case t.cr:
          case t.feed:
            next = start;
            do {
              next += 1;
              code = css.charCodeAt(next);
              if (code === t.newline) {
                offset = next;
                line += 1;
              }
            } while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
            tokenType = t.space;
            endLine = line;
            endColumn = next - offset - 1;
            end = next;
            break;
          case t.plus:
          case t.greaterThan:
          case t.tilde:
          case t.pipe:
            next = start;
            do {
              next += 1;
              code = css.charCodeAt(next);
            } while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
            tokenType = t.combinator;
            endLine = line;
            endColumn = start - offset;
            end = next;
            break;
          case t.asterisk:
          case t.ampersand:
          case t.bang:
          case t.comma:
          case t.equals:
          case t.dollar:
          case t.caret:
          case t.openSquare:
          case t.closeSquare:
          case t.colon:
          case t.semicolon:
          case t.openParenthesis:
          case t.closeParenthesis:
            next = start;
            tokenType = code;
            endLine = line;
            endColumn = start - offset;
            end = next + 1;
            break;
          case t.singleQuote:
          case t.doubleQuote:
            quote = code === t.singleQuote ? "'" : '"';
            next = start;
            do {
              escaped = false;
              next = css.indexOf(quote, next + 1);
              if (next === -1) {
                unclosed("quote", quote);
              }
              escapePos = next;
              while (css.charCodeAt(escapePos - 1) === t.backslash) {
                escapePos -= 1;
                escaped = !escaped;
              }
            } while (escaped);
            tokenType = t.str;
            endLine = line;
            endColumn = start - offset;
            end = next + 1;
            break;
          default:
            if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
              next = css.indexOf("*/", start + 2) + 1;
              if (next === 0) {
                unclosed("comment", "*/");
              }
              content = css.slice(start, next + 1);
              lines = content.split("\n");
              last = lines.length - 1;
              if (last > 0) {
                nextLine = line + last;
                nextOffset = next - lines[last].length;
              } else {
                nextLine = line;
                nextOffset = offset;
              }
              tokenType = t.comment;
              line = nextLine;
              endLine = nextLine;
              endColumn = next - nextOffset;
            } else if (code === t.slash) {
              next = start;
              tokenType = code;
              endLine = line;
              endColumn = start - offset;
              end = next + 1;
            } else {
              next = consumeWord(css, start);
              tokenType = t.word;
              endLine = line;
              endColumn = next - offset;
            }
            end = next + 1;
            break;
        }
        tokens.push([
          tokenType,
          line,
          start - offset,
          endLine,
          endColumn,
          start,
          end
        ]);
        if (nextOffset) {
          offset = nextOffset;
          nextOffset = null;
        }
        start = end;
      }
      return tokens;
    }
  }
});

// node_modules/postcss-selector-parser/dist/parser.js
var require_parser4 = __commonJS({
  "node_modules/postcss-selector-parser/dist/parser.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _root = _interopRequireDefault(require_root2());
    var _selector = _interopRequireDefault(require_selector3());
    var _className = _interopRequireDefault(require_className());
    var _comment = _interopRequireDefault(require_comment2());
    var _id = _interopRequireDefault(require_id());
    var _tag = _interopRequireDefault(require_tag());
    var _string = _interopRequireDefault(require_string());
    var _pseudo = _interopRequireDefault(require_pseudo2());
    var _attribute = _interopRequireWildcard(require_attribute());
    var _universal = _interopRequireDefault(require_universal());
    var _combinator = _interopRequireDefault(require_combinator());
    var _nesting = _interopRequireDefault(require_nesting());
    var _sortAscending = _interopRequireDefault(require_sortAscending());
    var _tokenize = _interopRequireWildcard(require_tokenize2());
    var tokens = _interopRequireWildcard(require_tokenTypes());
    var types = _interopRequireWildcard(require_types2());
    var _util = require_util3();
    var _WHITESPACE_TOKENS;
    var _Object$assign;
    function _getRequireWildcardCache() {
      if (typeof WeakMap !== "function")
        return null;
      var cache = /* @__PURE__ */ new WeakMap();
      _getRequireWildcardCache = function _getRequireWildcardCache2() {
        return cache;
      };
      return cache;
    }
    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      }
      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
        return { "default": obj };
      }
      var cache = _getRequireWildcardCache();
      if (cache && cache.has(obj)) {
        return cache.get(obj);
      }
      var newObj = {};
      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
      for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
          if (desc && (desc.get || desc.set)) {
            Object.defineProperty(newObj, key, desc);
          } else {
            newObj[key] = obj[key];
          }
        }
      }
      newObj["default"] = obj;
      if (cache) {
        cache.set(obj, newObj);
      }
      return newObj;
    }
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor)
          descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps)
        _defineProperties(Constructor.prototype, protoProps);
      if (staticProps)
        _defineProperties(Constructor, staticProps);
      return Constructor;
    }
    var WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS);
    var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign));
    function tokenStart(token) {
      return {
        line: token[_tokenize.FIELDS.START_LINE],
        column: token[_tokenize.FIELDS.START_COL]
      };
    }
    function tokenEnd(token) {
      return {
        line: token[_tokenize.FIELDS.END_LINE],
        column: token[_tokenize.FIELDS.END_COL]
      };
    }
    function getSource(startLine, startColumn, endLine, endColumn) {
      return {
        start: {
          line: startLine,
          column: startColumn
        },
        end: {
          line: endLine,
          column: endColumn
        }
      };
    }
    function getTokenSource(token) {
      return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
    }
    function getTokenSourceSpan(startToken, endToken) {
      if (!startToken) {
        return void 0;
      }
      return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
    }
    function unescapeProp(node, prop) {
      var value = node[prop];
      if (typeof value !== "string") {
        return;
      }
      if (value.indexOf("\\") !== -1) {
        (0, _util.ensureObject)(node, "raws");
        node[prop] = (0, _util.unesc)(value);
        if (node.raws[prop] === void 0) {
          node.raws[prop] = value;
        }
      }
      return node;
    }
    function indexesOf(array, item) {
      var i = -1;
      var indexes = [];
      while ((i = array.indexOf(item, i + 1)) !== -1) {
        indexes.push(i);
      }
      return indexes;
    }
    function uniqs() {
      var list = Array.prototype.concat.apply([], arguments);
      return list.filter(function(item, i) {
        return i === list.indexOf(item);
      });
    }
    var Parser = /* @__PURE__ */ function() {
      function Parser2(rule, options) {
        if (options === void 0) {
          options = {};
        }
        this.rule = rule;
        this.options = Object.assign({
          lossy: false,
          safe: false
        }, options);
        this.position = 0;
        this.css = typeof this.rule === "string" ? this.rule : this.rule.selector;
        this.tokens = (0, _tokenize["default"])({
          css: this.css,
          error: this._errorGenerator(),
          safe: this.options.safe
        });
        var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]);
        this.root = new _root["default"]({
          source: rootSource
        });
        this.root.errorGenerator = this._errorGenerator();
        var selector = new _selector["default"]({
          source: {
            start: {
              line: 1,
              column: 1
            }
          }
        });
        this.root.append(selector);
        this.current = selector;
        this.loop();
      }
      var _proto = Parser2.prototype;
      _proto._errorGenerator = function _errorGenerator() {
        var _this = this;
        return function(message, errorOptions) {
          if (typeof _this.rule === "string") {
            return new Error(message);
          }
          return _this.rule.error(message, errorOptions);
        };
      };
      _proto.attribute = function attribute() {
        var attr = [];
        var startingToken = this.currToken;
        this.position++;
        while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
          attr.push(this.currToken);
          this.position++;
        }
        if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
          return this.expected("closing square bracket", this.currToken[_tokenize.FIELDS.START_POS]);
        }
        var len = attr.length;
        var node = {
          source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]),
          sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
        };
        if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) {
          return this.expected("attribute", attr[0][_tokenize.FIELDS.START_POS]);
        }
        var pos = 0;
        var spaceBefore = "";
        var commentBefore = "";
        var lastAdded = null;
        var spaceAfterMeaningfulToken = false;
        while (pos < len) {
          var token = attr[pos];
          var content = this.content(token);
          var next = attr[pos + 1];
          switch (token[_tokenize.FIELDS.TYPE]) {
            case tokens.space:
              spaceAfterMeaningfulToken = true;
              if (this.options.lossy) {
                break;
              }
              if (lastAdded) {
                (0, _util.ensureObject)(node, "spaces", lastAdded);
                var prevContent = node.spaces[lastAdded].after || "";
                node.spaces[lastAdded].after = prevContent + content;
                var existingComment = (0, _util.getProp)(node, "raws", "spaces", lastAdded, "after") || null;
                if (existingComment) {
                  node.raws.spaces[lastAdded].after = existingComment + content;
                }
              } else {
                spaceBefore = spaceBefore + content;
                commentBefore = commentBefore + content;
              }
              break;
            case tokens.asterisk:
              if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
                node.operator = content;
                lastAdded = "operator";
              } else if ((!node.namespace || lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) {
                if (spaceBefore) {
                  (0, _util.ensureObject)(node, "spaces", "attribute");
                  node.spaces.attribute.before = spaceBefore;
                  spaceBefore = "";
                }
                if (commentBefore) {
                  (0, _util.ensureObject)(node, "raws", "spaces", "attribute");
                  node.raws.spaces.attribute.before = spaceBefore;
                  commentBefore = "";
                }
                node.namespace = (node.namespace || "") + content;
                var rawValue = (0, _util.getProp)(node, "raws", "namespace") || null;
                if (rawValue) {
                  node.raws.namespace += content;
                }
                lastAdded = "namespace";
              }
              spaceAfterMeaningfulToken = false;
              break;
            case tokens.dollar:
              if (lastAdded === "value") {
                var oldRawValue = (0, _util.getProp)(node, "raws", "value");
                node.value += "$";
                if (oldRawValue) {
                  node.raws.value = oldRawValue + "$";
                }
                break;
              }
            case tokens.caret:
              if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
                node.operator = content;
                lastAdded = "operator";
              }
              spaceAfterMeaningfulToken = false;
              break;
            case tokens.combinator:
              if (content === "~" && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
                node.operator = content;
                lastAdded = "operator";
              }
              if (content !== "|") {
                spaceAfterMeaningfulToken = false;
                break;
              }
              if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
                node.operator = content;
                lastAdded = "operator";
              } else if (!node.namespace && !node.attribute) {
                node.namespace = true;
              }
              spaceAfterMeaningfulToken = false;
              break;
            case tokens.word:
              if (next && this.content(next) === "|" && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals && !node.operator && !node.namespace) {
                node.namespace = content;
                lastAdded = "namespace";
              } else if (!node.attribute || lastAdded === "attribute" && !spaceAfterMeaningfulToken) {
                if (spaceBefore) {
                  (0, _util.ensureObject)(node, "spaces", "attribute");
                  node.spaces.attribute.before = spaceBefore;
                  spaceBefore = "";
                }
                if (commentBefore) {
                  (0, _util.ensureObject)(node, "raws", "spaces", "attribute");
                  node.raws.spaces.attribute.before = commentBefore;
                  commentBefore = "";
                }
                node.attribute = (node.attribute || "") + content;
                var _rawValue = (0, _util.getProp)(node, "raws", "attribute") || null;
                if (_rawValue) {
                  node.raws.attribute += content;
                }
                lastAdded = "attribute";
              } else if (!node.value && node.value !== "" || lastAdded === "value" && !spaceAfterMeaningfulToken) {
                var _unescaped = (0, _util.unesc)(content);
                var _oldRawValue = (0, _util.getProp)(node, "raws", "value") || "";
                var oldValue = node.value || "";
                node.value = oldValue + _unescaped;
                node.quoteMark = null;
                if (_unescaped !== content || _oldRawValue) {
                  (0, _util.ensureObject)(node, "raws");
                  node.raws.value = (_oldRawValue || oldValue) + content;
                }
                lastAdded = "value";
              } else {
                var insensitive = content === "i" || content === "I";
                if ((node.value || node.value === "") && (node.quoteMark || spaceAfterMeaningfulToken)) {
                  node.insensitive = insensitive;
                  if (!insensitive || content === "I") {
                    (0, _util.ensureObject)(node, "raws");
                    node.raws.insensitiveFlag = content;
                  }
                  lastAdded = "insensitive";
                  if (spaceBefore) {
                    (0, _util.ensureObject)(node, "spaces", "insensitive");
                    node.spaces.insensitive.before = spaceBefore;
                    spaceBefore = "";
                  }
                  if (commentBefore) {
                    (0, _util.ensureObject)(node, "raws", "spaces", "insensitive");
                    node.raws.spaces.insensitive.before = commentBefore;
                    commentBefore = "";
                  }
                } else if (node.value || node.value === "") {
                  lastAdded = "value";
                  node.value += content;
                  if (node.raws.value) {
                    node.raws.value += content;
                  }
                }
              }
              spaceAfterMeaningfulToken = false;
              break;
            case tokens.str:
              if (!node.attribute || !node.operator) {
                return this.error("Expected an attribute followed by an operator preceding the string.", {
                  index: token[_tokenize.FIELDS.START_POS]
                });
              }
              var _unescapeValue = (0, _attribute.unescapeValue)(content), unescaped = _unescapeValue.unescaped, quoteMark = _unescapeValue.quoteMark;
              node.value = unescaped;
              node.quoteMark = quoteMark;
              lastAdded = "value";
              (0, _util.ensureObject)(node, "raws");
              node.raws.value = content;
              spaceAfterMeaningfulToken = false;
              break;
            case tokens.equals:
              if (!node.attribute) {
                return this.expected("attribute", token[_tokenize.FIELDS.START_POS], content);
              }
              if (node.value) {
                return this.error('Unexpected "=" found; an operator was already defined.', {
                  index: token[_tokenize.FIELDS.START_POS]
                });
              }
              node.operator = node.operator ? node.operator + content : content;
              lastAdded = "operator";
              spaceAfterMeaningfulToken = false;
              break;
            case tokens.comment:
              if (lastAdded) {
                if (spaceAfterMeaningfulToken || next && next[_tokenize.FIELDS.TYPE] === tokens.space || lastAdded === "insensitive") {
                  var lastComment = (0, _util.getProp)(node, "spaces", lastAdded, "after") || "";
                  var rawLastComment = (0, _util.getProp)(node, "raws", "spaces", lastAdded, "after") || lastComment;
                  (0, _util.ensureObject)(node, "raws", "spaces", lastAdded);
                  node.raws.spaces[lastAdded].after = rawLastComment + content;
                } else {
                  var lastValue = node[lastAdded] || "";
                  var rawLastValue = (0, _util.getProp)(node, "raws", lastAdded) || lastValue;
                  (0, _util.ensureObject)(node, "raws");
                  node.raws[lastAdded] = rawLastValue + content;
                }
              } else {
                commentBefore = commentBefore + content;
              }
              break;
            default:
              return this.error('Unexpected "' + content + '" found.', {
                index: token[_tokenize.FIELDS.START_POS]
              });
          }
          pos++;
        }
        unescapeProp(node, "attribute");
        unescapeProp(node, "namespace");
        this.newNode(new _attribute["default"](node));
        this.position++;
      };
      _proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
        if (stopPosition < 0) {
          stopPosition = this.tokens.length;
        }
        var startPosition = this.position;
        var nodes = [];
        var space = "";
        var lastComment = void 0;
        do {
          if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
            if (!this.options.lossy) {
              space += this.content();
            }
          } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
            var spaces = {};
            if (space) {
              spaces.before = space;
              space = "";
            }
            lastComment = new _comment["default"]({
              value: this.content(),
              source: getTokenSource(this.currToken),
              sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
              spaces
            });
            nodes.push(lastComment);
          }
        } while (++this.position < stopPosition);
        if (space) {
          if (lastComment) {
            lastComment.spaces.after = space;
          } else if (!this.options.lossy) {
            var firstToken = this.tokens[startPosition];
            var lastToken = this.tokens[this.position - 1];
            nodes.push(new _string["default"]({
              value: "",
              source: getSource(firstToken[_tokenize.FIELDS.START_LINE], firstToken[_tokenize.FIELDS.START_COL], lastToken[_tokenize.FIELDS.END_LINE], lastToken[_tokenize.FIELDS.END_COL]),
              sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
              spaces: {
                before: space,
                after: ""
              }
            }));
          }
        }
        return nodes;
      };
      _proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) {
        var _this2 = this;
        if (requiredSpace === void 0) {
          requiredSpace = false;
        }
        var space = "";
        var rawSpace = "";
        nodes.forEach(function(n) {
          var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
          var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
          space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
          rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
        });
        if (rawSpace === space) {
          rawSpace = void 0;
        }
        var result = {
          space,
          rawSpace
        };
        return result;
      };
      _proto.isNamedCombinator = function isNamedCombinator(position) {
        if (position === void 0) {
          position = this.position;
        }
        return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash;
      };
      _proto.namedCombinator = function namedCombinator() {
        if (this.isNamedCombinator()) {
          var nameRaw = this.content(this.tokens[this.position + 1]);
          var name = (0, _util.unesc)(nameRaw).toLowerCase();
          var raws = {};
          if (name !== nameRaw) {
            raws.value = "/" + nameRaw + "/";
          }
          var node = new _combinator["default"]({
            value: "/" + name + "/",
            source: getSource(this.currToken[_tokenize.FIELDS.START_LINE], this.currToken[_tokenize.FIELDS.START_COL], this.tokens[this.position + 2][_tokenize.FIELDS.END_LINE], this.tokens[this.position + 2][_tokenize.FIELDS.END_COL]),
            sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
            raws
          });
          this.position = this.position + 3;
          return node;
        } else {
          this.unexpected();
        }
      };
      _proto.combinator = function combinator() {
        var _this3 = this;
        if (this.content() === "|") {
          return this.namespace();
        }
        var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
        if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
          var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
          if (nodes.length > 0) {
            var last = this.current.last;
            if (last) {
              var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes), space = _this$convertWhitespa.space, rawSpace = _this$convertWhitespa.rawSpace;
              if (rawSpace !== void 0) {
                last.rawSpaceAfter += rawSpace;
              }
              last.spaces.after += space;
            } else {
              nodes.forEach(function(n) {
                return _this3.newNode(n);
              });
            }
          }
          return;
        }
        var firstToken = this.currToken;
        var spaceOrDescendantSelectorNodes = void 0;
        if (nextSigTokenPos > this.position) {
          spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
        }
        var node;
        if (this.isNamedCombinator()) {
          node = this.namedCombinator();
        } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.combinator) {
          node = new _combinator["default"]({
            value: this.content(),
            source: getTokenSource(this.currToken),
            sourceIndex: this.currToken[_tokenize.FIELDS.START_POS]
          });
          this.position++;
        } else if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
        } else if (!spaceOrDescendantSelectorNodes) {
          this.unexpected();
        }
        if (node) {
          if (spaceOrDescendantSelectorNodes) {
            var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes), _space = _this$convertWhitespa2.space, _rawSpace = _this$convertWhitespa2.rawSpace;
            node.spaces.before = _space;
            node.rawSpaceBefore = _rawSpace;
          }
        } else {
          var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true), _space2 = _this$convertWhitespa3.space, _rawSpace2 = _this$convertWhitespa3.rawSpace;
          if (!_rawSpace2) {
            _rawSpace2 = _space2;
          }
          var spaces = {};
          var raws = {
            spaces: {}
          };
          if (_space2.endsWith(" ") && _rawSpace2.endsWith(" ")) {
            spaces.before = _space2.slice(0, _space2.length - 1);
            raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1);
          } else if (_space2.startsWith(" ") && _rawSpace2.startsWith(" ")) {
            spaces.after = _space2.slice(1);
            raws.spaces.after = _rawSpace2.slice(1);
          } else {
            raws.value = _rawSpace2;
          }
          node = new _combinator["default"]({
            value: " ",
            source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]),
            sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
            spaces,
            raws
          });
        }
        if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
          node.spaces.after = this.optionalSpace(this.content());
          this.position++;
        }
        return this.newNode(node);
      };
      _proto.comma = function comma() {
        if (this.position === this.tokens.length - 1) {
          this.root.trailingComma = true;
          this.position++;
          return;
        }
        this.current._inferEndPosition();
        var selector = new _selector["default"]({
          source: {
            start: tokenStart(this.tokens[this.position + 1])
          }
        });
        this.current.parent.append(selector);
        this.current = selector;
        this.position++;
      };
      _proto.comment = function comment() {
        var current = this.currToken;
        this.newNode(new _comment["default"]({
          value: this.content(),
          source: getTokenSource(current),
          sourceIndex: current[_tokenize.FIELDS.START_POS]
        }));
        this.position++;
      };
      _proto.error = function error(message, opts) {
        throw this.root.error(message, opts);
      };
      _proto.missingBackslash = function missingBackslash() {
        return this.error("Expected a backslash preceding the semicolon.", {
          index: this.currToken[_tokenize.FIELDS.START_POS]
        });
      };
      _proto.missingParenthesis = function missingParenthesis() {
        return this.expected("opening parenthesis", this.currToken[_tokenize.FIELDS.START_POS]);
      };
      _proto.missingSquareBracket = function missingSquareBracket() {
        return this.expected("opening square bracket", this.currToken[_tokenize.FIELDS.START_POS]);
      };
      _proto.unexpected = function unexpected() {
        return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]);
      };
      _proto.namespace = function namespace() {
        var before = this.prevToken && this.content(this.prevToken) || true;
        if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
          this.position++;
          return this.word(before);
        } else if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.asterisk) {
          this.position++;
          return this.universal(before);
        }
      };
      _proto.nesting = function nesting() {
        if (this.nextToken) {
          var nextContent = this.content(this.nextToken);
          if (nextContent === "|") {
            this.position++;
            return;
          }
        }
        var current = this.currToken;
        this.newNode(new _nesting["default"]({
          value: this.content(),
          source: getTokenSource(current),
          sourceIndex: current[_tokenize.FIELDS.START_POS]
        }));
        this.position++;
      };
      _proto.parentheses = function parentheses() {
        var last = this.current.last;
        var unbalanced = 1;
        this.position++;
        if (last && last.type === types.PSEUDO) {
          var selector = new _selector["default"]({
            source: {
              start: tokenStart(this.tokens[this.position - 1])
            }
          });
          var cache = this.current;
          last.append(selector);
          this.current = selector;
          while (this.position < this.tokens.length && unbalanced) {
            if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
              unbalanced++;
            }
            if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
              unbalanced--;
            }
            if (unbalanced) {
              this.parse();
            } else {
              this.current.source.end = tokenEnd(this.currToken);
              this.current.parent.source.end = tokenEnd(this.currToken);
              this.position++;
            }
          }
          this.current = cache;
        } else {
          var parenStart = this.currToken;
          var parenValue = "(";
          var parenEnd;
          while (this.position < this.tokens.length && unbalanced) {
            if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
              unbalanced++;
            }
            if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
              unbalanced--;
            }
            parenEnd = this.currToken;
            parenValue += this.parseParenthesisToken(this.currToken);
            this.position++;
          }
          if (last) {
            last.appendToPropertyAndEscape("value", parenValue, parenValue);
          } else {
            this.newNode(new _string["default"]({
              value: parenValue,
              source: getSource(parenStart[_tokenize.FIELDS.START_LINE], parenStart[_tokenize.FIELDS.START_COL], parenEnd[_tokenize.FIELDS.END_LINE], parenEnd[_tokenize.FIELDS.END_COL]),
              sourceIndex: parenStart[_tokenize.FIELDS.START_POS]
            }));
          }
        }
        if (unbalanced) {
          return this.expected("closing parenthesis", this.currToken[_tokenize.FIELDS.START_POS]);
        }
      };
      _proto.pseudo = function pseudo() {
        var _this4 = this;
        var pseudoStr = "";
        var startingToken = this.currToken;
        while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
          pseudoStr += this.content();
          this.position++;
        }
        if (!this.currToken) {
          return this.expected(["pseudo-class", "pseudo-element"], this.position - 1);
        }
        if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) {
          this.splitWord(false, function(first, length) {
            pseudoStr += first;
            _this4.newNode(new _pseudo["default"]({
              value: pseudoStr,
              source: getTokenSourceSpan(startingToken, _this4.currToken),
              sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
            }));
            if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
              _this4.error("Misplaced parenthesis.", {
                index: _this4.nextToken[_tokenize.FIELDS.START_POS]
              });
            }
          });
        } else {
          return this.expected(["pseudo-class", "pseudo-element"], this.currToken[_tokenize.FIELDS.START_POS]);
        }
      };
      _proto.space = function space() {
        var content = this.content();
        if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function(node) {
          return node.type === "comment";
        })) {
          this.spaces = this.optionalSpace(content);
          this.position++;
        } else if (this.position === this.tokens.length - 1 || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
          this.current.last.spaces.after = this.optionalSpace(content);
          this.position++;
        } else {
          this.combinator();
        }
      };
      _proto.string = function string() {
        var current = this.currToken;
        this.newNode(new _string["default"]({
          value: this.content(),
          source: getTokenSource(current),
          sourceIndex: current[_tokenize.FIELDS.START_POS]
        }));
        this.position++;
      };
      _proto.universal = function universal(namespace) {
        var nextToken = this.nextToken;
        if (nextToken && this.content(nextToken) === "|") {
          this.position++;
          return this.namespace();
        }
        var current = this.currToken;
        this.newNode(new _universal["default"]({
          value: this.content(),
          source: getTokenSource(current),
          sourceIndex: current[_tokenize.FIELDS.START_POS]
        }), namespace);
        this.position++;
      };
      _proto.splitWord = function splitWord(namespace, firstCallback) {
        var _this5 = this;
        var nextToken = this.nextToken;
        var word = this.content();
        while (nextToken && ~[tokens.dollar, tokens.caret, tokens.equals, tokens.word].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
          this.position++;
          var current = this.content();
          word += current;
          if (current.lastIndexOf("\\") === current.length - 1) {
            var next = this.nextToken;
            if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
              word += this.requiredSpace(this.content(next));
              this.position++;
            }
          }
          nextToken = this.nextToken;
        }
        var hasClass = indexesOf(word, ".").filter(function(i) {
          var escapedDot = word[i - 1] === "\\";
          var isKeyframesPercent = /^\d+\.\d+%$/.test(word);
          return !escapedDot && !isKeyframesPercent;
        });
        var hasId = indexesOf(word, "#").filter(function(i) {
          return word[i - 1] !== "\\";
        });
        var interpolations = indexesOf(word, "#{");
        if (interpolations.length) {
          hasId = hasId.filter(function(hashIndex) {
            return !~interpolations.indexOf(hashIndex);
          });
        }
        var indices = (0, _sortAscending["default"])(uniqs([0].concat(hasClass, hasId)));
        indices.forEach(function(ind, i) {
          var index = indices[i + 1] || word.length;
          var value = word.slice(ind, index);
          if (i === 0 && firstCallback) {
            return firstCallback.call(_this5, value, indices.length);
          }
          var node;
          var current2 = _this5.currToken;
          var sourceIndex = current2[_tokenize.FIELDS.START_POS] + indices[i];
          var source = getSource(current2[1], current2[2] + ind, current2[3], current2[2] + (index - 1));
          if (~hasClass.indexOf(ind)) {
            var classNameOpts = {
              value: value.slice(1),
              source,
              sourceIndex
            };
            node = new _className["default"](unescapeProp(classNameOpts, "value"));
          } else if (~hasId.indexOf(ind)) {
            var idOpts = {
              value: value.slice(1),
              source,
              sourceIndex
            };
            node = new _id["default"](unescapeProp(idOpts, "value"));
          } else {
            var tagOpts = {
              value,
              source,
              sourceIndex
            };
            unescapeProp(tagOpts, "value");
            node = new _tag["default"](tagOpts);
          }
          _this5.newNode(node, namespace);
          namespace = null;
        });
        this.position++;
      };
      _proto.word = function word(namespace) {
        var nextToken = this.nextToken;
        if (nextToken && this.content(nextToken) === "|") {
          this.position++;
          return this.namespace();
        }
        return this.splitWord(namespace);
      };
      _proto.loop = function loop() {
        while (this.position < this.tokens.length) {
          this.parse(true);
        }
        this.current._inferEndPosition();
        return this.root;
      };
      _proto.parse = function parse(throwOnParenthesis) {
        switch (this.currToken[_tokenize.FIELDS.TYPE]) {
          case tokens.space:
            this.space();
            break;
          case tokens.comment:
            this.comment();
            break;
          case tokens.openParenthesis:
            this.parentheses();
            break;
          case tokens.closeParenthesis:
            if (throwOnParenthesis) {
              this.missingParenthesis();
            }
            break;
          case tokens.openSquare:
            this.attribute();
            break;
          case tokens.dollar:
          case tokens.caret:
          case tokens.equals:
          case tokens.word:
            this.word();
            break;
          case tokens.colon:
            this.pseudo();
            break;
          case tokens.comma:
            this.comma();
            break;
          case tokens.asterisk:
            this.universal();
            break;
          case tokens.ampersand:
            this.nesting();
            break;
          case tokens.slash:
          case tokens.combinator:
            this.combinator();
            break;
          case tokens.str:
            this.string();
            break;
          case tokens.closeSquare:
            this.missingSquareBracket();
          case tokens.semicolon:
            this.missingBackslash();
          default:
            this.unexpected();
        }
      };
      _proto.expected = function expected(description, index, found) {
        if (Array.isArray(description)) {
          var last = description.pop();
          description = description.join(", ") + " or " + last;
        }
        var an = /^[aeiou]/.test(description[0]) ? "an" : "a";
        if (!found) {
          return this.error("Expected " + an + " " + description + ".", {
            index
          });
        }
        return this.error("Expected " + an + " " + description + ', found "' + found + '" instead.', {
          index
        });
      };
      _proto.requiredSpace = function requiredSpace(space) {
        return this.options.lossy ? " " : space;
      };
      _proto.optionalSpace = function optionalSpace(space) {
        return this.options.lossy ? "" : space;
      };
      _proto.lossySpace = function lossySpace(space, required) {
        if (this.options.lossy) {
          return required ? " " : "";
        } else {
          return space;
        }
      };
      _proto.parseParenthesisToken = function parseParenthesisToken(token) {
        var content = this.content(token);
        if (token[_tokenize.FIELDS.TYPE] === tokens.space) {
          return this.requiredSpace(content);
        } else {
          return content;
        }
      };
      _proto.newNode = function newNode(node, namespace) {
        if (namespace) {
          if (/^ +$/.test(namespace)) {
            if (!this.options.lossy) {
              this.spaces = (this.spaces || "") + namespace;
            }
            namespace = true;
          }
          node.namespace = namespace;
          unescapeProp(node, "namespace");
        }
        if (this.spaces) {
          node.spaces.before = this.spaces;
          this.spaces = "";
        }
        return this.current.append(node);
      };
      _proto.content = function content(token) {
        if (token === void 0) {
          token = this.currToken;
        }
        return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
      };
      _proto.locateNextMeaningfulToken = function locateNextMeaningfulToken(startPosition) {
        if (startPosition === void 0) {
          startPosition = this.position + 1;
        }
        var searchPosition = startPosition;
        while (searchPosition < this.tokens.length) {
          if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
            searchPosition++;
            continue;
          } else {
            return searchPosition;
          }
        }
        return -1;
      };
      _createClass(Parser2, [{
        key: "currToken",
        get: function get() {
          return this.tokens[this.position];
        }
      }, {
        key: "nextToken",
        get: function get() {
          return this.tokens[this.position + 1];
        }
      }, {
        key: "prevToken",
        get: function get() {
          return this.tokens[this.position - 1];
        }
      }]);
      return Parser2;
    }();
    exports2["default"] = Parser;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/processor.js
var require_processor3 = __commonJS({
  "node_modules/postcss-selector-parser/dist/processor.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _parser = _interopRequireDefault(require_parser4());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var Processor = /* @__PURE__ */ function() {
      function Processor2(func, options) {
        this.func = func || function noop() {
        };
        this.funcRes = null;
        this.options = options;
      }
      var _proto = Processor2.prototype;
      _proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
        if (options === void 0) {
          options = {};
        }
        var merged = Object.assign({}, this.options, options);
        if (merged.updateSelector === false) {
          return false;
        } else {
          return typeof rule !== "string";
        }
      };
      _proto._isLossy = function _isLossy(options) {
        if (options === void 0) {
          options = {};
        }
        var merged = Object.assign({}, this.options, options);
        if (merged.lossless === false) {
          return true;
        } else {
          return false;
        }
      };
      _proto._root = function _root(rule, options) {
        if (options === void 0) {
          options = {};
        }
        var parser = new _parser["default"](rule, this._parseOptions(options));
        return parser.root;
      };
      _proto._parseOptions = function _parseOptions(options) {
        return {
          lossy: this._isLossy(options)
        };
      };
      _proto._run = function _run(rule, options) {
        var _this = this;
        if (options === void 0) {
          options = {};
        }
        return new Promise(function(resolve, reject) {
          try {
            var root = _this._root(rule, options);
            Promise.resolve(_this.func(root)).then(function(transform) {
              var string = void 0;
              if (_this._shouldUpdateSelector(rule, options)) {
                string = root.toString();
                rule.selector = string;
              }
              return {
                transform,
                root,
                string
              };
            }).then(resolve, reject);
          } catch (e) {
            reject(e);
            return;
          }
        });
      };
      _proto._runSync = function _runSync(rule, options) {
        if (options === void 0) {
          options = {};
        }
        var root = this._root(rule, options);
        var transform = this.func(root);
        if (transform && typeof transform.then === "function") {
          throw new Error("Selector processor returned a promise to a synchronous call.");
        }
        var string = void 0;
        if (options.updateSelector && typeof rule !== "string") {
          string = root.toString();
          rule.selector = string;
        }
        return {
          transform,
          root,
          string
        };
      };
      _proto.ast = function ast(rule, options) {
        return this._run(rule, options).then(function(result) {
          return result.root;
        });
      };
      _proto.astSync = function astSync(rule, options) {
        return this._runSync(rule, options).root;
      };
      _proto.transform = function transform(rule, options) {
        return this._run(rule, options).then(function(result) {
          return result.transform;
        });
      };
      _proto.transformSync = function transformSync(rule, options) {
        return this._runSync(rule, options).transform;
      };
      _proto.process = function process2(rule, options) {
        return this._run(rule, options).then(function(result) {
          return result.string || result.root.toString();
        });
      };
      _proto.processSync = function processSync(rule, options) {
        var result = this._runSync(rule, options);
        return result.string || result.root.toString();
      };
      return Processor2;
    }();
    exports2["default"] = Processor;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/constructors.js
var require_constructors = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/constructors.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.universal = exports2.tag = exports2.string = exports2.selector = exports2.root = exports2.pseudo = exports2.nesting = exports2.id = exports2.comment = exports2.combinator = exports2.className = exports2.attribute = void 0;
    var _attribute = _interopRequireDefault(require_attribute());
    var _className = _interopRequireDefault(require_className());
    var _combinator = _interopRequireDefault(require_combinator());
    var _comment = _interopRequireDefault(require_comment2());
    var _id = _interopRequireDefault(require_id());
    var _nesting = _interopRequireDefault(require_nesting());
    var _pseudo = _interopRequireDefault(require_pseudo2());
    var _root = _interopRequireDefault(require_root2());
    var _selector = _interopRequireDefault(require_selector3());
    var _string = _interopRequireDefault(require_string());
    var _tag = _interopRequireDefault(require_tag());
    var _universal = _interopRequireDefault(require_universal());
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var attribute = function attribute2(opts) {
      return new _attribute["default"](opts);
    };
    exports2.attribute = attribute;
    var className = function className2(opts) {
      return new _className["default"](opts);
    };
    exports2.className = className;
    var combinator = function combinator2(opts) {
      return new _combinator["default"](opts);
    };
    exports2.combinator = combinator;
    var comment = function comment2(opts) {
      return new _comment["default"](opts);
    };
    exports2.comment = comment;
    var id = function id2(opts) {
      return new _id["default"](opts);
    };
    exports2.id = id;
    var nesting = function nesting2(opts) {
      return new _nesting["default"](opts);
    };
    exports2.nesting = nesting;
    var pseudo = function pseudo2(opts) {
      return new _pseudo["default"](opts);
    };
    exports2.pseudo = pseudo;
    var root = function root2(opts) {
      return new _root["default"](opts);
    };
    exports2.root = root;
    var selector = function selector2(opts) {
      return new _selector["default"](opts);
    };
    exports2.selector = selector;
    var string = function string2(opts) {
      return new _string["default"](opts);
    };
    exports2.string = string;
    var tag = function tag2(opts) {
      return new _tag["default"](opts);
    };
    exports2.tag = tag;
    var universal = function universal2(opts) {
      return new _universal["default"](opts);
    };
    exports2.universal = universal;
  }
});

// node_modules/postcss-selector-parser/dist/selectors/guards.js
var require_guards = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/guards.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.isNode = isNode;
    exports2.isPseudoElement = isPseudoElement;
    exports2.isPseudoClass = isPseudoClass;
    exports2.isContainer = isContainer;
    exports2.isNamespace = isNamespace;
    exports2.isUniversal = exports2.isTag = exports2.isString = exports2.isSelector = exports2.isRoot = exports2.isPseudo = exports2.isNesting = exports2.isIdentifier = exports2.isComment = exports2.isCombinator = exports2.isClassName = exports2.isAttribute = void 0;
    var _types = require_types2();
    var _IS_TYPE;
    var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE);
    function isNode(node) {
      return typeof node === "object" && IS_TYPE[node.type];
    }
    function isNodeType(type, node) {
      return isNode(node) && node.type === type;
    }
    var isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
    exports2.isAttribute = isAttribute;
    var isClassName = isNodeType.bind(null, _types.CLASS);
    exports2.isClassName = isClassName;
    var isCombinator = isNodeType.bind(null, _types.COMBINATOR);
    exports2.isCombinator = isCombinator;
    var isComment = isNodeType.bind(null, _types.COMMENT);
    exports2.isComment = isComment;
    var isIdentifier = isNodeType.bind(null, _types.ID);
    exports2.isIdentifier = isIdentifier;
    var isNesting = isNodeType.bind(null, _types.NESTING);
    exports2.isNesting = isNesting;
    var isPseudo = isNodeType.bind(null, _types.PSEUDO);
    exports2.isPseudo = isPseudo;
    var isRoot = isNodeType.bind(null, _types.ROOT);
    exports2.isRoot = isRoot;
    var isSelector = isNodeType.bind(null, _types.SELECTOR);
    exports2.isSelector = isSelector;
    var isString = isNodeType.bind(null, _types.STRING);
    exports2.isString = isString;
    var isTag = isNodeType.bind(null, _types.TAG);
    exports2.isTag = isTag;
    var isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
    exports2.isUniversal = isUniversal;
    function isPseudoElement(node) {
      return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after" || node.value.toLowerCase() === ":first-letter" || node.value.toLowerCase() === ":first-line");
    }
    function isPseudoClass(node) {
      return isPseudo(node) && !isPseudoElement(node);
    }
    function isContainer(node) {
      return !!(isNode(node) && node.walk);
    }
    function isNamespace(node) {
      return isAttribute(node) || isTag(node);
    }
  }
});

// node_modules/postcss-selector-parser/dist/selectors/index.js
var require_selectors = __commonJS({
  "node_modules/postcss-selector-parser/dist/selectors/index.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    var _types = require_types2();
    Object.keys(_types).forEach(function(key) {
      if (key === "default" || key === "__esModule")
        return;
      if (key in exports2 && exports2[key] === _types[key])
        return;
      exports2[key] = _types[key];
    });
    var _constructors = require_constructors();
    Object.keys(_constructors).forEach(function(key) {
      if (key === "default" || key === "__esModule")
        return;
      if (key in exports2 && exports2[key] === _constructors[key])
        return;
      exports2[key] = _constructors[key];
    });
    var _guards = require_guards();
    Object.keys(_guards).forEach(function(key) {
      if (key === "default" || key === "__esModule")
        return;
      if (key in exports2 && exports2[key] === _guards[key])
        return;
      exports2[key] = _guards[key];
    });
  }
});

// node_modules/postcss-selector-parser/dist/index.js
var require_dist4 = __commonJS({
  "node_modules/postcss-selector-parser/dist/index.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = void 0;
    var _processor = _interopRequireDefault(require_processor3());
    var selectors = _interopRequireWildcard(require_selectors());
    function _getRequireWildcardCache() {
      if (typeof WeakMap !== "function")
        return null;
      var cache = /* @__PURE__ */ new WeakMap();
      _getRequireWildcardCache = function _getRequireWildcardCache2() {
        return cache;
      };
      return cache;
    }
    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      }
      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
        return { "default": obj };
      }
      var cache = _getRequireWildcardCache();
      if (cache && cache.has(obj)) {
        return cache.get(obj);
      }
      var newObj = {};
      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
      for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
          if (desc && (desc.get || desc.set)) {
            Object.defineProperty(newObj, key, desc);
          } else {
            newObj[key] = obj[key];
          }
        }
      }
      newObj["default"] = obj;
      if (cache) {
        cache.set(obj, newObj);
      }
      return newObj;
    }
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var parser = function parser2(processor) {
      return new _processor["default"](processor);
    };
    Object.assign(parser, selectors);
    delete parser.__esModule;
    var _default = parser;
    exports2["default"] = _default;
    module2.exports = exports2.default;
  }
});

// node_modules/postcss-calc/src/parser.js
var require_parser5 = __commonJS({
  "node_modules/postcss-calc/src/parser.js"(exports2) {
    var parser = function() {
      function JisonParserError(msg, hash) {
        Object.defineProperty(this, "name", {
          enumerable: false,
          writable: false,
          value: "JisonParserError"
        });
        if (msg == null)
          msg = "???";
        Object.defineProperty(this, "message", {
          enumerable: false,
          writable: true,
          value: msg
        });
        this.hash = hash;
        var stacktrace;
        if (hash && hash.exception instanceof Error) {
          var ex2 = hash.exception;
          this.message = ex2.message || msg;
          stacktrace = ex2.stack;
        }
        if (!stacktrace) {
          if (Error.hasOwnProperty("captureStackTrace")) {
            Error.captureStackTrace(this, this.constructor);
          } else {
            stacktrace = new Error(msg).stack;
          }
        }
        if (stacktrace) {
          Object.defineProperty(this, "stack", {
            enumerable: false,
            writable: false,
            value: stacktrace
          });
        }
      }
      if (typeof Object.setPrototypeOf === "function") {
        Object.setPrototypeOf(JisonParserError.prototype, Error.prototype);
      } else {
        JisonParserError.prototype = Object.create(Error.prototype);
      }
      JisonParserError.prototype.constructor = JisonParserError;
      JisonParserError.prototype.name = "JisonParserError";
      function bp(s2) {
        var rv = [];
        var p = s2.pop;
        var r = s2.rule;
        for (var i = 0, l = p.length; i < l; i++) {
          rv.push([
            p[i],
            r[i]
          ]);
        }
        return rv;
      }
      function bda(s2) {
        var rv = {};
        var d = s2.idx;
        var g = s2.goto;
        for (var i = 0, l = d.length; i < l; i++) {
          var j = d[i];
          rv[j] = g[i];
        }
        return rv;
      }
      function bt(s2) {
        var rv = [];
        var d = s2.len;
        var y = s2.symbol;
        var t = s2.type;
        var a = s2.state;
        var m = s2.mode;
        var g = s2.goto;
        for (var i = 0, l = d.length; i < l; i++) {
          var n = d[i];
          var q = {};
          for (var j = 0; j < n; j++) {
            var z = y.shift();
            switch (t.shift()) {
              case 2:
                q[z] = [
                  m.shift(),
                  g.shift()
                ];
                break;
              case 0:
                q[z] = a.shift();
                break;
              default:
                q[z] = [
                  3
                ];
            }
          }
          rv.push(q);
        }
        return rv;
      }
      function s(c2, l, a) {
        a = a || 0;
        for (var i = 0; i < l; i++) {
          this.push(c2);
          c2 += a;
        }
      }
      function c(i, l) {
        i = this.length - i;
        for (l += i; i < l; i++) {
          this.push(this[i]);
        }
      }
      function u(a) {
        var rv = [];
        for (var i = 0, l = a.length; i < l; i++) {
          var e = a[i];
          if (typeof e === "function") {
            i++;
            e.apply(rv, a[i]);
          } else {
            rv.push(e);
          }
        }
        return rv;
      }
      var parser2 = {
        trace: function no_op_trace() {
        },
        JisonParserError,
        yy: {},
        options: {
          type: "lalr",
          hasPartialLrUpgradeOnConflict: true,
          errorRecoveryTokenDiscardCount: 3
        },
        symbols_: {
          "$accept": 0,
          "$end": 1,
          "ADD": 6,
          "ANGLE": 12,
          "CALC": 3,
          "CHS": 19,
          "DIV": 9,
          "EMS": 17,
          "EOF": 1,
          "EXS": 18,
          "FREQ": 14,
          "FUNCTION": 10,
          "LENGTH": 11,
          "LPAREN": 4,
          "MUL": 8,
          "NUMBER": 26,
          "PERCENTAGE": 25,
          "REMS": 20,
          "RES": 15,
          "RPAREN": 5,
          "SUB": 7,
          "TIME": 13,
          "UNKNOWN_DIMENSION": 16,
          "VHS": 21,
          "VMAXS": 24,
          "VMINS": 23,
          "VWS": 22,
          "dimension": 30,
          "error": 2,
          "expression": 27,
          "function": 29,
          "math_expression": 28,
          "number": 31
        },
        terminals_: {
          1: "EOF",
          2: "error",
          3: "CALC",
          4: "LPAREN",
          5: "RPAREN",
          6: "ADD",
          7: "SUB",
          8: "MUL",
          9: "DIV",
          10: "FUNCTION",
          11: "LENGTH",
          12: "ANGLE",
          13: "TIME",
          14: "FREQ",
          15: "RES",
          16: "UNKNOWN_DIMENSION",
          17: "EMS",
          18: "EXS",
          19: "CHS",
          20: "REMS",
          21: "VHS",
          22: "VWS",
          23: "VMINS",
          24: "VMAXS",
          25: "PERCENTAGE",
          26: "NUMBER"
        },
        TERROR: 2,
        EOF: 1,
        originalQuoteName: null,
        originalParseError: null,
        cleanupAfterParse: null,
        constructParseErrorInfo: null,
        yyMergeLocationInfo: null,
        __reentrant_call_depth: 0,
        __error_infos: [],
        __error_recovery_infos: [],
        quoteName: function parser_quoteName(id_str) {
          return '"' + id_str + '"';
        },
        getSymbolName: function parser_getSymbolName(symbol) {
          if (this.terminals_[symbol]) {
            return this.terminals_[symbol];
          }
          var s2 = this.symbols_;
          for (var key in s2) {
            if (s2[key] === symbol) {
              return key;
            }
          }
          return null;
        },
        describeSymbol: function parser_describeSymbol(symbol) {
          if (symbol !== this.EOF && this.terminal_descriptions_ && this.terminal_descriptions_[symbol]) {
            return this.terminal_descriptions_[symbol];
          } else if (symbol === this.EOF) {
            return "end of input";
          }
          var id = this.getSymbolName(symbol);
          if (id) {
            return this.quoteName(id);
          }
          return null;
        },
        collect_expected_token_set: function parser_collect_expected_token_set(state, do_not_describe) {
          var TERROR = this.TERROR;
          var tokenset = [];
          var check = {};
          if (!do_not_describe && this.state_descriptions_ && this.state_descriptions_[state]) {
            return [
              this.state_descriptions_[state]
            ];
          }
          for (var p in this.table[state]) {
            p = +p;
            if (p !== TERROR) {
              var d = do_not_describe ? p : this.describeSymbol(p);
              if (d && !check[d]) {
                tokenset.push(d);
                check[d] = true;
              }
            }
          }
          return tokenset;
        },
        productions_: bp({
          pop: u([
            27,
            s,
            [28, 9],
            29,
            s,
            [30, 17],
            s,
            [31, 3]
          ]),
          rule: u([
            2,
            4,
            s,
            [3, 5],
            s,
            [1, 19],
            2,
            2,
            c,
            [3, 3]
          ])
        }),
        performAction: function parser__PerformAction(yystate, yysp, yyvstack) {
          var yy = this.yy;
          var yyparser = yy.parser;
          var yylexer = yy.lexer;
          switch (yystate) {
            case 0:
              this.$ = yyvstack[yysp - 1];
              break;
            case 1:
              this.$ = yyvstack[yysp - 1];
              return yyvstack[yysp - 1];
              break;
            case 2:
              this.$ = yyvstack[yysp - 1];
              break;
            case 3:
            case 4:
            case 5:
            case 6:
              this.$ = { type: "MathExpression", operator: yyvstack[yysp - 1], left: yyvstack[yysp - 2], right: yyvstack[yysp] };
              break;
            case 7:
              this.$ = { type: "ParenthesizedExpression", content: yyvstack[yysp - 1] };
              break;
            case 8:
            case 9:
            case 10:
              this.$ = yyvstack[yysp];
              break;
            case 11:
              this.$ = { type: "Function", value: yyvstack[yysp] };
              break;
            case 12:
              this.$ = { type: "LengthValue", value: parseFloat(yyvstack[yysp]), unit: /[a-z]+$/i.exec(yyvstack[yysp])[0] };
              break;
            case 13:
              this.$ = { type: "AngleValue", value: parseFloat(yyvstack[yysp]), unit: /[a-z]+$/i.exec(yyvstack[yysp])[0] };
              break;
            case 14:
              this.$ = { type: "TimeValue", value: parseFloat(yyvstack[yysp]), unit: /[a-z]+$/i.exec(yyvstack[yysp])[0] };
              break;
            case 15:
              this.$ = { type: "FrequencyValue", value: parseFloat(yyvstack[yysp]), unit: /[a-z]+$/i.exec(yyvstack[yysp])[0] };
              break;
            case 16:
              this.$ = { type: "ResolutionValue", value: parseFloat(yyvstack[yysp]), unit: /[a-z]+$/i.exec(yyvstack[yysp])[0] };
              break;
            case 17:
              this.$ = { type: "UnknownDimension", value: parseFloat(yyvstack[yysp]), unit: /[a-z]+$/i.exec(yyvstack[yysp])[0] };
              break;
            case 18:
              this.$ = { type: "EmValue", value: parseFloat(yyvstack[yysp]), unit: "em" };
              break;
            case 19:
              this.$ = { type: "ExValue", value: parseFloat(yyvstack[yysp]), unit: "ex" };
              break;
            case 20:
              this.$ = { type: "ChValue", value: parseFloat(yyvstack[yysp]), unit: "ch" };
              break;
            case 21:
              this.$ = { type: "RemValue", value: parseFloat(yyvstack[yysp]), unit: "rem" };
              break;
            case 22:
              this.$ = { type: "VhValue", value: parseFloat(yyvstack[yysp]), unit: "vh" };
              break;
            case 23:
              this.$ = { type: "VwValue", value: parseFloat(yyvstack[yysp]), unit: "vw" };
              break;
            case 24:
              this.$ = { type: "VminValue", value: parseFloat(yyvstack[yysp]), unit: "vmin" };
              break;
            case 25:
              this.$ = { type: "VmaxValue", value: parseFloat(yyvstack[yysp]), unit: "vmax" };
              break;
            case 26:
              this.$ = { type: "PercentageValue", value: parseFloat(yyvstack[yysp]), unit: "%" };
              break;
            case 27:
              var prev = yyvstack[yysp];
              this.$ = prev;
              break;
            case 28:
              var prev = yyvstack[yysp];
              prev.value *= -1;
              this.$ = prev;
              break;
            case 29:
            case 30:
              this.$ = { type: "Number", value: parseFloat(yyvstack[yysp]) };
              break;
            case 31:
              this.$ = { type: "Number", value: parseFloat(yyvstack[yysp]) * -1 };
              break;
          }
        },
        table: bt({
          len: u([
            26,
            1,
            5,
            1,
            25,
            s,
            [0, 19],
            19,
            19,
            0,
            0,
            s,
            [25, 5],
            5,
            0,
            0,
            18,
            18,
            0,
            0,
            6,
            6,
            0,
            0,
            c,
            [11, 3]
          ]),
          symbol: u([
            3,
            4,
            6,
            7,
            s,
            [10, 22, 1],
            1,
            1,
            s,
            [6, 4, 1],
            4,
            c,
            [33, 21],
            c,
            [32, 4],
            6,
            7,
            c,
            [22, 16],
            30,
            c,
            [19, 19],
            c,
            [63, 25],
            c,
            [25, 100],
            s,
            [5, 5, 1],
            c,
            [149, 17],
            c,
            [167, 18],
            30,
            1,
            c,
            [42, 5],
            c,
            [6, 6],
            c,
            [5, 5]
          ]),
          type: u([
            s,
            [2, 21],
            s,
            [0, 5],
            1,
            s,
            [2, 27],
            s,
            [0, 4],
            c,
            [22, 19],
            c,
            [19, 37],
            c,
            [63, 25],
            c,
            [25, 103],
            c,
            [148, 19],
            c,
            [18, 18]
          ]),
          state: u([
            1,
            2,
            5,
            6,
            7,
            33,
            c,
            [4, 3],
            34,
            38,
            40,
            c,
            [6, 3],
            41,
            c,
            [4, 3],
            42,
            c,
            [4, 3],
            43,
            c,
            [4, 3],
            44,
            c,
            [22, 5]
          ]),
          mode: u([
            s,
            [1, 228],
            s,
            [2, 4],
            c,
            [6, 8],
            s,
            [1, 5]
          ]),
          goto: u([
            3,
            4,
            24,
            25,
            s,
            [8, 16, 1],
            s,
            [26, 7, 1],
            c,
            [27, 21],
            36,
            37,
            c,
            [18, 15],
            35,
            c,
            [18, 17],
            39,
            c,
            [57, 21],
            c,
            [21, 84],
            45,
            c,
            [168, 4],
            c,
            [128, 17],
            c,
            [17, 17],
            s,
            [3, 4],
            30,
            31,
            s,
            [4, 4],
            30,
            31,
            46,
            c,
            [51, 4]
          ])
        }),
        defaultActions: bda({
          idx: u([
            s,
            [5, 19, 1],
            26,
            27,
            34,
            35,
            38,
            39,
            42,
            43,
            45,
            46
          ]),
          goto: u([
            s,
            [8, 19, 1],
            29,
            1,
            27,
            30,
            28,
            31,
            5,
            6,
            7,
            2
          ])
        }),
        parseError: function parseError(str, hash, ExceptionClass) {
          if (hash.recoverable) {
            if (typeof this.trace === "function") {
              this.trace(str);
            }
            hash.destroy();
          } else {
            if (typeof this.trace === "function") {
              this.trace(str);
            }
            if (!ExceptionClass) {
              ExceptionClass = this.JisonParserError;
            }
            throw new ExceptionClass(str, hash);
          }
        },
        parse: function parse(input) {
          var self2 = this;
          var stack = new Array(128);
          var sstack = new Array(128);
          var vstack = new Array(128);
          var table = this.table;
          var sp = 0;
          var symbol = 0;
          var TERROR = this.TERROR;
          var EOF = this.EOF;
          var ERROR_RECOVERY_TOKEN_DISCARD_COUNT = this.options.errorRecoveryTokenDiscardCount | 0 || 3;
          var NO_ACTION = [0, 47];
          var lexer2;
          if (this.__lexer__) {
            lexer2 = this.__lexer__;
          } else {
            lexer2 = this.__lexer__ = Object.create(this.lexer);
          }
          var sharedState_yy = {
            parseError: void 0,
            quoteName: void 0,
            lexer: void 0,
            parser: void 0,
            pre_parse: void 0,
            post_parse: void 0,
            pre_lex: void 0,
            post_lex: void 0
          };
          var ASSERT;
          if (typeof assert !== "function") {
            ASSERT = function JisonAssert(cond, msg) {
              if (!cond) {
                throw new Error("assertion failed: " + (msg || "***"));
              }
            };
          } else {
            ASSERT = assert;
          }
          this.yyGetSharedState = function yyGetSharedState() {
            return sharedState_yy;
          };
          function shallow_copy_noclobber(dst, src) {
            for (var k in src) {
              if (typeof dst[k] === "undefined" && Object.prototype.hasOwnProperty.call(src, k)) {
                dst[k] = src[k];
              }
            }
          }
          shallow_copy_noclobber(sharedState_yy, this.yy);
          sharedState_yy.lexer = lexer2;
          sharedState_yy.parser = this;
          if (typeof sharedState_yy.parseError === "function") {
            this.parseError = function parseErrorAlt(str, hash, ExceptionClass) {
              if (!ExceptionClass) {
                ExceptionClass = this.JisonParserError;
              }
              return sharedState_yy.parseError.call(this, str, hash, ExceptionClass);
            };
          } else {
            this.parseError = this.originalParseError;
          }
          if (typeof sharedState_yy.quoteName === "function") {
            this.quoteName = function quoteNameAlt(id_str) {
              return sharedState_yy.quoteName.call(this, id_str);
            };
          } else {
            this.quoteName = this.originalQuoteName;
          }
          this.cleanupAfterParse = function parser_cleanupAfterParse(resultValue, invoke_post_methods, do_not_nuke_errorinfos) {
            var rv;
            if (invoke_post_methods) {
              var hash;
              if (sharedState_yy.post_parse || this.post_parse) {
                hash = this.constructParseErrorInfo(null, null, null, false);
              }
              if (sharedState_yy.post_parse) {
                rv = sharedState_yy.post_parse.call(this, sharedState_yy, resultValue, hash);
                if (typeof rv !== "undefined")
                  resultValue = rv;
              }
              if (this.post_parse) {
                rv = this.post_parse.call(this, sharedState_yy, resultValue, hash);
                if (typeof rv !== "undefined")
                  resultValue = rv;
              }
              if (hash && hash.destroy) {
                hash.destroy();
              }
            }
            if (this.__reentrant_call_depth > 1)
              return resultValue;
            if (lexer2.cleanupAfterLex) {
              lexer2.cleanupAfterLex(do_not_nuke_errorinfos);
            }
            if (sharedState_yy) {
              sharedState_yy.lexer = void 0;
              sharedState_yy.parser = void 0;
              if (lexer2.yy === sharedState_yy) {
                lexer2.yy = void 0;
              }
            }
            sharedState_yy = void 0;
            this.parseError = this.originalParseError;
            this.quoteName = this.originalQuoteName;
            stack.length = 0;
            sstack.length = 0;
            vstack.length = 0;
            sp = 0;
            if (!do_not_nuke_errorinfos) {
              for (var i = this.__error_infos.length - 1; i >= 0; i--) {
                var el = this.__error_infos[i];
                if (el && typeof el.destroy === "function") {
                  el.destroy();
                }
              }
              this.__error_infos.length = 0;
            }
            return resultValue;
          };
          this.constructParseErrorInfo = function parser_constructParseErrorInfo(msg, ex, expected2, recoverable) {
            var pei = {
              errStr: msg,
              exception: ex,
              text: lexer2.match,
              value: lexer2.yytext,
              token: this.describeSymbol(symbol) || symbol,
              token_id: symbol,
              line: lexer2.yylineno,
              expected: expected2,
              recoverable,
              state,
              action,
              new_state: newState,
              symbol_stack: stack,
              state_stack: sstack,
              value_stack: vstack,
              stack_pointer: sp,
              yy: sharedState_yy,
              lexer: lexer2,
              parser: this,
              destroy: function destructParseErrorInfo() {
                var rec = !!this.recoverable;
                for (var key in this) {
                  if (this.hasOwnProperty(key) && typeof key === "object") {
                    this[key] = void 0;
                  }
                }
                this.recoverable = rec;
              }
            };
            this.__error_infos.push(pei);
            return pei;
          };
          function getNonTerminalFromCode(symbol2) {
            var tokenName = self2.getSymbolName(symbol2);
            if (!tokenName) {
              tokenName = symbol2;
            }
            return tokenName;
          }
          function stdLex() {
            var token = lexer2.lex();
            if (typeof token !== "number") {
              token = self2.symbols_[token] || token;
            }
            return token || EOF;
          }
          function fastLex() {
            var token = lexer2.fastLex();
            if (typeof token !== "number") {
              token = self2.symbols_[token] || token;
            }
            return token || EOF;
          }
          var lex = stdLex;
          var state, action, r, t;
          var yyval = {
            $: true,
            _$: void 0,
            yy: sharedState_yy
          };
          var p;
          var yyrulelen;
          var this_production;
          var newState;
          var retval = false;
          try {
            this.__reentrant_call_depth++;
            lexer2.setInput(input, sharedState_yy);
            if (typeof lexer2.canIUse === "function") {
              var lexerInfo = lexer2.canIUse();
              if (lexerInfo.fastLex && typeof fastLex === "function") {
                lex = fastLex;
              }
            }
            vstack[sp] = null;
            sstack[sp] = 0;
            stack[sp] = 0;
            ++sp;
            if (this.pre_parse) {
              this.pre_parse.call(this, sharedState_yy);
            }
            if (sharedState_yy.pre_parse) {
              sharedState_yy.pre_parse.call(this, sharedState_yy);
            }
            newState = sstack[sp - 1];
            for (; ; ) {
              state = newState;
              if (this.defaultActions[state]) {
                action = 2;
                newState = this.defaultActions[state];
              } else {
                if (!symbol) {
                  symbol = lex();
                }
                t = table[state] && table[state][symbol] || NO_ACTION;
                newState = t[1];
                action = t[0];
                if (!action) {
                  var errStr;
                  var errSymbolDescr = this.describeSymbol(symbol) || symbol;
                  var expected = this.collect_expected_token_set(state);
                  if (typeof lexer2.yylineno === "number") {
                    errStr = "Parse error on line " + (lexer2.yylineno + 1) + ": ";
                  } else {
                    errStr = "Parse error: ";
                  }
                  if (typeof lexer2.showPosition === "function") {
                    errStr += "\n" + lexer2.showPosition(79 - 10, 10) + "\n";
                  }
                  if (expected.length) {
                    errStr += "Expecting " + expected.join(", ") + ", got unexpected " + errSymbolDescr;
                  } else {
                    errStr += "Unexpected " + errSymbolDescr;
                  }
                  p = this.constructParseErrorInfo(errStr, null, expected, false);
                  r = this.parseError(p.errStr, p, this.JisonParserError);
                  if (typeof r !== "undefined") {
                    retval = r;
                  }
                  break;
                }
              }
              switch (action) {
                default:
                  if (action instanceof Array) {
                    p = this.constructParseErrorInfo("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol, null, null, false);
                    r = this.parseError(p.errStr, p, this.JisonParserError);
                    if (typeof r !== "undefined") {
                      retval = r;
                    }
                    break;
                  }
                  p = this.constructParseErrorInfo("Parsing halted. No viable error recovery approach available due to internal system failure.", null, null, false);
                  r = this.parseError(p.errStr, p, this.JisonParserError);
                  if (typeof r !== "undefined") {
                    retval = r;
                  }
                  break;
                case 1:
                  stack[sp] = symbol;
                  vstack[sp] = lexer2.yytext;
                  sstack[sp] = newState;
                  ++sp;
                  symbol = 0;
                  continue;
                case 2:
                  this_production = this.productions_[newState - 1];
                  yyrulelen = this_production[1];
                  r = this.performAction.call(yyval, newState, sp - 1, vstack);
                  if (typeof r !== "undefined") {
                    retval = r;
                    break;
                  }
                  sp -= yyrulelen;
                  var ntsymbol = this_production[0];
                  stack[sp] = ntsymbol;
                  vstack[sp] = yyval.$;
                  newState = table[sstack[sp - 1]][ntsymbol];
                  sstack[sp] = newState;
                  ++sp;
                  continue;
                case 3:
                  if (sp !== -2) {
                    retval = true;
                    sp--;
                    if (typeof vstack[sp] !== "undefined") {
                      retval = vstack[sp];
                    }
                  }
                  break;
              }
              break;
            }
          } catch (ex) {
            if (ex instanceof this.JisonParserError) {
              throw ex;
            } else if (lexer2 && typeof lexer2.JisonLexerError === "function" && ex instanceof lexer2.JisonLexerError) {
              throw ex;
            }
            p = this.constructParseErrorInfo("Parsing aborted due to exception.", ex, null, false);
            retval = false;
            r = this.parseError(p.errStr, p, this.JisonParserError);
            if (typeof r !== "undefined") {
              retval = r;
            }
          } finally {
            retval = this.cleanupAfterParse(retval, true, true);
            this.__reentrant_call_depth--;
          }
          return retval;
        }
      };
      parser2.originalParseError = parser2.parseError;
      parser2.originalQuoteName = parser2.quoteName;
      var lexer = function() {
        function JisonLexerError(msg, hash) {
          Object.defineProperty(this, "name", {
            enumerable: false,
            writable: false,
            value: "JisonLexerError"
          });
          if (msg == null)
            msg = "???";
          Object.defineProperty(this, "message", {
            enumerable: false,
            writable: true,
            value: msg
          });
          this.hash = hash;
          var stacktrace;
          if (hash && hash.exception instanceof Error) {
            var ex2 = hash.exception;
            this.message = ex2.message || msg;
            stacktrace = ex2.stack;
          }
          if (!stacktrace) {
            if (Error.hasOwnProperty("captureStackTrace")) {
              Error.captureStackTrace(this, this.constructor);
            } else {
              stacktrace = new Error(msg).stack;
            }
          }
          if (stacktrace) {
            Object.defineProperty(this, "stack", {
              enumerable: false,
              writable: false,
              value: stacktrace
            });
          }
        }
        if (typeof Object.setPrototypeOf === "function") {
          Object.setPrototypeOf(JisonLexerError.prototype, Error.prototype);
        } else {
          JisonLexerError.prototype = Object.create(Error.prototype);
        }
        JisonLexerError.prototype.constructor = JisonLexerError;
        JisonLexerError.prototype.name = "JisonLexerError";
        var lexer2 = {
          EOF: 1,
          ERROR: 2,
          __currentRuleSet__: null,
          __error_infos: [],
          __decompressed: false,
          done: false,
          _backtrack: false,
          _input: "",
          _more: false,
          _signaled_error_token: false,
          conditionStack: [],
          match: "",
          matched: "",
          matches: false,
          yytext: "",
          offset: 0,
          yyleng: 0,
          yylineno: 0,
          yylloc: null,
          constructLexErrorInfo: function lexer_constructLexErrorInfo(msg, recoverable, show_input_position) {
            msg = "" + msg;
            if (show_input_position == void 0) {
              show_input_position = !(msg.indexOf("\n") > 0 && msg.indexOf("^") > 0);
            }
            if (this.yylloc && show_input_position) {
              if (typeof this.prettyPrintRange === "function") {
                var pretty_src = this.prettyPrintRange(this.yylloc);
                if (!/\n\s*$/.test(msg)) {
                  msg += "\n";
                }
                msg += "\n  Erroneous area:\n" + this.prettyPrintRange(this.yylloc);
              } else if (typeof this.showPosition === "function") {
                var pos_str = this.showPosition();
                if (pos_str) {
                  if (msg.length && msg[msg.length - 1] !== "\n" && pos_str[0] !== "\n") {
                    msg += "\n" + pos_str;
                  } else {
                    msg += pos_str;
                  }
                }
              }
            }
            var pei = {
              errStr: msg,
              recoverable: !!recoverable,
              text: this.match,
              token: null,
              line: this.yylineno,
              loc: this.yylloc,
              yy: this.yy,
              lexer: this,
              destroy: function destructLexErrorInfo() {
                var rec = !!this.recoverable;
                for (var key in this) {
                  if (this.hasOwnProperty(key) && typeof key === "object") {
                    this[key] = void 0;
                  }
                }
                this.recoverable = rec;
              }
            };
            this.__error_infos.push(pei);
            return pei;
          },
          parseError: function lexer_parseError(str, hash, ExceptionClass) {
            if (!ExceptionClass) {
              ExceptionClass = this.JisonLexerError;
            }
            if (this.yy) {
              if (this.yy.parser && typeof this.yy.parser.parseError === "function") {
                return this.yy.parser.parseError.call(this, str, hash, ExceptionClass) || this.ERROR;
              } else if (typeof this.yy.parseError === "function") {
                return this.yy.parseError.call(this, str, hash, ExceptionClass) || this.ERROR;
              }
            }
            throw new ExceptionClass(str, hash);
          },
          yyerror: function yyError(str) {
            var lineno_msg = "";
            if (this.yylloc) {
              lineno_msg = " on line " + (this.yylineno + 1);
            }
            var p = this.constructLexErrorInfo("Lexical error" + lineno_msg + ": " + str, this.options.lexerErrorsAreRecoverable);
            var args = Array.prototype.slice.call(arguments, 1);
            if (args.length) {
              p.extra_error_attributes = args;
            }
            return this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
          },
          cleanupAfterLex: function lexer_cleanupAfterLex(do_not_nuke_errorinfos) {
            this.setInput("", {});
            if (!do_not_nuke_errorinfos) {
              for (var i = this.__error_infos.length - 1; i >= 0; i--) {
                var el = this.__error_infos[i];
                if (el && typeof el.destroy === "function") {
                  el.destroy();
                }
              }
              this.__error_infos.length = 0;
            }
            return this;
          },
          clear: function lexer_clear() {
            this.yytext = "";
            this.yyleng = 0;
            this.match = "";
            this.matches = false;
            this._more = false;
            this._backtrack = false;
            var col = this.yylloc ? this.yylloc.last_column : 0;
            this.yylloc = {
              first_line: this.yylineno + 1,
              first_column: col,
              last_line: this.yylineno + 1,
              last_column: col,
              range: [this.offset, this.offset]
            };
          },
          setInput: function lexer_setInput(input, yy) {
            this.yy = yy || this.yy || {};
            if (!this.__decompressed) {
              var rules = this.rules;
              for (var i = 0, len = rules.length; i < len; i++) {
                var rule_re = rules[i];
                if (typeof rule_re === "number") {
                  rules[i] = rules[rule_re];
                }
              }
              var conditions = this.conditions;
              for (var k in conditions) {
                var spec = conditions[k];
                var rule_ids = spec.rules;
                var len = rule_ids.length;
                var rule_regexes = new Array(len + 1);
                var rule_new_ids = new Array(len + 1);
                for (var i = 0; i < len; i++) {
                  var idx = rule_ids[i];
                  var rule_re = rules[idx];
                  rule_regexes[i + 1] = rule_re;
                  rule_new_ids[i + 1] = idx;
                }
                spec.rules = rule_new_ids;
                spec.__rule_regexes = rule_regexes;
                spec.__rule_count = len;
              }
              this.__decompressed = true;
            }
            this._input = input || "";
            this.clear();
            this._signaled_error_token = false;
            this.done = false;
            this.yylineno = 0;
            this.matched = "";
            this.conditionStack = ["INITIAL"];
            this.__currentRuleSet__ = null;
            this.yylloc = {
              first_line: 1,
              first_column: 0,
              last_line: 1,
              last_column: 0,
              range: [0, 0]
            };
            this.offset = 0;
            return this;
          },
          editRemainingInput: function lexer_editRemainingInput(callback, cpsArg) {
            var rv = callback.call(this, this._input, cpsArg);
            if (typeof rv !== "string") {
              if (rv) {
                this._input = "" + rv;
              }
            } else {
              this._input = rv;
            }
            return this;
          },
          input: function lexer_input() {
            if (!this._input) {
              return null;
            }
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var slice_len = 1;
            var lines = false;
            if (ch === "\n") {
              lines = true;
            } else if (ch === "\r") {
              lines = true;
              var ch2 = this._input[1];
              if (ch2 === "\n") {
                slice_len++;
                ch += ch2;
                this.yytext += ch2;
                this.yyleng++;
                this.offset++;
                this.match += ch2;
                this.matched += ch2;
                this.yylloc.range[1]++;
              }
            }
            if (lines) {
              this.yylineno++;
              this.yylloc.last_line++;
              this.yylloc.last_column = 0;
            } else {
              this.yylloc.last_column++;
            }
            this.yylloc.range[1]++;
            this._input = this._input.slice(slice_len);
            return ch;
          },
          unput: function lexer_unput(ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);
            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len);
            this.yyleng = this.yytext.length;
            this.offset -= len;
            this.match = this.match.substr(0, this.match.length - len);
            this.matched = this.matched.substr(0, this.matched.length - len);
            if (lines.length > 1) {
              this.yylineno -= lines.length - 1;
              this.yylloc.last_line = this.yylineno + 1;
              var pre = this.match;
              var pre_lines = pre.split(/(?:\r\n?|\n)/g);
              if (pre_lines.length === 1) {
                pre = this.matched;
                pre_lines = pre.split(/(?:\r\n?|\n)/g);
              }
              this.yylloc.last_column = pre_lines[pre_lines.length - 1].length;
            } else {
              this.yylloc.last_column -= len;
            }
            this.yylloc.range[1] = this.yylloc.range[0] + this.yyleng;
            this.done = false;
            return this;
          },
          more: function lexer_more() {
            this._more = true;
            return this;
          },
          reject: function lexer_reject() {
            if (this.options.backtrack_lexer) {
              this._backtrack = true;
            } else {
              var lineno_msg = "";
              if (this.yylloc) {
                lineno_msg = " on line " + (this.yylineno + 1);
              }
              var p = this.constructLexErrorInfo("Lexical error" + lineno_msg + ": You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).", false);
              this._signaled_error_token = this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
            }
            return this;
          },
          less: function lexer_less(n) {
            return this.unput(this.match.slice(n));
          },
          pastInput: function lexer_pastInput(maxSize, maxLines) {
            var past = this.matched.substring(0, this.matched.length - this.match.length);
            if (maxSize < 0)
              maxSize = past.length;
            else if (!maxSize)
              maxSize = 20;
            if (maxLines < 0)
              maxLines = past.length;
            else if (!maxLines)
              maxLines = 1;
            past = past.substr(-maxSize * 2 - 2);
            var a = past.replace(/\r\n|\r/g, "\n").split("\n");
            a = a.slice(-maxLines);
            past = a.join("\n");
            if (past.length > maxSize) {
              past = "..." + past.substr(-maxSize);
            }
            return past;
          },
          upcomingInput: function lexer_upcomingInput(maxSize, maxLines) {
            var next = this.match;
            if (maxSize < 0)
              maxSize = next.length + this._input.length;
            else if (!maxSize)
              maxSize = 20;
            if (maxLines < 0)
              maxLines = maxSize;
            else if (!maxLines)
              maxLines = 1;
            if (next.length < maxSize * 2 + 2) {
              next += this._input.substring(0, maxSize * 2 + 2);
            }
            var a = next.replace(/\r\n|\r/g, "\n").split("\n");
            a = a.slice(0, maxLines);
            next = a.join("\n");
            if (next.length > maxSize) {
              next = next.substring(0, maxSize) + "...";
            }
            return next;
          },
          showPosition: function lexer_showPosition(maxPrefix, maxPostfix) {
            var pre = this.pastInput(maxPrefix).replace(/\s/g, " ");
            var c2 = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput(maxPostfix).replace(/\s/g, " ") + "\n" + c2 + "^";
          },
          deriveLocationInfo: function lexer_deriveYYLLOC(actual, preceding, following, current) {
            var loc = {
              first_line: 1,
              first_column: 0,
              last_line: 1,
              last_column: 0,
              range: [0, 0]
            };
            if (actual) {
              loc.first_line = actual.first_line | 0;
              loc.last_line = actual.last_line | 0;
              loc.first_column = actual.first_column | 0;
              loc.last_column = actual.last_column | 0;
              if (actual.range) {
                loc.range[0] = actual.range[0] | 0;
                loc.range[1] = actual.range[1] | 0;
              }
            }
            if (loc.first_line <= 0 || loc.last_line < loc.first_line) {
              if (loc.first_line <= 0 && preceding) {
                loc.first_line = preceding.last_line | 0;
                loc.first_column = preceding.last_column | 0;
                if (preceding.range) {
                  loc.range[0] = actual.range[1] | 0;
                }
              }
              if ((loc.last_line <= 0 || loc.last_line < loc.first_line) && following) {
                loc.last_line = following.first_line | 0;
                loc.last_column = following.first_column | 0;
                if (following.range) {
                  loc.range[1] = actual.range[0] | 0;
                }
              }
              if (loc.first_line <= 0 && current && (loc.last_line <= 0 || current.last_line <= loc.last_line)) {
                loc.first_line = current.first_line | 0;
                loc.first_column = current.first_column | 0;
                if (current.range) {
                  loc.range[0] = current.range[0] | 0;
                }
              }
              if (loc.last_line <= 0 && current && (loc.first_line <= 0 || current.first_line >= loc.first_line)) {
                loc.last_line = current.last_line | 0;
                loc.last_column = current.last_column | 0;
                if (current.range) {
                  loc.range[1] = current.range[1] | 0;
                }
              }
            }
            if (loc.last_line <= 0) {
              if (loc.first_line <= 0) {
                loc.first_line = this.yylloc.first_line;
                loc.last_line = this.yylloc.last_line;
                loc.first_column = this.yylloc.first_column;
                loc.last_column = this.yylloc.last_column;
                loc.range[0] = this.yylloc.range[0];
                loc.range[1] = this.yylloc.range[1];
              } else {
                loc.last_line = this.yylloc.last_line;
                loc.last_column = this.yylloc.last_column;
                loc.range[1] = this.yylloc.range[1];
              }
            }
            if (loc.first_line <= 0) {
              loc.first_line = loc.last_line;
              loc.first_column = 0;
              loc.range[1] = loc.range[0];
            }
            if (loc.first_column < 0) {
              loc.first_column = 0;
            }
            if (loc.last_column < 0) {
              loc.last_column = loc.first_column > 0 ? loc.first_column : 80;
            }
            return loc;
          },
          prettyPrintRange: function lexer_prettyPrintRange(loc, context_loc, context_loc2) {
            loc = this.deriveLocationInfo(loc, context_loc, context_loc2);
            const CONTEXT = 3;
            const CONTEXT_TAIL = 1;
            const MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT = 2;
            var input = this.matched + this._input;
            var lines = input.split("\n");
            var l0 = Math.max(1, context_loc ? context_loc.first_line : loc.first_line - CONTEXT);
            var l1 = Math.max(1, context_loc2 ? context_loc2.last_line : loc.last_line + CONTEXT_TAIL);
            var lineno_display_width = 1 + Math.log10(l1 | 1) | 0;
            var ws_prefix = new Array(lineno_display_width).join(" ");
            var nonempty_line_indexes = [];
            var rv = lines.slice(l0 - 1, l1 + 1).map(function injectLineNumber(line, index) {
              var lno = index + l0;
              var lno_pfx = (ws_prefix + lno).substr(-lineno_display_width);
              var rv2 = lno_pfx + ": " + line;
              var errpfx = new Array(lineno_display_width + 1).join("^");
              var offset = 2 + 1;
              var len = 0;
              if (lno === loc.first_line) {
                offset += loc.first_column;
                len = Math.max(2, (lno === loc.last_line ? loc.last_column : line.length) - loc.first_column + 1);
              } else if (lno === loc.last_line) {
                len = Math.max(2, loc.last_column + 1);
              } else if (lno > loc.first_line && lno < loc.last_line) {
                len = Math.max(2, line.length + 1);
              }
              if (len) {
                var lead = new Array(offset).join(".");
                var mark = new Array(len).join("^");
                rv2 += "\n" + errpfx + lead + mark;
                if (line.trim().length > 0) {
                  nonempty_line_indexes.push(index);
                }
              }
              rv2 = rv2.replace(/\t/g, " ");
              return rv2;
            });
            if (nonempty_line_indexes.length > 2 * MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT) {
              var clip_start = nonempty_line_indexes[MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT - 1] + 1;
              var clip_end = nonempty_line_indexes[nonempty_line_indexes.length - MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT] - 1;
              var intermediate_line = new Array(lineno_display_width + 1).join(" ") + "  (...continued...)";
              intermediate_line += "\n" + new Array(lineno_display_width + 1).join("-") + "  (---------------)";
              rv.splice(clip_start, clip_end - clip_start + 1, intermediate_line);
            }
            return rv.join("\n");
          },
          describeYYLLOC: function lexer_describe_yylloc(yylloc, display_range_too) {
            var l1 = yylloc.first_line;
            var l2 = yylloc.last_line;
            var c1 = yylloc.first_column;
            var c2 = yylloc.last_column;
            var dl = l2 - l1;
            var dc = c2 - c1;
            var rv;
            if (dl === 0) {
              rv = "line " + l1 + ", ";
              if (dc <= 1) {
                rv += "column " + c1;
              } else {
                rv += "columns " + c1 + " .. " + c2;
              }
            } else {
              rv = "lines " + l1 + "(column " + c1 + ") .. " + l2 + "(column " + c2 + ")";
            }
            if (yylloc.range && display_range_too) {
              var r1 = yylloc.range[0];
              var r2 = yylloc.range[1] - 1;
              if (r2 <= r1) {
                rv += " {String Offset: " + r1 + "}";
              } else {
                rv += " {String Offset range: " + r1 + " .. " + r2 + "}";
              }
            }
            return rv;
          },
          test_match: function lexer_test_match(match, indexed_rule) {
            var token, lines, backup, match_str, match_str_len;
            if (this.options.backtrack_lexer) {
              backup = {
                yylineno: this.yylineno,
                yylloc: {
                  first_line: this.yylloc.first_line,
                  last_line: this.yylloc.last_line,
                  first_column: this.yylloc.first_column,
                  last_column: this.yylloc.last_column,
                  range: this.yylloc.range.slice(0)
                },
                yytext: this.yytext,
                match: this.match,
                matches: this.matches,
                matched: this.matched,
                yyleng: this.yyleng,
                offset: this.offset,
                _more: this._more,
                _input: this._input,
                yy: this.yy,
                conditionStack: this.conditionStack.slice(0),
                done: this.done
              };
            }
            match_str = match[0];
            match_str_len = match_str.length;
            lines = match_str.split(/(?:\r\n?|\n)/g);
            if (lines.length > 1) {
              this.yylineno += lines.length - 1;
              this.yylloc.last_line = this.yylineno + 1;
              this.yylloc.last_column = lines[lines.length - 1].length;
            } else {
              this.yylloc.last_column += match_str_len;
            }
            this.yytext += match_str;
            this.match += match_str;
            this.matched += match_str;
            this.matches = match;
            this.yyleng = this.yytext.length;
            this.yylloc.range[1] += match_str_len;
            this.offset += match_str_len;
            this._more = false;
            this._backtrack = false;
            this._input = this._input.slice(match_str_len);
            token = this.performAction.call(this, this.yy, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
            if (this.done && this._input) {
              this.done = false;
            }
            if (token) {
              return token;
            } else if (this._backtrack) {
              for (var k in backup) {
                this[k] = backup[k];
              }
              this.__currentRuleSet__ = null;
              return false;
            } else if (this._signaled_error_token) {
              token = this._signaled_error_token;
              this._signaled_error_token = false;
              return token;
            }
            return false;
          },
          next: function lexer_next() {
            if (this.done) {
              this.clear();
              return this.EOF;
            }
            if (!this._input) {
              this.done = true;
            }
            var token, match, tempMatch, index;
            if (!this._more) {
              this.clear();
            }
            var spec = this.__currentRuleSet__;
            if (!spec) {
              spec = this.__currentRuleSet__ = this._currentRules();
              if (!spec || !spec.rules) {
                var lineno_msg = "";
                if (this.options.trackPosition) {
                  lineno_msg = " on line " + (this.yylineno + 1);
                }
                var p = this.constructLexErrorInfo("Internal lexer engine error" + lineno_msg + ': The lex grammar programmer pushed a non-existing condition name "' + this.topState() + '"; this is a fatal error and should be reported to the application programmer team!', false);
                return this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
              }
            }
            var rule_ids = spec.rules;
            var regexes = spec.__rule_regexes;
            var len = spec.__rule_count;
            for (var i = 1; i <= len; i++) {
              tempMatch = this._input.match(regexes[i]);
              if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                match = tempMatch;
                index = i;
                if (this.options.backtrack_lexer) {
                  token = this.test_match(tempMatch, rule_ids[i]);
                  if (token !== false) {
                    return token;
                  } else if (this._backtrack) {
                    match = void 0;
                    continue;
                  } else {
                    return false;
                  }
                } else if (!this.options.flex) {
                  break;
                }
              }
            }
            if (match) {
              token = this.test_match(match, rule_ids[index]);
              if (token !== false) {
                return token;
              }
              return false;
            }
            if (!this._input) {
              this.done = true;
              this.clear();
              return this.EOF;
            } else {
              var lineno_msg = "";
              if (this.options.trackPosition) {
                lineno_msg = " on line " + (this.yylineno + 1);
              }
              var p = this.constructLexErrorInfo("Lexical error" + lineno_msg + ": Unrecognized text.", this.options.lexerErrorsAreRecoverable);
              var pendingInput = this._input;
              var activeCondition = this.topState();
              var conditionStackDepth = this.conditionStack.length;
              token = this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
              if (token === this.ERROR) {
                if (!this.matches && pendingInput === this._input && activeCondition === this.topState() && conditionStackDepth === this.conditionStack.length) {
                  this.input();
                }
              }
              return token;
            }
          },
          lex: function lexer_lex() {
            var r;
            if (typeof this.pre_lex === "function") {
              r = this.pre_lex.call(this, 0);
            }
            if (typeof this.options.pre_lex === "function") {
              r = this.options.pre_lex.call(this, r) || r;
            }
            if (this.yy && typeof this.yy.pre_lex === "function") {
              r = this.yy.pre_lex.call(this, r) || r;
            }
            while (!r) {
              r = this.next();
            }
            if (this.yy && typeof this.yy.post_lex === "function") {
              r = this.yy.post_lex.call(this, r) || r;
            }
            if (typeof this.options.post_lex === "function") {
              r = this.options.post_lex.call(this, r) || r;
            }
            if (typeof this.post_lex === "function") {
              r = this.post_lex.call(this, r) || r;
            }
            return r;
          },
          fastLex: function lexer_fastLex() {
            var r;
            while (!r) {
              r = this.next();
            }
            return r;
          },
          canIUse: function lexer_canIUse() {
            var rv = {
              fastLex: !(typeof this.pre_lex === "function" || typeof this.options.pre_lex === "function" || this.yy && typeof this.yy.pre_lex === "function" || this.yy && typeof this.yy.post_lex === "function" || typeof this.options.post_lex === "function" || typeof this.post_lex === "function") && typeof this.fastLex === "function"
            };
            return rv;
          },
          begin: function lexer_begin(condition) {
            return this.pushState(condition);
          },
          pushState: function lexer_pushState(condition) {
            this.conditionStack.push(condition);
            this.__currentRuleSet__ = null;
            return this;
          },
          popState: function lexer_popState() {
            var n = this.conditionStack.length - 1;
            if (n > 0) {
              this.__currentRuleSet__ = null;
              return this.conditionStack.pop();
            } else {
              return this.conditionStack[0];
            }
          },
          topState: function lexer_topState(n) {
            n = this.conditionStack.length - 1 - Math.abs(n || 0);
            if (n >= 0) {
              return this.conditionStack[n];
            } else {
              return "INITIAL";
            }
          },
          _currentRules: function lexer__currentRules() {
            if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
              return this.conditions[this.conditionStack[this.conditionStack.length - 1]];
            } else {
              return this.conditions["INITIAL"];
            }
          },
          stateStackSize: function lexer_stateStackSize() {
            return this.conditionStack.length;
          },
          options: {
            trackPosition: true,
            caseInsensitive: true
          },
          JisonLexerError,
          performAction: function lexer__performAction(yy, yyrulenumber, YY_START) {
            var yy_ = this;
            var YYSTATE = YY_START;
            switch (yyrulenumber) {
              case 0:
                break;
              default:
                return this.simpleCaseActionClusters[yyrulenumber];
            }
          },
          simpleCaseActionClusters: {
            1: 3,
            2: 10,
            3: 8,
            4: 9,
            5: 6,
            6: 7,
            7: 17,
            8: 18,
            9: 19,
            10: 20,
            11: 22,
            12: 21,
            13: 23,
            14: 24,
            15: 11,
            16: 11,
            17: 11,
            18: 11,
            19: 11,
            20: 11,
            21: 11,
            22: 12,
            23: 12,
            24: 12,
            25: 12,
            26: 13,
            27: 13,
            28: 14,
            29: 14,
            30: 15,
            31: 15,
            32: 15,
            33: 25,
            34: 26,
            35: 16,
            36: 4,
            37: 5,
            38: 1
          },
          rules: [
            /^(?:\s+)/i,
            /^(?:(-(webkit|moz)-)?calc\b)/i,
            /^(?:[a-z][\d\-a-z]*\s*\((?:(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')|\([^)]*\)|[^()]*)*\))/i,
            /^(?:\*)/i,
            /^(?:\/)/i,
            /^(?:\+)/i,
            /^(?:-)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)em\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)ex\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)ch\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)rem\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)vw\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)vh\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)vmin\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)vmax\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)cm\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)mm\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)Q\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)in\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)pt\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)pc\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)px\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)deg\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)grad\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)rad\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)turn\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)s\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)ms\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)Hz\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)kHz\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)dpi\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)dpcm\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)dppx\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)%)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)\b)/i,
            /^(?:((\d+(\.\d+)?|\.\d+)(e(\+|-)\d+)?)-?([^\W\d]|[ -ÿ]|(\\[\dA-Fa-f]{1,6}(\r\n|[\t\n\f\r ])?|\\[^\d\n\f\rA-Fa-f]))([\w\-]|[ -ÿ]|(\\[\dA-Fa-f]{1,6}(\r\n|[\t\n\f\r ])?|\\[^\d\n\f\rA-Fa-f]))*\b)/i,
            /^(?:\()/i,
            /^(?:\))/i,
            /^(?:$)/i
          ],
          conditions: {
            "INITIAL": {
              rules: [
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                16,
                17,
                18,
                19,
                20,
                21,
                22,
                23,
                24,
                25,
                26,
                27,
                28,
                29,
                30,
                31,
                32,
                33,
                34,
                35,
                36,
                37,
                38
              ],
              inclusive: true
            }
          }
        };
        return lexer2;
      }();
      parser2.lexer = lexer;
      function Parser() {
        this.yy = {};
      }
      Parser.prototype = parser2;
      parser2.Parser = Parser;
      return new Parser();
    }();
    if (typeof require !== "undefined" && typeof exports2 !== "undefined") {
      exports2.parser = parser;
      exports2.Parser = parser.Parser;
      exports2.parse = function() {
        return parser.parse.apply(parser, arguments);
      };
    }
  }
});

// node_modules/postcss-calc/src/lib/convertUnit.js
var require_convertUnit = __commonJS({
  "node_modules/postcss-calc/src/lib/convertUnit.js"(exports2, module2) {
    "use strict";
    var conversions = {
      px: {
        px: 1,
        cm: 96 / 2.54,
        mm: 96 / 25.4,
        q: 96 / 101.6,
        in: 96,
        pt: 96 / 72,
        pc: 16
      },
      cm: {
        px: 2.54 / 96,
        cm: 1,
        mm: 0.1,
        q: 0.025,
        in: 2.54,
        pt: 2.54 / 72,
        pc: 2.54 / 6
      },
      mm: {
        px: 25.4 / 96,
        cm: 10,
        mm: 1,
        q: 0.25,
        in: 25.4,
        pt: 25.4 / 72,
        pc: 25.4 / 6
      },
      q: {
        px: 101.6 / 96,
        cm: 40,
        mm: 4,
        q: 1,
        in: 101.6,
        pt: 101.6 / 72,
        pc: 101.6 / 6
      },
      in: {
        px: 1 / 96,
        cm: 1 / 2.54,
        mm: 1 / 25.4,
        q: 1 / 101.6,
        in: 1,
        pt: 1 / 72,
        pc: 1 / 6
      },
      pt: {
        px: 0.75,
        cm: 72 / 2.54,
        mm: 72 / 25.4,
        q: 72 / 101.6,
        in: 72,
        pt: 1,
        pc: 12
      },
      pc: {
        px: 0.0625,
        cm: 6 / 2.54,
        mm: 6 / 25.4,
        q: 6 / 101.6,
        in: 6,
        pt: 6 / 72,
        pc: 1
      },
      deg: {
        deg: 1,
        grad: 0.9,
        rad: 180 / Math.PI,
        turn: 360
      },
      grad: {
        deg: 400 / 360,
        grad: 1,
        rad: 200 / Math.PI,
        turn: 400
      },
      rad: {
        deg: Math.PI / 180,
        grad: Math.PI / 200,
        rad: 1,
        turn: Math.PI * 2
      },
      turn: {
        deg: 1 / 360,
        grad: 25e-4,
        rad: 0.5 / Math.PI,
        turn: 1
      },
      s: {
        s: 1,
        ms: 1e-3
      },
      ms: {
        s: 1e3,
        ms: 1
      },
      hz: {
        hz: 1,
        khz: 1e3
      },
      khz: {
        hz: 1e-3,
        khz: 1
      },
      dpi: {
        dpi: 1,
        dpcm: 1 / 2.54,
        dppx: 1 / 96
      },
      dpcm: {
        dpi: 2.54,
        dpcm: 1,
        dppx: 2.54 / 96
      },
      dppx: {
        dpi: 96,
        dpcm: 96 / 2.54,
        dppx: 1
      }
    };
    function convertUnit(value, sourceUnit, targetUnit, precision) {
      const sourceUnitNormalized = sourceUnit.toLowerCase();
      const targetUnitNormalized = targetUnit.toLowerCase();
      if (!conversions[targetUnitNormalized]) {
        throw new Error("Cannot convert to " + targetUnit);
      }
      if (!conversions[targetUnitNormalized][sourceUnitNormalized]) {
        throw new Error("Cannot convert from " + sourceUnit + " to " + targetUnit);
      }
      const converted = conversions[targetUnitNormalized][sourceUnitNormalized] * value;
      if (precision !== false) {
        precision = Math.pow(10, Math.ceil(precision) || 5);
        return Math.round(converted * precision) / precision;
      }
      return converted;
    }
    module2.exports = convertUnit;
  }
});

// node_modules/postcss-calc/src/lib/reducer.js
var require_reducer = __commonJS({
  "node_modules/postcss-calc/src/lib/reducer.js"(exports2, module2) {
    "use strict";
    var convertUnit = require_convertUnit();
    function isValueType(node) {
      switch (node.type) {
        case "LengthValue":
        case "AngleValue":
        case "TimeValue":
        case "FrequencyValue":
        case "ResolutionValue":
        case "EmValue":
        case "ExValue":
        case "ChValue":
        case "RemValue":
        case "VhValue":
        case "VwValue":
        case "VminValue":
        case "VmaxValue":
        case "PercentageValue":
        case "Number":
          return true;
      }
      return false;
    }
    function flip(operator) {
      return operator === "+" ? "-" : "+";
    }
    function isAddSubOperator(operator) {
      return operator === "+" || operator === "-";
    }
    function collectAddSubItems(preOperator, node, collected, precision) {
      if (!isAddSubOperator(preOperator)) {
        throw new Error(`invalid operator ${preOperator}`);
      }
      if (isValueType(node)) {
        const itemIndex = collected.findIndex((x) => x.node.type === node.type);
        if (itemIndex >= 0) {
          if (node.value === 0) {
            return;
          }
          const otherValueNode = collected[itemIndex].node;
          const { left: reducedNode, right: current } = convertNodesUnits(otherValueNode, node, precision);
          if (collected[itemIndex].preOperator === "-") {
            collected[itemIndex].preOperator = "+";
            reducedNode.value *= -1;
          }
          if (preOperator === "+") {
            reducedNode.value += current.value;
          } else {
            reducedNode.value -= current.value;
          }
          if (reducedNode.value >= 0) {
            collected[itemIndex] = { node: reducedNode, preOperator: "+" };
          } else {
            reducedNode.value *= -1;
            collected[itemIndex] = { node: reducedNode, preOperator: "-" };
          }
        } else {
          if (node.value >= 0) {
            collected.push({ node, preOperator });
          } else {
            node.value *= -1;
            collected.push({ node, preOperator: flip(preOperator) });
          }
        }
      } else if (node.type === "MathExpression") {
        if (isAddSubOperator(node.operator)) {
          collectAddSubItems(preOperator, node.left, collected, precision);
          const collectRightOperator = preOperator === "-" ? flip(node.operator) : node.operator;
          collectAddSubItems(collectRightOperator, node.right, collected, precision);
        } else {
          const reducedNode = reduce(node, precision);
          if (reducedNode.type !== "MathExpression" || isAddSubOperator(reducedNode.operator)) {
            collectAddSubItems(preOperator, reducedNode, collected, precision);
          } else {
            collected.push({ node: reducedNode, preOperator });
          }
        }
      } else if (node.type === "ParenthesizedExpression") {
        collectAddSubItems(preOperator, node.content, collected, precision);
      } else {
        collected.push({ node, preOperator });
      }
    }
    function reduceAddSubExpression(node, precision) {
      const collected = [];
      collectAddSubItems("+", node, collected, precision);
      const withoutZeroItem = collected.filter((item) => !(isValueType(item.node) && item.node.value === 0));
      const firstNonZeroItem = withoutZeroItem[0];
      if (!firstNonZeroItem || firstNonZeroItem.preOperator === "-" && !isValueType(firstNonZeroItem.node)) {
        const firstZeroItem = collected.find((item) => isValueType(item.node) && item.node.value === 0);
        if (firstZeroItem) {
          withoutZeroItem.unshift(firstZeroItem);
        }
      }
      if (withoutZeroItem[0].preOperator === "-" && isValueType(withoutZeroItem[0].node)) {
        withoutZeroItem[0].node.value *= -1;
        withoutZeroItem[0].preOperator = "+";
      }
      let root = withoutZeroItem[0].node;
      for (let i = 1; i < withoutZeroItem.length; i++) {
        root = {
          type: "MathExpression",
          operator: withoutZeroItem[i].preOperator,
          left: root,
          right: withoutZeroItem[i].node
        };
      }
      return root;
    }
    function reduceDivisionExpression(node) {
      if (!isValueType(node.right)) {
        return node;
      }
      if (node.right.type !== "Number") {
        throw new Error(`Cannot divide by "${node.right.unit}", number expected`);
      }
      return applyNumberDivision(node.left, node.right.value);
    }
    function applyNumberDivision(node, divisor) {
      if (divisor === 0) {
        throw new Error("Cannot divide by zero");
      }
      if (isValueType(node)) {
        node.value /= divisor;
        return node;
      }
      if (node.type === "MathExpression" && isAddSubOperator(node.operator)) {
        return {
          type: "MathExpression",
          operator: node.operator,
          left: applyNumberDivision(node.left, divisor),
          right: applyNumberDivision(node.right, divisor)
        };
      }
      return {
        type: "MathExpression",
        operator: "/",
        left: node,
        right: {
          type: "Number",
          value: divisor
        }
      };
    }
    function reduceMultiplicationExpression(node) {
      if (node.right.type === "Number") {
        return applyNumberMultiplication(node.left, node.right.value);
      }
      if (node.left.type === "Number") {
        return applyNumberMultiplication(node.right, node.left.value);
      }
      return node;
    }
    function applyNumberMultiplication(node, multiplier) {
      if (isValueType(node)) {
        node.value *= multiplier;
        return node;
      }
      if (node.type === "MathExpression" && isAddSubOperator(node.operator)) {
        return {
          type: "MathExpression",
          operator: node.operator,
          left: applyNumberMultiplication(node.left, multiplier),
          right: applyNumberMultiplication(node.right, multiplier)
        };
      }
      return {
        type: "MathExpression",
        operator: "*",
        left: node,
        right: {
          type: "Number",
          value: multiplier
        }
      };
    }
    function convertNodesUnits(left, right, precision) {
      switch (left.type) {
        case "LengthValue":
        case "AngleValue":
        case "TimeValue":
        case "FrequencyValue":
        case "ResolutionValue":
          if (right.type === left.type && right.unit && left.unit) {
            const converted = convertUnit(right.value, right.unit, left.unit, precision);
            right = {
              type: left.type,
              value: converted,
              unit: left.unit
            };
          }
          return { left, right };
        default:
          return { left, right };
      }
    }
    function includesNoCssProperties(node) {
      return node.content.type !== "Function" && (node.content.type !== "MathExpression" || node.content.right.type !== "Function" && node.content.left.type !== "Function");
    }
    function reduce(node, precision) {
      if (node.type === "MathExpression") {
        if (isAddSubOperator(node.operator)) {
          return reduceAddSubExpression(node, precision);
        }
        node.left = reduce(node.left, precision);
        node.right = reduce(node.right, precision);
        switch (node.operator) {
          case "/":
            return reduceDivisionExpression(node);
          case "*":
            return reduceMultiplicationExpression(node);
        }
        return node;
      }
      if (node.type === "ParenthesizedExpression") {
        if (includesNoCssProperties(node)) {
          return reduce(node.content, precision);
        }
      }
      return node;
    }
    module2.exports = reduce;
  }
});

// node_modules/postcss-calc/src/lib/stringifier.js
var require_stringifier3 = __commonJS({
  "node_modules/postcss-calc/src/lib/stringifier.js"(exports2, module2) {
    "use strict";
    var order = {
      "*": 0,
      "/": 0,
      "+": 1,
      "-": 1
    };
    function round(value, prec) {
      if (prec !== false) {
        const precision = Math.pow(10, prec);
        return Math.round(value * precision) / precision;
      }
      return value;
    }
    function stringify(node, prec) {
      switch (node.type) {
        case "MathExpression": {
          const { left, right, operator: op } = node;
          let str = "";
          if (left.type === "MathExpression" && order[op] < order[left.operator]) {
            str += `(${stringify(left, prec)})`;
          } else {
            str += stringify(left, prec);
          }
          str += order[op] ? ` ${node.operator} ` : node.operator;
          if (right.type === "MathExpression" && order[op] < order[right.operator]) {
            str += `(${stringify(right, prec)})`;
          } else {
            str += stringify(right, prec);
          }
          return str;
        }
        case "Number":
          return round(node.value, prec).toString();
        case "Function":
          return node.value.toString();
        case "ParenthesizedExpression":
          return `(${stringify(node.content, prec)})`;
        default:
          return round(node.value, prec) + node.unit;
      }
    }
    module2.exports = function(calc, node, originalValue, options, result, item) {
      let str = stringify(node, options.precision);
      const shouldPrintCalc = node.type === "MathExpression" || node.type === "Function";
      if (shouldPrintCalc) {
        str = `${calc}(${str})`;
        if (options.warnWhenCannotResolve) {
          result.warn("Could not reduce expression: " + originalValue, {
            plugin: "postcss-calc",
            node: item
          });
        }
      }
      return str;
    };
  }
});

// node_modules/postcss-calc/src/lib/transform.js
var require_transform = __commonJS({
  "node_modules/postcss-calc/src/lib/transform.js"(exports2, module2) {
    "use strict";
    var selectorParser = require_dist4();
    var valueParser = require_lib();
    var { parser } = require_parser5();
    var reducer = require_reducer();
    var stringifier = require_stringifier3();
    var MATCH_CALC = /((?:-(moz|webkit)-)?calc)/i;
    function transformValue(value, options, result, item) {
      return valueParser(value).walk((node) => {
        if (node.type !== "function" || !MATCH_CALC.test(node.value)) {
          return;
        }
        const contents = valueParser.stringify(node.nodes);
        const ast = parser.parse(contents);
        const reducedAst = reducer(ast, options.precision);
        node.type = "word";
        node.value = stringifier(node.value, reducedAst, value, options, result, item);
        return false;
      }).toString();
    }
    function transformSelector(value, options, result, item) {
      return selectorParser((selectors) => {
        selectors.walk((node) => {
          if (node.type === "attribute" && node.value) {
            node.setValue(transformValue(node.value, options, result, item));
          }
          if (node.type === "tag") {
            node.value = transformValue(node.value, options, result, item);
          }
          return;
        });
      }).processSync(value);
    }
    module2.exports = (node, property, options, result) => {
      let value = node[property];
      try {
        value = property === "selector" ? transformSelector(node[property], options, result, node) : transformValue(node[property], options, result, node);
      } catch (error) {
        if (error instanceof Error) {
          result.warn(error.message, { node });
        } else {
          result.warn("Error", { node });
        }
        return;
      }
      if (options.preserve && node[property] !== value) {
        const clone = node.clone();
        clone[property] = value;
        node.parent.insertBefore(node, clone);
      } else {
        node[property] = value;
      }
    };
  }
});

// node_modules/postcss-calc/src/index.js
var require_src9 = __commonJS({
  "node_modules/postcss-calc/src/index.js"(exports2, module2) {
    "use strict";
    var transform = require_transform();
    function pluginCreator(opts) {
      const options = Object.assign({
        precision: 5,
        preserve: false,
        warnWhenCannotResolve: false,
        mediaQueries: false,
        selectors: false
      }, opts);
      return {
        postcssPlugin: "postcss-calc",
        OnceExit(css, { result }) {
          css.walk((node) => {
            const { type } = node;
            if (type === "decl") {
              transform(node, "value", options, result);
            }
            if (type === "atrule" && options.mediaQueries) {
              transform(node, "params", options, result);
            }
            if (type === "rule" && options.selectors) {
              transform(node, "selector", options, result);
            }
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/colord/plugins/minify.js
var require_minify = __commonJS({
  "node_modules/colord/plugins/minify.js"(exports2, module2) {
    module2.exports = function(t) {
      var r = function(t2) {
        var r2, n2, e, i = t2.toHex(), a = t2.alpha(), h = i.split(""), s = h[1], o = h[2], u = h[3], l = h[4], p = h[5], f = h[6], g = h[7], v = h[8];
        if (a > 0 && a < 1 && (r2 = parseInt(g + v, 16) / 255, (n2 = 2) === void 0 && (n2 = 0), e === void 0 && (e = Math.pow(10, n2)), Math.round(e * r2) / e + 0 !== a))
          return null;
        if (s === o && u === l && p === f) {
          if (a === 1)
            return "#" + s + u + p;
          if (g === v)
            return "#" + s + u + p + g;
        }
        return i;
      }, n = function(t2) {
        return t2 > 0 && t2 < 1 ? t2.toString().replace("0.", ".") : t2;
      };
      t.prototype.minify = function(t2) {
        t2 === void 0 && (t2 = {});
        var e = this.toRgb(), i = n(e.r), a = n(e.g), h = n(e.b), s = this.toHsl(), o = n(s.h), u = n(s.s), l = n(s.l), p = n(this.alpha()), f = Object.assign({ hex: true, rgb: true, hsl: true }, t2), g = [];
        if (f.hex && (p === 1 || f.alphaHex)) {
          var v = r(this);
          v && g.push(v);
        }
        if (f.rgb && g.push(p === 1 ? "rgb(" + i + "," + a + "," + h + ")" : "rgba(" + i + "," + a + "," + h + "," + p + ")"), f.hsl && g.push(p === 1 ? "hsl(" + o + "," + u + "%," + l + "%)" : "hsla(" + o + "," + u + "%," + l + "%," + p + ")"), f.transparent && i === 0 && a === 0 && h === 0 && p === 0)
          g.push("transparent");
        else if (p === 1 && f.name && typeof this.toName == "function") {
          var c = this.toName();
          c && g.push(c);
        }
        return function(t3) {
          for (var r2 = t3[0], n2 = 1; n2 < t3.length; n2++)
            t3[n2].length < r2.length && (r2 = t3[n2]);
          return r2;
        }(g);
      };
    };
  }
});

// node_modules/postcss-colormin/src/minifyColor.js
var require_minifyColor = __commonJS({
  "node_modules/postcss-colormin/src/minifyColor.js"(exports2, module2) {
    "use strict";
    var { colord, extend } = require_colord();
    var namesPlugin = require_names();
    var minifierPlugin = require_minify();
    extend([namesPlugin, minifierPlugin]);
    module2.exports = function minifyColor(input, options = {}) {
      const instance = colord(input);
      if (instance.isValid()) {
        const minified = instance.minify(options);
        return minified.length < input.length ? minified : input.toLowerCase();
      } else {
        return input;
      }
    };
  }
});

// node_modules/postcss-colormin/src/index.js
var require_src10 = __commonJS({
  "node_modules/postcss-colormin/src/index.js"(exports2, module2) {
    "use strict";
    var browserslist = require_browserslist();
    var { isSupported } = require_dist3();
    var valueParser = require_lib();
    var minifyColor = require_minifyColor();
    function walk(parent, callback) {
      parent.nodes.forEach((node, index) => {
        const bubble = callback(node, index, parent);
        if (node.type === "function" && bubble !== false) {
          walk(node, callback);
        }
      });
    }
    var browsersWithTransparentBug = /* @__PURE__ */ new Set(["ie 8", "ie 9"]);
    var mathFunctions = /* @__PURE__ */ new Set(["calc", "min", "max", "clamp"]);
    function isMathFunctionNode(node) {
      if (node.type !== "function") {
        return false;
      }
      return mathFunctions.has(node.value.toLowerCase());
    }
    function transform(value, options) {
      const parsed = valueParser(value);
      walk(parsed, (node, index, parent) => {
        if (node.type === "function") {
          if (/^(rgb|hsl)a?$/i.test(node.value)) {
            const { value: originalValue } = node;
            node.value = minifyColor(valueParser.stringify(node), options);
            node.type = "word";
            const next = parent.nodes[index + 1];
            if (node.value !== originalValue && next && (next.type === "word" || next.type === "function")) {
              parent.nodes.splice(index + 1, 0, {
                type: "space",
                value: " "
              });
            }
          } else if (isMathFunctionNode(node)) {
            return false;
          }
        } else if (node.type === "word") {
          node.value = minifyColor(node.value, options);
        }
      });
      return parsed.toString();
    }
    function addPluginDefaults(options, browsers) {
      const defaults = {
        transparent: browsers.some((b) => browsersWithTransparentBug.has(b)) === false,
        alphaHex: isSupported("css-rrggbbaa", browsers),
        name: true
      };
      return { ...defaults, ...options };
    }
    function pluginCreator(config = {}) {
      return {
        postcssPlugin: "postcss-colormin",
        prepare(result) {
          const resultOptions = result.opts || {};
          const browsers = browserslist(null, {
            stats: resultOptions.stats,
            path: __dirname,
            env: resultOptions.env
          });
          const cache = /* @__PURE__ */ new Map();
          const options = addPluginDefaults(config, browsers);
          return {
            OnceExit(css) {
              css.walkDecls((decl) => {
                if (/^(composes|font|filter|-webkit-tap-highlight-color)/i.test(decl.prop)) {
                  return;
                }
                const value = decl.value;
                if (!value) {
                  return;
                }
                const cacheKey = JSON.stringify({ value, options, browsers });
                if (cache.has(cacheKey)) {
                  decl.value = cache.get(cacheKey);
                  return;
                }
                const newValue = transform(value, options);
                decl.value = newValue;
                cache.set(cacheKey, newValue);
              });
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-ordered-values/src/lib/joinGridValue.js
var require_joinGridValue = __commonJS({
  "node_modules/postcss-ordered-values/src/lib/joinGridValue.js"(exports2, module2) {
    "use strict";
    module2.exports = function joinGridVal(grid) {
      return grid.join(" / ").trim();
    };
  }
});

// node_modules/postcss-ordered-values/src/rules/grid.js
var require_grid = __commonJS({
  "node_modules/postcss-ordered-values/src/rules/grid.js"(exports2, module2) {
    "use strict";
    var joinGridValue = require_joinGridValue();
    var normalizeGridAutoFlow = (gridAutoFlow) => {
      let newValue = { front: "", back: "" };
      let shouldNormalize = false;
      gridAutoFlow.walk((node) => {
        if (node.value === "dense") {
          shouldNormalize = true;
          newValue.back = node.value;
        } else if (["row", "column"].includes(node.value.trim().toLowerCase())) {
          shouldNormalize = true;
          newValue.front = node.value;
        } else {
          shouldNormalize = false;
        }
      });
      if (shouldNormalize) {
        return `${newValue.front.trim()} ${newValue.back.trim()}`;
      }
      return gridAutoFlow;
    };
    var normalizeGridColumnRowGap = (gridGap) => {
      let newValue = { front: "", back: "" };
      let shouldNormalize = false;
      gridGap.walk((node) => {
        if (node.value === "normal") {
          shouldNormalize = true;
          newValue.front = node.value;
        } else {
          newValue.back = `${newValue.back} ${node.value}`;
        }
      });
      if (shouldNormalize) {
        return `${newValue.front.trim()} ${newValue.back.trim()}`;
      }
      return gridGap;
    };
    var normalizeGridColumnRow = (grid) => {
      let gridValue = grid.toString().split("/");
      if (gridValue.length > 1) {
        return joinGridValue(gridValue.map((gridLine) => {
          let normalizeValue = {
            front: "",
            back: ""
          };
          gridLine = gridLine.trim();
          gridLine.split(" ").forEach((node) => {
            if (node === "span") {
              normalizeValue.front = node;
            } else {
              normalizeValue.back = `${normalizeValue.back} ${node}`;
            }
          });
          return `${normalizeValue.front.trim()} ${normalizeValue.back.trim()}`;
        }));
      }
      return gridValue.map((gridLine) => {
        let normalizeValue = {
          front: "",
          back: ""
        };
        gridLine = gridLine.trim();
        gridLine.split(" ").forEach((node) => {
          if (node === "span") {
            normalizeValue.front = node;
          } else {
            normalizeValue.back = `${normalizeValue.back} ${node}`;
          }
        });
        return `${normalizeValue.front.trim()} ${normalizeValue.back.trim()}`;
      });
    };
    module2.exports = {
      normalizeGridAutoFlow,
      normalizeGridColumnRowGap,
      normalizeGridColumnRow
    };
  }
});

// node_modules/postcss-ordered-values/src/lib/addSpace.js
var require_addSpace = __commonJS({
  "node_modules/postcss-ordered-values/src/lib/addSpace.js"(exports2, module2) {
    "use strict";
    module2.exports = function addSpace() {
      return {
        type: "space",
        value: " "
      };
    };
  }
});

// node_modules/postcss-ordered-values/src/lib/getValue.js
var require_getValue = __commonJS({
  "node_modules/postcss-ordered-values/src/lib/getValue.js"(exports2, module2) {
    "use strict";
    var { stringify } = require_lib();
    module2.exports = function getValue(values) {
      return stringify(flatten(values));
    };
    function flatten(values) {
      const nodes = [];
      for (const [index, arg] of values.entries()) {
        arg.forEach((val, idx) => {
          if (idx === arg.length - 1 && index === values.length - 1 && val.type === "space") {
            return;
          }
          nodes.push(val);
        });
        if (index !== values.length - 1) {
          nodes[nodes.length - 1].type = "div";
          nodes[nodes.length - 1].value = ",";
        }
      }
      return nodes;
    }
  }
});

// node_modules/postcss-ordered-values/src/rules/animation.js
var require_animation2 = __commonJS({
  "node_modules/postcss-ordered-values/src/rules/animation.js"(exports2, module2) {
    "use strict";
    var { unit } = require_lib();
    var { getArguments } = require_src4();
    var addSpace = require_addSpace();
    var getValue = require_getValue();
    var functions = /* @__PURE__ */ new Set(["steps", "cubic-bezier", "frames"]);
    var keywords = /* @__PURE__ */ new Set([
      "ease",
      "ease-in",
      "ease-in-out",
      "ease-out",
      "linear",
      "step-end",
      "step-start"
    ]);
    var directions = /* @__PURE__ */ new Set([
      "normal",
      "reverse",
      "alternate",
      "alternate-reverse"
    ]);
    var fillModes = /* @__PURE__ */ new Set(["none", "forwards", "backwards", "both"]);
    var playStates = /* @__PURE__ */ new Set(["running", "paused"]);
    var timeUnits = /* @__PURE__ */ new Set(["ms", "s"]);
    var isTimingFunction = (value, type) => {
      return type === "function" && functions.has(value) || keywords.has(value);
    };
    var isDirection = (value) => {
      return directions.has(value);
    };
    var isFillMode = (value) => {
      return fillModes.has(value);
    };
    var isPlayState = (value) => {
      return playStates.has(value);
    };
    var isTime = (value) => {
      const quantity = unit(value);
      return quantity && timeUnits.has(quantity.unit);
    };
    var isIterationCount = (value) => {
      const quantity = unit(value);
      return value === "infinite" || quantity && !quantity.unit;
    };
    var stateConditions = [
      { property: "duration", delegate: isTime },
      { property: "timingFunction", delegate: isTimingFunction },
      { property: "delay", delegate: isTime },
      { property: "iterationCount", delegate: isIterationCount },
      { property: "direction", delegate: isDirection },
      { property: "fillMode", delegate: isFillMode },
      { property: "playState", delegate: isPlayState }
    ];
    function normalize(args) {
      const list = [];
      for (const arg of args) {
        const state = {
          name: [],
          duration: [],
          timingFunction: [],
          delay: [],
          iterationCount: [],
          direction: [],
          fillMode: [],
          playState: []
        };
        arg.forEach((node) => {
          let { type, value } = node;
          if (type === "space") {
            return;
          }
          value = value.toLowerCase();
          const hasMatch = stateConditions.some(({ property, delegate }) => {
            if (delegate(value, type) && !state[property].length) {
              state[property] = [node, addSpace()];
              return true;
            }
          });
          if (!hasMatch) {
            state.name = [...state.name, node, addSpace()];
          }
        });
        list.push([
          ...state.name,
          ...state.duration,
          ...state.timingFunction,
          ...state.delay,
          ...state.iterationCount,
          ...state.direction,
          ...state.fillMode,
          ...state.playState
        ]);
      }
      return list;
    }
    module2.exports = function normalizeAnimation(parsed) {
      const values = normalize(getArguments(parsed));
      return getValue(values);
    };
  }
});

// node_modules/postcss-ordered-values/src/lib/mathfunctions.js
var require_mathfunctions = __commonJS({
  "node_modules/postcss-ordered-values/src/lib/mathfunctions.js"(exports2, module2) {
    "use strict";
    module2.exports = /* @__PURE__ */ new Set(["calc", "clamp", "max", "min"]);
  }
});

// node_modules/postcss-ordered-values/src/rules/border.js
var require_border2 = __commonJS({
  "node_modules/postcss-ordered-values/src/rules/border.js"(exports2, module2) {
    "use strict";
    var { unit, stringify } = require_lib();
    var mathFunctions = require_mathfunctions();
    var borderWidths = /* @__PURE__ */ new Set(["thin", "medium", "thick"]);
    var borderStyles = /* @__PURE__ */ new Set([
      "none",
      "auto",
      "hidden",
      "dotted",
      "dashed",
      "solid",
      "double",
      "groove",
      "ridge",
      "inset",
      "outset"
    ]);
    module2.exports = function normalizeBorder(border) {
      const order = { width: "", style: "", color: "" };
      border.walk((node) => {
        const { type, value } = node;
        if (type === "word") {
          if (borderStyles.has(value.toLowerCase())) {
            order.style = value;
            return false;
          }
          if (borderWidths.has(value.toLowerCase()) || unit(value.toLowerCase())) {
            if (order.width !== "") {
              order.width = `${order.width} ${value}`;
              return false;
            }
            order.width = value;
            return false;
          }
          order.color = value;
          return false;
        }
        if (type === "function") {
          if (mathFunctions.has(value.toLowerCase())) {
            order.width = stringify(node);
          } else {
            order.color = stringify(node);
          }
          return false;
        }
      });
      return `${order.width} ${order.style} ${order.color}`.trim();
    };
  }
});

// node_modules/postcss-ordered-values/src/lib/vendorUnprefixed.js
var require_vendorUnprefixed = __commonJS({
  "node_modules/postcss-ordered-values/src/lib/vendorUnprefixed.js"(exports2, module2) {
    "use strict";
    function vendorUnprefixed(prop) {
      return prop.replace(/^-\w+-/, "");
    }
    module2.exports = vendorUnprefixed;
  }
});

// node_modules/postcss-ordered-values/src/rules/boxShadow.js
var require_boxShadow = __commonJS({
  "node_modules/postcss-ordered-values/src/rules/boxShadow.js"(exports2, module2) {
    "use strict";
    var { unit } = require_lib();
    var { getArguments } = require_src4();
    var addSpace = require_addSpace();
    var getValue = require_getValue();
    var mathFunctions = require_mathfunctions();
    var vendorUnprefixed = require_vendorUnprefixed();
    module2.exports = function normalizeBoxShadow(parsed) {
      let args = getArguments(parsed);
      const normalized = normalize(args);
      if (normalized === false) {
        return parsed.toString();
      }
      return getValue(normalized);
    };
    function normalize(args) {
      const list = [];
      let abort = false;
      for (const arg of args) {
        let val = [];
        let state = {
          inset: [],
          color: []
        };
        arg.forEach((node) => {
          const { type, value } = node;
          if (type === "function" && mathFunctions.has(vendorUnprefixed(value.toLowerCase()))) {
            abort = true;
            return;
          }
          if (type === "space") {
            return;
          }
          if (unit(value)) {
            val = [...val, node, addSpace()];
          } else if (value.toLowerCase() === "inset") {
            state.inset = [...state.inset, node, addSpace()];
          } else {
            state.color = [...state.color, node, addSpace()];
          }
        });
        if (abort) {
          return false;
        }
        list.push([...state.inset, ...val, ...state.color]);
      }
      return list;
    }
  }
});

// node_modules/postcss-ordered-values/src/rules/flexFlow.js
var require_flexFlow = __commonJS({
  "node_modules/postcss-ordered-values/src/rules/flexFlow.js"(exports2, module2) {
    "use strict";
    var flexDirection = /* @__PURE__ */ new Set([
      "row",
      "row-reverse",
      "column",
      "column-reverse"
    ]);
    var flexWrap = /* @__PURE__ */ new Set(["nowrap", "wrap", "wrap-reverse"]);
    module2.exports = function normalizeFlexFlow(flexFlow) {
      let order = {
        direction: "",
        wrap: ""
      };
      flexFlow.walk(({ value }) => {
        if (flexDirection.has(value.toLowerCase())) {
          order.direction = value;
          return;
        }
        if (flexWrap.has(value.toLowerCase())) {
          order.wrap = value;
          return;
        }
      });
      return `${order.direction} ${order.wrap}`.trim();
    };
  }
});

// node_modules/postcss-ordered-values/src/rules/transition.js
var require_transition2 = __commonJS({
  "node_modules/postcss-ordered-values/src/rules/transition.js"(exports2, module2) {
    "use strict";
    var { unit } = require_lib();
    var { getArguments } = require_src4();
    var addSpace = require_addSpace();
    var getValue = require_getValue();
    var timingFunctions = /* @__PURE__ */ new Set([
      "ease",
      "linear",
      "ease-in",
      "ease-out",
      "ease-in-out",
      "step-start",
      "step-end"
    ]);
    function normalize(args) {
      const list = [];
      for (const arg of args) {
        let state = {
          timingFunction: [],
          property: [],
          time1: [],
          time2: []
        };
        arg.forEach((node) => {
          const { type, value } = node;
          if (type === "space") {
            return;
          }
          if (type === "function" && (/* @__PURE__ */ new Set(["steps", "cubic-bezier"])).has(value.toLowerCase())) {
            state.timingFunction = [...state.timingFunction, node, addSpace()];
          } else if (unit(value)) {
            if (!state.time1.length) {
              state.time1 = [...state.time1, node, addSpace()];
            } else {
              state.time2 = [...state.time2, node, addSpace()];
            }
          } else if (timingFunctions.has(value.toLowerCase())) {
            state.timingFunction = [...state.timingFunction, node, addSpace()];
          } else {
            state.property = [...state.property, node, addSpace()];
          }
        });
        list.push([
          ...state.property,
          ...state.time1,
          ...state.timingFunction,
          ...state.time2
        ]);
      }
      return list;
    }
    module2.exports = function normalizeTransition(parsed) {
      const values = normalize(getArguments(parsed));
      return getValue(values);
    };
  }
});

// node_modules/postcss-ordered-values/src/rules/listStyleTypes.json
var require_listStyleTypes = __commonJS({
  "node_modules/postcss-ordered-values/src/rules/listStyleTypes.json"(exports2, module2) {
    module2.exports = {
      "list-style-type": [
        "afar",
        "amharic",
        "amharic-abegede",
        "arabic-indic",
        "armenian",
        "asterisks",
        "bengali",
        "binary",
        "cambodian",
        "circle",
        "cjk-decimal",
        "cjk-earthly-branch",
        "cjk-heavenly-stem",
        "cjk-ideographic",
        "decimal",
        "decimal-leading-zero",
        "devanagari",
        "disc",
        "disclosure-closed",
        "disclosure-open",
        "ethiopic",
        "ethiopic-abegede",
        "ethiopic-abegede-am-et",
        "ethiopic-abegede-gez",
        "ethiopic-abegede-ti-er",
        "ethiopic-abegede-ti-et",
        "ethiopic-halehame",
        "ethiopic-halehame-aa-er",
        "ethiopic-halehame-aa-et",
        "ethiopic-halehame-am",
        "ethiopic-halehame-am-et",
        "ethiopic-halehame-gez",
        "ethiopic-halehame-om-et",
        "ethiopic-halehame-sid-et",
        "ethiopic-halehame-so-et",
        "ethiopic-halehame-ti-er",
        "ethiopic-halehame-ti-et",
        "ethiopic-halehame-tig",
        "ethiopic-numeric",
        "footnotes",
        "georgian",
        "gujarati",
        "gurmukhi",
        "hangul",
        "hangul-consonant",
        "hebrew",
        "hiragana",
        "hiragana-iroha",
        "japanese-formal",
        "japanese-informal",
        "kannada",
        "katakana",
        "katakana-iroha",
        "khmer",
        "korean-hangul-formal",
        "korean-hanja-formal",
        "korean-hanja-informal",
        "lao",
        "lower-alpha",
        "lower-armenian",
        "lower-greek",
        "lower-hexadecimal",
        "lower-latin",
        "lower-norwegian",
        "lower-roman",
        "malayalam",
        "mongolian",
        "myanmar",
        "octal",
        "oriya",
        "oromo",
        "persian",
        "sidama",
        "simp-chinese-formal",
        "simp-chinese-informal",
        "somali",
        "square",
        "string",
        "symbols",
        "tamil",
        "telugu",
        "thai",
        "tibetan",
        "tigre",
        "tigrinya-er",
        "tigrinya-er-abegede",
        "tigrinya-et",
        "tigrinya-et-abegede",
        "trad-chinese-formal",
        "trad-chinese-informal",
        "upper-alpha",
        "upper-armenian",
        "upper-greek",
        "upper-hexadecimal",
        "upper-latin",
        "upper-norwegian",
        "upper-roman",
        "urdu"
      ]
    };
  }
});

// node_modules/postcss-ordered-values/src/rules/listStyle.js
var require_listStyle = __commonJS({
  "node_modules/postcss-ordered-values/src/rules/listStyle.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var listStyleTypes = require_listStyleTypes();
    var definedTypes = new Set(listStyleTypes["list-style-type"]);
    var definedPosition = /* @__PURE__ */ new Set(["inside", "outside"]);
    module2.exports = function listStyleNormalizer(listStyle) {
      const order = { type: "", position: "", image: "" };
      listStyle.walk((decl) => {
        if (decl.type === "word") {
          if (definedTypes.has(decl.value)) {
            order.type = `${order.type} ${decl.value}`;
          } else if (definedPosition.has(decl.value)) {
            order.position = `${order.position} ${decl.value}`;
          } else if (decl.value === "none") {
            if (order.type.split(" ").filter((e) => e !== "" && e !== " ").includes("none")) {
              order.image = `${order.image} ${decl.value}`;
            } else {
              order.type = `${order.type} ${decl.value}`;
            }
          } else {
            order.type = `${order.type} ${decl.value}`;
          }
        }
        if (decl.type === "function") {
          order.image = `${order.image} ${valueParser.stringify(decl)}`;
        }
      });
      return `${order.type.trim()} ${order.position.trim()} ${order.image.trim()}`.trim();
    };
  }
});

// node_modules/postcss-ordered-values/src/rules/columns.js
var require_columns = __commonJS({
  "node_modules/postcss-ordered-values/src/rules/columns.js"(exports2, module2) {
    "use strict";
    var { unit } = require_lib();
    function hasUnit(value) {
      const parsedVal = unit(value);
      return parsedVal && parsedVal.unit !== "";
    }
    module2.exports = (columns) => {
      const widths = [];
      const other = [];
      columns.walk((node) => {
        const { type, value } = node;
        if (type === "word") {
          if (hasUnit(value)) {
            widths.push(value);
          } else {
            other.push(value);
          }
        }
      });
      if (other.length === 1 && widths.length === 1) {
        return `${widths[0].trimStart()} ${other[0].trimStart()}`;
      }
      return columns;
    };
  }
});

// node_modules/postcss-ordered-values/src/index.js
var require_src11 = __commonJS({
  "node_modules/postcss-ordered-values/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var {
      normalizeGridAutoFlow,
      normalizeGridColumnRowGap,
      normalizeGridColumnRow
    } = require_grid();
    var animation = require_animation2();
    var border = require_border2();
    var boxShadow = require_boxShadow();
    var flexFlow = require_flexFlow();
    var transition = require_transition2();
    var listStyle = require_listStyle();
    var column = require_columns();
    var vendorUnprefixed = require_vendorUnprefixed();
    var borderRules = [
      ["border", border],
      ["border-block", border],
      ["border-inline", border],
      ["border-block-end", border],
      ["border-block-start", border],
      ["border-inline-end", border],
      ["border-inline-start", border],
      ["border-top", border],
      ["border-right", border],
      ["border-bottom", border],
      ["border-left", border]
    ];
    var grid = [
      ["grid-auto-flow", normalizeGridAutoFlow],
      ["grid-column-gap", normalizeGridColumnRowGap],
      ["grid-row-gap", normalizeGridColumnRowGap],
      ["grid-column", normalizeGridColumnRow],
      ["grid-row", normalizeGridColumnRow],
      ["grid-row-start", normalizeGridColumnRow],
      ["grid-row-end", normalizeGridColumnRow],
      ["grid-column-start", normalizeGridColumnRow],
      ["grid-column-end", normalizeGridColumnRow]
    ];
    var columnRules = [
      ["column-rule", border],
      ["columns", column]
    ];
    var rules = new Map([
      ["animation", animation],
      ["outline", border],
      ["box-shadow", boxShadow],
      ["flex-flow", flexFlow],
      ["list-style", listStyle],
      ["transition", transition],
      ...borderRules,
      ...grid,
      ...columnRules
    ]);
    function isVariableFunctionNode(node) {
      if (node.type !== "function") {
        return false;
      }
      return ["var", "env", "constant"].includes(node.value.toLowerCase());
    }
    function shouldAbort(parsed) {
      let abort = false;
      parsed.walk((node) => {
        if (node.type === "comment" || isVariableFunctionNode(node) || node.type === "word" && node.value.includes(`___CSS_LOADER_IMPORT___`)) {
          abort = true;
          return false;
        }
      });
      return abort;
    }
    function getValue(decl) {
      let { value, raws } = decl;
      if (raws && raws.value && raws.value.raw) {
        value = raws.value.raw;
      }
      return value;
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-ordered-values",
        prepare() {
          const cache = /* @__PURE__ */ new Map();
          return {
            OnceExit(css) {
              css.walkDecls((decl) => {
                const lowerCasedProp = decl.prop.toLowerCase();
                const normalizedProp = vendorUnprefixed(lowerCasedProp);
                const processor = rules.get(normalizedProp);
                if (!processor) {
                  return;
                }
                const value = getValue(decl);
                if (cache.has(value)) {
                  decl.value = cache.get(value);
                  return;
                }
                const parsed = valueParser(value);
                if (parsed.nodes.length < 2 || shouldAbort(parsed)) {
                  cache.set(value, value);
                  return;
                }
                const result = processor(parsed);
                decl.value = result.toString();
                cache.set(value, result.toString());
              });
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-minify-selectors/src/lib/canUnquote.js
var require_canUnquote = __commonJS({
  "node_modules/postcss-minify-selectors/src/lib/canUnquote.js"(exports2, module2) {
    "use strict";
    var escapes = /\\([0-9A-Fa-f]{1,6})[ \t\n\f\r]?/g;
    var range = /[\u0000-\u002c\u002e\u002f\u003A-\u0040\u005B-\u005E\u0060\u007B-\u009f]/;
    module2.exports = function canUnquote(value) {
      if (value === "-" || value === "") {
        return false;
      }
      value = value.replace(escapes, "a").replace(/\\./g, "a");
      return !(range.test(value) || /^(?:-?\d|--)/.test(value));
    };
  }
});

// node_modules/postcss-minify-selectors/src/index.js
var require_src12 = __commonJS({
  "node_modules/postcss-minify-selectors/src/index.js"(exports2, module2) {
    "use strict";
    var parser = require_dist4();
    var canUnquote = require_canUnquote();
    var pseudoElements = /* @__PURE__ */ new Set([
      "::before",
      "::after",
      "::first-letter",
      "::first-line"
    ]);
    function attribute(selector) {
      if (selector.value) {
        if (selector.raws.value) {
          selector.raws.value = selector.raws.value.replace(/\\\n/g, "").trim();
        }
        if (canUnquote(selector.value)) {
          selector.quoteMark = null;
        }
        if (selector.operator) {
          selector.operator = selector.operator.trim();
        }
      }
      selector.rawSpaceBefore = "";
      selector.rawSpaceAfter = "";
      selector.spaces.attribute = { before: "", after: "" };
      selector.spaces.operator = { before: "", after: "" };
      selector.spaces.value = {
        before: "",
        after: selector.insensitive ? " " : ""
      };
      if (selector.raws.spaces) {
        selector.raws.spaces.attribute = {
          before: "",
          after: ""
        };
        selector.raws.spaces.operator = {
          before: "",
          after: ""
        };
        selector.raws.spaces.value = {
          before: "",
          after: selector.insensitive ? " " : ""
        };
        if (selector.insensitive) {
          selector.raws.spaces.insensitive = {
            before: "",
            after: ""
          };
        }
      }
      selector.attribute = selector.attribute.trim();
    }
    function combinator(selector) {
      const value = selector.value.trim();
      selector.spaces.before = "";
      selector.spaces.after = "";
      selector.rawSpaceBefore = "";
      selector.rawSpaceAfter = "";
      selector.value = value.length ? value : " ";
    }
    var pseudoReplacements = /* @__PURE__ */ new Map([
      [":nth-child", ":first-child"],
      [":nth-of-type", ":first-of-type"],
      [":nth-last-child", ":last-child"],
      [":nth-last-of-type", ":last-of-type"]
    ]);
    function pseudo(selector) {
      const value = selector.value.toLowerCase();
      if (selector.nodes.length === 1 && pseudoReplacements.has(value)) {
        const first = selector.at(0);
        const one = first.at(0);
        if (first.length === 1) {
          if (one.value === "1") {
            selector.replaceWith(parser.pseudo({
              value: pseudoReplacements.get(value)
            }));
          }
          if (one.value && one.value.toLowerCase() === "even") {
            one.value = "2n";
          }
        }
        if (first.length === 3) {
          const two = first.at(1);
          const three = first.at(2);
          if (one.value && one.value.toLowerCase() === "2n" && two.value === "+" && three.value === "1") {
            one.value = "odd";
            two.remove();
            three.remove();
          }
        }
        return;
      }
      selector.walk((child) => {
        if (child.type === "selector" && child.parent) {
          const uniques = /* @__PURE__ */ new Set();
          child.parent.each((sibling) => {
            const siblingStr = String(sibling);
            if (!uniques.has(siblingStr)) {
              uniques.add(siblingStr);
            } else {
              sibling.remove();
            }
          });
        }
      });
      if (pseudoElements.has(value)) {
        selector.value = selector.value.slice(1);
      }
    }
    var tagReplacements = /* @__PURE__ */ new Map([
      ["from", "0%"],
      ["100%", "to"]
    ]);
    function tag(selector) {
      const value = selector.value.toLowerCase();
      if (tagReplacements.has(value)) {
        selector.value = tagReplacements.get(value);
      }
    }
    function universal(selector) {
      const next = selector.next();
      if (next && next.type !== "combinator") {
        selector.remove();
      }
    }
    var reducers = /* @__PURE__ */ new Map([
      ["attribute", attribute],
      ["combinator", combinator],
      ["pseudo", pseudo],
      ["tag", tag],
      ["universal", universal]
    ]);
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-minify-selectors",
        OnceExit(css) {
          const cache = /* @__PURE__ */ new Map();
          const processor = parser((selectors) => {
            const uniqueSelectors = /* @__PURE__ */ new Set();
            selectors.walk((sel) => {
              sel.spaces.before = sel.spaces.after = "";
              const reducer = reducers.get(sel.type);
              if (reducer !== void 0) {
                reducer(sel);
                return;
              }
              const toString = String(sel);
              if (sel.type === "selector" && sel.parent && sel.parent.type !== "pseudo") {
                if (!uniqueSelectors.has(toString)) {
                  uniqueSelectors.add(toString);
                } else {
                  sel.remove();
                }
              }
            });
            selectors.nodes.sort();
          });
          css.walkRules((rule) => {
            const selector = rule.raws.selector && rule.raws.selector.value === rule.selector ? rule.raws.selector.raw : rule.selector;
            if (selector[selector.length - 1] === ":") {
              return;
            }
            if (cache.has(selector)) {
              rule.selector = cache.get(selector);
              return;
            }
            const optimizedSelector = processor.processSync(selector);
            rule.selector = optimizedSelector;
            cache.set(selector, optimizedSelector);
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-minify-params/src/index.js
var require_src13 = __commonJS({
  "node_modules/postcss-minify-params/src/index.js"(exports2, module2) {
    "use strict";
    var browserslist = require_browserslist();
    var valueParser = require_lib();
    var { getArguments } = require_src4();
    function gcd(a, b) {
      return b ? gcd(b, a % b) : a;
    }
    function aspectRatio(a, b) {
      const divisor = gcd(a, b);
      return [a / divisor, b / divisor];
    }
    function split(args) {
      return args.map((arg) => valueParser.stringify(arg)).join("");
    }
    function removeNode(node) {
      node.value = "";
      node.type = "word";
    }
    function sortAndDedupe(items) {
      const a = [...new Set(items)];
      a.sort();
      return a.join();
    }
    function transform(legacy, rule) {
      const ruleName = rule.name.toLowerCase();
      if (!rule.params || !["media", "supports"].includes(ruleName)) {
        return;
      }
      const params = valueParser(rule.params);
      params.walk((node, index) => {
        if (node.type === "div") {
          node.before = node.after = "";
        } else if (node.type === "function") {
          node.before = "";
          if (node.nodes[0] && node.nodes[0].type === "word" && node.nodes[0].value.startsWith("--") && node.nodes[2] === void 0) {
            node.after = " ";
          } else {
            node.after = "";
          }
          if (node.nodes[4] && node.nodes[0].value.toLowerCase().indexOf("-aspect-ratio") === 3) {
            const [a, b] = aspectRatio(Number(node.nodes[2].value), Number(node.nodes[4].value));
            node.nodes[2].value = a.toString();
            node.nodes[4].value = b.toString();
          }
        } else if (node.type === "space") {
          node.value = " ";
        } else {
          const prevWord = params.nodes[index - 2];
          if (node.value.toLowerCase() === "all" && rule.name.toLowerCase() === "media" && !prevWord) {
            const nextWord = params.nodes[index + 2];
            if (!legacy || nextWord) {
              removeNode(node);
            }
            if (nextWord && nextWord.value.toLowerCase() === "and") {
              const nextSpace = params.nodes[index + 1];
              const secondSpace = params.nodes[index + 3];
              removeNode(nextWord);
              removeNode(nextSpace);
              removeNode(secondSpace);
            }
          }
        }
      }, true);
      rule.params = sortAndDedupe(getArguments(params).map(split));
      if (!rule.params.length) {
        rule.raws.afterName = "";
      }
    }
    var allBugBrowers = /* @__PURE__ */ new Set(["ie 10", "ie 11"]);
    function pluginCreator(options = {}) {
      const browsers = browserslist(null, {
        stats: options.stats,
        path: __dirname,
        env: options.env
      });
      const hasAllBug = browsers.some((browser) => allBugBrowers.has(browser));
      return {
        postcssPlugin: "postcss-minify-params",
        OnceExit(css) {
          css.walkAtRules((rule) => transform(hasAllBug, rule));
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-normalize-charset/src/index.js
var require_src14 = __commonJS({
  "node_modules/postcss-normalize-charset/src/index.js"(exports2, module2) {
    "use strict";
    var charset = "charset";
    var nonAscii = /[^\x00-\x7F]/;
    function pluginCreator(opts = {}) {
      return {
        postcssPlugin: "postcss-normalize-" + charset,
        OnceExit(css, { AtRule }) {
          let charsetRule;
          let nonAsciiNode;
          css.walk((node) => {
            if (node.type === "atrule" && node.name === charset) {
              if (!charsetRule) {
                charsetRule = node;
              }
              node.remove();
            } else if (!nonAsciiNode && node.parent === css && nonAscii.test(node.toString())) {
              nonAsciiNode = node;
            }
          });
          if (nonAsciiNode) {
            if (!charsetRule && opts.add !== false) {
              charsetRule = new AtRule({
                name: charset,
                params: '"utf-8"'
              });
            }
            if (charsetRule) {
              charsetRule.source = nonAsciiNode.source;
              css.prepend(charsetRule);
            }
          }
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-minify-font-values/src/lib/minify-weight.js
var require_minify_weight = __commonJS({
  "node_modules/postcss-minify-font-values/src/lib/minify-weight.js"(exports2, module2) {
    "use strict";
    module2.exports = function(value) {
      const lowerCasedValue = value.toLowerCase();
      return lowerCasedValue === "normal" ? "400" : lowerCasedValue === "bold" ? "700" : value;
    };
  }
});

// node_modules/postcss-minify-font-values/src/lib/minify-family.js
var require_minify_family = __commonJS({
  "node_modules/postcss-minify-font-values/src/lib/minify-family.js"(exports2, module2) {
    "use strict";
    var { stringify } = require_lib();
    function uniqueFontFamilies(list) {
      return list.filter((item, i) => {
        if (item.toLowerCase() === "monospace") {
          return true;
        }
        return i === list.indexOf(item);
      });
    }
    var globalKeywords = ["inherit", "initial", "unset"];
    var genericFontFamilykeywords = /* @__PURE__ */ new Set([
      "sans-serif",
      "serif",
      "fantasy",
      "cursive",
      "monospace",
      "system-ui"
    ]);
    function makeArray(value, length) {
      let array = [];
      while (length--) {
        array[length] = value;
      }
      return array;
    }
    var regexSimpleEscapeCharacters = /[ !"#$%&'()*+,.\/;<=>?@\[\\\]^`{|}~]/;
    function escape(string, escapeForString) {
      let counter = 0;
      let character;
      let charCode;
      let value;
      let output = "";
      while (counter < string.length) {
        character = string.charAt(counter++);
        charCode = character.charCodeAt(0);
        if (!escapeForString && /[\t\n\v\f:]/.test(character)) {
          value = "\\" + charCode.toString(16) + " ";
        } else if (!escapeForString && regexSimpleEscapeCharacters.test(character)) {
          value = "\\" + character;
        } else {
          value = character;
        }
        output += value;
      }
      if (!escapeForString) {
        if (/^-[-\d]/.test(output)) {
          output = "\\-" + output.slice(1);
        }
        const firstChar = string.charAt(0);
        if (/\d/.test(firstChar)) {
          output = "\\3" + firstChar + " " + output.slice(1);
        }
      }
      return output;
    }
    var regexKeyword = new RegExp([...genericFontFamilykeywords].concat(globalKeywords).join("|"), "i");
    var regexInvalidIdentifier = /^(-?\d|--)/;
    var regexSpaceAtStart = /^\x20/;
    var regexWhitespace = /[\t\n\f\r\x20]/g;
    var regexIdentifierCharacter = /^[a-zA-Z\d\xa0-\uffff_-]+$/;
    var regexConsecutiveSpaces = /(\\(?:[a-fA-F0-9]{1,6}\x20|\x20))?(\x20{2,})/g;
    var regexTrailingEscape = /\\[a-fA-F0-9]{0,6}\x20$/;
    var regexTrailingSpace = /\x20$/;
    function escapeIdentifierSequence(string) {
      let identifiers = string.split(regexWhitespace);
      let index = 0;
      let result = [];
      let escapeResult;
      while (index < identifiers.length) {
        let subString = identifiers[index++];
        if (subString === "") {
          result.push(subString);
          continue;
        }
        escapeResult = escape(subString, false);
        if (regexIdentifierCharacter.test(subString)) {
          if (regexInvalidIdentifier.test(subString)) {
            if (index === 1) {
              result.push(escapeResult);
            } else {
              result[index - 2] += "\\";
              result.push(escape(subString, true));
            }
          } else {
            result.push(escapeResult);
          }
        } else {
          result.push(escapeResult);
        }
      }
      result = result.join(" ").replace(regexConsecutiveSpaces, ($0, $1, $2) => {
        const spaceCount = $2.length;
        const escapesNeeded = Math.floor(spaceCount / 2);
        const array = makeArray("\\ ", escapesNeeded);
        if (spaceCount % 2) {
          array[escapesNeeded - 1] += "\\ ";
        }
        return ($1 || "") + " " + array.join(" ");
      });
      if (regexTrailingSpace.test(result) && !regexTrailingEscape.test(result)) {
        result = result.replace(regexTrailingSpace, "\\ ");
      }
      if (regexSpaceAtStart.test(result)) {
        result = "\\ " + result.slice(1);
      }
      return result;
    }
    module2.exports = function(nodes, opts) {
      const family = [];
      let last = null;
      let i, max;
      nodes.forEach((node, index, arr) => {
        if (node.type === "string" || node.type === "function") {
          family.push(node);
        } else if (node.type === "word") {
          if (!last) {
            last = {
              type: "word",
              value: ""
            };
            family.push(last);
          }
          last.value += node.value;
        } else if (node.type === "space") {
          if (last && index !== arr.length - 1) {
            last.value += " ";
          }
        } else {
          last = null;
        }
      });
      let normalizedFamilies = family.map((node) => {
        if (node.type === "string") {
          const isKeyword = regexKeyword.test(node.value);
          if (!opts.removeQuotes || isKeyword || /[0-9]/.test(node.value.slice(0, 1))) {
            return stringify(node);
          }
          let escaped = escapeIdentifierSequence(node.value);
          if (escaped.length < node.value.length + 2) {
            return escaped;
          }
        }
        return stringify(node);
      });
      if (opts.removeAfterKeyword) {
        for (i = 0, max = normalizedFamilies.length; i < max; i += 1) {
          if (genericFontFamilykeywords.has(normalizedFamilies[i].toLowerCase())) {
            normalizedFamilies = normalizedFamilies.slice(0, i + 1);
            break;
          }
        }
      }
      if (opts.removeDuplicates) {
        normalizedFamilies = uniqueFontFamilies(normalizedFamilies);
      }
      return [
        {
          type: "word",
          value: normalizedFamilies.join()
        }
      ];
    };
  }
});

// node_modules/postcss-minify-font-values/src/lib/keywords.js
var require_keywords = __commonJS({
  "node_modules/postcss-minify-font-values/src/lib/keywords.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      style: /* @__PURE__ */ new Set(["italic", "oblique"]),
      variant: /* @__PURE__ */ new Set(["small-caps"]),
      weight: /* @__PURE__ */ new Set([
        "100",
        "200",
        "300",
        "400",
        "500",
        "600",
        "700",
        "800",
        "900",
        "bold",
        "lighter",
        "bolder"
      ]),
      stretch: /* @__PURE__ */ new Set([
        "ultra-condensed",
        "extra-condensed",
        "condensed",
        "semi-condensed",
        "semi-expanded",
        "expanded",
        "extra-expanded",
        "ultra-expanded"
      ]),
      size: /* @__PURE__ */ new Set([
        "xx-small",
        "x-small",
        "small",
        "medium",
        "large",
        "x-large",
        "xx-large",
        "larger",
        "smaller"
      ])
    };
  }
});

// node_modules/postcss-minify-font-values/src/lib/minify-font.js
var require_minify_font = __commonJS({
  "node_modules/postcss-minify-font-values/src/lib/minify-font.js"(exports2, module2) {
    "use strict";
    var { unit } = require_lib();
    var keywords = require_keywords();
    var minifyFamily = require_minify_family();
    var minifyWeight = require_minify_weight();
    module2.exports = function(nodes, opts) {
      let i, max, node, family;
      let familyStart = NaN;
      let hasSize = false;
      for (i = 0, max = nodes.length; i < max; i += 1) {
        node = nodes[i];
        if (node.type === "word") {
          if (hasSize) {
            continue;
          }
          const value = node.value.toLowerCase();
          if (value === "normal" || value === "inherit" || value === "initial" || value === "unset") {
            familyStart = i;
          } else if (keywords.style.has(value) || unit(value)) {
            familyStart = i;
          } else if (keywords.variant.has(value)) {
            familyStart = i;
          } else if (keywords.weight.has(value)) {
            node.value = minifyWeight(value);
            familyStart = i;
          } else if (keywords.stretch.has(value)) {
            familyStart = i;
          } else if (keywords.size.has(value) || unit(value)) {
            familyStart = i;
            hasSize = true;
          }
        } else if (node.type === "function" && nodes[i + 1] && nodes[i + 1].type === "space") {
          familyStart = i;
        } else if (node.type === "div" && node.value === "/") {
          familyStart = i + 1;
          break;
        }
      }
      familyStart += 2;
      family = minifyFamily(nodes.slice(familyStart), opts);
      return nodes.slice(0, familyStart).concat(family);
    };
  }
});

// node_modules/postcss-minify-font-values/src/index.js
var require_src15 = __commonJS({
  "node_modules/postcss-minify-font-values/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var minifyWeight = require_minify_weight();
    var minifyFamily = require_minify_family();
    var minifyFont = require_minify_font();
    function hasVariableFunction(value) {
      const lowerCasedValue = value.toLowerCase();
      return lowerCasedValue.includes("var(") || lowerCasedValue.includes("env(");
    }
    function transform(prop, value, opts) {
      let lowerCasedProp = prop.toLowerCase();
      if (lowerCasedProp === "font-weight" && !hasVariableFunction(value)) {
        return minifyWeight(value);
      } else if (lowerCasedProp === "font-family" && !hasVariableFunction(value)) {
        const tree = valueParser(value);
        tree.nodes = minifyFamily(tree.nodes, opts);
        return tree.toString();
      } else if (lowerCasedProp === "font") {
        const tree = valueParser(value);
        tree.nodes = minifyFont(tree.nodes, opts);
        return tree.toString();
      }
      return value;
    }
    function pluginCreator(opts) {
      opts = Object.assign({}, {
        removeAfterKeyword: false,
        removeDuplicates: true,
        removeQuotes: true
      }, opts);
      return {
        postcssPlugin: "postcss-minify-font-values",
        prepare() {
          const cache = /* @__PURE__ */ new Map();
          return {
            OnceExit(css) {
              css.walkDecls(/font/i, (decl) => {
                const value = decl.value;
                if (!value) {
                  return;
                }
                const prop = decl.prop;
                const cacheKey = `${prop}|${value}`;
                if (cache.has(cacheKey)) {
                  decl.value = cache.get(cacheKey);
                  return;
                }
                const newValue = transform(prop, value, opts);
                decl.value = newValue;
                cache.set(cacheKey, newValue);
              });
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/normalize-url/index.js
var require_normalize_url = __commonJS({
  "node_modules/normalize-url/index.js"(exports2, module2) {
    "use strict";
    var DATA_URL_DEFAULT_MIME_TYPE = "text/plain";
    var DATA_URL_DEFAULT_CHARSET = "us-ascii";
    var testParameter = (name, filters) => {
      return filters.some((filter) => filter instanceof RegExp ? filter.test(name) : filter === name);
    };
    var normalizeDataURL = (urlString, { stripHash }) => {
      const match = /^data:(?<type>[^,]*?),(?<data>[^#]*?)(?:#(?<hash>.*))?$/.exec(urlString);
      if (!match) {
        throw new Error(`Invalid URL: ${urlString}`);
      }
      let { type, data, hash } = match.groups;
      const mediaType = type.split(";");
      hash = stripHash ? "" : hash;
      let isBase64 = false;
      if (mediaType[mediaType.length - 1] === "base64") {
        mediaType.pop();
        isBase64 = true;
      }
      const mimeType = (mediaType.shift() || "").toLowerCase();
      const attributes = mediaType.map((attribute) => {
        let [key, value = ""] = attribute.split("=").map((string) => string.trim());
        if (key === "charset") {
          value = value.toLowerCase();
          if (value === DATA_URL_DEFAULT_CHARSET) {
            return "";
          }
        }
        return `${key}${value ? `=${value}` : ""}`;
      }).filter(Boolean);
      const normalizedMediaType = [
        ...attributes
      ];
      if (isBase64) {
        normalizedMediaType.push("base64");
      }
      if (normalizedMediaType.length !== 0 || mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE) {
        normalizedMediaType.unshift(mimeType);
      }
      return `data:${normalizedMediaType.join(";")},${isBase64 ? data.trim() : data}${hash ? `#${hash}` : ""}`;
    };
    var normalizeUrl = (urlString, options) => {
      options = {
        defaultProtocol: "http:",
        normalizeProtocol: true,
        forceHttp: false,
        forceHttps: false,
        stripAuthentication: true,
        stripHash: false,
        stripTextFragment: true,
        stripWWW: true,
        removeQueryParameters: [/^utm_\w+/i],
        removeTrailingSlash: true,
        removeSingleSlash: true,
        removeDirectoryIndex: false,
        sortQueryParameters: true,
        ...options
      };
      urlString = urlString.trim();
      if (/^data:/i.test(urlString)) {
        return normalizeDataURL(urlString, options);
      }
      if (/^view-source:/i.test(urlString)) {
        throw new Error("`view-source:` is not supported as it is a non-standard protocol");
      }
      const hasRelativeProtocol = urlString.startsWith("//");
      const isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString);
      if (!isRelativeUrl) {
        urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
      }
      const urlObj = new URL(urlString);
      if (options.forceHttp && options.forceHttps) {
        throw new Error("The `forceHttp` and `forceHttps` options cannot be used together");
      }
      if (options.forceHttp && urlObj.protocol === "https:") {
        urlObj.protocol = "http:";
      }
      if (options.forceHttps && urlObj.protocol === "http:") {
        urlObj.protocol = "https:";
      }
      if (options.stripAuthentication) {
        urlObj.username = "";
        urlObj.password = "";
      }
      if (options.stripHash) {
        urlObj.hash = "";
      } else if (options.stripTextFragment) {
        urlObj.hash = urlObj.hash.replace(/#?:~:text.*?$/i, "");
      }
      if (urlObj.pathname) {
        urlObj.pathname = urlObj.pathname.replace(/(?<!\b(?:[a-z][a-z\d+\-.]{1,50}:))\/{2,}/g, "/");
      }
      if (urlObj.pathname) {
        try {
          urlObj.pathname = decodeURI(urlObj.pathname);
        } catch (_) {
        }
      }
      if (options.removeDirectoryIndex === true) {
        options.removeDirectoryIndex = [/^index\.[a-z]+$/];
      }
      if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
        let pathComponents = urlObj.pathname.split("/");
        const lastComponent = pathComponents[pathComponents.length - 1];
        if (testParameter(lastComponent, options.removeDirectoryIndex)) {
          pathComponents = pathComponents.slice(0, pathComponents.length - 1);
          urlObj.pathname = pathComponents.slice(1).join("/") + "/";
        }
      }
      if (urlObj.hostname) {
        urlObj.hostname = urlObj.hostname.replace(/\.$/, "");
        if (options.stripWWW && /^www\.(?!www\.)(?:[a-z\-\d]{1,63})\.(?:[a-z.\-\d]{2,63})$/.test(urlObj.hostname)) {
          urlObj.hostname = urlObj.hostname.replace(/^www\./, "");
        }
      }
      if (Array.isArray(options.removeQueryParameters)) {
        for (const key of [...urlObj.searchParams.keys()]) {
          if (testParameter(key, options.removeQueryParameters)) {
            urlObj.searchParams.delete(key);
          }
        }
      }
      if (options.removeQueryParameters === true) {
        urlObj.search = "";
      }
      if (options.sortQueryParameters) {
        urlObj.searchParams.sort();
      }
      if (options.removeTrailingSlash) {
        urlObj.pathname = urlObj.pathname.replace(/\/$/, "");
      }
      const oldUrlString = urlString;
      urlString = urlObj.toString();
      if (!options.removeSingleSlash && urlObj.pathname === "/" && !oldUrlString.endsWith("/") && urlObj.hash === "") {
        urlString = urlString.replace(/\/$/, "");
      }
      if ((options.removeTrailingSlash || urlObj.pathname === "/") && urlObj.hash === "" && options.removeSingleSlash) {
        urlString = urlString.replace(/\/$/, "");
      }
      if (hasRelativeProtocol && !options.normalizeProtocol) {
        urlString = urlString.replace(/^http:\/\//, "//");
      }
      if (options.stripProtocol) {
        urlString = urlString.replace(/^(?:https?:)?\/\//, "");
      }
      return urlString;
    };
    module2.exports = normalizeUrl;
  }
});

// node_modules/postcss-normalize-url/src/index.js
var require_src16 = __commonJS({
  "node_modules/postcss-normalize-url/src/index.js"(exports2, module2) {
    "use strict";
    var path = require("path");
    var valueParser = require_lib();
    var normalize = require_normalize_url();
    var multiline = /\\[\r\n]/;
    var escapeChars = /([\s\(\)"'])/g;
    var ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;
    var WINDOWS_PATH_REGEX = /^[a-zA-Z]:\\/;
    function isAbsolute(url) {
      if (WINDOWS_PATH_REGEX.test(url)) {
        return false;
      }
      return ABSOLUTE_URL_REGEX.test(url);
    }
    function convert(url, options) {
      if (isAbsolute(url) || url.startsWith("//")) {
        let normalizedURL;
        try {
          normalizedURL = normalize(url, options);
        } catch (e) {
          normalizedURL = url;
        }
        return normalizedURL;
      }
      return path.normalize(url).replace(new RegExp("\\" + path.sep, "g"), "/");
    }
    function transformNamespace(rule) {
      rule.params = valueParser(rule.params).walk((node) => {
        if (node.type === "function" && node.value.toLowerCase() === "url" && node.nodes.length) {
          node.type = "string";
          node.quote = node.nodes[0].type === "string" ? node.nodes[0].quote : '"';
          node.value = node.nodes[0].value;
        }
        if (node.type === "string") {
          node.value = node.value.trim();
        }
        return false;
      }).toString();
    }
    function transformDecl(decl, opts) {
      decl.value = valueParser(decl.value).walk((node) => {
        if (node.type !== "function" || node.value.toLowerCase() !== "url") {
          return false;
        }
        node.before = node.after = "";
        if (!node.nodes.length) {
          return false;
        }
        let url = node.nodes[0];
        let escaped;
        url.value = url.value.trim().replace(multiline, "");
        if (url.value.length === 0) {
          url.quote = "";
          return false;
        }
        if (/^data:(.*)?,/i.test(url.value)) {
          return false;
        }
        if (!/^.+-extension:\//i.test(url.value)) {
          url.value = convert(url.value, opts);
        }
        if (escapeChars.test(url.value) && url.type === "string") {
          escaped = url.value.replace(escapeChars, "\\$1");
          if (escaped.length < url.value.length + 2) {
            url.value = escaped;
            url.type = "word";
          }
        } else {
          url.type = "word";
        }
        return false;
      }).toString();
    }
    function pluginCreator(opts) {
      opts = Object.assign({}, {
        normalizeProtocol: false,
        sortQueryParameters: false,
        stripHash: false,
        stripWWW: false,
        stripTextFragment: false
      }, opts);
      return {
        postcssPlugin: "postcss-normalize-url",
        OnceExit(css) {
          css.walk((node) => {
            if (node.type === "decl") {
              return transformDecl(node, opts);
            } else if (node.type === "atrule" && node.name.toLowerCase() === "namespace") {
              return transformNamespace(node);
            }
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/stylehacks/src/exists.js
var require_exists = __commonJS({
  "node_modules/stylehacks/src/exists.js"(exports2, module2) {
    "use strict";
    module2.exports = function exists(selector, index, value) {
      const node = selector.at(index);
      return node && node.value && node.value.toLowerCase() === value;
    };
  }
});

// node_modules/stylehacks/src/isMixin.js
var require_isMixin = __commonJS({
  "node_modules/stylehacks/src/isMixin.js"(exports2, module2) {
    "use strict";
    module2.exports = function isMixin(node) {
      const { selector } = node;
      if (!selector || selector[selector.length - 1] === ":") {
        return true;
      }
      return false;
    };
  }
});

// node_modules/stylehacks/src/plugin.js
var require_plugin = __commonJS({
  "node_modules/stylehacks/src/plugin.js"(exports2, module2) {
    "use strict";
    module2.exports = class BasePlugin {
      constructor(targets, nodeTypes, result) {
        this.nodes = [];
        this.targets = new Set(targets);
        this.nodeTypes = new Set(nodeTypes);
        this.result = result;
      }
      push(node, metadata) {
        node._stylehacks = Object.assign({}, metadata, {
          message: `Bad ${metadata.identifier}: ${metadata.hack}`,
          browsers: this.targets
        });
        this.nodes.push(node);
      }
      any(node) {
        if (this.nodeTypes.has(node.type)) {
          this.detect(node);
          return node._stylehacks !== void 0;
        }
        return false;
      }
      detectAndResolve(node) {
        this.nodes = [];
        this.detect(node);
        return this.resolve();
      }
      detectAndWarn(node) {
        this.nodes = [];
        this.detect(node);
        return this.warn();
      }
      detect(node) {
        throw new Error("You need to implement this method in a subclass.");
      }
      resolve() {
        return this.nodes.forEach((node) => node.remove());
      }
      warn() {
        return this.nodes.forEach((node) => {
          const { message, browsers, identifier, hack } = node._stylehacks;
          return node.warn(this.result, message + JSON.stringify({ browsers, identifier, hack }));
        });
      }
    };
  }
});

// node_modules/stylehacks/src/dictionary/browsers.js
var require_browsers4 = __commonJS({
  "node_modules/stylehacks/src/dictionary/browsers.js"(exports2, module2) {
    "use strict";
    var FF_2 = "firefox 2";
    var IE_5_5 = "ie 5.5";
    var IE_6 = "ie 6";
    var IE_7 = "ie 7";
    var IE_8 = "ie 8";
    var OP_9 = "opera 9";
    module2.exports = { FF_2, IE_5_5, IE_6, IE_7, IE_8, OP_9 };
  }
});

// node_modules/stylehacks/src/dictionary/identifiers.js
var require_identifiers = __commonJS({
  "node_modules/stylehacks/src/dictionary/identifiers.js"(exports2, module2) {
    "use strict";
    var MEDIA_QUERY = "media query";
    var PROPERTY = "property";
    var SELECTOR = "selector";
    var VALUE = "value";
    module2.exports = { MEDIA_QUERY, PROPERTY, SELECTOR, VALUE };
  }
});

// node_modules/stylehacks/src/dictionary/postcss.js
var require_postcss2 = __commonJS({
  "node_modules/stylehacks/src/dictionary/postcss.js"(exports2, module2) {
    "use strict";
    var ATRULE = "atrule";
    var DECL = "decl";
    var RULE = "rule";
    module2.exports = { ATRULE, DECL, RULE };
  }
});

// node_modules/stylehacks/src/dictionary/tags.js
var require_tags = __commonJS({
  "node_modules/stylehacks/src/dictionary/tags.js"(exports2, module2) {
    "use strict";
    var BODY = "body";
    var HTML = "html";
    module2.exports = { BODY, HTML };
  }
});

// node_modules/stylehacks/src/plugins/bodyEmpty.js
var require_bodyEmpty = __commonJS({
  "node_modules/stylehacks/src/plugins/bodyEmpty.js"(exports2, module2) {
    "use strict";
    var parser = require_dist4();
    var exists = require_exists();
    var isMixin = require_isMixin();
    var BasePlugin = require_plugin();
    var { FF_2 } = require_browsers4();
    var { SELECTOR } = require_identifiers();
    var { RULE } = require_postcss2();
    var { BODY } = require_tags();
    module2.exports = class BodyEmpty extends BasePlugin {
      constructor(result) {
        super([FF_2], [RULE], result);
      }
      detect(rule) {
        if (isMixin(rule)) {
          return;
        }
        parser(this.analyse(rule)).processSync(rule.selector);
      }
      analyse(rule) {
        return (selectors) => {
          selectors.each((selector) => {
            if (exists(selector, 0, BODY) && exists(selector, 1, ":empty") && exists(selector, 2, " ") && selector.at(3)) {
              this.push(rule, {
                identifier: SELECTOR,
                hack: selector.toString()
              });
            }
          });
        };
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/htmlCombinatorCommentBody.js
var require_htmlCombinatorCommentBody = __commonJS({
  "node_modules/stylehacks/src/plugins/htmlCombinatorCommentBody.js"(exports2, module2) {
    "use strict";
    var parser = require_dist4();
    var exists = require_exists();
    var isMixin = require_isMixin();
    var BasePlugin = require_plugin();
    var { IE_5_5, IE_6, IE_7 } = require_browsers4();
    var { SELECTOR } = require_identifiers();
    var { RULE } = require_postcss2();
    var { BODY, HTML } = require_tags();
    module2.exports = class HtmlCombinatorCommentBody extends BasePlugin {
      constructor(result) {
        super([IE_5_5, IE_6, IE_7], [RULE], result);
      }
      detect(rule) {
        if (isMixin(rule)) {
          return;
        }
        if (rule.raws.selector && rule.raws.selector.raw) {
          parser(this.analyse(rule)).processSync(rule.raws.selector.raw);
        }
      }
      analyse(rule) {
        return (selectors) => {
          selectors.each((selector) => {
            if (exists(selector, 0, HTML) && (exists(selector, 1, ">") || exists(selector, 1, "~")) && selector.at(2) && selector.at(2).type === "comment" && exists(selector, 3, " ") && exists(selector, 4, BODY) && exists(selector, 5, " ") && selector.at(6)) {
              this.push(rule, {
                identifier: SELECTOR,
                hack: selector.toString()
              });
            }
          });
        };
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/htmlFirstChild.js
var require_htmlFirstChild = __commonJS({
  "node_modules/stylehacks/src/plugins/htmlFirstChild.js"(exports2, module2) {
    "use strict";
    var parser = require_dist4();
    var exists = require_exists();
    var isMixin = require_isMixin();
    var BasePlugin = require_plugin();
    var { OP_9 } = require_browsers4();
    var { SELECTOR } = require_identifiers();
    var { RULE } = require_postcss2();
    var { HTML } = require_tags();
    module2.exports = class HtmlFirstChild extends BasePlugin {
      constructor(result) {
        super([OP_9], [RULE], result);
      }
      detect(rule) {
        if (isMixin(rule)) {
          return;
        }
        parser(this.analyse(rule)).processSync(rule.selector);
      }
      analyse(rule) {
        return (selectors) => {
          selectors.each((selector) => {
            if (exists(selector, 0, HTML) && exists(selector, 1, ":first-child") && exists(selector, 2, " ") && selector.at(3)) {
              this.push(rule, {
                identifier: SELECTOR,
                hack: selector.toString()
              });
            }
          });
        };
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/important.js
var require_important = __commonJS({
  "node_modules/stylehacks/src/plugins/important.js"(exports2, module2) {
    "use strict";
    var BasePlugin = require_plugin();
    var { IE_5_5, IE_6, IE_7 } = require_browsers4();
    var { DECL } = require_postcss2();
    module2.exports = class Important extends BasePlugin {
      constructor(result) {
        super([IE_5_5, IE_6, IE_7], [DECL], result);
      }
      detect(decl) {
        const match = decl.value.match(/!\w/);
        if (match && match.index) {
          const hack = decl.value.substr(match.index, decl.value.length - 1);
          this.push(decl, {
            identifier: "!important",
            hack
          });
        }
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/leadingStar.js
var require_leadingStar = __commonJS({
  "node_modules/stylehacks/src/plugins/leadingStar.js"(exports2, module2) {
    "use strict";
    var BasePlugin = require_plugin();
    var { IE_5_5, IE_6, IE_7 } = require_browsers4();
    var { PROPERTY } = require_identifiers();
    var { ATRULE, DECL } = require_postcss2();
    var hacks = "!_$_&_*_)_=_%_+_,_._/_`_]_#_~_?_:_|".split("_");
    module2.exports = class LeadingStar extends BasePlugin {
      constructor(result) {
        super([IE_5_5, IE_6, IE_7], [ATRULE, DECL], result);
      }
      detect(node) {
        if (node.type === DECL) {
          hacks.forEach((hack) => {
            if (!node.prop.indexOf(hack)) {
              this.push(node, {
                identifier: PROPERTY,
                hack: node.prop
              });
            }
          });
          const { before } = node.raws;
          if (!before) {
            return;
          }
          hacks.forEach((hack) => {
            if (before.includes(hack)) {
              this.push(node, {
                identifier: PROPERTY,
                hack: `${before.trim()}${node.prop}`
              });
            }
          });
        } else {
          const { name } = node;
          const len = name.length - 1;
          if (name.lastIndexOf(":") === len) {
            this.push(node, {
              identifier: PROPERTY,
              hack: `@${name.substr(0, len)}`
            });
          }
        }
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/leadingUnderscore.js
var require_leadingUnderscore = __commonJS({
  "node_modules/stylehacks/src/plugins/leadingUnderscore.js"(exports2, module2) {
    "use strict";
    var BasePlugin = require_plugin();
    var { IE_6 } = require_browsers4();
    var { PROPERTY } = require_identifiers();
    var { DECL } = require_postcss2();
    function vendorPrefix(prop) {
      let match = prop.match(/^(-\w+-)/);
      if (match) {
        return match[0];
      }
      return "";
    }
    module2.exports = class LeadingUnderscore extends BasePlugin {
      constructor(result) {
        super([IE_6], [DECL], result);
      }
      detect(decl) {
        const { before } = decl.raws;
        if (before && before.includes("_")) {
          this.push(decl, {
            identifier: PROPERTY,
            hack: `${before.trim()}${decl.prop}`
          });
        }
        if (decl.prop[0] === "-" && decl.prop[1] !== "-" && vendorPrefix(decl.prop) === "") {
          this.push(decl, {
            identifier: PROPERTY,
            hack: decl.prop
          });
        }
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/mediaSlash0.js
var require_mediaSlash0 = __commonJS({
  "node_modules/stylehacks/src/plugins/mediaSlash0.js"(exports2, module2) {
    "use strict";
    var BasePlugin = require_plugin();
    var { IE_8 } = require_browsers4();
    var { MEDIA_QUERY } = require_identifiers();
    var { ATRULE } = require_postcss2();
    module2.exports = class MediaSlash0 extends BasePlugin {
      constructor(result) {
        super([IE_8], [ATRULE], result);
      }
      detect(rule) {
        const params = rule.params.trim();
        if (params.toLowerCase() === "\\0screen") {
          this.push(rule, {
            identifier: MEDIA_QUERY,
            hack: params
          });
        }
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/mediaSlash0Slash9.js
var require_mediaSlash0Slash9 = __commonJS({
  "node_modules/stylehacks/src/plugins/mediaSlash0Slash9.js"(exports2, module2) {
    "use strict";
    var BasePlugin = require_plugin();
    var { IE_5_5, IE_6, IE_7, IE_8 } = require_browsers4();
    var { MEDIA_QUERY } = require_identifiers();
    var { ATRULE } = require_postcss2();
    module2.exports = class MediaSlash0Slash9 extends BasePlugin {
      constructor(result) {
        super([IE_5_5, IE_6, IE_7, IE_8], [ATRULE], result);
      }
      detect(rule) {
        const params = rule.params.trim();
        if (params.toLowerCase() === "\\0screen\\,screen\\9") {
          this.push(rule, {
            identifier: MEDIA_QUERY,
            hack: params
          });
        }
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/mediaSlash9.js
var require_mediaSlash9 = __commonJS({
  "node_modules/stylehacks/src/plugins/mediaSlash9.js"(exports2, module2) {
    "use strict";
    var BasePlugin = require_plugin();
    var { IE_5_5, IE_6, IE_7 } = require_browsers4();
    var { MEDIA_QUERY } = require_identifiers();
    var { ATRULE } = require_postcss2();
    module2.exports = class MediaSlash9 extends BasePlugin {
      constructor(result) {
        super([IE_5_5, IE_6, IE_7], [ATRULE], result);
      }
      detect(rule) {
        const params = rule.params.trim();
        if (params.toLowerCase() === "screen\\9") {
          this.push(rule, {
            identifier: MEDIA_QUERY,
            hack: params
          });
        }
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/slash9.js
var require_slash9 = __commonJS({
  "node_modules/stylehacks/src/plugins/slash9.js"(exports2, module2) {
    "use strict";
    var BasePlugin = require_plugin();
    var { IE_6, IE_7, IE_8 } = require_browsers4();
    var { VALUE } = require_identifiers();
    var { DECL } = require_postcss2();
    module2.exports = class Slash9 extends BasePlugin {
      constructor(result) {
        super([IE_6, IE_7, IE_8], [DECL], result);
      }
      detect(decl) {
        let v = decl.value;
        if (v && v.length > 2 && v.indexOf("\\9") === v.length - 2) {
          this.push(decl, {
            identifier: VALUE,
            hack: v
          });
        }
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/starHtml.js
var require_starHtml = __commonJS({
  "node_modules/stylehacks/src/plugins/starHtml.js"(exports2, module2) {
    "use strict";
    var parser = require_dist4();
    var exists = require_exists();
    var isMixin = require_isMixin();
    var BasePlugin = require_plugin();
    var { IE_5_5, IE_6 } = require_browsers4();
    var { SELECTOR } = require_identifiers();
    var { RULE } = require_postcss2();
    var { HTML } = require_tags();
    module2.exports = class StarHtml extends BasePlugin {
      constructor(result) {
        super([IE_5_5, IE_6], [RULE], result);
      }
      detect(rule) {
        if (isMixin(rule)) {
          return;
        }
        parser(this.analyse(rule)).processSync(rule.selector);
      }
      analyse(rule) {
        return (selectors) => {
          selectors.each((selector) => {
            if (exists(selector, 0, "*") && exists(selector, 1, " ") && exists(selector, 2, HTML) && exists(selector, 3, " ") && selector.at(4)) {
              this.push(rule, {
                identifier: SELECTOR,
                hack: selector.toString()
              });
            }
          });
        };
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/trailingSlashComma.js
var require_trailingSlashComma = __commonJS({
  "node_modules/stylehacks/src/plugins/trailingSlashComma.js"(exports2, module2) {
    "use strict";
    var BasePlugin = require_plugin();
    var isMixin = require_isMixin();
    var { IE_5_5, IE_6, IE_7 } = require_browsers4();
    var { SELECTOR } = require_identifiers();
    var { RULE } = require_postcss2();
    module2.exports = class TrailingSlashComma extends BasePlugin {
      constructor(result) {
        super([IE_5_5, IE_6, IE_7], [RULE], result);
      }
      detect(rule) {
        if (isMixin(rule)) {
          return;
        }
        const { selector } = rule;
        const trim = selector.trim();
        if (trim.lastIndexOf(",") === selector.length - 1 || trim.lastIndexOf("\\") === selector.length - 1) {
          this.push(rule, {
            identifier: SELECTOR,
            hack: selector
          });
        }
      }
    };
  }
});

// node_modules/stylehacks/src/plugins/index.js
var require_plugins3 = __commonJS({
  "node_modules/stylehacks/src/plugins/index.js"(exports2, module2) {
    "use strict";
    var bodyEmpty = require_bodyEmpty();
    var htmlCombinatorCommentBody = require_htmlCombinatorCommentBody();
    var htmlFirstChild = require_htmlFirstChild();
    var important = require_important();
    var leadingStar = require_leadingStar();
    var leadingUnderscore = require_leadingUnderscore();
    var mediaSlash0 = require_mediaSlash0();
    var mediaSlash0Slash9 = require_mediaSlash0Slash9();
    var mediaSlash9 = require_mediaSlash9();
    var slash9 = require_slash9();
    var starHtml = require_starHtml();
    var trailingSlashComma = require_trailingSlashComma();
    module2.exports = [
      bodyEmpty,
      htmlCombinatorCommentBody,
      htmlFirstChild,
      important,
      leadingStar,
      leadingUnderscore,
      mediaSlash0,
      mediaSlash0Slash9,
      mediaSlash9,
      slash9,
      starHtml,
      trailingSlashComma
    ];
  }
});

// node_modules/stylehacks/src/index.js
var require_src17 = __commonJS({
  "node_modules/stylehacks/src/index.js"(exports2, module2) {
    "use strict";
    var browserslist = require_browserslist();
    var plugins = require_plugins3();
    function pluginCreator(opts = {}) {
      return {
        postcssPlugin: "stylehacks",
        OnceExit(css, { result }) {
          const resultOpts = result.opts || {};
          const browsers = browserslist(null, {
            stats: resultOpts.stats,
            path: __dirname,
            env: resultOpts.env
          });
          const processors = [];
          for (const Plugin of plugins) {
            const hack = new Plugin(result);
            if (!browsers.some((browser) => hack.targets.has(browser))) {
              processors.push(hack);
            }
          }
          css.walk((node) => {
            processors.forEach((proc) => {
              if (!proc.nodeTypes.has(node.type)) {
                return;
              }
              if (opts.lint) {
                return proc.detectAndWarn(node);
              }
              return proc.detectAndResolve(node);
            });
          });
        }
      };
    }
    pluginCreator.detect = (node) => {
      return plugins.some((Plugin) => {
        const hack = new Plugin();
        return hack.any(node);
      });
    };
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-merge-longhand/src/lib/insertCloned.js
var require_insertCloned = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/insertCloned.js"(exports2, module2) {
    "use strict";
    module2.exports = function insertCloned(rule, decl, props) {
      const newNode = Object.assign(decl.clone(), props);
      rule.insertAfter(decl, newNode);
      return newNode;
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/parseTrbl.js
var require_parseTrbl = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/parseTrbl.js"(exports2, module2) {
    "use strict";
    var { list } = require_postcss();
    module2.exports = (v) => {
      const s = typeof v === "string" ? list.space(v) : v;
      return [
        s[0],
        s[1] || s[0],
        s[2] || s[0],
        s[3] || s[1] || s[0]
      ];
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/hasAllProps.js
var require_hasAllProps = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/hasAllProps.js"(exports2, module2) {
    "use strict";
    module2.exports = (rule, ...props) => {
      return props.every((p) => rule.some((node) => node.prop && node.prop.toLowerCase().includes(p)));
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/getDecls.js
var require_getDecls = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/getDecls.js"(exports2, module2) {
    "use strict";
    module2.exports = function getDecls(rule, properties) {
      return rule.nodes.filter((node) => node.type === "decl" && properties.includes(node.prop.toLowerCase()));
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/getLastNode.js
var require_getLastNode = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/getLastNode.js"(exports2, module2) {
    "use strict";
    module2.exports = (rule, prop) => {
      return rule.filter((n) => n.type === "decl" && n.prop.toLowerCase() === prop).pop();
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/getRules.js
var require_getRules = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/getRules.js"(exports2, module2) {
    "use strict";
    var getLastNode = require_getLastNode();
    module2.exports = function getRules(props, properties) {
      return properties.map((property) => {
        return getLastNode(props, property);
      }).filter(Boolean);
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/getValue.js
var require_getValue2 = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/getValue.js"(exports2, module2) {
    "use strict";
    module2.exports = function getValue({ value }) {
      return value;
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/mergeRules.js
var require_mergeRules = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/mergeRules.js"(exports2, module2) {
    "use strict";
    var hasAllProps = require_hasAllProps();
    var getDecls = require_getDecls();
    var getRules = require_getRules();
    function isConflictingProp(propA, propB) {
      if (!propB.prop || propB.important !== propA.important || propA.prop === propB.prop) {
        return false;
      }
      const partsA = propA.prop.split("-");
      const partsB = propB.prop.split("-");
      if (partsA[0] !== partsB[0]) {
        return false;
      }
      const partsASet = new Set(partsA);
      return partsB.every((partB) => partsASet.has(partB));
    }
    function hasConflicts(match, nodes) {
      const firstNode = Math.min(...match.map((n) => nodes.indexOf(n)));
      const lastNode = Math.max(...match.map((n) => nodes.indexOf(n)));
      const between = nodes.slice(firstNode + 1, lastNode);
      return match.some((a) => between.some((b) => isConflictingProp(a, b)));
    }
    module2.exports = function mergeRules(rule, properties, callback) {
      let decls = getDecls(rule, properties);
      while (decls.length) {
        const last = decls[decls.length - 1];
        const props = decls.filter((node) => node.important === last.important);
        const rules = getRules(props, properties);
        if (hasAllProps(rules, ...properties) && !hasConflicts(rules, rule.nodes)) {
          if (callback(rules, last, props)) {
            decls = decls.filter((node) => !rules.includes(node));
          }
        }
        decls = decls.filter((node) => node !== last);
      }
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/minifyTrbl.js
var require_minifyTrbl = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/minifyTrbl.js"(exports2, module2) {
    "use strict";
    var parseTrbl = require_parseTrbl();
    module2.exports = (v) => {
      const value = parseTrbl(v);
      if (value[3] === value[1]) {
        value.pop();
        if (value[2] === value[0]) {
          value.pop();
          if (value[0] === value[1]) {
            value.pop();
          }
        }
      }
      return value.join(" ");
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/colornames.js
var require_colornames = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/colornames.js"(exports2, module2) {
    "use strict";
    module2.exports = /* @__PURE__ */ new Set([
      "aliceblue",
      "antiquewhite",
      "aqua",
      "aquamarine",
      "azure",
      "beige",
      "bisque",
      "black",
      "blanchedalmond",
      "blue",
      "blueviolet",
      "brown",
      "burlywood",
      "cadetblue",
      "chartreuse",
      "chocolate",
      "coral",
      "cornflowerblue",
      "cornsilk",
      "crimson",
      "cyan",
      "darkblue",
      "darkcyan",
      "darkgoldenrod",
      "darkgray",
      "darkgreen",
      "darkgrey",
      "darkkhaki",
      "darkmagenta",
      "darkolivegreen",
      "darkorange",
      "darkorchid",
      "darkred",
      "darksalmon",
      "darkseagreen",
      "darkslateblue",
      "darkslategray",
      "darkslategrey",
      "darkturquoise",
      "darkviolet",
      "deeppink",
      "deepskyblue",
      "dimgray",
      "dimgrey",
      "dodgerblue",
      "firebrick",
      "floralwhite",
      "forestgreen",
      "fuchsia",
      "gainsboro",
      "ghostwhite",
      "gold",
      "goldenrod",
      "gray",
      "green",
      "greenyellow",
      "grey",
      "honeydew",
      "hotpink",
      "indianred",
      "indigo",
      "ivory",
      "khaki",
      "lavender",
      "lavenderblush",
      "lawngreen",
      "lemonchiffon",
      "lightblue",
      "lightcoral",
      "lightcyan",
      "lightgoldenrodyellow",
      "lightgray",
      "lightgreen",
      "lightgrey",
      "lightpink",
      "lightsalmon",
      "lightseagreen",
      "lightskyblue",
      "lightslategray",
      "lightslategrey",
      "lightsteelblue",
      "lightyellow",
      "lime",
      "limegreen",
      "linen",
      "magenta",
      "maroon",
      "mediumaquamarine",
      "mediumblue",
      "mediumorchid",
      "mediumpurple",
      "mediumseagreen",
      "mediumslateblue",
      "mediumspringgreen",
      "mediumturquoise",
      "mediumvioletred",
      "midnightblue",
      "mintcream",
      "mistyrose",
      "moccasin",
      "navajowhite",
      "navy",
      "oldlace",
      "olive",
      "olivedrab",
      "orange",
      "orangered",
      "orchid",
      "palegoldenrod",
      "palegreen",
      "paleturquoise",
      "palevioletred",
      "papayawhip",
      "peachpuff",
      "peru",
      "pink",
      "plum",
      "powderblue",
      "purple",
      "rebeccapurple",
      "red",
      "rosybrown",
      "royalblue",
      "saddlebrown",
      "salmon",
      "sandybrown",
      "seagreen",
      "seashell",
      "sienna",
      "silver",
      "skyblue",
      "slateblue",
      "slategray",
      "slategrey",
      "snow",
      "springgreen",
      "steelblue",
      "tan",
      "teal",
      "thistle",
      "tomato",
      "turquoise",
      "violet",
      "wheat",
      "white",
      "whitesmoke",
      "yellow",
      "yellowgreen"
    ]);
  }
});

// node_modules/postcss-merge-longhand/src/lib/validateWsc.js
var require_validateWsc = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/validateWsc.js"(exports2, module2) {
    "use strict";
    var colors = require_colornames();
    var widths = /* @__PURE__ */ new Set(["thin", "medium", "thick"]);
    var styles = /* @__PURE__ */ new Set([
      "none",
      "hidden",
      "dotted",
      "dashed",
      "solid",
      "double",
      "groove",
      "ridge",
      "inset",
      "outset"
    ]);
    function isStyle(value) {
      return value !== void 0 && styles.has(value.toLowerCase());
    }
    function isWidth(value) {
      return value && widths.has(value.toLowerCase()) || /^(\d+(\.\d+)?|\.\d+)(\w+)?$/.test(value);
    }
    function isColor(value) {
      if (!value) {
        return false;
      }
      value = value.toLowerCase();
      if (/rgba?\(/.test(value)) {
        return true;
      }
      if (/hsla?\(/.test(value)) {
        return true;
      }
      if (/#([0-9a-z]{6}|[0-9a-z]{3})/.test(value)) {
        return true;
      }
      if (value === "transparent") {
        return true;
      }
      if (value === "currentcolor") {
        return true;
      }
      return colors.has(value);
    }
    function isValidWsc(wscs) {
      const validWidth = isWidth(wscs[0]);
      const validStyle = isStyle(wscs[1]);
      const validColor = isColor(wscs[2]);
      return validWidth && validStyle || validWidth && validColor || validStyle && validColor;
    }
    module2.exports = { isStyle, isWidth, isColor, isValidWsc };
  }
});

// node_modules/postcss-merge-longhand/src/lib/parseWsc.js
var require_parseWsc = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/parseWsc.js"(exports2, module2) {
    "use strict";
    var { list } = require_postcss();
    var { isWidth, isStyle, isColor } = require_validateWsc();
    var none = /^\s*(none|medium)(\s+none(\s+(none|currentcolor))?)?\s*$/i;
    var varRE = /--(\w|[^\x00-\x7F])+/g;
    var toLower = (v) => {
      let match;
      let lastIndex = 0;
      let result = "";
      varRE.lastIndex = 0;
      while ((match = varRE.exec(v)) !== null) {
        if (match.index > lastIndex) {
          result += v.substring(lastIndex, match.index).toLowerCase();
        }
        result += match[0];
        lastIndex = match.index + match[0].length;
      }
      if (lastIndex < v.length) {
        result += v.substring(lastIndex).toLowerCase();
      }
      if (result === "") {
        return v;
      }
      return result;
    };
    module2.exports = function parseWsc(value) {
      if (none.test(value)) {
        return ["medium", "none", "currentcolor"];
      }
      let width, style, color;
      const values = list.space(value);
      if (values.length > 1 && isStyle(values[1]) && values[0].toLowerCase() === "none") {
        values.unshift();
        width = "0";
      }
      const unknown = [];
      values.forEach((v) => {
        if (isStyle(v)) {
          style = toLower(v);
        } else if (isWidth(v)) {
          width = toLower(v);
        } else if (isColor(v)) {
          color = toLower(v);
        } else {
          unknown.push(v);
        }
      });
      if (unknown.length) {
        if (!width && style && color) {
          width = unknown.pop();
        }
        if (width && !style && color) {
          style = unknown.pop();
        }
        if (width && style && !color) {
          color = unknown.pop();
        }
      }
      return [width, style, color];
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/minifyWsc.js
var require_minifyWsc = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/minifyWsc.js"(exports2, module2) {
    "use strict";
    var parseWsc = require_parseWsc();
    var minifyTrbl = require_minifyTrbl();
    var { isValidWsc } = require_validateWsc();
    var defaults = ["medium", "none", "currentcolor"];
    module2.exports = (v) => {
      const values = parseWsc(v);
      if (!isValidWsc(values)) {
        return minifyTrbl(v);
      }
      const value = [...values, ""].reduceRight((prev, cur, i, arr) => {
        if (cur === void 0 || cur.toLowerCase() === defaults[i] && (!i || (arr[i - 1] || "").toLowerCase() !== cur.toLowerCase())) {
          return prev;
        }
        return cur + " " + prev;
      }).trim();
      return minifyTrbl(value || "none");
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/isCustomProp.js
var require_isCustomProp = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/isCustomProp.js"(exports2, module2) {
    "use strict";
    module2.exports = (node) => node.value.search(/var\s*\(\s*--/i) !== -1;
  }
});

// node_modules/postcss-merge-longhand/src/lib/canMerge.js
var require_canMerge = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/canMerge.js"(exports2, module2) {
    "use strict";
    var isCustomProp = require_isCustomProp();
    var important = (node) => node.important;
    var unimportant = (node) => !node.important;
    var cssWideKeywords = ["inherit", "initial", "unset", "revert"];
    module2.exports = (props, includeCustomProps = true) => {
      const uniqueProps = new Set(props.map((node) => node.value.toLowerCase()));
      if (uniqueProps.size > 1) {
        for (const unmergeable of cssWideKeywords) {
          if (uniqueProps.has(unmergeable)) {
            return false;
          }
        }
      }
      if (includeCustomProps && props.some(isCustomProp) && !props.every(isCustomProp)) {
        return false;
      }
      return props.every(unimportant) || props.every(important);
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/trbl.js
var require_trbl = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/trbl.js"(exports2, module2) {
    "use strict";
    module2.exports = ["top", "right", "bottom", "left"];
  }
});

// node_modules/postcss-merge-longhand/src/lib/canExplode.js
var require_canExplode = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/canExplode.js"(exports2, module2) {
    "use strict";
    var isCustomProp = require_isCustomProp();
    var globalKeywords = /* @__PURE__ */ new Set(["inherit", "initial", "unset", "revert"]);
    module2.exports = (prop, includeCustomProps = true) => {
      if (!prop.value || includeCustomProps && isCustomProp(prop) || prop.value && globalKeywords.has(prop.value.toLowerCase())) {
        return false;
      }
      return true;
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/decl/borders.js
var require_borders = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/decl/borders.js"(exports2, module2) {
    "use strict";
    var { list } = require_postcss();
    var stylehacks = require_src17();
    var insertCloned = require_insertCloned();
    var parseTrbl = require_parseTrbl();
    var hasAllProps = require_hasAllProps();
    var getDecls = require_getDecls();
    var getRules = require_getRules();
    var getValue = require_getValue2();
    var mergeRules = require_mergeRules();
    var minifyTrbl = require_minifyTrbl();
    var minifyWsc = require_minifyWsc();
    var canMerge = require_canMerge();
    var trbl = require_trbl();
    var isCustomProp = require_isCustomProp();
    var canExplode = require_canExplode();
    var getLastNode = require_getLastNode();
    var parseWsc = require_parseWsc();
    var { isValidWsc } = require_validateWsc();
    var wsc = ["width", "style", "color"];
    var defaults = ["medium", "none", "currentcolor"];
    var colorMightRequireFallback = /(hsla|rgba|color|hwb|lab|lch|oklab|oklch)\(/i;
    function borderProperty(...parts) {
      return `border-${parts.join("-")}`;
    }
    function mapBorderProperty(value) {
      return borderProperty(value);
    }
    var directions = trbl.map(mapBorderProperty);
    var properties = wsc.map(mapBorderProperty);
    var directionalProperties = directions.reduce((prev, curr) => prev.concat(wsc.map((prop) => `${curr}-${prop}`)), []);
    var precedence = [
      ["border"],
      directions.concat(properties),
      directionalProperties
    ];
    var allProperties = precedence.reduce((a, b) => a.concat(b));
    function getLevel(prop) {
      for (let i = 0; i < precedence.length; i++) {
        if (precedence[i].includes(prop.toLowerCase())) {
          return i;
        }
      }
    }
    var isValueCustomProp = (value) => value !== void 0 && value.search(/var\s*\(\s*--/i) !== -1;
    function canMergeValues(values) {
      return !values.some(isValueCustomProp);
    }
    function getColorValue(decl) {
      if (decl.prop.substr(-5) === "color") {
        return decl.value;
      }
      return parseWsc(decl.value)[2] || defaults[2];
    }
    function diffingProps(values, nextValues) {
      return wsc.reduce((prev, curr, i) => {
        if (values[i] === nextValues[i]) {
          return prev;
        }
        return [...prev, curr];
      }, []);
    }
    function mergeRedundant({ values, nextValues, decl, nextDecl, index }) {
      if (!canMerge([decl, nextDecl])) {
        return;
      }
      if (stylehacks.detect(decl) || stylehacks.detect(nextDecl)) {
        return;
      }
      const diff = diffingProps(values, nextValues);
      if (diff.length !== 1) {
        return;
      }
      const prop = diff.pop();
      const position = wsc.indexOf(prop);
      const prop1 = `${nextDecl.prop}-${prop}`;
      const prop2 = `border-${prop}`;
      let props = parseTrbl(values[position]);
      props[index] = nextValues[position];
      const borderValue2 = values.filter((e, i) => i !== position).join(" ");
      const propValue2 = minifyTrbl(props);
      const origLength = (minifyWsc(decl.value) + nextDecl.prop + nextDecl.value).length;
      const newLength1 = decl.value.length + prop1.length + minifyWsc(nextValues[position]).length;
      const newLength2 = borderValue2.length + prop2.length + propValue2.length;
      if (newLength1 < newLength2 && newLength1 < origLength) {
        nextDecl.prop = prop1;
        nextDecl.value = nextValues[position];
      }
      if (newLength2 < newLength1 && newLength2 < origLength) {
        decl.value = borderValue2;
        nextDecl.prop = prop2;
        nextDecl.value = propValue2;
      }
    }
    function isCloseEnough(mapped) {
      return mapped[0] === mapped[1] && mapped[1] === mapped[2] || mapped[1] === mapped[2] && mapped[2] === mapped[3] || mapped[2] === mapped[3] && mapped[3] === mapped[0] || mapped[3] === mapped[0] && mapped[0] === mapped[1];
    }
    function getDistinctShorthands(mapped) {
      return [...new Set(mapped)];
    }
    function explode(rule) {
      rule.walkDecls(/^border/i, (decl) => {
        if (!canExplode(decl, false)) {
          return;
        }
        if (stylehacks.detect(decl)) {
          return;
        }
        const prop = decl.prop.toLowerCase();
        if (prop === "border") {
          if (isValidWsc(parseWsc(decl.value))) {
            directions.forEach((direction) => {
              insertCloned(decl.parent, decl, { prop: direction });
            });
            decl.remove();
          }
        }
        if (directions.some((direction) => prop === direction)) {
          let values = parseWsc(decl.value);
          if (isValidWsc(values)) {
            wsc.forEach((d, i) => {
              insertCloned(decl.parent, decl, {
                prop: `${prop}-${d}`,
                value: values[i] || defaults[i]
              });
            });
            decl.remove();
          }
        }
        wsc.some((style) => {
          if (prop !== borderProperty(style)) {
            return false;
          }
          if (isCustomProp(decl)) {
            decl.prop = decl.prop.toLowerCase();
            return false;
          }
          parseTrbl(decl.value).forEach((value, i) => {
            insertCloned(decl.parent, decl, {
              prop: borderProperty(trbl[i], style),
              value
            });
          });
          return decl.remove();
        });
      });
    }
    function merge(rule) {
      trbl.forEach((direction) => {
        const prop = borderProperty(direction);
        mergeRules(rule, wsc.map((style) => borderProperty(direction, style)), (rules, lastNode) => {
          if (canMerge(rules, false) && !rules.some(stylehacks.detect)) {
            insertCloned(lastNode.parent, lastNode, {
              prop,
              value: rules.map(getValue).join(" ")
            });
            for (const node of rules) {
              node.remove();
            }
            return true;
          }
          return false;
        });
      });
      wsc.forEach((style) => {
        const prop = borderProperty(style);
        mergeRules(rule, trbl.map((direction) => borderProperty(direction, style)), (rules, lastNode) => {
          if (canMerge(rules) && !rules.some(stylehacks.detect)) {
            insertCloned(lastNode.parent, lastNode, {
              prop,
              value: minifyTrbl(rules.map(getValue).join(" "))
            });
            for (const node of rules) {
              node.remove();
            }
            return true;
          }
          return false;
        });
      });
      mergeRules(rule, directions, (rules, lastNode) => {
        if (rules.some(stylehacks.detect)) {
          return false;
        }
        const values = rules.map(({ value }) => value);
        if (!canMergeValues(values)) {
          return false;
        }
        const parsed = values.map((value) => parseWsc(value));
        if (!parsed.every(isValidWsc)) {
          return false;
        }
        wsc.forEach((d, i) => {
          const value = parsed.map((v) => v[i] || defaults[i]);
          if (canMergeValues(value)) {
            insertCloned(lastNode.parent, lastNode, {
              prop: borderProperty(d),
              value: minifyTrbl(value)
            });
          } else {
            insertCloned(lastNode.parent, lastNode);
          }
        });
        for (const node of rules) {
          node.remove();
        }
        return true;
      });
      mergeRules(rule, properties, (rules, lastNode) => {
        if (rules.some(stylehacks.detect)) {
          return false;
        }
        const values = rules.map((node) => parseTrbl(node.value));
        const mapped = [0, 1, 2, 3].map((i) => [values[0][i], values[1][i], values[2][i]].join(" "));
        if (!canMergeValues(mapped)) {
          return false;
        }
        const [width, style, color] = rules;
        const reduced = getDistinctShorthands(mapped);
        if (isCloseEnough(mapped) && canMerge(rules, false)) {
          const first = mapped.indexOf(reduced[0]) !== mapped.lastIndexOf(reduced[0]);
          const border = insertCloned(lastNode.parent, lastNode, {
            prop: "border",
            value: first ? reduced[0] : reduced[1]
          });
          if (reduced[1]) {
            const value = first ? reduced[1] : reduced[0];
            const prop = borderProperty(trbl[mapped.indexOf(value)]);
            rule.insertAfter(border, Object.assign(lastNode.clone(), {
              prop,
              value
            }));
          }
          for (const node of rules) {
            node.remove();
          }
          return true;
        } else if (reduced.length === 1) {
          rule.insertBefore(color, Object.assign(lastNode.clone(), {
            prop: "border",
            value: [width, style].map(getValue).join(" ")
          }));
          rules.filter((node) => node.prop.toLowerCase() !== properties[2]).forEach((node) => node.remove());
          return true;
        }
        return false;
      });
      mergeRules(rule, properties, (rules, lastNode) => {
        if (rules.some(stylehacks.detect)) {
          return false;
        }
        const values = rules.map((node) => parseTrbl(node.value));
        const mapped = [0, 1, 2, 3].map((i) => [values[0][i], values[1][i], values[2][i]].join(" "));
        const reduced = getDistinctShorthands(mapped);
        const none = "medium none currentcolor";
        if (reduced.length > 1 && reduced.length < 4 && reduced.includes(none)) {
          const filtered = mapped.filter((p) => p !== none);
          const mostCommon = reduced.sort((a, b) => mapped.filter((v) => v === b).length - mapped.filter((v) => v === a).length)[0];
          const borderValue = reduced.length === 2 ? filtered[0] : mostCommon;
          rule.insertBefore(lastNode, Object.assign(lastNode.clone(), {
            prop: "border",
            value: borderValue
          }));
          directions.forEach((dir, i) => {
            if (mapped[i] !== borderValue) {
              rule.insertBefore(lastNode, Object.assign(lastNode.clone(), {
                prop: dir,
                value: mapped[i]
              }));
            }
          });
          for (const node of rules) {
            node.remove();
          }
          return true;
        }
        return false;
      });
      mergeRules(rule, directions, (rules, lastNode) => {
        if (rules.some(stylehacks.detect)) {
          return false;
        }
        const values = rules.map((node) => {
          const wscValue = parseWsc(node.value);
          if (!isValidWsc(wscValue)) {
            return node.value;
          }
          return wscValue.map((value, i) => value || defaults[i]).join(" ");
        });
        const reduced = getDistinctShorthands(values);
        if (isCloseEnough(values)) {
          const first = values.indexOf(reduced[0]) !== values.lastIndexOf(reduced[0]);
          rule.insertBefore(lastNode, Object.assign(lastNode.clone(), {
            prop: "border",
            value: minifyWsc(first ? values[0] : values[1])
          }));
          if (reduced[1]) {
            const value = first ? reduced[1] : reduced[0];
            const prop = directions[values.indexOf(value)];
            rule.insertBefore(lastNode, Object.assign(lastNode.clone(), {
              prop,
              value: minifyWsc(value)
            }));
          }
          for (const node of rules) {
            node.remove();
          }
          return true;
        }
        return false;
      });
      directions.forEach((direction) => {
        wsc.forEach((style, i) => {
          const prop = `${direction}-${style}`;
          mergeRules(rule, [direction, prop], (rules, lastNode) => {
            if (lastNode.prop !== direction) {
              return false;
            }
            const values = parseWsc(lastNode.value);
            if (!isValidWsc(values)) {
              return false;
            }
            const wscProp = rules.filter((r) => r !== lastNode)[0];
            if (!isValueCustomProp(values[i]) || isCustomProp(wscProp)) {
              return false;
            }
            const wscValue = values[i];
            values[i] = wscProp.value;
            if (canMerge(rules, false) && !rules.some(stylehacks.detect)) {
              insertCloned(lastNode.parent, lastNode, {
                prop,
                value: wscValue
              });
              lastNode.value = minifyWsc(values);
              wscProp.remove();
              return true;
            }
            return false;
          });
        });
      });
      wsc.forEach((style, i) => {
        const prop = borderProperty(style);
        mergeRules(rule, ["border", prop], (rules, lastNode) => {
          if (lastNode.prop !== "border") {
            return false;
          }
          const values = parseWsc(lastNode.value);
          if (!isValidWsc(values)) {
            return false;
          }
          const wscProp = rules.filter((r) => r !== lastNode)[0];
          if (!isValueCustomProp(values[i]) || isCustomProp(wscProp)) {
            return false;
          }
          const wscValue = values[i];
          values[i] = wscProp.value;
          if (canMerge(rules, false) && !rules.some(stylehacks.detect)) {
            insertCloned(lastNode.parent, lastNode, {
              prop,
              value: wscValue
            });
            lastNode.value = minifyWsc(values);
            wscProp.remove();
            return true;
          }
          return false;
        });
      });
      let decls = getDecls(rule, directions);
      while (decls.length) {
        const lastNode = decls[decls.length - 1];
        wsc.forEach((d, i) => {
          const names = directions.filter((name) => name !== lastNode.prop).map((name) => `${name}-${d}`);
          let nodes = rule.nodes.slice(0, rule.nodes.indexOf(lastNode));
          const border = getLastNode(nodes, "border");
          if (border) {
            nodes = nodes.slice(nodes.indexOf(border));
          }
          const props = nodes.filter((node) => node.type === "decl" && names.includes(node.prop) && node.important === lastNode.important);
          const rules = getRules(props, names);
          if (hasAllProps(rules, ...names) && !rules.some(stylehacks.detect)) {
            const values = rules.map((node) => node ? node.value : null);
            const filteredValues = values.filter(Boolean);
            const lastNodeValue = list.space(lastNode.value)[i];
            values[directions.indexOf(lastNode.prop)] = lastNodeValue;
            let value = minifyTrbl(values.join(" "));
            if (filteredValues[0] === filteredValues[1] && filteredValues[1] === filteredValues[2]) {
              value = filteredValues[0];
            }
            let refNode = props[props.length - 1];
            if (value === lastNodeValue) {
              refNode = lastNode;
              let valueArray = list.space(lastNode.value);
              valueArray.splice(i, 1);
              lastNode.value = valueArray.join(" ");
            }
            insertCloned(refNode.parent, refNode, {
              prop: borderProperty(d),
              value
            });
            decls = decls.filter((node) => !rules.includes(node));
            for (const node of rules) {
              node.remove();
            }
          }
        });
        decls = decls.filter((node) => node !== lastNode);
      }
      rule.walkDecls("border", (decl) => {
        const nextDecl = decl.next();
        if (!nextDecl || nextDecl.type !== "decl") {
          return false;
        }
        const index = directions.indexOf(nextDecl.prop);
        if (index === -1) {
          return;
        }
        const values = parseWsc(decl.value);
        const nextValues = parseWsc(nextDecl.value);
        if (!isValidWsc(values) || !isValidWsc(nextValues)) {
          return;
        }
        const config = {
          values,
          nextValues,
          decl,
          nextDecl,
          index
        };
        return mergeRedundant(config);
      });
      rule.walkDecls(/^border($|-(top|right|bottom|left)$)/i, (decl) => {
        let values = parseWsc(decl.value);
        if (!isValidWsc(values)) {
          return;
        }
        const position = directions.indexOf(decl.prop);
        let dirs = [...directions];
        dirs.splice(position, 1);
        wsc.forEach((d, i) => {
          const props = dirs.map((dir) => `${dir}-${d}`);
          mergeRules(rule, [decl.prop, ...props], (rules) => {
            if (!rules.includes(decl)) {
              return false;
            }
            const longhands = rules.filter((p) => p !== decl);
            if (longhands[0].value.toLowerCase() === longhands[1].value.toLowerCase() && longhands[1].value.toLowerCase() === longhands[2].value.toLowerCase() && values[i] !== void 0 && longhands[0].value.toLowerCase() === values[i].toLowerCase()) {
              for (const node of longhands) {
                node.remove();
              }
              insertCloned(decl.parent, decl, {
                prop: borderProperty(d),
                value: values[i]
              });
              values[i] = null;
            }
            return false;
          });
          const newValue = values.join(" ");
          if (newValue) {
            decl.value = newValue;
          } else {
            decl.remove();
          }
        });
      });
      rule.walkDecls(/^border($|-(top|right|bottom|left)$)/i, (decl) => {
        decl.value = minifyWsc(decl.value);
      });
      rule.walkDecls(/^border-spacing$/i, (decl) => {
        const value = list.space(decl.value);
        if (value.length > 1 && value[0] === value[1]) {
          decl.value = value.slice(1).join(" ");
        }
      });
      decls = getDecls(rule, allProperties);
      while (decls.length) {
        const lastNode = decls[decls.length - 1];
        const lastPart = lastNode.prop.split("-").pop();
        const lesser = decls.filter((node) => !stylehacks.detect(lastNode) && !stylehacks.detect(node) && !isCustomProp(lastNode) && node !== lastNode && node.important === lastNode.important && getLevel(node.prop) > getLevel(lastNode.prop) && (node.prop.toLowerCase().includes(lastNode.prop) || node.prop.toLowerCase().endsWith(lastPart)));
        for (const node of lesser) {
          node.remove();
        }
        decls = decls.filter((node) => !lesser.includes(node));
        let duplicates = decls.filter((node) => !stylehacks.detect(lastNode) && !stylehacks.detect(node) && node !== lastNode && node.important === lastNode.important && node.prop === lastNode.prop && !(!isCustomProp(node) && isCustomProp(lastNode)));
        if (duplicates.length) {
          if (colorMightRequireFallback.test(getColorValue(lastNode))) {
            const preserve = duplicates.filter((node) => !colorMightRequireFallback.test(getColorValue(node))).pop();
            duplicates = duplicates.filter((node) => node !== preserve);
          }
          for (const node of duplicates) {
            node.remove();
          }
        }
        decls = decls.filter((node) => node !== lastNode && !duplicates.includes(node));
      }
    }
    module2.exports = {
      explode,
      merge
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/decl/columns.js
var require_columns2 = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/decl/columns.js"(exports2, module2) {
    "use strict";
    var { list } = require_postcss();
    var { unit } = require_lib();
    var stylehacks = require_src17();
    var canMerge = require_canMerge();
    var getDecls = require_getDecls();
    var getValue = require_getValue2();
    var mergeRules = require_mergeRules();
    var insertCloned = require_insertCloned();
    var isCustomProp = require_isCustomProp();
    var canExplode = require_canExplode();
    var properties = ["column-width", "column-count"];
    var auto = "auto";
    var inherit = "inherit";
    function normalize(values) {
      if (values[0].toLowerCase() === auto) {
        return values[1];
      }
      if (values[1].toLowerCase() === auto) {
        return values[0];
      }
      if (values[0].toLowerCase() === inherit && values[1].toLowerCase() === inherit) {
        return inherit;
      }
      return values.join(" ");
    }
    function explode(rule) {
      rule.walkDecls(/^columns$/i, (decl) => {
        if (!canExplode(decl)) {
          return;
        }
        if (stylehacks.detect(decl)) {
          return;
        }
        let values = list.space(decl.value);
        if (values.length === 1) {
          values.push(auto);
        }
        values.forEach((value, i) => {
          let prop = properties[1];
          const dimension = unit(value);
          if (value.toLowerCase() === auto) {
            prop = properties[i];
          } else if (dimension && dimension.unit !== "") {
            prop = properties[0];
          }
          insertCloned(decl.parent, decl, {
            prop,
            value
          });
        });
        decl.remove();
      });
    }
    function cleanup(rule) {
      let decls = getDecls(rule, ["columns"].concat(properties));
      while (decls.length) {
        const lastNode = decls[decls.length - 1];
        const lesser = decls.filter((node) => !stylehacks.detect(lastNode) && !stylehacks.detect(node) && node !== lastNode && node.important === lastNode.important && lastNode.prop === "columns" && node.prop !== lastNode.prop);
        for (const node of lesser) {
          node.remove();
        }
        decls = decls.filter((node) => !lesser.includes(node));
        let duplicates = decls.filter((node) => !stylehacks.detect(lastNode) && !stylehacks.detect(node) && node !== lastNode && node.important === lastNode.important && node.prop === lastNode.prop && !(!isCustomProp(node) && isCustomProp(lastNode)));
        for (const node of duplicates) {
          node.remove();
        }
        decls = decls.filter((node) => node !== lastNode && !duplicates.includes(node));
      }
    }
    function merge(rule) {
      mergeRules(rule, properties, (rules, lastNode) => {
        if (canMerge(rules) && !rules.some(stylehacks.detect)) {
          insertCloned(lastNode.parent, lastNode, {
            prop: "columns",
            value: normalize(rules.map(getValue))
          });
          for (const node of rules) {
            node.remove();
          }
          return true;
        }
        return false;
      });
      cleanup(rule);
    }
    module2.exports = {
      explode,
      merge
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/mergeValues.js
var require_mergeValues = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/mergeValues.js"(exports2, module2) {
    "use strict";
    var getValue = require_getValue2();
    module2.exports = (...rules) => rules.map(getValue).join(" ");
  }
});

// node_modules/postcss-merge-longhand/src/lib/decl/boxBase.js
var require_boxBase = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/decl/boxBase.js"(exports2, module2) {
    "use strict";
    var stylehacks = require_src17();
    var canMerge = require_canMerge();
    var getDecls = require_getDecls();
    var minifyTrbl = require_minifyTrbl();
    var parseTrbl = require_parseTrbl();
    var insertCloned = require_insertCloned();
    var mergeRules = require_mergeRules();
    var mergeValues = require_mergeValues();
    var trbl = require_trbl();
    var isCustomProp = require_isCustomProp();
    var canExplode = require_canExplode();
    module2.exports = (prop) => {
      const properties = trbl.map((direction) => `${prop}-${direction}`);
      const cleanup = (rule) => {
        let decls = getDecls(rule, [prop].concat(properties));
        while (decls.length) {
          const lastNode = decls[decls.length - 1];
          const lesser = decls.filter((node) => !stylehacks.detect(lastNode) && !stylehacks.detect(node) && node !== lastNode && node.important === lastNode.important && lastNode.prop === prop && node.prop !== lastNode.prop);
          for (const node of lesser) {
            node.remove();
          }
          decls = decls.filter((node) => !lesser.includes(node));
          let duplicates = decls.filter((node) => !stylehacks.detect(lastNode) && !stylehacks.detect(node) && node !== lastNode && node.important === lastNode.important && node.prop === lastNode.prop && !(!isCustomProp(node) && isCustomProp(lastNode)));
          for (const node of duplicates) {
            node.remove();
          }
          decls = decls.filter((node) => node !== lastNode && !duplicates.includes(node));
        }
      };
      const processor = {
        explode: (rule) => {
          rule.walkDecls(new RegExp("^" + prop + "$", "i"), (decl) => {
            if (!canExplode(decl)) {
              return;
            }
            if (stylehacks.detect(decl)) {
              return;
            }
            const values = parseTrbl(decl.value);
            trbl.forEach((direction, index) => {
              insertCloned(decl.parent, decl, {
                prop: properties[index],
                value: values[index]
              });
            });
            decl.remove();
          });
        },
        merge: (rule) => {
          mergeRules(rule, properties, (rules, lastNode) => {
            if (canMerge(rules) && !rules.some(stylehacks.detect)) {
              insertCloned(lastNode.parent, lastNode, {
                prop,
                value: minifyTrbl(mergeValues(...rules))
              });
              for (const node of rules) {
                node.remove();
              }
              return true;
            }
            return false;
          });
          cleanup(rule);
        }
      };
      return processor;
    };
  }
});

// node_modules/postcss-merge-longhand/src/lib/decl/margin.js
var require_margin = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/decl/margin.js"(exports2, module2) {
    "use strict";
    var base = require_boxBase();
    module2.exports = base("margin");
  }
});

// node_modules/postcss-merge-longhand/src/lib/decl/padding.js
var require_padding = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/decl/padding.js"(exports2, module2) {
    "use strict";
    var base = require_boxBase();
    module2.exports = base("padding");
  }
});

// node_modules/postcss-merge-longhand/src/lib/decl/index.js
var require_decl = __commonJS({
  "node_modules/postcss-merge-longhand/src/lib/decl/index.js"(exports2, module2) {
    "use strict";
    var borders = require_borders();
    var columns = require_columns2();
    var margin = require_margin();
    var padding = require_padding();
    module2.exports = [borders, columns, margin, padding];
  }
});

// node_modules/postcss-merge-longhand/src/index.js
var require_src18 = __commonJS({
  "node_modules/postcss-merge-longhand/src/index.js"(exports2, module2) {
    "use strict";
    var processors = require_decl();
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-merge-longhand",
        OnceExit(css) {
          css.walkRules((rule) => {
            processors.forEach((p) => {
              p.explode(rule);
              p.merge(rule);
            });
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-discard-duplicates/src/index.js
var require_src19 = __commonJS({
  "node_modules/postcss-discard-duplicates/src/index.js"(exports2, module2) {
    "use strict";
    function trimValue(value) {
      return value ? value.trim() : value;
    }
    function empty(node) {
      return !node.nodes.filter((child) => child.type !== "comment").length;
    }
    function equals(nodeA, nodeB) {
      const a = nodeA;
      const b = nodeB;
      if (a.type !== b.type) {
        return false;
      }
      if (a.important !== b.important) {
        return false;
      }
      if (a.raws && !b.raws || !a.raws && b.raws) {
        return false;
      }
      switch (a.type) {
        case "rule":
          if (a.selector !== b.selector) {
            return false;
          }
          break;
        case "atrule":
          if (a.name !== b.name || a.params !== b.params) {
            return false;
          }
          if (a.raws && trimValue(a.raws.before) !== trimValue(b.raws.before)) {
            return false;
          }
          if (a.raws && trimValue(a.raws.afterName) !== trimValue(b.raws.afterName)) {
            return false;
          }
          break;
        case "decl":
          if (a.prop !== b.prop || a.value !== b.value) {
            return false;
          }
          if (a.raws && trimValue(a.raws.before) !== trimValue(b.raws.before)) {
            return false;
          }
          break;
      }
      if (a.nodes) {
        if (a.nodes.length !== b.nodes.length) {
          return false;
        }
        for (let i = 0; i < a.nodes.length; i++) {
          if (!equals(a.nodes[i], b.nodes[i])) {
            return false;
          }
        }
      }
      return true;
    }
    function dedupeRule(last, nodes) {
      let index = nodes.indexOf(last) - 1;
      while (index >= 0) {
        const node = nodes[index--];
        if (node && node.type === "rule" && node.selector === last.selector) {
          last.each((child) => {
            if (child.type === "decl") {
              dedupeNode(child, node.nodes);
            }
          });
          if (empty(node)) {
            node.remove();
          }
        }
      }
    }
    function dedupeNode(last, nodes) {
      let index = nodes.includes(last) ? nodes.indexOf(last) - 1 : nodes.length - 1;
      while (index >= 0) {
        const node = nodes[index--];
        if (node && equals(node, last)) {
          node.remove();
        }
      }
    }
    function dedupe(root) {
      const { nodes } = root;
      if (!nodes) {
        return;
      }
      let index = nodes.length - 1;
      while (index >= 0) {
        let last = nodes[index--];
        if (!last || !last.parent) {
          continue;
        }
        dedupe(last);
        if (last.type === "rule") {
          dedupeRule(last, nodes);
        } else if (last.type === "atrule" || last.type === "decl") {
          dedupeNode(last, nodes);
        }
      }
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-discard-duplicates",
        OnceExit(css) {
          dedupe(css);
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-discard-overridden/src/index.js
var require_src20 = __commonJS({
  "node_modules/postcss-discard-overridden/src/index.js"(exports2, module2) {
    "use strict";
    var OVERRIDABLE_RULES = /* @__PURE__ */ new Set(["keyframes", "counter-style"]);
    var SCOPE_RULES = /* @__PURE__ */ new Set(["media", "supports"]);
    function vendorUnprefixed(prop) {
      return prop.replace(/^-\w+-/, "");
    }
    function isOverridable(name) {
      return OVERRIDABLE_RULES.has(vendorUnprefixed(name.toLowerCase()));
    }
    function isScope(name) {
      return SCOPE_RULES.has(vendorUnprefixed(name.toLowerCase()));
    }
    function getScope(node) {
      let current = node.parent;
      const chain = [node.name.toLowerCase(), node.params];
      while (current) {
        if (current.type === "atrule" && isScope(current.name)) {
          chain.unshift(current.name + " " + current.params);
        }
        current = current.parent;
      }
      return chain.join("|");
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-discard-overridden",
        prepare() {
          const cache = /* @__PURE__ */ new Map();
          const rules = [];
          return {
            OnceExit(css) {
              css.walkAtRules((node) => {
                if (isOverridable(node.name)) {
                  const scope = getScope(node);
                  cache.set(scope, node);
                  rules.push({
                    node,
                    scope
                  });
                }
              });
              rules.forEach((rule) => {
                if (cache.get(rule.scope) !== rule.node) {
                  rule.node.remove();
                }
              });
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-normalize-repeat-style/src/lib/map.js
var require_map = __commonJS({
  "node_modules/postcss-normalize-repeat-style/src/lib/map.js"(exports2, module2) {
    "use strict";
    module2.exports = /* @__PURE__ */ new Map([
      [["repeat", "no-repeat"].toString(), "repeat-x"],
      [["no-repeat", "repeat"].toString(), "repeat-y"],
      [["repeat", "repeat"].toString(), "repeat"],
      [["space", "space"].toString(), "space"],
      [["round", "round"].toString(), "round"],
      [["no-repeat", "no-repeat"].toString(), "no-repeat"]
    ]);
  }
});

// node_modules/postcss-normalize-repeat-style/src/index.js
var require_src21 = __commonJS({
  "node_modules/postcss-normalize-repeat-style/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var mappings = require_map();
    function evenValues(item, index) {
      return index % 2 === 0;
    }
    var repeatKeywords = new Set(mappings.values());
    function isCommaNode(node) {
      return node.type === "div" && node.value === ",";
    }
    function isVariableFunctionNode(node) {
      if (node.type !== "function") {
        return false;
      }
      return ["var", "env"].includes(node.value.toLowerCase());
    }
    function transform(value) {
      const parsed = valueParser(value);
      if (parsed.nodes.length === 1) {
        return value;
      }
      const ranges = [];
      let rangeIndex = 0;
      let shouldContinue = true;
      parsed.nodes.forEach((node, index) => {
        if (isCommaNode(node)) {
          rangeIndex += 1;
          shouldContinue = true;
          return;
        }
        if (!shouldContinue) {
          return;
        }
        if (node.type === "div" && node.value === "/") {
          shouldContinue = false;
          return;
        }
        if (!ranges[rangeIndex]) {
          ranges[rangeIndex] = {
            start: null,
            end: null
          };
        }
        if (isVariableFunctionNode(node)) {
          shouldContinue = false;
          ranges[rangeIndex].start = null;
          ranges[rangeIndex].end = null;
          return;
        }
        const isRepeatKeyword = node.type === "word" && repeatKeywords.has(node.value.toLowerCase());
        if (ranges[rangeIndex].start === null && isRepeatKeyword) {
          ranges[rangeIndex].start = index;
          ranges[rangeIndex].end = index;
          return;
        }
        if (ranges[rangeIndex].start !== null) {
          if (node.type === "space") {
            return;
          } else if (isRepeatKeyword) {
            ranges[rangeIndex].end = index;
            return;
          }
          return;
        }
      });
      ranges.forEach((range) => {
        if (range.start === null) {
          return;
        }
        const nodes = parsed.nodes.slice(range.start, range.end + 1);
        if (nodes.length !== 3) {
          return;
        }
        const key = nodes.filter(evenValues).map((n) => n.value.toLowerCase()).toString();
        const match = mappings.get(key);
        if (match) {
          nodes[0].value = match;
          nodes[1].value = nodes[2].value = "";
        }
      });
      return parsed.toString();
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-normalize-repeat-style",
        prepare() {
          const cache = /* @__PURE__ */ new Map();
          return {
            OnceExit(css) {
              css.walkDecls(/^(background(-repeat)?|(-\w+-)?mask-repeat)$/i, (decl) => {
                const value = decl.value;
                if (!value) {
                  return;
                }
                if (cache.has(value)) {
                  decl.value = cache.get(value);
                  return;
                }
                const result = transform(value);
                decl.value = result;
                cache.set(value, result);
              });
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-merge-rules/src/lib/ensureCompatibility.js
var require_ensureCompatibility = __commonJS({
  "node_modules/postcss-merge-rules/src/lib/ensureCompatibility.js"(exports2, module2) {
    "use strict";
    var { isSupported } = require_dist3();
    var selectorParser = require_dist4();
    var simpleSelectorRe = /^#?[-._a-z0-9 ]+$/i;
    var cssSel2 = "css-sel2";
    var cssSel3 = "css-sel3";
    var cssGencontent = "css-gencontent";
    var cssFirstLetter = "css-first-letter";
    var cssFirstLine = "css-first-line";
    var cssInOutOfRange = "css-in-out-of-range";
    var formValidation = "form-validation";
    var vendorPrefix = /-(ah|apple|atsc|epub|hp|khtml|moz|ms|o|rim|ro|tc|wap|webkit|xv)-/;
    var level2Sel = /* @__PURE__ */ new Set(["=", "~=", "|="]);
    var level3Sel = /* @__PURE__ */ new Set(["^=", "$=", "*="]);
    function filterPrefixes(selector) {
      return selector.match(vendorPrefix);
    }
    var findMsInputPlaceholder = (selector) => ~selector.search(/-ms-input-placeholder/i);
    function sameVendor(selectorsA, selectorsB) {
      let same = (selectors) => selectors.map(filterPrefixes).join();
      let findMsVendor = (selectors) => selectors.find(findMsInputPlaceholder);
      return same(selectorsA) === same(selectorsB) && !(findMsVendor(selectorsA) && findMsVendor(selectorsB));
    }
    function noVendor(selector) {
      return !vendorPrefix.test(selector);
    }
    var pseudoElements = {
      ":active": cssSel2,
      ":after": cssGencontent,
      ":any-link": "css-any-link",
      ":before": cssGencontent,
      ":checked": cssSel3,
      ":default": "css-default-pseudo",
      ":dir": "css-dir-pseudo",
      ":disabled": cssSel3,
      ":empty": cssSel3,
      ":enabled": cssSel3,
      ":first-child": cssSel2,
      ":first-letter": cssFirstLetter,
      ":first-line": cssFirstLine,
      ":first-of-type": cssSel3,
      ":focus": cssSel2,
      ":focus-within": "css-focus-within",
      ":focus-visible": "css-focus-visible",
      ":has": "css-has",
      ":hover": cssSel2,
      ":in-range": cssInOutOfRange,
      ":indeterminate": "css-indeterminate-pseudo",
      ":invalid": formValidation,
      ":is": "css-matches-pseudo",
      ":lang": cssSel2,
      ":last-child": cssSel3,
      ":last-of-type": cssSel3,
      ":link": cssSel2,
      ":matches": "css-matches-pseudo",
      ":not": cssSel3,
      ":nth-child": cssSel3,
      ":nth-last-child": cssSel3,
      ":nth-last-of-type": cssSel3,
      ":nth-of-type": cssSel3,
      ":only-child": cssSel3,
      ":only-of-type": cssSel3,
      ":optional": "css-optional-pseudo",
      ":out-of-range": cssInOutOfRange,
      ":placeholder-shown": "css-placeholder-shown",
      ":required": formValidation,
      ":root": cssSel3,
      ":target": cssSel3,
      "::after": cssGencontent,
      "::backdrop": "dialog",
      "::before": cssGencontent,
      "::first-letter": cssFirstLetter,
      "::first-line": cssFirstLine,
      "::marker": "css-marker-pseudo",
      "::placeholder": "css-placeholder",
      "::selection": "css-selection",
      ":valid": formValidation,
      ":visited": cssSel2
    };
    function isCssMixin(selector) {
      return selector[selector.length - 1] === ":";
    }
    function isHostPseudoClass(selector) {
      return selector.includes(":host");
    }
    var isSupportedCache = /* @__PURE__ */ new Map();
    function isSupportedCached(feature, browsers) {
      const key = JSON.stringify({ feature, browsers });
      let result = isSupportedCache.get(key);
      if (!result) {
        result = isSupported(feature, browsers);
        isSupportedCache.set(key, result);
      }
      return result;
    }
    function ensureCompatibility(selectors, browsers, compatibilityCache) {
      if (selectors.some(isCssMixin)) {
        return false;
      }
      if (selectors.some(isHostPseudoClass)) {
        return false;
      }
      return selectors.every((selector) => {
        if (simpleSelectorRe.test(selector)) {
          return true;
        }
        if (compatibilityCache && compatibilityCache.has(selector)) {
          return compatibilityCache.get(selector);
        }
        let compatible = true;
        selectorParser((ast) => {
          ast.walk((node) => {
            const { type, value } = node;
            if (type === "pseudo") {
              const entry = pseudoElements[value];
              if (!entry && noVendor(value)) {
                compatible = false;
              }
              if (entry && compatible) {
                compatible = isSupportedCached(entry, browsers);
              }
            }
            if (type === "combinator") {
              if (value.includes("~")) {
                compatible = isSupportedCached(cssSel3, browsers);
              }
              if (value.includes(">") || value.includes("+")) {
                compatible = isSupportedCached(cssSel2, browsers);
              }
            }
            if (type === "attribute" && node.attribute) {
              if (!node.operator) {
                compatible = isSupportedCached(cssSel2, browsers);
              }
              if (value) {
                if (level2Sel.has(node.operator)) {
                  compatible = isSupportedCached(cssSel2, browsers);
                }
                if (level3Sel.has(node.operator)) {
                  compatible = isSupportedCached(cssSel3, browsers);
                }
              }
              if (node.insensitive) {
                compatible = isSupportedCached("css-case-insensitive", browsers);
              }
            }
            if (!compatible) {
              return false;
            }
          });
        }).processSync(selector);
        if (compatibilityCache) {
          compatibilityCache.set(selector, compatible);
        }
        return compatible;
      });
    }
    module2.exports = { sameVendor, noVendor, pseudoElements, ensureCompatibility };
  }
});

// node_modules/postcss-merge-rules/src/index.js
var require_src22 = __commonJS({
  "node_modules/postcss-merge-rules/src/index.js"(exports2, module2) {
    "use strict";
    var browserslist = require_browserslist();
    var { sameParent } = require_src4();
    var {
      ensureCompatibility,
      sameVendor,
      noVendor
    } = require_ensureCompatibility();
    function declarationIsEqual(a, b) {
      return a.important === b.important && a.prop === b.prop && a.value === b.value;
    }
    function indexOfDeclaration(array, decl) {
      return array.findIndex((d) => declarationIsEqual(d, decl));
    }
    function intersect(a, b, not) {
      return a.filter((c) => {
        const index = indexOfDeclaration(b, c) !== -1;
        return not ? !index : index;
      });
    }
    function sameDeclarationsAndOrder(a, b) {
      if (a.length !== b.length) {
        return false;
      }
      return a.every((d, index) => declarationIsEqual(d, b[index]));
    }
    function canMerge(ruleA, ruleB, browsers, compatibilityCache) {
      const a = ruleA.selectors;
      const b = ruleB.selectors;
      const selectors = a.concat(b);
      if (!ensureCompatibility(selectors, browsers, compatibilityCache)) {
        return false;
      }
      const parent = sameParent(ruleA, ruleB);
      if (parent && ruleA.parent && ruleA.parent.type === "atrule" && ruleA.parent.name.includes("keyframes")) {
        return false;
      }
      return parent && (selectors.every(noVendor) || sameVendor(a, b));
    }
    function isDeclaration(node) {
      return node.type === "decl";
    }
    function getDecls(rule) {
      return rule.nodes.filter(isDeclaration);
    }
    var joinSelectors = (...rules) => rules.map((s) => s.selector).join();
    function ruleLength(...rules) {
      return rules.map((r) => r.nodes.length ? String(r) : "").join("").length;
    }
    function splitProp(prop) {
      const parts = prop.split("-");
      if (prop[0] !== "-") {
        return {
          prefix: "",
          base: parts[0],
          rest: parts.slice(1)
        };
      }
      if (prop[1] === "-") {
        return {
          prefix: null,
          base: null,
          rest: [prop]
        };
      }
      return {
        prefix: parts[1],
        base: parts[2],
        rest: parts.slice(3)
      };
    }
    function isConflictingProp(propA, propB) {
      if (propA === propB) {
        return true;
      }
      const a = splitProp(propA);
      const b = splitProp(propB);
      if (!a.base && !b.base) {
        return true;
      }
      if (a.base !== b.base) {
        return false;
      }
      if (a.rest.length !== b.rest.length) {
        return true;
      }
      return a.rest.every((s, index) => b.rest[index] === s);
    }
    function mergeParents(first, second) {
      if (!first.parent || !second.parent) {
        return false;
      }
      if (first.parent === second.parent) {
        return false;
      }
      second.remove();
      first.parent.append(second);
      return true;
    }
    function partialMerge(first, second) {
      let intersection = intersect(getDecls(first), getDecls(second));
      if (!intersection.length) {
        return second;
      }
      let nextRule = second.next();
      if (!nextRule) {
        const parentSibling = second.parent.next();
        nextRule = parentSibling && parentSibling.nodes && parentSibling.nodes[0];
      }
      if (nextRule && nextRule.type === "rule" && canMerge(second, nextRule)) {
        let nextIntersection = intersect(getDecls(second), getDecls(nextRule));
        if (nextIntersection.length > intersection.length) {
          mergeParents(second, nextRule);
          first = second;
          second = nextRule;
          intersection = nextIntersection;
        }
      }
      const firstDecls = getDecls(first);
      intersection = intersection.filter((decl, intersectIndex) => {
        const indexOfDecl = indexOfDeclaration(firstDecls, decl);
        const nextConflictInFirst = firstDecls.slice(indexOfDecl + 1).filter((d) => isConflictingProp(d.prop, decl.prop));
        if (!nextConflictInFirst.length) {
          return true;
        }
        const nextConflictInIntersection = intersection.slice(intersectIndex + 1).filter((d) => isConflictingProp(d.prop, decl.prop));
        if (!nextConflictInIntersection.length) {
          return false;
        }
        if (nextConflictInFirst.length !== nextConflictInIntersection.length) {
          return false;
        }
        return nextConflictInFirst.every((d, index) => declarationIsEqual(d, nextConflictInIntersection[index]));
      });
      const secondDecls = getDecls(second);
      intersection = intersection.filter((decl) => {
        const nextConflictIndex = secondDecls.findIndex((d) => isConflictingProp(d.prop, decl.prop));
        if (nextConflictIndex === -1) {
          return false;
        }
        if (!declarationIsEqual(secondDecls[nextConflictIndex], decl)) {
          return false;
        }
        if (decl.prop.toLowerCase() !== "direction" && decl.prop.toLowerCase() !== "unicode-bidi" && secondDecls.some((declaration) => declaration.prop.toLowerCase() === "all")) {
          return false;
        }
        secondDecls.splice(nextConflictIndex, 1);
        return true;
      });
      if (!intersection.length) {
        return second;
      }
      const receivingBlock = second.clone();
      receivingBlock.selector = joinSelectors(first, second);
      receivingBlock.nodes = [];
      second.parent.insertBefore(second, receivingBlock);
      const firstClone = first.clone();
      const secondClone = second.clone();
      function moveDecl(callback) {
        return (decl) => {
          if (indexOfDeclaration(intersection, decl) !== -1) {
            callback.call(this, decl);
          }
        };
      }
      firstClone.walkDecls(moveDecl((decl) => {
        decl.remove();
        receivingBlock.append(decl);
      }));
      secondClone.walkDecls(moveDecl((decl) => decl.remove()));
      const merged = ruleLength(firstClone, receivingBlock, secondClone);
      const original = ruleLength(first, second);
      if (merged < original) {
        first.replaceWith(firstClone);
        second.replaceWith(secondClone);
        [firstClone, receivingBlock, secondClone].forEach((r) => {
          if (!r.nodes.length) {
            r.remove();
          }
        });
        if (!secondClone.parent) {
          return receivingBlock;
        }
        return secondClone;
      } else {
        receivingBlock.remove();
        return second;
      }
    }
    function selectorMerger(browsers, compatibilityCache) {
      let cache = null;
      return function(rule) {
        if (!cache || !canMerge(rule, cache, browsers, compatibilityCache)) {
          cache = rule;
          return;
        }
        if (cache === rule) {
          cache = rule;
          return;
        }
        mergeParents(cache, rule);
        if (sameDeclarationsAndOrder(getDecls(rule), getDecls(cache))) {
          rule.selector = joinSelectors(cache, rule);
          cache.remove();
          cache = rule;
          return;
        }
        if (cache.selector === rule.selector) {
          const cached = getDecls(cache);
          rule.walk((node) => {
            if (node.type === "decl" && indexOfDeclaration(cached, node) !== -1) {
              node.remove();
              return;
            }
            cache.append(node);
          });
          rule.remove();
          return;
        }
        cache = partialMerge(cache, rule);
      };
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-merge-rules",
        prepare(result) {
          const resultOpts = result.opts || {};
          const browsers = browserslist(null, {
            stats: resultOpts.stats,
            path: __dirname,
            env: resultOpts.env
          });
          const compatibilityCache = /* @__PURE__ */ new Map();
          return {
            OnceExit(css) {
              css.walkRules(selectorMerger(browsers, compatibilityCache));
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-discard-empty/src/index.js
var require_src23 = __commonJS({
  "node_modules/postcss-discard-empty/src/index.js"(exports2, module2) {
    "use strict";
    var plugin = "postcss-discard-empty";
    function discardAndReport(css, result) {
      function discardEmpty(node) {
        const { type } = node;
        const sub = node.nodes;
        if (sub) {
          node.each(discardEmpty);
        }
        if (type === "decl" && !node.value && !node.prop.startsWith("--") || type === "rule" && !node.selector || sub && !sub.length || type === "atrule" && (!sub && !node.params || !node.params && !sub.length)) {
          node.remove();
          result.messages.push({
            type: "removal",
            plugin,
            node
          });
        }
      }
      css.each(discardEmpty);
    }
    function pluginCreator() {
      return {
        postcssPlugin: plugin,
        OnceExit(css, { result }) {
          discardAndReport(css, result);
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-unique-selectors/src/index.js
var require_src24 = __commonJS({
  "node_modules/postcss-unique-selectors/src/index.js"(exports2, module2) {
    "use strict";
    var selectorParser = require_dist4();
    function parseSelectors(selectors, callback) {
      return selectorParser(callback).processSync(selectors);
    }
    function unique(rule) {
      const selector = [...new Set(rule.selectors)];
      selector.sort();
      return selector.join();
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-unique-selectors",
        OnceExit(css) {
          css.walkRules((nodes) => {
            let comments = [];
            const removeAndSaveComments = (selNode) => {
              selNode.walk((sel) => {
                if (sel.type === "comment") {
                  comments.push(sel.value);
                  sel.remove();
                  return;
                } else {
                  return;
                }
              });
            };
            if (nodes.raws.selector && nodes.raws.selector.raw) {
              parseSelectors(nodes.raws.selector.raw, removeAndSaveComments);
              nodes.raws.selector.raw = unique(nodes);
            }
            nodes.selector = parseSelectors(nodes.selector, removeAndSaveComments);
            nodes.selector = unique(nodes);
            nodes.selectors = nodes.selectors.concat(comments);
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-normalize-string/src/index.js
var require_src25 = __commonJS({
  "node_modules/postcss-normalize-string/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var SINGLE_QUOTE = "'".charCodeAt(0);
    var DOUBLE_QUOTE = '"'.charCodeAt(0);
    var BACKSLASH = "\\".charCodeAt(0);
    var NEWLINE = "\n".charCodeAt(0);
    var SPACE = " ".charCodeAt(0);
    var FEED = "\f".charCodeAt(0);
    var TAB = "	".charCodeAt(0);
    var CR = "\r".charCodeAt(0);
    var WORD_END = /[ \n\t\r\f'"\\]/g;
    var C_STRING = "string";
    var C_ESCAPED_SINGLE_QUOTE = "escapedSingleQuote";
    var C_ESCAPED_DOUBLE_QUOTE = "escapedDoubleQuote";
    var C_SINGLE_QUOTE = "singleQuote";
    var C_DOUBLE_QUOTE = "doubleQuote";
    var C_NEWLINE = "newline";
    var C_SINGLE = "single";
    var L_SINGLE_QUOTE = `'`;
    var L_DOUBLE_QUOTE = `"`;
    var L_NEWLINE = `\\
`;
    var T_ESCAPED_SINGLE_QUOTE = { type: C_ESCAPED_SINGLE_QUOTE, value: `\\'` };
    var T_ESCAPED_DOUBLE_QUOTE = { type: C_ESCAPED_DOUBLE_QUOTE, value: `\\"` };
    var T_SINGLE_QUOTE = { type: C_SINGLE_QUOTE, value: L_SINGLE_QUOTE };
    var T_DOUBLE_QUOTE = { type: C_DOUBLE_QUOTE, value: L_DOUBLE_QUOTE };
    var T_NEWLINE = { type: C_NEWLINE, value: L_NEWLINE };
    function stringify(ast) {
      return ast.nodes.reduce((str, { value }) => {
        if (value === L_NEWLINE) {
          return str;
        }
        return str + value;
      }, "");
    }
    function parse(str) {
      let code, next, value;
      let pos = 0;
      let len = str.length;
      const ast = {
        nodes: [],
        types: {
          escapedSingleQuote: 0,
          escapedDoubleQuote: 0,
          singleQuote: 0,
          doubleQuote: 0
        },
        quotes: false
      };
      while (pos < len) {
        code = str.charCodeAt(pos);
        switch (code) {
          case SPACE:
          case TAB:
          case CR:
          case FEED:
            next = pos;
            do {
              next += 1;
              code = str.charCodeAt(next);
            } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
            ast.nodes.push({
              type: "space",
              value: str.slice(pos, next)
            });
            pos = next - 1;
            break;
          case SINGLE_QUOTE:
            ast.nodes.push(T_SINGLE_QUOTE);
            ast.types[C_SINGLE_QUOTE]++;
            ast.quotes = true;
            break;
          case DOUBLE_QUOTE:
            ast.nodes.push(T_DOUBLE_QUOTE);
            ast.types[C_DOUBLE_QUOTE]++;
            ast.quotes = true;
            break;
          case BACKSLASH:
            next = pos + 1;
            if (str.charCodeAt(next) === SINGLE_QUOTE) {
              ast.nodes.push(T_ESCAPED_SINGLE_QUOTE);
              ast.types[C_ESCAPED_SINGLE_QUOTE]++;
              ast.quotes = true;
              pos = next;
              break;
            } else if (str.charCodeAt(next) === DOUBLE_QUOTE) {
              ast.nodes.push(T_ESCAPED_DOUBLE_QUOTE);
              ast.types[C_ESCAPED_DOUBLE_QUOTE]++;
              ast.quotes = true;
              pos = next;
              break;
            } else if (str.charCodeAt(next) === NEWLINE) {
              ast.nodes.push(T_NEWLINE);
              pos = next;
              break;
            }
          default:
            WORD_END.lastIndex = pos + 1;
            WORD_END.test(str);
            if (WORD_END.lastIndex === 0) {
              next = len - 1;
            } else {
              next = WORD_END.lastIndex - 2;
            }
            value = str.slice(pos, next + 1);
            ast.nodes.push({
              type: C_STRING,
              value
            });
            pos = next;
        }
        pos++;
      }
      return ast;
    }
    function changeWrappingQuotes(node, ast) {
      const { types } = ast;
      if (types[C_SINGLE_QUOTE] || types[C_DOUBLE_QUOTE]) {
        return;
      }
      if (node.quote === L_SINGLE_QUOTE && types[C_ESCAPED_SINGLE_QUOTE] > 0 && !types[C_ESCAPED_DOUBLE_QUOTE]) {
        node.quote = L_DOUBLE_QUOTE;
      }
      if (node.quote === L_DOUBLE_QUOTE && types[C_ESCAPED_DOUBLE_QUOTE] > 0 && !types[C_ESCAPED_SINGLE_QUOTE]) {
        node.quote = L_SINGLE_QUOTE;
      }
      ast.nodes = changeChildQuotes(ast.nodes, node.quote);
    }
    function changeChildQuotes(childNodes, parentQuote) {
      const updatedChildren = [];
      for (const child of childNodes) {
        if (child.type === C_ESCAPED_DOUBLE_QUOTE && parentQuote === L_SINGLE_QUOTE) {
          updatedChildren.push(T_DOUBLE_QUOTE);
        } else if (child.type === C_ESCAPED_SINGLE_QUOTE && parentQuote === L_DOUBLE_QUOTE) {
          updatedChildren.push(T_SINGLE_QUOTE);
        } else {
          updatedChildren.push(child);
        }
      }
      return updatedChildren;
    }
    function normalize(value, preferredQuote) {
      if (!value || !value.length) {
        return value;
      }
      return valueParser(value).walk((child) => {
        if (child.type !== C_STRING) {
          return;
        }
        const ast = parse(child.value);
        if (ast.quotes) {
          changeWrappingQuotes(child, ast);
        } else if (preferredQuote === C_SINGLE) {
          child.quote = L_SINGLE_QUOTE;
        } else {
          child.quote = L_DOUBLE_QUOTE;
        }
        child.value = stringify(ast);
      }).toString();
    }
    function minify(original, cache, preferredQuote) {
      const key = original + "|" + preferredQuote;
      if (cache.has(key)) {
        return cache.get(key);
      }
      const newValue = normalize(original, preferredQuote);
      cache.set(key, newValue);
      return newValue;
    }
    function pluginCreator(opts) {
      const { preferredQuote } = Object.assign({}, {
        preferredQuote: "double"
      }, opts);
      return {
        postcssPlugin: "postcss-normalize-string",
        OnceExit(css) {
          const cache = /* @__PURE__ */ new Map();
          css.walk((node) => {
            switch (node.type) {
              case "rule":
                node.selector = minify(node.selector, cache, preferredQuote);
                break;
              case "decl":
                node.value = minify(node.value, cache, preferredQuote);
                break;
              case "atrule":
                node.params = minify(node.params, cache, preferredQuote);
                break;
            }
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-normalize-positions/src/index.js
var require_src26 = __commonJS({
  "node_modules/postcss-normalize-positions/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var directionKeywords = /* @__PURE__ */ new Set(["top", "right", "bottom", "left", "center"]);
    var center = "50%";
    var horizontal = /* @__PURE__ */ new Map([
      ["right", "100%"],
      ["left", "0"]
    ]);
    var verticalValue = /* @__PURE__ */ new Map([
      ["bottom", "100%"],
      ["top", "0"]
    ]);
    var mathFunctions = /* @__PURE__ */ new Set(["calc", "min", "max", "clamp"]);
    function isCommaNode(node) {
      return node.type === "div" && node.value === ",";
    }
    function isVariableFunctionNode(node) {
      if (node.type !== "function") {
        return false;
      }
      return ["var", "env"].includes(node.value.toLowerCase());
    }
    function isMathFunctionNode(node) {
      if (node.type !== "function") {
        return false;
      }
      return mathFunctions.has(node.value.toLowerCase());
    }
    function isNumberNode(node) {
      if (node.type !== "word") {
        return false;
      }
      const value = parseFloat(node.value);
      return !isNaN(value);
    }
    function isDimensionNode(node) {
      if (node.type !== "word") {
        return false;
      }
      const parsed = valueParser.unit(node.value);
      if (!parsed) {
        return false;
      }
      return parsed.unit !== "";
    }
    function transform(value) {
      const parsed = valueParser(value);
      const ranges = [];
      let rangeIndex = 0;
      let shouldContinue = true;
      parsed.nodes.forEach((node, index) => {
        if (isCommaNode(node)) {
          rangeIndex += 1;
          shouldContinue = true;
          return;
        }
        if (!shouldContinue) {
          return;
        }
        if (node.type === "div" && node.value === "/") {
          shouldContinue = false;
          return;
        }
        if (!ranges[rangeIndex]) {
          ranges[rangeIndex] = {
            start: null,
            end: null
          };
        }
        if (isVariableFunctionNode(node)) {
          shouldContinue = false;
          ranges[rangeIndex].start = null;
          ranges[rangeIndex].end = null;
          return;
        }
        const isPositionKeyword = node.type === "word" && directionKeywords.has(node.value.toLowerCase()) || isDimensionNode(node) || isNumberNode(node) || isMathFunctionNode(node);
        if (ranges[rangeIndex].start === null && isPositionKeyword) {
          ranges[rangeIndex].start = index;
          ranges[rangeIndex].end = index;
          return;
        }
        if (ranges[rangeIndex].start !== null) {
          if (node.type === "space") {
            return;
          } else if (isPositionKeyword) {
            ranges[rangeIndex].end = index;
            return;
          }
          return;
        }
      });
      ranges.forEach((range) => {
        if (range.start === null) {
          return;
        }
        const nodes = parsed.nodes.slice(range.start, range.end + 1);
        if (nodes.length > 3) {
          return;
        }
        const firstNode = nodes[0].value.toLowerCase();
        const secondNode = nodes[2] && nodes[2].value ? nodes[2].value.toLowerCase() : null;
        if (nodes.length === 1 || secondNode === "center") {
          if (secondNode) {
            nodes[2].value = nodes[1].value = "";
          }
          const map = new Map([...horizontal, ["center", center]]);
          if (map.has(firstNode)) {
            nodes[0].value = map.get(firstNode);
          }
          return;
        }
        if (secondNode !== null) {
          if (firstNode === "center" && directionKeywords.has(secondNode)) {
            nodes[0].value = nodes[1].value = "";
            if (horizontal.has(secondNode)) {
              nodes[2].value = horizontal.get(secondNode);
            }
            return;
          }
          if (horizontal.has(firstNode) && verticalValue.has(secondNode)) {
            nodes[0].value = horizontal.get(firstNode);
            nodes[2].value = verticalValue.get(secondNode);
            return;
          } else if (verticalValue.has(firstNode) && horizontal.has(secondNode)) {
            nodes[0].value = horizontal.get(secondNode);
            nodes[2].value = verticalValue.get(firstNode);
            return;
          }
        }
      });
      return parsed.toString();
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-normalize-positions",
        OnceExit(css) {
          const cache = /* @__PURE__ */ new Map();
          css.walkDecls(/^(background(-position)?|(-\w+-)?perspective-origin)$/i, (decl) => {
            const value = decl.value;
            if (!value) {
              return;
            }
            if (cache.has(value)) {
              decl.value = cache.get(value);
              return;
            }
            const result = transform(value);
            decl.value = result;
            cache.set(value, result);
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-normalize-whitespace/src/index.js
var require_src27 = __commonJS({
  "node_modules/postcss-normalize-whitespace/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var atrule = "atrule";
    var decl = "decl";
    var rule = "rule";
    var variableFunctions = /* @__PURE__ */ new Set(["var", "env", "constant"]);
    function reduceCalcWhitespaces(node) {
      if (node.type === "space") {
        node.value = " ";
      } else if (node.type === "function") {
        if (!variableFunctions.has(node.value.toLowerCase())) {
          node.before = node.after = "";
        }
      }
    }
    function reduceWhitespaces(node) {
      if (node.type === "space") {
        node.value = " ";
      } else if (node.type === "div") {
        node.before = node.after = "";
      } else if (node.type === "function") {
        if (!variableFunctions.has(node.value.toLowerCase())) {
          node.before = node.after = "";
        }
        if (node.value.toLowerCase() === "calc") {
          valueParser.walk(node.nodes, reduceCalcWhitespaces);
          return false;
        }
      }
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-normalize-whitespace",
        OnceExit(css) {
          const cache = /* @__PURE__ */ new Map();
          css.walk((node) => {
            const { type } = node;
            if ([decl, rule, atrule].includes(type) && node.raws.before) {
              node.raws.before = node.raws.before.replace(/\s/g, "");
            }
            if (type === decl) {
              if (node.important) {
                node.raws.important = "!important";
              }
              node.value = node.value.replace(/\s*(\\9)\s*/, "$1");
              const value = node.value;
              if (cache.has(value)) {
                node.value = cache.get(value);
              } else {
                const parsed = valueParser(node.value);
                const result = parsed.walk(reduceWhitespaces).toString();
                node.value = result;
                cache.set(value, result);
              }
              if (node.prop.startsWith("--") && node.value === "") {
                node.value = " ";
              }
              if (node.raws.before) {
                const prev = node.prev();
                if (prev && prev.type !== rule) {
                  node.raws.before = node.raws.before.replace(/;/g, "");
                }
              }
              node.raws.between = ":";
              node.raws.semicolon = false;
            } else if (type === rule || type === atrule) {
              node.raws.between = node.raws.after = "";
              node.raws.semicolon = false;
            }
          });
          css.raws.after = "";
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-normalize-unicode/src/index.js
var require_src28 = __commonJS({
  "node_modules/postcss-normalize-unicode/src/index.js"(exports2, module2) {
    "use strict";
    var browserslist = require_browserslist();
    var valueParser = require_lib();
    var regexLowerCaseUPrefix = /^u(?=\+)/;
    function unicode(range) {
      const values = range.slice(2).split("-");
      if (values.length < 2) {
        return range;
      }
      const left = values[0].split("");
      const right = values[1].split("");
      if (left.length !== right.length) {
        return range;
      }
      const merged = mergeRangeBounds(left, right);
      if (merged) {
        return merged;
      }
      return range;
    }
    function mergeRangeBounds(left, right) {
      let questionCounter = 0;
      let group = "u+";
      for (const [index, value] of left.entries()) {
        if (value === right[index] && questionCounter === 0) {
          group = group + value;
        } else if (value === "0" && right[index] === "f") {
          questionCounter++;
          group = group + "?";
        } else {
          return false;
        }
      }
      if (questionCounter < 6) {
        return group;
      } else {
        return false;
      }
    }
    function hasLowerCaseUPrefixBug(browser) {
      return browserslist("ie <=11, edge <= 15").includes(browser);
    }
    function transform(value, isLegacy = false) {
      return valueParser(value).walk((child) => {
        if (child.type === "unicode-range") {
          const transformed = unicode(child.value.toLowerCase());
          child.value = isLegacy ? transformed.replace(regexLowerCaseUPrefix, "U") : transformed;
        }
        return false;
      }).toString();
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-normalize-unicode",
        prepare(result) {
          const cache = /* @__PURE__ */ new Map();
          const resultOpts = result.opts || {};
          const browsers = browserslist(null, {
            stats: resultOpts.stats,
            path: __dirname,
            env: resultOpts.env
          });
          const isLegacy = browsers.some(hasLowerCaseUPrefixBug);
          return {
            OnceExit(css) {
              css.walkDecls(/^unicode-range$/i, (decl) => {
                const value = decl.value;
                if (cache.has(value)) {
                  decl.value = cache.get(value);
                  return;
                }
                const newValue = transform(value, isLegacy);
                decl.value = newValue;
                cache.set(value, newValue);
              });
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-normalize-display-values/src/lib/map.js
var require_map2 = __commonJS({
  "node_modules/postcss-normalize-display-values/src/lib/map.js"(exports2, module2) {
    "use strict";
    var block = "block";
    var flex = "flex";
    var flow = "flow";
    var flowRoot = "flow-root";
    var grid = "grid";
    var inline = "inline";
    var inlineBlock = "inline-block";
    var inlineFlex = "inline-flex";
    var inlineGrid = "inline-grid";
    var inlineTable = "inline-table";
    var listItem = "list-item";
    var ruby = "ruby";
    var rubyBase = "ruby-base";
    var rubyText = "ruby-text";
    var runIn = "run-in";
    var table = "table";
    var tableCell = "table-cell";
    var tableCaption = "table-caption";
    module2.exports = /* @__PURE__ */ new Map([
      [[block, flow].toString(), block],
      [[block, flowRoot].toString(), flowRoot],
      [[inline, flow].toString(), inline],
      [[inline, flowRoot].toString(), inlineBlock],
      [[runIn, flow].toString(), runIn],
      [[listItem, block, flow].toString(), listItem],
      [[inline, flow, listItem].toString(), inline + " " + listItem],
      [[block, flex].toString(), flex],
      [[inline, flex].toString(), inlineFlex],
      [[block, grid].toString(), grid],
      [[inline, grid].toString(), inlineGrid],
      [[inline, ruby].toString(), ruby],
      [[block, table].toString(), table],
      [[inline, table].toString(), inlineTable],
      [[tableCell, flow].toString(), tableCell],
      [[tableCaption, flow].toString(), tableCaption],
      [[rubyBase, flow].toString(), rubyBase],
      [[rubyText, flow].toString(), rubyText]
    ]);
  }
});

// node_modules/postcss-normalize-display-values/src/index.js
var require_src29 = __commonJS({
  "node_modules/postcss-normalize-display-values/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var mappings = require_map2();
    function transform(value) {
      const { nodes } = valueParser(value);
      if (nodes.length === 1) {
        return value;
      }
      const values = nodes.filter((list, index) => index % 2 === 0).filter((node) => node.type === "word").map((n) => n.value.toLowerCase());
      if (values.length === 0) {
        return value;
      }
      const match = mappings.get(values.toString());
      if (!match) {
        return value;
      }
      return match;
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-normalize-display-values",
        prepare() {
          const cache = /* @__PURE__ */ new Map();
          return {
            OnceExit(css) {
              css.walkDecls(/^display$/i, (decl) => {
                const value = decl.value;
                if (!value) {
                  return;
                }
                if (cache.has(value)) {
                  decl.value = cache.get(value);
                  return;
                }
                const result = transform(value);
                decl.value = result;
                cache.set(value, result);
              });
            }
          };
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/postcss-normalize-timing-functions/src/index.js
var require_src30 = __commonJS({
  "node_modules/postcss-normalize-timing-functions/src/index.js"(exports2, module2) {
    "use strict";
    var valueParser = require_lib();
    var getValue = (node) => parseFloat(node.value);
    var conversions = /* @__PURE__ */ new Map([
      [[0.25, 0.1, 0.25, 1].toString(), "ease"],
      [[0, 0, 1, 1].toString(), "linear"],
      [[0.42, 0, 1, 1].toString(), "ease-in"],
      [[0, 0, 0.58, 1].toString(), "ease-out"],
      [[0.42, 0, 0.58, 1].toString(), "ease-in-out"]
    ]);
    function reduce(node) {
      if (node.type !== "function") {
        return false;
      }
      if (!node.value) {
        return;
      }
      const lowerCasedValue = node.value.toLowerCase();
      if (lowerCasedValue === "steps") {
        if (node.nodes[0].type === "word" && getValue(node.nodes[0]) === 1 && node.nodes[2] && node.nodes[2].type === "word" && (node.nodes[2].value.toLowerCase() === "start" || node.nodes[2].value.toLowerCase() === "jump-start")) {
          node.type = "word";
          node.value = "step-start";
          delete node.nodes;
          return;
        }
        if (node.nodes[0].type === "word" && getValue(node.nodes[0]) === 1 && node.nodes[2] && node.nodes[2].type === "word" && (node.nodes[2].value.toLowerCase() === "end" || node.nodes[2].value.toLowerCase() === "jump-end")) {
          node.type = "word";
          node.value = "step-end";
          delete node.nodes;
          return;
        }
        if (node.nodes[2] && node.nodes[2].type === "word" && (node.nodes[2].value.toLowerCase() === "end" || node.nodes[2].value.toLowerCase() === "jump-end")) {
          node.nodes = [node.nodes[0]];
          return;
        }
        return false;
      }
      if (lowerCasedValue === "cubic-bezier") {
        const values = node.nodes.filter((list, index) => {
          return index % 2 === 0;
        }).map(getValue);
        if (values.length !== 4) {
          return;
        }
        const match = conversions.get(values.toString());
        if (match) {
          node.type = "word";
          node.value = match;
          delete node.nodes;
          return;
        }
      }
    }
    function transform(value) {
      return valueParser(value).walk(reduce).toString();
    }
    function pluginCreator() {
      return {
        postcssPlugin: "postcss-normalize-timing-functions",
        OnceExit(css) {
          const cache = /* @__PURE__ */ new Map();
          css.walkDecls(/^(-\w+-)?(animation|transition)(-timing-function)?$/i, (decl) => {
            const value = decl.value;
            if (cache.has(value)) {
              decl.value = cache.get(value);
              return;
            }
            const result = transform(value);
            decl.value = result;
            cache.set(value, result);
          });
        }
      };
    }
    pluginCreator.postcss = true;
    module2.exports = pluginCreator;
  }
});

// node_modules/cssnano-preset-default/src/index.js
var require_src31 = __commonJS({
  "node_modules/cssnano-preset-default/src/index.js"(exports2, module2) {
    "use strict";
    var cssDeclarationSorter = require_main();
    var postcssDiscardComments = require_src2();
    var postcssReduceInitial = require_src3();
    var postcssMinifyGradients = require_src5();
    var postcssSvgo = require_src6();
    var postcssReduceTransforms = require_src7();
    var postcssConvertValues = require_src8();
    var postcssCalc = require_src9();
    var postcssColormin = require_src10();
    var postcssOrderedValues = require_src11();
    var postcssMinifySelectors = require_src12();
    var postcssMinifyParams = require_src13();
    var postcssNormalizeCharset = require_src14();
    var postcssMinifyFontValues = require_src15();
    var postcssNormalizeUrl = require_src16();
    var postcssMergeLonghand = require_src18();
    var postcssDiscardDuplicates = require_src19();
    var postcssDiscardOverridden = require_src20();
    var postcssNormalizeRepeatStyle = require_src21();
    var postcssMergeRules = require_src22();
    var postcssDiscardEmpty = require_src23();
    var postcssUniqueSelectors = require_src24();
    var postcssNormalizeString = require_src25();
    var postcssNormalizePositions = require_src26();
    var postcssNormalizeWhitespace = require_src27();
    var postcssNormalizeUnicode = require_src28();
    var postcssNormalizeDisplayValues = require_src29();
    var postcssNormalizeTimingFunctions = require_src30();
    var { rawCache } = require_src4();
    var defaultOpts = {
      convertValues: {
        length: false
      },
      normalizeCharset: {
        add: false
      },
      cssDeclarationSorter: {
        keepOverrides: true
      }
    };
    function defaultPreset(opts = {}) {
      const options = Object.assign({}, defaultOpts, opts);
      const plugins = [
        [postcssDiscardComments, options.discardComments],
        [postcssMinifyGradients, options.minifyGradients],
        [postcssReduceInitial, options.reduceInitial],
        [postcssSvgo, options.svgo],
        [postcssNormalizeDisplayValues, options.normalizeDisplayValues],
        [postcssReduceTransforms, options.reduceTransforms],
        [postcssColormin, options.colormin],
        [postcssNormalizeTimingFunctions, options.normalizeTimingFunctions],
        [postcssCalc, options.calc],
        [postcssConvertValues, options.convertValues],
        [postcssOrderedValues, options.orderedValues],
        [postcssMinifySelectors, options.minifySelectors],
        [postcssMinifyParams, options.minifyParams],
        [postcssNormalizeCharset, options.normalizeCharset],
        [postcssDiscardOverridden, options.discardOverridden],
        [postcssNormalizeString, options.normalizeString],
        [postcssNormalizeUnicode, options.normalizeUnicode],
        [postcssMinifyFontValues, options.minifyFontValues],
        [postcssNormalizeUrl, options.normalizeUrl],
        [postcssNormalizeRepeatStyle, options.normalizeRepeatStyle],
        [postcssNormalizePositions, options.normalizePositions],
        [postcssNormalizeWhitespace, options.normalizeWhitespace],
        [postcssMergeLonghand, options.mergeLonghand],
        [postcssDiscardDuplicates, options.discardDuplicates],
        [postcssMergeRules, options.mergeRules],
        [postcssDiscardEmpty, options.discardEmpty],
        [postcssUniqueSelectors, options.uniqueSelectors],
        [cssDeclarationSorter, options.cssDeclarationSorter],
        [rawCache, options.rawCache]
      ];
      return { plugins };
    }
    module2.exports = defaultPreset;
  }
});

// node_modules/cssnano/src/index.js
var require_src32 = __commonJS({
  "node_modules/cssnano/src/index.js"(exports2, module2) {
    "use strict";
    var path = require("path");
    var postcss = require_postcss();
    var yaml = require_yaml();
    var { lilconfigSync } = require_dist2();
    var cssnano = "cssnano";
    function isResolvable(moduleId) {
      try {
        require.resolve(moduleId);
        return true;
      } catch (e) {
        return false;
      }
    }
    function resolvePreset(preset) {
      let fn, options;
      if (Array.isArray(preset)) {
        fn = preset[0];
        options = preset[1];
      } else {
        fn = preset;
        options = {};
      }
      if (preset.plugins) {
        return preset.plugins;
      }
      if (fn === "default") {
        return require_src31()(options).plugins;
      }
      if (typeof fn === "function") {
        return fn(options).plugins;
      }
      if (isResolvable(fn)) {
        return require(fn)(options).plugins;
      }
      const sugar = `cssnano-preset-${fn}`;
      if (isResolvable(sugar)) {
        return require(sugar)(options).plugins;
      }
      throw new Error(`Cannot load preset "${fn}". Please check your configuration for errors and try again.`);
    }
    function resolveConfig(options) {
      if (options.preset) {
        return resolvePreset(options.preset);
      }
      let searchPath = process.cwd();
      let configPath = void 0;
      if (options.configFile) {
        searchPath = void 0;
        configPath = path.resolve(process.cwd(), options.configFile);
      }
      const configExplorer = lilconfigSync(cssnano, {
        searchPlaces: [
          "package.json",
          ".cssnanorc",
          ".cssnanorc.json",
          ".cssnanorc.yaml",
          ".cssnanorc.yml",
          ".cssnanorc.js",
          "cssnano.config.js"
        ],
        loaders: {
          ".yaml": (filepath, content) => yaml.parse(content),
          ".yml": (filepath, content) => yaml.parse(content)
        }
      });
      const config = configPath ? configExplorer.load(configPath) : configExplorer.search(searchPath);
      if (config === null) {
        return resolvePreset("default");
      }
      return resolvePreset(config.config.preset || config.config);
    }
    function cssnanoPlugin(options = {}) {
      if (Array.isArray(options.plugins)) {
        if (!options.preset || !options.preset.plugins) {
          options.preset = { plugins: [] };
        }
        options.plugins.forEach((plugin) => {
          if (Array.isArray(plugin)) {
            const [pluginDef, opts = {}] = plugin;
            if (typeof pluginDef === "string" && isResolvable(pluginDef)) {
              options.preset.plugins.push([require(pluginDef), opts]);
            } else {
              options.preset.plugins.push([pluginDef, opts]);
            }
          } else if (typeof plugin === "string" && isResolvable(plugin)) {
            options.preset.plugins.push([require(plugin), {}]);
          } else {
            options.preset.plugins.push([plugin, {}]);
          }
        });
      }
      const plugins = [];
      const nanoPlugins = resolveConfig(options);
      for (const nanoPlugin of nanoPlugins) {
        if (Array.isArray(nanoPlugin)) {
          const [processor, opts] = nanoPlugin;
          if (typeof opts === "undefined" || typeof opts === "object" && !opts.exclude || typeof opts === "boolean" && opts === true) {
            plugins.push(processor(opts));
          }
        } else {
          plugins.push(nanoPlugin);
        }
      }
      return postcss(plugins);
    }
    cssnanoPlugin.postcss = true;
    module2.exports = cssnanoPlugin;
  }
});

// lib/cli-peer-dependencies.js
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.lazyPostcss = lazyPostcss;
exports.lazyPostcssImport = lazyPostcssImport;
exports.lazyAutoprefixer = lazyAutoprefixer;
exports.lazyCssnano = lazyCssnano;
function lazyPostcss() {
  return require_postcss();
}
function lazyPostcssImport() {
  return require_postcss_import();
}
function lazyAutoprefixer() {
  return require_autoprefixer();
}
function lazyCssnano() {
  return require_src32();
}
/*! https://mths.be/cssesc v3.0.0 by @mathias */
/**
 * @author Ben Briggs
 * @license MIT
 * @module cssnano:preset:default
 * @overview
 *
 * This default preset for cssnano only includes transforms that make no
 * assumptions about your CSS other than what is passed in. In previous
 * iterations of cssnano, assumptions were made about your CSS which caused
 * output to look different in certain use cases, but not others. These
 * transforms have been moved from the defaults to other presets, to make
 * this preset require only minimal configuration.
 */
/**
 * @license Fraction.js v4.2.0 05/03/2022
 * https://www.xarg.org/2014/03/rational-numbers-in-javascript/
 *
 * Copyright (c) 2021, Robert Eisele (robert@xarg.org)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 **/
//! stable.js 0.1.8, https://github.com/Two-Screen/stable
//! © 2018 Angry Bytes and contributors. MIT licensed.