@lvce-editor/server 0.16.9 → 0.16.11

package/static/{c1ca266 → 9243b38}/packages/renderer-process/dist/rendererProcessMain.js

@@ -1619,637 +1619,47 @@ var init_babel_parser = __esm({
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      const defaultOptions = {
-        sourceType: "script",
-        sourceFilename: void 0,
-        startColumn: 0,
-        startLine: 1,
-        allowAwaitOutsideFunction: false,
-        allowReturnOutsideFunction: false,
-        allowNewTargetOutsideFunction: false,
-        allowImportExportEverywhere: false,
-        allowSuperOutsideMethod: false,
-        allowUndeclaredExports: false,
-        plugins: [],
-        strictMode: null,
-        ranges: false,
-        tokens: false,
-        createParenthesizedExpressions: false,
-        errorRecovery: false,
-        attachComment: true,
-        annexB: true
-      };
-      function getOptions(opts) {
-        if (opts && opts.annexB != null && opts.annexB !== false) {
-          throw new Error("The `annexB` option can only be set to `false`.");
-        }
-        const options = {};
-        for (const key of Object.keys(defaultOptions)) {
-          options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
+      function _objectWithoutPropertiesLoose(source, excluded) {
+        if (source == null)
+          return {};
+        var target = {};
+        var sourceKeys = Object.keys(source);
+        var key, i;
+        for (i = 0; i < sourceKeys.length; i++) {
+          key = sourceKeys[i];
+          if (excluded.indexOf(key) >= 0)
+            continue;
+          target[key] = source[key];
         }
-        return options;
+        return target;
       }
-      class TokContext {
-        constructor(token, preserveSpace) {
-          this.token = void 0;
-          this.preserveSpace = void 0;
-          this.token = token;
-          this.preserveSpace = !!preserveSpace;
+      class Position {
+        constructor(line, col, index) {
+          this.line = void 0;
+          this.column = void 0;
+          this.index = void 0;
+          this.line = line;
+          this.column = col;
+          this.index = index;
         }
       }
-      const types = {
-        brace: new TokContext("{"),
-        j_oTag: new TokContext("<tag"),
-        j_cTag: new TokContext("</tag"),
-        j_expr: new TokContext("<tag>...</tag>", true)
-      };
-      {
-        types.template = new TokContext("`", true);
-      }
-      const beforeExpr = true;
-      const startsExpr = true;
-      const isLoop = true;
-      const isAssign = true;
-      const prefix = true;
-      const postfix = true;
-      class ExportedTokenType {
-        constructor(label, conf = {}) {
-          this.label = void 0;
-          this.keyword = void 0;
-          this.beforeExpr = void 0;
-          this.startsExpr = void 0;
-          this.rightAssociative = void 0;
-          this.isLoop = void 0;
-          this.isAssign = void 0;
-          this.prefix = void 0;
-          this.postfix = void 0;
-          this.binop = void 0;
-          this.label = label;
-          this.keyword = conf.keyword;
-          this.beforeExpr = !!conf.beforeExpr;
-          this.startsExpr = !!conf.startsExpr;
-          this.rightAssociative = !!conf.rightAssociative;
-          this.isLoop = !!conf.isLoop;
-          this.isAssign = !!conf.isAssign;
-          this.prefix = !!conf.prefix;
-          this.postfix = !!conf.postfix;
-          this.binop = conf.binop != null ? conf.binop : null;
-          {
-            this.updateContext = null;
-          }
+      class SourceLocation {
+        constructor(start2, end) {
+          this.start = void 0;
+          this.end = void 0;
+          this.filename = void 0;
+          this.identifierName = void 0;
+          this.start = start2;
+          this.end = end;
         }
       }
-      const keywords$1 = /* @__PURE__ */ new Map();
-      function createKeyword(name32, options = {}) {
-        options.keyword = name32;
-        const token = createToken(name32, options);
-        keywords$1.set(name32, token);
-        return token;
-      }
-      function createBinop(name32, binop) {
-        return createToken(name32, {
-          beforeExpr,
-          binop
-        });
-      }
-      let tokenTypeCounter = -1;
-      const tokenTypes = [];
-      const tokenLabels = [];
-      const tokenBinops = [];
-      const tokenBeforeExprs = [];
-      const tokenStartsExprs = [];
-      const tokenPrefixes = [];
-      function createToken(name32, options = {}) {
-        var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;
-        ++tokenTypeCounter;
-        tokenLabels.push(name32);
-        tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1);
-        tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false);
-        tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false);
-        tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false);
-        tokenTypes.push(new ExportedTokenType(name32, options));
-        return tokenTypeCounter;
-      }
-      function createKeywordLike(name32, options = {}) {
-        var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;
-        ++tokenTypeCounter;
-        keywords$1.set(name32, tokenTypeCounter);
-        tokenLabels.push(name32);
-        tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1);
-        tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false);
-        tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false);
-        tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false);
-        tokenTypes.push(new ExportedTokenType("name", options));
-        return tokenTypeCounter;
-      }
-      const tt = {
-        bracketL: createToken("[", {
-          beforeExpr,
-          startsExpr
-        }),
-        bracketHashL: createToken("#[", {
-          beforeExpr,
-          startsExpr
-        }),
-        bracketBarL: createToken("[|", {
-          beforeExpr,
-          startsExpr
-        }),
-        bracketR: createToken("]"),
-        bracketBarR: createToken("|]"),
-        braceL: createToken("{", {
-          beforeExpr,
-          startsExpr
-        }),
-        braceBarL: createToken("{|", {
-          beforeExpr,
-          startsExpr
-        }),
-        braceHashL: createToken("#{", {
-          beforeExpr,
-          startsExpr
-        }),
-        braceR: createToken("}"),
-        braceBarR: createToken("|}"),
-        parenL: createToken("(", {
-          beforeExpr,
-          startsExpr
-        }),
-        parenR: createToken(")"),
-        comma: createToken(",", {
-          beforeExpr
-        }),
-        semi: createToken(";", {
-          beforeExpr
-        }),
-        colon: createToken(":", {
-          beforeExpr
-        }),
-        doubleColon: createToken("::", {
-          beforeExpr
-        }),
-        dot: createToken("."),
-        question: createToken("?", {
-          beforeExpr
-        }),
-        questionDot: createToken("?."),
-        arrow: createToken("=>", {
-          beforeExpr
-        }),
-        template: createToken("template"),
-        ellipsis: createToken("...", {
-          beforeExpr
-        }),
-        backQuote: createToken("`", {
-          startsExpr
-        }),
-        dollarBraceL: createToken("${", {
-          beforeExpr,
-          startsExpr
-        }),
-        templateTail: createToken("...`", {
-          startsExpr
-        }),
-        templateNonTail: createToken("...${", {
-          beforeExpr,
-          startsExpr
-        }),
-        at: createToken("@"),
-        hash: createToken("#", {
-          startsExpr
-        }),
-        interpreterDirective: createToken("#!..."),
-        eq: createToken("=", {
-          beforeExpr,
-          isAssign
-        }),
-        assign: createToken("_=", {
-          beforeExpr,
-          isAssign
-        }),
-        slashAssign: createToken("_=", {
-          beforeExpr,
-          isAssign
-        }),
-        xorAssign: createToken("_=", {
-          beforeExpr,
-          isAssign
-        }),
-        moduloAssign: createToken("_=", {
-          beforeExpr,
-          isAssign
-        }),
-        incDec: createToken("++/--", {
-          prefix,
-          postfix,
-          startsExpr
-        }),
-        bang: createToken("!", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        tilde: createToken("~", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        doubleCaret: createToken("^^", {
-          startsExpr
-        }),
-        doubleAt: createToken("@@", {
-          startsExpr
-        }),
-        pipeline: createBinop("|>", 0),
-        nullishCoalescing: createBinop("??", 1),
-        logicalOR: createBinop("||", 1),
-        logicalAND: createBinop("&&", 2),
-        bitwiseOR: createBinop("|", 3),
-        bitwiseXOR: createBinop("^", 4),
-        bitwiseAND: createBinop("&", 5),
-        equality: createBinop("==/!=/===/!==", 6),
-        lt: createBinop("</>/<=/>=", 7),
-        gt: createBinop("</>/<=/>=", 7),
-        relational: createBinop("</>/<=/>=", 7),
-        bitShift: createBinop("<</>>/>>>", 8),
-        bitShiftL: createBinop("<</>>/>>>", 8),
-        bitShiftR: createBinop("<</>>/>>>", 8),
-        plusMin: createToken("+/-", {
-          beforeExpr,
-          binop: 9,
-          prefix,
-          startsExpr
-        }),
-        modulo: createToken("%", {
-          binop: 10,
-          startsExpr
-        }),
-        star: createToken("*", {
-          binop: 10
-        }),
-        slash: createBinop("/", 10),
-        exponent: createToken("**", {
-          beforeExpr,
-          binop: 11,
-          rightAssociative: true
-        }),
-        _in: createKeyword("in", {
-          beforeExpr,
-          binop: 7
-        }),
-        _instanceof: createKeyword("instanceof", {
-          beforeExpr,
-          binop: 7
-        }),
-        _break: createKeyword("break"),
-        _case: createKeyword("case", {
-          beforeExpr
-        }),
-        _catch: createKeyword("catch"),
-        _continue: createKeyword("continue"),
-        _debugger: createKeyword("debugger"),
-        _default: createKeyword("default", {
-          beforeExpr
-        }),
-        _else: createKeyword("else", {
-          beforeExpr
-        }),
-        _finally: createKeyword("finally"),
-        _function: createKeyword("function", {
-          startsExpr
-        }),
-        _if: createKeyword("if"),
-        _return: createKeyword("return", {
-          beforeExpr
-        }),
-        _switch: createKeyword("switch"),
-        _throw: createKeyword("throw", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        _try: createKeyword("try"),
-        _var: createKeyword("var"),
-        _const: createKeyword("const"),
-        _with: createKeyword("with"),
-        _new: createKeyword("new", {
-          beforeExpr,
-          startsExpr
-        }),
-        _this: createKeyword("this", {
-          startsExpr
-        }),
-        _super: createKeyword("super", {
-          startsExpr
-        }),
-        _class: createKeyword("class", {
-          startsExpr
-        }),
-        _extends: createKeyword("extends", {
-          beforeExpr
-        }),
-        _export: createKeyword("export"),
-        _import: createKeyword("import", {
-          startsExpr
-        }),
-        _null: createKeyword("null", {
-          startsExpr
-        }),
-        _true: createKeyword("true", {
-          startsExpr
-        }),
-        _false: createKeyword("false", {
-          startsExpr
-        }),
-        _typeof: createKeyword("typeof", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        _void: createKeyword("void", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        _delete: createKeyword("delete", {
-          beforeExpr,
-          prefix,
-          startsExpr
-        }),
-        _do: createKeyword("do", {
-          isLoop,
-          beforeExpr
-        }),
-        _for: createKeyword("for", {
-          isLoop
-        }),
-        _while: createKeyword("while", {
-          isLoop
-        }),
-        _as: createKeywordLike("as", {
-          startsExpr
-        }),
-        _assert: createKeywordLike("assert", {
-          startsExpr
-        }),
-        _async: createKeywordLike("async", {
-          startsExpr
-        }),
-        _await: createKeywordLike("await", {
-          startsExpr
-        }),
-        _from: createKeywordLike("from", {
-          startsExpr
-        }),
-        _get: createKeywordLike("get", {
-          startsExpr
-        }),
-        _let: createKeywordLike("let", {
-          startsExpr
-        }),
-        _meta: createKeywordLike("meta", {
-          startsExpr
-        }),
-        _of: createKeywordLike("of", {
-          startsExpr
-        }),
-        _sent: createKeywordLike("sent", {
-          startsExpr
-        }),
-        _set: createKeywordLike("set", {
-          startsExpr
-        }),
-        _static: createKeywordLike("static", {
-          startsExpr
-        }),
-        _using: createKeywordLike("using", {
-          startsExpr
-        }),
-        _yield: createKeywordLike("yield", {
-          startsExpr
-        }),
-        _asserts: createKeywordLike("asserts", {
-          startsExpr
-        }),
-        _checks: createKeywordLike("checks", {
-          startsExpr
-        }),
-        _exports: createKeywordLike("exports", {
-          startsExpr
-        }),
-        _global: createKeywordLike("global", {
-          startsExpr
-        }),
-        _implements: createKeywordLike("implements", {
-          startsExpr
-        }),
-        _intrinsic: createKeywordLike("intrinsic", {
-          startsExpr
-        }),
-        _infer: createKeywordLike("infer", {
-          startsExpr
-        }),
-        _is: createKeywordLike("is", {
-          startsExpr
-        }),
-        _mixins: createKeywordLike("mixins", {
-          startsExpr
-        }),
-        _proto: createKeywordLike("proto", {
-          startsExpr
-        }),
-        _require: createKeywordLike("require", {
-          startsExpr
-        }),
-        _satisfies: createKeywordLike("satisfies", {
-          startsExpr
-        }),
-        _keyof: createKeywordLike("keyof", {
-          startsExpr
-        }),
-        _readonly: createKeywordLike("readonly", {
-          startsExpr
-        }),
-        _unique: createKeywordLike("unique", {
-          startsExpr
-        }),
-        _abstract: createKeywordLike("abstract", {
-          startsExpr
-        }),
-        _declare: createKeywordLike("declare", {
-          startsExpr
-        }),
-        _enum: createKeywordLike("enum", {
-          startsExpr
-        }),
-        _module: createKeywordLike("module", {
-          startsExpr
-        }),
-        _namespace: createKeywordLike("namespace", {
-          startsExpr
-        }),
-        _interface: createKeywordLike("interface", {
-          startsExpr
-        }),
-        _type: createKeywordLike("type", {
-          startsExpr
-        }),
-        _opaque: createKeywordLike("opaque", {
-          startsExpr
-        }),
-        name: createToken("name", {
-          startsExpr
-        }),
-        string: createToken("string", {
-          startsExpr
-        }),
-        num: createToken("num", {
-          startsExpr
-        }),
-        bigint: createToken("bigint", {
-          startsExpr
-        }),
-        decimal: createToken("decimal", {
-          startsExpr
-        }),
-        regexp: createToken("regexp", {
-          startsExpr
-        }),
-        privateName: createToken("#name", {
-          startsExpr
-        }),
-        eof: createToken("eof"),
-        jsxName: createToken("jsxName"),
-        jsxText: createToken("jsxText", {
-          beforeExpr: true
-        }),
-        jsxTagStart: createToken("jsxTagStart", {
-          startsExpr: true
-        }),
-        jsxTagEnd: createToken("jsxTagEnd"),
-        placeholder: createToken("%%", {
-          startsExpr: true
-        })
-      };
-      function tokenIsIdentifier(token) {
-        return token >= 93 && token <= 130;
-      }
-      function tokenKeywordOrIdentifierIsKeyword(token) {
-        return token <= 92;
-      }
-      function tokenIsKeywordOrIdentifier(token) {
-        return token >= 58 && token <= 130;
-      }
-      function tokenIsLiteralPropertyName(token) {
-        return token >= 58 && token <= 134;
-      }
-      function tokenComesBeforeExpression(token) {
-        return tokenBeforeExprs[token];
-      }
-      function tokenCanStartExpression(token) {
-        return tokenStartsExprs[token];
-      }
-      function tokenIsAssignment(token) {
-        return token >= 29 && token <= 33;
-      }
-      function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
-        return token >= 127 && token <= 129;
-      }
-      function tokenIsLoop(token) {
-        return token >= 90 && token <= 92;
-      }
-      function tokenIsKeyword(token) {
-        return token >= 58 && token <= 92;
-      }
-      function tokenIsOperator(token) {
-        return token >= 39 && token <= 59;
-      }
-      function tokenIsPostfix(token) {
-        return token === 34;
-      }
-      function tokenIsPrefix(token) {
-        return tokenPrefixes[token];
-      }
-      function tokenIsTSTypeOperator(token) {
-        return token >= 119 && token <= 121;
-      }
-      function tokenIsTSDeclarationStart(token) {
-        return token >= 122 && token <= 128;
-      }
-      function tokenLabelName(token) {
-        return tokenLabels[token];
-      }
-      function tokenOperatorPrecedence(token) {
-        return tokenBinops[token];
-      }
-      function tokenIsRightAssociative(token) {
-        return token === 57;
-      }
-      function tokenIsTemplate(token) {
-        return token >= 24 && token <= 25;
-      }
-      function getExportedToken(token) {
-        return tokenTypes[token];
-      }
-      {
-        tokenTypes[8].updateContext = (context) => {
-          context.pop();
-        };
-        tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = (context) => {
-          context.push(types.brace);
-        };
-        tokenTypes[22].updateContext = (context) => {
-          if (context[context.length - 1] === types.template) {
-            context.pop();
-          } else {
-            context.push(types.template);
-          }
-        };
-        tokenTypes[140].updateContext = (context) => {
-          context.push(types.j_expr, types.j_oTag);
-        };
-      }
-      function _objectWithoutPropertiesLoose(source, excluded) {
-        if (source == null)
-          return {};
-        var target = {};
-        var sourceKeys = Object.keys(source);
-        var key, i;
-        for (i = 0; i < sourceKeys.length; i++) {
-          key = sourceKeys[i];
-          if (excluded.indexOf(key) >= 0)
-            continue;
-          target[key] = source[key];
-        }
-        return target;
-      }
-      class Position {
-        constructor(line, col, index) {
-          this.line = void 0;
-          this.column = void 0;
-          this.index = void 0;
-          this.line = line;
-          this.column = col;
-          this.index = index;
-        }
-      }
-      class SourceLocation {
-        constructor(start2, end) {
-          this.start = void 0;
-          this.end = void 0;
-          this.filename = void 0;
-          this.identifierName = void 0;
-          this.start = start2;
-          this.end = end;
-        }
-      }
-      function createPositionWithColumnOffset(position, columnOffset) {
-        const {
-          line,
-          column,
-          index
-        } = position;
-        return new Position(line, column + columnOffset, index + columnOffset);
+      function createPositionWithColumnOffset(position, columnOffset) {
+        const {
+          line,
+          column,
+          index
+        } = position;
+        return new Position(line, column + columnOffset, index + columnOffset);
       }
       var ParseErrorCode = {
         SyntaxError: "BABEL_PARSER_SYNTAX_ERROR",
@@ -2317,6 +1727,7 @@ var init_babel_parser = __esm({
         AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
         AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
         AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
+        AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
         AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
         AwaitNotInAsyncFunction: "'await' is only allowed within async functions.",
         BadGetterArity: "A 'get' accessor must not have any formal parameters.",
@@ -2366,6 +1777,7 @@ var init_babel_parser = __esm({
         }) => `Unsyntactic ${type3 === "BreakStatement" ? "break" : "continue"}.`,
         IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
         IllegalReturn: "'return' outside of function.",
+        ImportAttributesUseAssert: "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.",
         ImportBindingIsString: ({
           importName
         }) => `A string literal cannot be used as an imported binding.
@@ -2553,10 +1965,10 @@ var init_babel_parser = __esm({
         PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'
       };
       const _excluded$1 = ["toMessage"], _excluded2$1 = ["message"];
-      function toParseErrorConstructor(_ref2) {
+      function toParseErrorConstructor(_ref) {
         let {
           toMessage
-        } = _ref2, properties = _objectWithoutPropertiesLoose(_ref2, _excluded$1);
+        } = _ref, properties = _objectWithoutPropertiesLoose(_ref, _excluded$1);
         return function constructor({
           loc,
           details
@@ -2863,96 +2275,656 @@ var init_babel_parser = __esm({
               at: prop.key
             });
           } else {
-            super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
-          }
-        }
-        finishCallExpression(unfinished, optional) {
-          const node = super.finishCallExpression(unfinished, optional);
-          if (node.callee.type === "Import") {
-            node.type = "ImportExpression";
-            node.source = node.arguments[0];
-            if (this.hasPlugin("importAssertions")) {
-              var _node$arguments$;
-              node.attributes = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null;
-            }
-            delete node.arguments;
-            delete node.callee;
-          }
-          return node;
-        }
-        toReferencedArguments(node) {
-          if (node.type === "ImportExpression") {
-            return;
-          }
-          super.toReferencedArguments(node);
-        }
-        parseExport(unfinished, decorators) {
-          const exportStartLoc = this.state.lastTokStartLoc;
-          const node = super.parseExport(unfinished, decorators);
-          switch (node.type) {
-            case "ExportAllDeclaration":
-              node.exported = null;
-              break;
-            case "ExportNamedDeclaration":
-              if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
-                node.type = "ExportAllDeclaration";
-                node.exported = node.specifiers[0].exported;
-                delete node.specifiers;
-              }
-            case "ExportDefaultDeclaration":
-              {
-                var _declaration$decorato;
-                const {
-                  declaration
-                } = node;
-                if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {
-                  this.resetStartLocation(node, exportStartLoc);
-                }
-              }
-              break;
-          }
-          return node;
-        }
-        parseSubscript(base, startLoc, noCalls, state17) {
-          const node = super.parseSubscript(base, startLoc, noCalls, state17);
-          if (state17.optionalChainMember) {
-            if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") {
-              node.type = node.type.substring(8);
-            }
-            if (state17.stop) {
-              const chain = this.startNodeAtNode(node);
-              chain.expression = node;
-              return this.finishNode(chain, "ChainExpression");
-            }
-          } else if (node.type === "MemberExpression" || node.type === "CallExpression") {
-            node.optional = false;
-          }
-          return node;
-        }
-        hasPropertyAsPrivateName(node) {
-          if (node.type === "ChainExpression") {
-            node = node.expression;
+            super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
+          }
+        }
+        finishCallExpression(unfinished, optional) {
+          const node = super.finishCallExpression(unfinished, optional);
+          if (node.callee.type === "Import") {
+            node.type = "ImportExpression";
+            node.source = node.arguments[0];
+            if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
+              var _node$arguments$;
+              node.attributes = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null;
+            }
+            delete node.arguments;
+            delete node.callee;
+          }
+          return node;
+        }
+        toReferencedArguments(node) {
+          if (node.type === "ImportExpression") {
+            return;
+          }
+          super.toReferencedArguments(node);
+        }
+        parseExport(unfinished, decorators) {
+          const exportStartLoc = this.state.lastTokStartLoc;
+          const node = super.parseExport(unfinished, decorators);
+          switch (node.type) {
+            case "ExportAllDeclaration":
+              node.exported = null;
+              break;
+            case "ExportNamedDeclaration":
+              if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
+                node.type = "ExportAllDeclaration";
+                node.exported = node.specifiers[0].exported;
+                delete node.specifiers;
+              }
+            case "ExportDefaultDeclaration":
+              {
+                var _declaration$decorato;
+                const {
+                  declaration
+                } = node;
+                if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {
+                  this.resetStartLocation(node, exportStartLoc);
+                }
+              }
+              break;
+          }
+          return node;
+        }
+        parseSubscript(base, startLoc, noCalls, state17) {
+          const node = super.parseSubscript(base, startLoc, noCalls, state17);
+          if (state17.optionalChainMember) {
+            if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") {
+              node.type = node.type.substring(8);
+            }
+            if (state17.stop) {
+              const chain = this.startNodeAtNode(node);
+              chain.expression = node;
+              return this.finishNode(chain, "ChainExpression");
+            }
+          } else if (node.type === "MemberExpression" || node.type === "CallExpression") {
+            node.optional = false;
+          }
+          return node;
+        }
+        hasPropertyAsPrivateName(node) {
+          if (node.type === "ChainExpression") {
+            node = node.expression;
+          }
+          return super.hasPropertyAsPrivateName(node);
+        }
+        isObjectProperty(node) {
+          return node.type === "Property" && node.kind === "init" && !node.method;
+        }
+        isObjectMethod(node) {
+          return node.method || node.kind === "get" || node.kind === "set";
+        }
+        finishNodeAt(node, type3, endLoc) {
+          return toESTreeLocation(super.finishNodeAt(node, type3, endLoc));
+        }
+        resetStartLocation(node, startLoc) {
+          super.resetStartLocation(node, startLoc);
+          toESTreeLocation(node);
+        }
+        resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
+          super.resetEndLocation(node, endLoc);
+          toESTreeLocation(node);
+        }
+      };
+      class TokContext {
+        constructor(token, preserveSpace) {
+          this.token = void 0;
+          this.preserveSpace = void 0;
+          this.token = token;
+          this.preserveSpace = !!preserveSpace;
+        }
+      }
+      const types = {
+        brace: new TokContext("{"),
+        j_oTag: new TokContext("<tag"),
+        j_cTag: new TokContext("</tag"),
+        j_expr: new TokContext("<tag>...</tag>", true)
+      };
+      {
+        types.template = new TokContext("`", true);
+      }
+      const beforeExpr = true;
+      const startsExpr = true;
+      const isLoop = true;
+      const isAssign = true;
+      const prefix = true;
+      const postfix = true;
+      class ExportedTokenType {
+        constructor(label, conf = {}) {
+          this.label = void 0;
+          this.keyword = void 0;
+          this.beforeExpr = void 0;
+          this.startsExpr = void 0;
+          this.rightAssociative = void 0;
+          this.isLoop = void 0;
+          this.isAssign = void 0;
+          this.prefix = void 0;
+          this.postfix = void 0;
+          this.binop = void 0;
+          this.label = label;
+          this.keyword = conf.keyword;
+          this.beforeExpr = !!conf.beforeExpr;
+          this.startsExpr = !!conf.startsExpr;
+          this.rightAssociative = !!conf.rightAssociative;
+          this.isLoop = !!conf.isLoop;
+          this.isAssign = !!conf.isAssign;
+          this.prefix = !!conf.prefix;
+          this.postfix = !!conf.postfix;
+          this.binop = conf.binop != null ? conf.binop : null;
+          {
+            this.updateContext = null;
+          }
+        }
+      }
+      const keywords$1 = /* @__PURE__ */ new Map();
+      function createKeyword(name32, options = {}) {
+        options.keyword = name32;
+        const token = createToken(name32, options);
+        keywords$1.set(name32, token);
+        return token;
+      }
+      function createBinop(name32, binop) {
+        return createToken(name32, {
+          beforeExpr,
+          binop
+        });
+      }
+      let tokenTypeCounter = -1;
+      const tokenTypes = [];
+      const tokenLabels = [];
+      const tokenBinops = [];
+      const tokenBeforeExprs = [];
+      const tokenStartsExprs = [];
+      const tokenPrefixes = [];
+      function createToken(name32, options = {}) {
+        var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;
+        ++tokenTypeCounter;
+        tokenLabels.push(name32);
+        tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1);
+        tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false);
+        tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false);
+        tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false);
+        tokenTypes.push(new ExportedTokenType(name32, options));
+        return tokenTypeCounter;
+      }
+      function createKeywordLike(name32, options = {}) {
+        var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;
+        ++tokenTypeCounter;
+        keywords$1.set(name32, tokenTypeCounter);
+        tokenLabels.push(name32);
+        tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1);
+        tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false);
+        tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false);
+        tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false);
+        tokenTypes.push(new ExportedTokenType("name", options));
+        return tokenTypeCounter;
+      }
+      const tt = {
+        bracketL: createToken("[", {
+          beforeExpr,
+          startsExpr
+        }),
+        bracketHashL: createToken("#[", {
+          beforeExpr,
+          startsExpr
+        }),
+        bracketBarL: createToken("[|", {
+          beforeExpr,
+          startsExpr
+        }),
+        bracketR: createToken("]"),
+        bracketBarR: createToken("|]"),
+        braceL: createToken("{", {
+          beforeExpr,
+          startsExpr
+        }),
+        braceBarL: createToken("{|", {
+          beforeExpr,
+          startsExpr
+        }),
+        braceHashL: createToken("#{", {
+          beforeExpr,
+          startsExpr
+        }),
+        braceR: createToken("}"),
+        braceBarR: createToken("|}"),
+        parenL: createToken("(", {
+          beforeExpr,
+          startsExpr
+        }),
+        parenR: createToken(")"),
+        comma: createToken(",", {
+          beforeExpr
+        }),
+        semi: createToken(";", {
+          beforeExpr
+        }),
+        colon: createToken(":", {
+          beforeExpr
+        }),
+        doubleColon: createToken("::", {
+          beforeExpr
+        }),
+        dot: createToken("."),
+        question: createToken("?", {
+          beforeExpr
+        }),
+        questionDot: createToken("?."),
+        arrow: createToken("=>", {
+          beforeExpr
+        }),
+        template: createToken("template"),
+        ellipsis: createToken("...", {
+          beforeExpr
+        }),
+        backQuote: createToken("`", {
+          startsExpr
+        }),
+        dollarBraceL: createToken("${", {
+          beforeExpr,
+          startsExpr
+        }),
+        templateTail: createToken("...`", {
+          startsExpr
+        }),
+        templateNonTail: createToken("...${", {
+          beforeExpr,
+          startsExpr
+        }),
+        at: createToken("@"),
+        hash: createToken("#", {
+          startsExpr
+        }),
+        interpreterDirective: createToken("#!..."),
+        eq: createToken("=", {
+          beforeExpr,
+          isAssign
+        }),
+        assign: createToken("_=", {
+          beforeExpr,
+          isAssign
+        }),
+        slashAssign: createToken("_=", {
+          beforeExpr,
+          isAssign
+        }),
+        xorAssign: createToken("_=", {
+          beforeExpr,
+          isAssign
+        }),
+        moduloAssign: createToken("_=", {
+          beforeExpr,
+          isAssign
+        }),
+        incDec: createToken("++/--", {
+          prefix,
+          postfix,
+          startsExpr
+        }),
+        bang: createToken("!", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        tilde: createToken("~", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        doubleCaret: createToken("^^", {
+          startsExpr
+        }),
+        doubleAt: createToken("@@", {
+          startsExpr
+        }),
+        pipeline: createBinop("|>", 0),
+        nullishCoalescing: createBinop("??", 1),
+        logicalOR: createBinop("||", 1),
+        logicalAND: createBinop("&&", 2),
+        bitwiseOR: createBinop("|", 3),
+        bitwiseXOR: createBinop("^", 4),
+        bitwiseAND: createBinop("&", 5),
+        equality: createBinop("==/!=/===/!==", 6),
+        lt: createBinop("</>/<=/>=", 7),
+        gt: createBinop("</>/<=/>=", 7),
+        relational: createBinop("</>/<=/>=", 7),
+        bitShift: createBinop("<</>>/>>>", 8),
+        bitShiftL: createBinop("<</>>/>>>", 8),
+        bitShiftR: createBinop("<</>>/>>>", 8),
+        plusMin: createToken("+/-", {
+          beforeExpr,
+          binop: 9,
+          prefix,
+          startsExpr
+        }),
+        modulo: createToken("%", {
+          binop: 10,
+          startsExpr
+        }),
+        star: createToken("*", {
+          binop: 10
+        }),
+        slash: createBinop("/", 10),
+        exponent: createToken("**", {
+          beforeExpr,
+          binop: 11,
+          rightAssociative: true
+        }),
+        _in: createKeyword("in", {
+          beforeExpr,
+          binop: 7
+        }),
+        _instanceof: createKeyword("instanceof", {
+          beforeExpr,
+          binop: 7
+        }),
+        _break: createKeyword("break"),
+        _case: createKeyword("case", {
+          beforeExpr
+        }),
+        _catch: createKeyword("catch"),
+        _continue: createKeyword("continue"),
+        _debugger: createKeyword("debugger"),
+        _default: createKeyword("default", {
+          beforeExpr
+        }),
+        _else: createKeyword("else", {
+          beforeExpr
+        }),
+        _finally: createKeyword("finally"),
+        _function: createKeyword("function", {
+          startsExpr
+        }),
+        _if: createKeyword("if"),
+        _return: createKeyword("return", {
+          beforeExpr
+        }),
+        _switch: createKeyword("switch"),
+        _throw: createKeyword("throw", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        _try: createKeyword("try"),
+        _var: createKeyword("var"),
+        _const: createKeyword("const"),
+        _with: createKeyword("with"),
+        _new: createKeyword("new", {
+          beforeExpr,
+          startsExpr
+        }),
+        _this: createKeyword("this", {
+          startsExpr
+        }),
+        _super: createKeyword("super", {
+          startsExpr
+        }),
+        _class: createKeyword("class", {
+          startsExpr
+        }),
+        _extends: createKeyword("extends", {
+          beforeExpr
+        }),
+        _export: createKeyword("export"),
+        _import: createKeyword("import", {
+          startsExpr
+        }),
+        _null: createKeyword("null", {
+          startsExpr
+        }),
+        _true: createKeyword("true", {
+          startsExpr
+        }),
+        _false: createKeyword("false", {
+          startsExpr
+        }),
+        _typeof: createKeyword("typeof", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        _void: createKeyword("void", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        _delete: createKeyword("delete", {
+          beforeExpr,
+          prefix,
+          startsExpr
+        }),
+        _do: createKeyword("do", {
+          isLoop,
+          beforeExpr
+        }),
+        _for: createKeyword("for", {
+          isLoop
+        }),
+        _while: createKeyword("while", {
+          isLoop
+        }),
+        _as: createKeywordLike("as", {
+          startsExpr
+        }),
+        _assert: createKeywordLike("assert", {
+          startsExpr
+        }),
+        _async: createKeywordLike("async", {
+          startsExpr
+        }),
+        _await: createKeywordLike("await", {
+          startsExpr
+        }),
+        _from: createKeywordLike("from", {
+          startsExpr
+        }),
+        _get: createKeywordLike("get", {
+          startsExpr
+        }),
+        _let: createKeywordLike("let", {
+          startsExpr
+        }),
+        _meta: createKeywordLike("meta", {
+          startsExpr
+        }),
+        _of: createKeywordLike("of", {
+          startsExpr
+        }),
+        _sent: createKeywordLike("sent", {
+          startsExpr
+        }),
+        _set: createKeywordLike("set", {
+          startsExpr
+        }),
+        _static: createKeywordLike("static", {
+          startsExpr
+        }),
+        _using: createKeywordLike("using", {
+          startsExpr
+        }),
+        _yield: createKeywordLike("yield", {
+          startsExpr
+        }),
+        _asserts: createKeywordLike("asserts", {
+          startsExpr
+        }),
+        _checks: createKeywordLike("checks", {
+          startsExpr
+        }),
+        _exports: createKeywordLike("exports", {
+          startsExpr
+        }),
+        _global: createKeywordLike("global", {
+          startsExpr
+        }),
+        _implements: createKeywordLike("implements", {
+          startsExpr
+        }),
+        _intrinsic: createKeywordLike("intrinsic", {
+          startsExpr
+        }),
+        _infer: createKeywordLike("infer", {
+          startsExpr
+        }),
+        _is: createKeywordLike("is", {
+          startsExpr
+        }),
+        _mixins: createKeywordLike("mixins", {
+          startsExpr
+        }),
+        _proto: createKeywordLike("proto", {
+          startsExpr
+        }),
+        _require: createKeywordLike("require", {
+          startsExpr
+        }),
+        _satisfies: createKeywordLike("satisfies", {
+          startsExpr
+        }),
+        _keyof: createKeywordLike("keyof", {
+          startsExpr
+        }),
+        _readonly: createKeywordLike("readonly", {
+          startsExpr
+        }),
+        _unique: createKeywordLike("unique", {
+          startsExpr
+        }),
+        _abstract: createKeywordLike("abstract", {
+          startsExpr
+        }),
+        _declare: createKeywordLike("declare", {
+          startsExpr
+        }),
+        _enum: createKeywordLike("enum", {
+          startsExpr
+        }),
+        _module: createKeywordLike("module", {
+          startsExpr
+        }),
+        _namespace: createKeywordLike("namespace", {
+          startsExpr
+        }),
+        _interface: createKeywordLike("interface", {
+          startsExpr
+        }),
+        _type: createKeywordLike("type", {
+          startsExpr
+        }),
+        _opaque: createKeywordLike("opaque", {
+          startsExpr
+        }),
+        name: createToken("name", {
+          startsExpr
+        }),
+        string: createToken("string", {
+          startsExpr
+        }),
+        num: createToken("num", {
+          startsExpr
+        }),
+        bigint: createToken("bigint", {
+          startsExpr
+        }),
+        decimal: createToken("decimal", {
+          startsExpr
+        }),
+        regexp: createToken("regexp", {
+          startsExpr
+        }),
+        privateName: createToken("#name", {
+          startsExpr
+        }),
+        eof: createToken("eof"),
+        jsxName: createToken("jsxName"),
+        jsxText: createToken("jsxText", {
+          beforeExpr: true
+        }),
+        jsxTagStart: createToken("jsxTagStart", {
+          startsExpr: true
+        }),
+        jsxTagEnd: createToken("jsxTagEnd"),
+        placeholder: createToken("%%", {
+          startsExpr: true
+        })
+      };
+      function tokenIsIdentifier(token) {
+        return token >= 93 && token <= 130;
+      }
+      function tokenKeywordOrIdentifierIsKeyword(token) {
+        return token <= 92;
+      }
+      function tokenIsKeywordOrIdentifier(token) {
+        return token >= 58 && token <= 130;
+      }
+      function tokenIsLiteralPropertyName(token) {
+        return token >= 58 && token <= 134;
+      }
+      function tokenComesBeforeExpression(token) {
+        return tokenBeforeExprs[token];
+      }
+      function tokenCanStartExpression(token) {
+        return tokenStartsExprs[token];
+      }
+      function tokenIsAssignment(token) {
+        return token >= 29 && token <= 33;
+      }
+      function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
+        return token >= 127 && token <= 129;
+      }
+      function tokenIsLoop(token) {
+        return token >= 90 && token <= 92;
+      }
+      function tokenIsKeyword(token) {
+        return token >= 58 && token <= 92;
+      }
+      function tokenIsOperator(token) {
+        return token >= 39 && token <= 59;
+      }
+      function tokenIsPostfix(token) {
+        return token === 34;
+      }
+      function tokenIsPrefix(token) {
+        return tokenPrefixes[token];
+      }
+      function tokenIsTSTypeOperator(token) {
+        return token >= 119 && token <= 121;
+      }
+      function tokenIsTSDeclarationStart(token) {
+        return token >= 122 && token <= 128;
+      }
+      function tokenLabelName(token) {
+        return tokenLabels[token];
+      }
+      function tokenOperatorPrecedence(token) {
+        return tokenBinops[token];
+      }
+      function tokenIsRightAssociative(token) {
+        return token === 57;
+      }
+      function tokenIsTemplate(token) {
+        return token >= 24 && token <= 25;
+      }
+      function getExportedToken(token) {
+        return tokenTypes[token];
+      }
+      {
+        tokenTypes[8].updateContext = (context) => {
+          context.pop();
+        };
+        tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = (context) => {
+          context.push(types.brace);
+        };
+        tokenTypes[22].updateContext = (context) => {
+          if (context[context.length - 1] === types.template) {
+            context.pop();
+          } else {
+            context.push(types.template);
           }
-          return super.hasPropertyAsPrivateName(node);
-        }
-        isObjectProperty(node) {
-          return node.type === "Property" && node.kind === "init" && !node.method;
-        }
-        isObjectMethod(node) {
-          return node.method || node.kind === "get" || node.kind === "set";
-        }
-        finishNodeAt(node, type3, endLoc) {
-          return toESTreeLocation(super.finishNodeAt(node, type3, endLoc));
-        }
-        resetStartLocation(node, startLoc) {
-          super.resetStartLocation(node, startLoc);
-          toESTreeLocation(node);
-        }
-        resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
-          super.resetEndLocation(node, endLoc);
-          toESTreeLocation(node);
-        }
-      };
+        };
+        tokenTypes[140].updateContext = (context) => {
+          context.push(types.j_expr, types.j_oTag);
+        };
+      }
       let nonASCIIidentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
       let nonASCIIidentifierChars = "\u200C\u200D\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
       const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
@@ -3381,9 +3353,23 @@ var init_babel_parser = __esm({
           for (let i = commentStack.length - 1; i >= 0; i--) {
             this.finalizeComment(commentStack[i]);
           }
-          this.state.commentStack = [];
+          this.state.commentStack = [];
+        }
+        resetPreviousNodeTrailingComments(node) {
+          const {
+            commentStack
+          } = this.state;
+          const {
+            length
+          } = commentStack;
+          if (length === 0)
+            return;
+          const commentWS = commentStack[length - 1];
+          if (commentWS.leadingNode === node) {
+            commentWS.leadingNode = null;
+          }
         }
-        resetPreviousNodeTrailingComments(node) {
+        resetPreviousIdentifierLeadingComments(node) {
           const {
             commentStack
           } = this.state;
@@ -3392,9 +3378,10 @@ var init_babel_parser = __esm({
           } = commentStack;
           if (length === 0)
             return;
-          const commentWS = commentStack[length - 1];
-          if (commentWS.leadingNode === node) {
-            commentWS.leadingNode = null;
+          if (commentStack[length - 1].trailingNode === node) {
+            commentStack[length - 1].trailingNode = null;
+          } else if (length >= 2 && commentStack[length - 2].trailingNode === node) {
+            commentStack[length - 2].trailingNode = null;
           }
         }
         takeSurroundingComments(node, start2, end) {
@@ -4582,7 +4569,6 @@ var init_babel_parser = __esm({
             const char = String.fromCharCode(cp);
             if (VALID_REGEX_FLAGS.has(cp)) {
               if (cp === 118) {
-                this.expectPlugin("regexpUnicodeSets", nextPos());
                 if (mods.includes("u")) {
                   this.raise(Errors.IncompatibleRegExpUVFlags, {
                     at: nextPos()
@@ -5614,9 +5600,6 @@ var init_babel_parser = __esm({
       function hasTypeImportKind(node) {
         return node.importKind === "type" || node.importKind === "typeof";
       }
-      function isMaybeDefaultImport(type3) {
-        return tokenIsKeywordOrIdentifier(type3) && type3 !== 97;
-      }
       const exportSuggestions = {
         const: "declare export var",
         let: "declare export var",
@@ -6937,13 +6920,6 @@ var init_babel_parser = __esm({
           }
           super.assertModuleNodeAllowed(node);
         }
-        parseExport(node, decorators) {
-          const decl = super.parseExport(node, decorators);
-          if (decl.type === "ExportNamedDeclaration" || decl.type === "ExportAllDeclaration") {
-            decl.exportKind = decl.exportKind || "value";
-          }
-          return decl;
-        }
         parseExportDeclaration(node) {
           if (this.isContextual(128)) {
             node.exportKind = "type";
@@ -7252,12 +7228,6 @@ var init_babel_parser = __esm({
           }
           return node;
         }
-        shouldParseDefaultImport(node) {
-          if (!hasTypeImportKind(node)) {
-            return super.shouldParseDefaultImport(node);
-          }
-          return isMaybeDefaultImport(this.state.type);
-        }
         checkImportReflection(node) {
           super.checkImportReflection(node);
           if (node.module && node.importKind !== "value") {
@@ -7270,28 +7240,29 @@ var init_babel_parser = __esm({
           specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
           node.specifiers.push(this.finishImportSpecifier(specifier, type3));
         }
-        maybeParseDefaultImportSpecifier(node) {
-          node.importKind = "value";
-          let kind = null;
-          if (this.match(87)) {
-            kind = "typeof";
-          } else if (this.isContextual(128)) {
-            kind = "type";
+        isPotentialImportPhase(isExport) {
+          if (super.isPotentialImportPhase(isExport))
+            return true;
+          if (this.isContextual(128)) {
+            if (!isExport)
+              return true;
+            const ch = this.lookaheadCharCode();
+            return ch === 123 || ch === 42;
           }
-          if (kind) {
-            const lh = this.lookahead();
-            const {
-              type: type3
-            } = lh;
-            if (kind === "type" && type3 === 55) {
-              this.unexpected(null, lh.type);
-            }
-            if (isMaybeDefaultImport(type3) || type3 === 5 || type3 === 55) {
-              this.next();
-              node.importKind = kind;
+          return !isExport && this.isContextual(87);
+        }
+        applyImportPhase(node, isExport, phase, loc) {
+          super.applyImportPhase(node, isExport, phase, loc);
+          if (isExport) {
+            if (!phase && this.match(65)) {
+              return;
             }
+            node.exportKind = phase === "type" ? phase : "value";
+          } else {
+            if (phase === "type" && this.match(55))
+              this.unexpected();
+            node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
           }
-          return super.maybeParseDefaultImportSpecifier(node);
         }
         parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
           const firstIdent = specifier.imported;
@@ -10503,9 +10474,9 @@ var init_babel_parser = __esm({
           }
           return this.finishNode(node, "TSModuleDeclaration");
         }
-        tsParseImportEqualsDeclaration(node, isExport) {
+        tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {
           node.isExport = isExport || false;
-          node.id = this.parseIdentifier();
+          node.id = maybeDefaultIdentifier || this.parseIdentifier();
           this.checkIdentifier(node.id, BIND_FLAGS_TS_IMPORT);
           this.expect(29);
           const moduleReference = this.tsParseModuleReference();
@@ -10533,6 +10504,7 @@ var init_babel_parser = __esm({
           }
           node.expression = super.parseExprAtom();
           this.expect(11);
+          this.sawUnambiguousESM = true;
           return this.finishNode(node, "TSExternalModuleReference");
         }
         tsLookAhead(f) {
@@ -10705,6 +10677,8 @@ var init_babel_parser = __esm({
             this.raise(TSErrors.EmptyTypeArguments, {
               at: node
             });
+          } else if (!this.state.inType && this.curContext() === types.brace) {
+            this.reScan_lt_gt();
           }
           this.expect(48);
           return this.finishNode(node, "TSTypeParameterInstantiation");
@@ -10942,20 +10916,42 @@ var init_babel_parser = __esm({
         }
         checkDuplicateExports() {
         }
+        isPotentialImportPhase(isExport) {
+          if (super.isPotentialImportPhase(isExport))
+            return true;
+          if (this.isContextual(128)) {
+            const ch = this.lookaheadCharCode();
+            return isExport ? ch === 123 || ch === 42 : ch !== 61;
+          }
+          return !isExport && this.isContextual(87);
+        }
+        applyImportPhase(node, isExport, phase, loc) {
+          super.applyImportPhase(node, isExport, phase, loc);
+          if (isExport) {
+            node.exportKind = phase === "type" ? "type" : "value";
+          } else {
+            node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
+          }
+        }
         parseImport(node) {
-          node.importKind = "value";
-          if (tokenIsIdentifier(this.state.type) || this.match(55) || this.match(5)) {
-            let ahead = this.lookahead();
-            if (this.isContextual(128) && ahead.type !== 12 && ahead.type !== 97 && ahead.type !== 29) {
-              node.importKind = "type";
-              this.next();
-              ahead = this.lookahead();
-            }
-            if (tokenIsIdentifier(this.state.type) && ahead.type === 29) {
-              return this.tsParseImportEqualsDeclaration(node);
+          if (this.match(131)) {
+            node.importKind = "value";
+            return super.parseImport(node);
+          }
+          let importNode;
+          if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {
+            node.importKind = "value";
+            return this.tsParseImportEqualsDeclaration(node);
+          } else if (this.isContextual(128)) {
+            const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
+            if (this.lookaheadCharCode() === 61) {
+              return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);
+            } else {
+              importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);
             }
+          } else {
+            importNode = super.parseImport(node);
           }
-          const importNode = super.parseImport(node);
           if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
             this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
               at: importNode
@@ -10966,17 +10962,18 @@ var init_babel_parser = __esm({
         parseExport(node, decorators) {
           if (this.match(83)) {
             this.next();
-            if (this.isContextual(128) && this.lookaheadCharCode() !== 61) {
-              node.importKind = "type";
-              this.next();
+            let maybeDefaultIdentifier = null;
+            if (this.isContextual(128) && this.isPotentialImportPhase(false)) {
+              maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
             } else {
               node.importKind = "value";
             }
-            return this.tsParseImportEqualsDeclaration(node, true);
+            return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, true);
           } else if (this.eat(29)) {
             const assign = node;
             assign.expression = super.parseExpression();
             this.semicolon();
+            this.sawUnambiguousESM = true;
             return this.finishNode(assign, "TSExportAssignment");
           } else if (this.eatContextual(93)) {
             const decl = node;
@@ -10985,14 +10982,6 @@ var init_babel_parser = __esm({
             this.semicolon();
             return this.finishNode(decl, "TSNamespaceExportDeclaration");
           } else {
-            node.exportKind = "value";
-            if (this.isContextual(128)) {
-              const ch = this.lookaheadCharCode();
-              if (ch === 123 || ch === 42) {
-                this.next();
-                node.exportKind = "type";
-              }
-            }
             return super.parseExport(node, decorators);
           }
         }
@@ -12012,11 +12001,12 @@ var init_babel_parser = __esm({
           }
           return super.isExportDefaultSpecifier();
         }
-        maybeParseExportDefaultSpecifier(node) {
-          if (node.specifiers && node.specifiers.length > 0) {
+        maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
+          var _specifiers;
+          if ((_specifiers = node.specifiers) != null && _specifiers.length) {
             return true;
           }
-          return super.maybeParseExportDefaultSpecifier(node);
+          return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
         }
         checkExport(node) {
           const {
@@ -12170,8 +12160,8 @@ var init_babel_parser = __esm({
         }
         if (hasPlugin(plugins, "moduleAttributes")) {
           {
-            if (hasPlugin(plugins, "importAssertions")) {
-              throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
+            if (hasPlugin(plugins, "importAssertions") || hasPlugin(plugins, "importAttributes")) {
+              throw new Error("Cannot combine importAssertions, importAttributes and moduleAttributes plugins.");
             }
             const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
             if (moduleAttributesVersionPluginOption !== "may-2020") {
@@ -12179,6 +12169,9 @@ var init_babel_parser = __esm({
             }
           }
         }
+        if (hasPlugin(plugins, "importAssertions") && hasPlugin(plugins, "importAttributes")) {
+          throw new Error("Cannot combine importAssertions and importAttributes plugins.");
+        }
         if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
           throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map((p) => `'${p}'`).join(", "));
         }
@@ -12197,6 +12190,36 @@ var init_babel_parser = __esm({
         placeholders
       };
       const mixinPluginNames = Object.keys(mixinPlugins);
+      const defaultOptions = {
+        sourceType: "script",
+        sourceFilename: void 0,
+        startColumn: 0,
+        startLine: 1,
+        allowAwaitOutsideFunction: false,
+        allowReturnOutsideFunction: false,
+        allowNewTargetOutsideFunction: false,
+        allowImportExportEverywhere: false,
+        allowSuperOutsideMethod: false,
+        allowUndeclaredExports: false,
+        plugins: [],
+        strictMode: null,
+        ranges: false,
+        tokens: false,
+        createParenthesizedExpressions: false,
+        errorRecovery: false,
+        attachComment: true,
+        annexB: true
+      };
+      function getOptions(opts) {
+        if (opts && opts.annexB != null && opts.annexB !== false) {
+          throw new Error("The `annexB` option can only be set to `false`.");
+        }
+        const options = {};
+        for (const key of Object.keys(defaultOptions)) {
+          options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
+        }
+        return options;
+      }
       class ExpressionParser extends LValParser {
         checkProto(prop, isRecord, protoRef, refExpressionErrors) {
           if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {
@@ -12702,19 +12725,24 @@ var init_babel_parser = __esm({
         atPossibleAsyncArrow(base) {
           return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;
         }
+        expectImportAttributesPlugin() {
+          if (!this.hasPlugin("importAssertions")) {
+            this.expectPlugin("importAttributes");
+          }
+        }
         finishCallExpression(node, optional) {
           if (node.callee.type === "Import") {
             if (node.arguments.length === 2) {
               {
                 if (!this.hasPlugin("moduleAttributes")) {
-                  this.expectPlugin("importAssertions");
+                  this.expectImportAttributesPlugin();
                 }
               }
             }
             if (node.arguments.length === 0 || node.arguments.length > 2) {
               this.raise(Errors.ImportCallArity, {
                 at: node,
-                maxArgumentCount: this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
+                maxArgumentCount: this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
               });
             } else {
               for (const arg of node.arguments) {
@@ -12739,7 +12767,7 @@ var init_babel_parser = __esm({
             } else {
               this.expect(12);
               if (this.match(close3)) {
-                if (dynamicImport && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
+                if (dynamicImport && !this.hasPlugin("importAttributes") && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
                   this.raise(Errors.ImportCallArgumentTrailingComma, {
                     at: this.state.lastTokStartLoc
                   });
@@ -14205,6 +14233,18 @@ var init_babel_parser = __esm({
             return true;
           }
         }
+        startsAwaitUsing() {
+          let next = this.nextTokenInLineStart();
+          if (this.isUnparsedContextual(next, "using")) {
+            next = this.nextTokenInLineStartSince(next + 5);
+            const nextCh = this.codePointAtPos(next);
+            if (this.chStartsBindingIdentifier(nextCh, next)) {
+              this.expectPlugin("explicitResourceManagement");
+              return true;
+            }
+          }
+          return false;
+        }
         parseModuleItem() {
           return this.parseStatementLike(1 | 2 | 4 | 8);
         }
@@ -14271,6 +14311,21 @@ var init_babel_parser = __esm({
               return this.parseThrowStatement(node);
             case 73:
               return this.parseTryStatement(node);
+            case 96:
+              if (!this.state.containsEsc && this.startsAwaitUsing()) {
+                if (!this.isAwaitAllowed()) {
+                  this.raise(Errors.AwaitUsingNotInAsyncContext, {
+                    at: node
+                  });
+                } else if (!allowDeclaration) {
+                  this.raise(Errors.UnexpectedLexicalDeclaration, {
+                    at: node
+                  });
+                }
+                this.next();
+                return this.parseVarStatement(node, "await using");
+              }
+              break;
             case 105:
               if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifier()) {
                 break;
@@ -14539,27 +14594,41 @@ var init_babel_parser = __esm({
             return this.parseFor(node, null);
           }
           const startsWithLet = this.isContextual(99);
-          const startsWithUsing = this.isContextual(105);
-          const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || startsWithUsing && this.startsUsingForOf();
-          if (this.match(74) || this.match(75) || isLetOrUsing) {
-            const initNode = this.startNode();
-            const kind = this.state.value;
-            this.next();
-            this.parseVar(initNode, true, kind);
-            const init2 = this.finishNode(initNode, "VariableDeclaration");
-            const isForIn = this.match(58);
-            if (isForIn && startsWithUsing) {
-              this.raise(Errors.ForInUsing, {
-                at: init2
-              });
-            }
-            if ((isForIn || this.isContextual(101)) && init2.declarations.length === 1) {
-              return this.parseForIn(node, init2, awaitAt);
-            }
-            if (awaitAt !== null) {
-              this.unexpected(awaitAt);
+          {
+            const startsWithAwaitUsing = this.isContextual(96) && this.startsAwaitUsing();
+            const starsWithUsingDeclaration = startsWithAwaitUsing || this.isContextual(105) && this.startsUsingForOf();
+            const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;
+            if (this.match(74) || this.match(75) || isLetOrUsing) {
+              const initNode = this.startNode();
+              let kind;
+              if (startsWithAwaitUsing) {
+                kind = "await using";
+                if (!this.isAwaitAllowed()) {
+                  this.raise(Errors.AwaitUsingNotInAsyncContext, {
+                    at: this.state.startLoc
+                  });
+                }
+                this.next();
+              } else {
+                kind = this.state.value;
+              }
+              this.next();
+              this.parseVar(initNode, true, kind);
+              const init2 = this.finishNode(initNode, "VariableDeclaration");
+              const isForIn = this.match(58);
+              if (isForIn && starsWithUsingDeclaration) {
+                this.raise(Errors.ForInUsing, {
+                  at: init2
+                });
+              }
+              if ((isForIn || this.isContextual(101)) && init2.declarations.length === 1) {
+                return this.parseForIn(node, init2, awaitAt);
+              }
+              if (awaitAt !== null) {
+                this.unexpected(awaitAt);
+              }
+              return this.parseFor(node, init2);
             }
-            return this.parseFor(node, init2);
           }
           const startsWithAsync = this.isContextual(95);
           const refExpressionErrors = new ExpressionErrors();
@@ -14820,9 +14889,7 @@ var init_babel_parser = __esm({
             }
             body.push(stmt);
           }
-          if (afterBlockParse) {
-            afterBlockParse.call(this, hasStrictModeDirective);
-          }
+          afterBlockParse == null ? void 0 : afterBlockParse.call(this, hasStrictModeDirective);
           if (!oldStrict) {
             this.setStrict(false);
           }
@@ -15300,7 +15367,8 @@ var init_babel_parser = __esm({
           node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
         }
         parseExport(node, decorators) {
-          const hasDefault = this.maybeParseExportDefaultSpecifier(node);
+          const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);
+          const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
           const parseAfterDefault = !hasDefault || this.eat(12);
           const hasStar = parseAfterDefault && this.eatExportStar(node);
           const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
@@ -15368,11 +15436,12 @@ var init_babel_parser = __esm({
         eatExportStar(node) {
           return this.eat(55);
         }
-        maybeParseExportDefaultSpecifier(node) {
-          if (this.isExportDefaultSpecifier()) {
-            this.expectPlugin("exportDefaultFrom");
-            const specifier = this.startNode();
-            specifier.exported = this.parseIdentifier(true);
+        maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
+          if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {
+            this.expectPlugin("exportDefaultFrom", maybeDefaultIdentifier == null ? void 0 : maybeDefaultIdentifier.loc.start);
+            const id = maybeDefaultIdentifier || this.parseIdentifier(true);
+            const specifier = this.startNodeAtNode(id);
+            specifier.exported = id;
             node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
             return true;
           }
@@ -15420,8 +15489,8 @@ var init_babel_parser = __esm({
         isAsyncFunction() {
           if (!this.isContextual(95))
             return false;
-          const next = this.nextTokenStart();
-          return !lineBreak.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, "function");
+          const next = this.nextTokenInLineStart();
+          return this.isUnparsedContextual(next, "function");
         }
         parseExportDefaultExpression() {
           const expr = this.startNode();
@@ -15495,11 +15564,8 @@ var init_babel_parser = __esm({
           if (this.eatContextual(97)) {
             node.source = this.parseImportSource();
             this.checkExport(node);
-            const assertions = this.maybeParseImportAssertions();
-            if (assertions) {
-              node.assertions = assertions;
-              this.checkJSONModuleImport(node);
-            }
+            this.maybeParseImportAttributes(node);
+            this.checkJSONModuleImport(node);
           } else if (expect) {
             this.unexpected();
           }
@@ -15703,53 +15769,66 @@ var init_babel_parser = __esm({
             }
           }
         }
-        parseMaybeImportReflection(node) {
-          let isImportReflection = false;
-          if (this.isContextual(125)) {
-            const lookahead = this.lookahead();
-            const nextType = lookahead.type;
-            if (tokenIsIdentifier(nextType)) {
-              if (nextType !== 97) {
-                isImportReflection = true;
-              } else {
-                const nextNextTokenFirstChar = this.input.charCodeAt(this.nextTokenStartSince(lookahead.end));
-                if (nextNextTokenFirstChar === 102) {
-                  isImportReflection = true;
-                }
-              }
-            } else if (nextType !== 12) {
-              isImportReflection = true;
-            }
+        isPotentialImportPhase(isExport) {
+          return !isExport && this.isContextual(125);
+        }
+        applyImportPhase(node, isExport, phase, loc) {
+          if (isExport) {
+            return;
           }
-          if (isImportReflection) {
-            this.expectPlugin("importReflection");
-            this.next();
+          if (phase === "module") {
+            this.expectPlugin("importReflection", loc);
             node.module = true;
           } else if (this.hasPlugin("importReflection")) {
             node.module = false;
           }
         }
-        parseImport(node) {
-          node.specifiers = [];
-          if (!this.match(131)) {
-            this.parseMaybeImportReflection(node);
-            const hasDefault = this.maybeParseDefaultImportSpecifier(node);
-            const parseNext = !hasDefault || this.eat(12);
-            const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
-            if (parseNext && !hasStar)
-              this.parseNamedImportSpecifiers(node);
-            this.expectContextual(97);
+        parseMaybeImportPhase(node, isExport) {
+          if (!this.isPotentialImportPhase(isExport)) {
+            this.applyImportPhase(node, isExport, null);
+            return null;
           }
-          node.source = this.parseImportSource();
-          const assertions = this.maybeParseImportAssertions();
-          if (assertions) {
-            node.assertions = assertions;
+          const phaseIdentifier = this.parseIdentifier(true);
+          const {
+            type: type3
+          } = this.state;
+          const isImportPhase = tokenIsKeywordOrIdentifier(type3) ? type3 !== 97 || this.lookaheadCharCode() === 102 : type3 !== 12;
+          if (isImportPhase) {
+            this.resetPreviousIdentifierLeadingComments(phaseIdentifier);
+            this.applyImportPhase(node, isExport, phaseIdentifier.name, phaseIdentifier.loc.start);
+            return null;
           } else {
-            const attributes = this.maybeParseModuleAttributes();
-            if (attributes) {
-              node.attributes = attributes;
-            }
+            this.applyImportPhase(node, isExport, null);
+            return phaseIdentifier;
+          }
+        }
+        isPrecedingIdImportPhase(phase) {
+          const {
+            type: type3
+          } = this.state;
+          return tokenIsIdentifier(type3) ? type3 !== 97 || this.lookaheadCharCode() === 102 : type3 !== 12;
+        }
+        parseImport(node) {
+          if (this.match(131)) {
+            return this.parseImportSourceAndAttributes(node);
           }
+          return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false));
+        }
+        parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) {
+          node.specifiers = [];
+          const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier);
+          const parseNext = !hasDefault || this.eat(12);
+          const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
+          if (parseNext && !hasStar)
+            this.parseNamedImportSpecifiers(node);
+          this.expectContextual(97);
+          return this.parseImportSourceAndAttributes(node);
+        }
+        parseImportSourceAndAttributes(node) {
+          var _node$specifiers;
+          (_node$specifiers = node.specifiers) != null ? _node$specifiers : node.specifiers = [];
+          node.source = this.parseImportSource();
+          this.maybeParseImportAttributes(node);
           this.checkImportReflection(node);
           this.checkJSONModuleImport(node);
           this.semicolon();
@@ -15760,9 +15839,6 @@ var init_babel_parser = __esm({
             this.unexpected();
           return this.parseExprAtom();
         }
-        shouldParseDefaultImport(node) {
-          return tokenIsIdentifier(this.state.type);
-        }
         parseImportSpecifierLocal(node, specifier, type3) {
           specifier.local = this.parseIdentifier();
           node.specifiers.push(this.finishImportSpecifier(specifier, type3));
@@ -15776,7 +15852,8 @@ var init_babel_parser = __esm({
           });
           return this.finishNode(specifier, type3);
         }
-        parseAssertEntries() {
+        parseImportAttributes() {
+          this.expect(5);
           const attrs = [];
           const attrNames = /* @__PURE__ */ new Set();
           do {
@@ -15806,17 +15883,10 @@ var init_babel_parser = __esm({
             node.value = this.parseStringLiteral(this.state.value);
             attrs.push(this.finishNode(node, "ImportAttribute"));
           } while (this.eat(12));
+          this.expect(8);
           return attrs;
         }
-        maybeParseModuleAttributes() {
-          if (this.match(76) && !this.hasPrecedingLineBreak()) {
-            this.expectPlugin("moduleAttributes");
-            this.next();
-          } else {
-            if (this.hasPlugin("moduleAttributes"))
-              return [];
-            return null;
-          }
+        parseModuleAttributes() {
           const attrs = [];
           const attributes = /* @__PURE__ */ new Set();
           do {
@@ -15841,27 +15911,61 @@ var init_babel_parser = __esm({
               });
             }
             node.value = this.parseStringLiteral(this.state.value);
-            this.finishNode(node, "ImportAttribute");
-            attrs.push(node);
+            attrs.push(this.finishNode(node, "ImportAttribute"));
           } while (this.eat(12));
           return attrs;
         }
-        maybeParseImportAssertions() {
-          if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
-            this.expectPlugin("importAssertions");
+        maybeParseImportAttributes(node) {
+          let attributes;
+          let useWith = false;
+          if (this.match(76)) {
+            if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) {
+              return;
+            }
+            this.next();
+            {
+              if (this.hasPlugin("moduleAttributes")) {
+                attributes = this.parseModuleAttributes();
+              } else {
+                this.expectImportAttributesPlugin();
+                attributes = this.parseImportAttributes();
+              }
+            }
+            useWith = true;
+          } else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
+            if (this.hasPlugin("importAttributes")) {
+              if (this.getPluginOption("importAttributes", "deprecatedAssertSyntax") !== true) {
+                this.raise(Errors.ImportAttributesUseAssert, {
+                  at: this.state.startLoc
+                });
+              }
+              this.addExtra(node, "deprecatedAssertSyntax", true);
+            } else {
+              this.expectOnePlugin(["importAttributes", "importAssertions"]);
+            }
             this.next();
+            attributes = this.parseImportAttributes();
+          } else if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
+            attributes = [];
           } else {
-            if (this.hasPlugin("importAssertions"))
-              return [];
-            return null;
+            if (this.hasPlugin("moduleAttributes")) {
+              attributes = [];
+            } else
+              return;
+          }
+          if (!useWith && this.hasPlugin("importAssertions")) {
+            node.assertions = attributes;
+          } else {
+            node.attributes = attributes;
           }
-          this.eat(5);
-          const attrs = this.parseAssertEntries();
-          this.eat(8);
-          return attrs;
         }
-        maybeParseDefaultImportSpecifier(node) {
-          if (this.shouldParseDefaultImport(node)) {
+        maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) {
+          if (maybeDefaultIdentifier) {
+            const specifier = this.startNodeAtNode(maybeDefaultIdentifier);
+            specifier.local = maybeDefaultIdentifier;
+            node.specifiers.push(this.finishImportSpecifier(specifier, "ImportDefaultSpecifier"));
+            return true;
+          } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
             this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier");
             return true;
           }
@@ -16907,7 +17011,7 @@ var init_Platform = __esm({
     state9 = {
       getAssetDir() {
         if (true) {
-          return "/c1ca266";
+          return "/9243b38";
         }
         if (platform === "electron") {
           return "../../../../..";
@@ -18043,178 +18147,6 @@ var init_Performance_ipc = __esm({
 });
 
 // static/js/dompurify.js
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-  return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
-    return typeof obj2;
-  } : function(obj2) {
-    return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-  }, _typeof(obj);
-}
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
-    o2.__proto__ = p2;
-    return o2;
-  };
-  return _setPrototypeOf(o, p);
-}
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct)
-    return false;
-  if (Reflect.construct.sham)
-    return false;
-  if (typeof Proxy === "function")
-    return true;
-  try {
-    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
-    }));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-function _construct(Parent, args, Class) {
-  if (_isNativeReflectConstruct()) {
-    _construct = Reflect.construct;
-  } else {
-    _construct = function _construct2(Parent2, args2, Class2) {
-      var a = [null];
-      a.push.apply(a, args2);
-      var Constructor = Function.bind.apply(Parent2, a);
-      var instance = new Constructor();
-      if (Class2)
-        _setPrototypeOf(instance, Class2.prototype);
-      return instance;
-    };
-  }
-  return _construct.apply(null, arguments);
-}
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr))
-    return _arrayLikeToArray(arr);
-}
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr))
-    return arr;
-}
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
-    return Array.from(iter);
-}
-function _iterableToArrayLimit(arr, i) {
-  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-  if (_i == null)
-    return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-  var _s, _e;
-  try {
-    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-      if (i && _arr.length === i)
-        break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n && _i["return"] != null)
-        _i["return"]();
-    } finally {
-      if (_d)
-        throw _e;
-    }
-  }
-  return _arr;
-}
-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 _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _createForOfIteratorHelper(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (!it) {
-    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-      if (it)
-        o = it;
-      var i = 0;
-      var F = function() {
-      };
-      return {
-        s: F,
-        n: function() {
-          if (i >= o.length)
-            return {
-              done: true
-            };
-          return {
-            done: false,
-            value: o[i++]
-          };
-        },
-        e: function(e) {
-          throw e;
-        },
-        f: F
-      };
-    }
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  var normalCompletion = true, didErr = false, err;
-  return {
-    s: function() {
-      it = it.call(o);
-    },
-    n: function() {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
-    },
-    e: function(e) {
-      didErr = true;
-      err = e;
-    },
-    f: function() {
-      try {
-        if (!normalCompletion && it.return != null)
-          it.return();
-      } finally {
-        if (didErr)
-          throw err;
-      }
-    }
-  };
-}
 function unapply(func) {
   return function(thisArg) {
     for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
@@ -18232,15 +18164,16 @@ function unconstruct(func) {
   };
 }
 function addToSet(set4, array2, transformCaseFunc) {
-  transformCaseFunc = transformCaseFunc ? transformCaseFunc : stringToLowerCase;
+  var _transformCaseFunc;
+  transformCaseFunc = (_transformCaseFunc = transformCaseFunc) !== null && _transformCaseFunc !== void 0 ? _transformCaseFunc : stringToLowerCase;
   if (setPrototypeOf) {
     setPrototypeOf(set4, null);
   }
-  var l = array2.length;
+  let l = array2.length;
   while (l--) {
-    var element = array2[l];
+    let element = array2[l];
     if (typeof element === "string") {
-      var lcElement = transformCaseFunc(element);
+      const lcElement = transformCaseFunc(element);
       if (lcElement !== element) {
         if (!isFrozen(array2)) {
           array2[l] = lcElement;
@@ -18253,23 +18186,15 @@ function addToSet(set4, array2, transformCaseFunc) {
   return set4;
 }
 function clone(object2) {
-  var newObject = create17(null);
-  var _iterator = _createForOfIteratorHelper(entries(object2)), _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done; ) {
-      var _step$value = _slicedToArray(_step.value, 2), property = _step$value[0], value = _step$value[1];
-      newObject[property] = value;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  const newObject = create17(null);
+  for (const [property, value] of entries(object2)) {
+    newObject[property] = value;
   }
   return newObject;
 }
 function lookupGetter(object2, prop) {
   while (object2 !== null) {
-    var desc = getOwnPropertyDescriptor(object2, prop);
+    const desc = getOwnPropertyDescriptor(object2, prop);
     if (desc) {
       if (desc.get) {
         return unapply(desc.get);
@@ -18287,43 +18212,71 @@ function lookupGetter(object2, prop) {
   return fallbackValue;
 }
 function createDOMPurify() {
-  var window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
-  var DOMPurify = function DOMPurify2(root) {
-    return createDOMPurify(root);
-  };
-  DOMPurify.version = "3.0.1";
+  let window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
+  const DOMPurify = (root) => createDOMPurify(root);
+  DOMPurify.version = "3.0.4";
   DOMPurify.removed = [];
   if (!window2 || !window2.document || window2.document.nodeType !== 9) {
     DOMPurify.isSupported = false;
     return DOMPurify;
   }
-  var originalDocument = window2.document;
-  var document2 = window2.document;
-  var DocumentFragment = window2.DocumentFragment, HTMLTemplateElement = window2.HTMLTemplateElement, Node = window2.Node, Element = window2.Element, NodeFilter2 = window2.NodeFilter, _window$NamedNodeMap = window2.NamedNodeMap, NamedNodeMap = _window$NamedNodeMap === void 0 ? window2.NamedNodeMap || window2.MozNamedAttrMap : _window$NamedNodeMap, HTMLFormElement = window2.HTMLFormElement, DOMParser = window2.DOMParser, trustedTypes = window2.trustedTypes;
-  var ElementPrototype = Element.prototype;
-  var cloneNode = lookupGetter(ElementPrototype, "cloneNode");
-  var getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
-  var getChildNodes = lookupGetter(ElementPrototype, "childNodes");
-  var getParentNode = lookupGetter(ElementPrototype, "parentNode");
+  const originalDocument = window2.document;
+  const currentScript = originalDocument.currentScript;
+  let {
+    document: document2
+  } = window2;
+  const {
+    DocumentFragment,
+    HTMLTemplateElement,
+    Node,
+    Element,
+    NodeFilter: NodeFilter2,
+    NamedNodeMap = window2.NamedNodeMap || window2.MozNamedAttrMap,
+    HTMLFormElement,
+    DOMParser,
+    trustedTypes
+  } = window2;
+  const ElementPrototype = Element.prototype;
+  const cloneNode = lookupGetter(ElementPrototype, "cloneNode");
+  const getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
+  const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
+  const getParentNode = lookupGetter(ElementPrototype, "parentNode");
   if (typeof HTMLTemplateElement === "function") {
-    var template = document2.createElement("template");
+    const template = document2.createElement("template");
     if (template.content && template.content.ownerDocument) {
       document2 = template.content.ownerDocument;
     }
   }
-  var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument);
-  var emptyHTML = trustedTypesPolicy ? trustedTypesPolicy.createHTML("") : "";
-  var _document = document2, implementation = _document.implementation, createNodeIterator = _document.createNodeIterator, createDocumentFragment = _document.createDocumentFragment, getElementsByTagName = _document.getElementsByTagName;
-  var importNode = originalDocument.importNode;
-  var hooks = {};
-  DOMPurify.isSupported = typeof entries === "function" && typeof getParentNode === "function" && implementation && typeof implementation.createHTMLDocument !== "undefined";
-  var MUSTACHE_EXPR$1 = MUSTACHE_EXPR, ERB_EXPR$1 = ERB_EXPR, TMPLIT_EXPR$1 = TMPLIT_EXPR, DATA_ATTR$1 = DATA_ATTR, ARIA_ATTR$1 = ARIA_ATTR, IS_SCRIPT_OR_DATA$1 = IS_SCRIPT_OR_DATA, ATTR_WHITESPACE$1 = ATTR_WHITESPACE;
-  var IS_ALLOWED_URI$1 = IS_ALLOWED_URI;
-  var ALLOWED_TAGS = null;
-  var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray(html$1), _toConsumableArray(svg$1), _toConsumableArray(svgFilters), _toConsumableArray(mathMl$1), _toConsumableArray(text)));
-  var ALLOWED_ATTR = null;
-  var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray(html), _toConsumableArray(svg), _toConsumableArray(mathMl), _toConsumableArray(xml)));
-  var CUSTOM_ELEMENT_HANDLING = Object.seal(Object.create(null, {
+  let trustedTypesPolicy;
+  let emptyHTML = "";
+  const {
+    implementation,
+    createNodeIterator,
+    createDocumentFragment,
+    getElementsByTagName
+  } = document2;
+  const {
+    importNode
+  } = originalDocument;
+  let hooks = {};
+  DOMPurify.isSupported = typeof entries === "function" && typeof getParentNode === "function" && implementation && implementation.createHTMLDocument !== void 0;
+  const {
+    MUSTACHE_EXPR: MUSTACHE_EXPR2,
+    ERB_EXPR: ERB_EXPR2,
+    TMPLIT_EXPR: TMPLIT_EXPR2,
+    DATA_ATTR: DATA_ATTR2,
+    ARIA_ATTR: ARIA_ATTR2,
+    IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA2,
+    ATTR_WHITESPACE: ATTR_WHITESPACE2
+  } = EXPRESSIONS;
+  let {
+    IS_ALLOWED_URI: IS_ALLOWED_URI$1
+  } = EXPRESSIONS;
+  let ALLOWED_TAGS = null;
+  const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
+  let ALLOWED_ATTR = null;
+  const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
+  let CUSTOM_ELEMENT_HANDLING = Object.seal(Object.create(null, {
     tagNameCheck: {
       writable: true,
       configurable: false,
@@ -18343,52 +18296,52 @@ function createDOMPurify() {
       value: false
     }
   }));
-  var FORBID_TAGS = null;
-  var FORBID_ATTR = null;
-  var ALLOW_ARIA_ATTR = true;
-  var ALLOW_DATA_ATTR = true;
-  var ALLOW_UNKNOWN_PROTOCOLS = false;
-  var ALLOW_SELF_CLOSE_IN_ATTR = true;
-  var SAFE_FOR_TEMPLATES = false;
-  var WHOLE_DOCUMENT = false;
-  var SET_CONFIG = false;
-  var FORCE_BODY = false;
-  var RETURN_DOM = false;
-  var RETURN_DOM_FRAGMENT = false;
-  var RETURN_TRUSTED_TYPE = false;
-  var SANITIZE_DOM = true;
-  var SANITIZE_NAMED_PROPS = false;
-  var SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
-  var KEEP_CONTENT = true;
-  var IN_PLACE = false;
-  var USE_PROFILES = {};
-  var FORBID_CONTENTS = null;
-  var DEFAULT_FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
-  var DATA_URI_TAGS = null;
-  var DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]);
-  var URI_SAFE_ATTRIBUTES = null;
-  var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]);
-  var MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
-  var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
-  var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
-  var NAMESPACE = HTML_NAMESPACE;
-  var IS_EMPTY_INPUT = false;
-  var ALLOWED_NAMESPACES = null;
-  var DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
-  var PARSER_MEDIA_TYPE;
-  var SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
-  var DEFAULT_PARSER_MEDIA_TYPE = "text/html";
-  var transformCaseFunc;
-  var CONFIG = null;
-  var formElement = document2.createElement("form");
-  var isRegexOrFunction = function isRegexOrFunction2(testValue) {
+  let FORBID_TAGS = null;
+  let FORBID_ATTR = null;
+  let ALLOW_ARIA_ATTR = true;
+  let ALLOW_DATA_ATTR = true;
+  let ALLOW_UNKNOWN_PROTOCOLS = false;
+  let ALLOW_SELF_CLOSE_IN_ATTR = true;
+  let SAFE_FOR_TEMPLATES = false;
+  let WHOLE_DOCUMENT = false;
+  let SET_CONFIG = false;
+  let FORCE_BODY = false;
+  let RETURN_DOM = false;
+  let RETURN_DOM_FRAGMENT = false;
+  let RETURN_TRUSTED_TYPE = false;
+  let SANITIZE_DOM = true;
+  let SANITIZE_NAMED_PROPS = false;
+  const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
+  let KEEP_CONTENT = true;
+  let IN_PLACE = false;
+  let USE_PROFILES = {};
+  let FORBID_CONTENTS = null;
+  const DEFAULT_FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
+  let DATA_URI_TAGS = null;
+  const DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]);
+  let URI_SAFE_ATTRIBUTES = null;
+  const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]);
+  const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+  const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+  const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+  let NAMESPACE = HTML_NAMESPACE;
+  let IS_EMPTY_INPUT = false;
+  let ALLOWED_NAMESPACES = null;
+  const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
+  let PARSER_MEDIA_TYPE;
+  const SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
+  const DEFAULT_PARSER_MEDIA_TYPE = "text/html";
+  let transformCaseFunc;
+  let CONFIG = null;
+  const formElement = document2.createElement("form");
+  const isRegexOrFunction = function isRegexOrFunction2(testValue) {
     return testValue instanceof RegExp || testValue instanceof Function;
   };
-  var _parseConfig = function _parseConfig2(cfg) {
+  const _parseConfig = function _parseConfig2(cfg) {
     if (CONFIG && CONFIG === cfg) {
       return;
     }
-    if (!cfg || _typeof(cfg) !== "object") {
+    if (!cfg || typeof cfg !== "object") {
       cfg = {};
     }
     cfg = clone(cfg);
@@ -18417,7 +18370,7 @@ function createDOMPurify() {
     SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false;
     KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
     IN_PLACE = cfg.IN_PLACE || false;
-    IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$1;
+    IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
     NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
     CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
     if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
@@ -18436,7 +18389,7 @@ function createDOMPurify() {
       RETURN_DOM = true;
     }
     if (USE_PROFILES) {
-      ALLOWED_TAGS = addToSet({}, _toConsumableArray(text));
+      ALLOWED_TAGS = addToSet({}, [...text]);
       ALLOWED_ATTR = [];
       if (USE_PROFILES.html === true) {
         addToSet(ALLOWED_TAGS, html$1);
@@ -18489,29 +18442,46 @@ function createDOMPurify() {
       addToSet(ALLOWED_TAGS, ["tbody"]);
       delete FORBID_TAGS.tbody;
     }
+    if (cfg.TRUSTED_TYPES_POLICY) {
+      if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== "function") {
+        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+      }
+      if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== "function") {
+        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+      }
+      trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
+      emptyHTML = trustedTypesPolicy.createHTML("");
+    } else {
+      if (trustedTypesPolicy === void 0) {
+        trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+      }
+      if (trustedTypesPolicy !== null && typeof emptyHTML === "string") {
+        emptyHTML = trustedTypesPolicy.createHTML("");
+      }
+    }
     if (freeze) {
       freeze(cfg);
     }
     CONFIG = cfg;
   };
-  var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
-  var HTML_INTEGRATION_POINTS = addToSet({}, ["foreignobject", "desc", "title", "annotation-xml"]);
-  var COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ["title", "style", "font", "a", "script"]);
-  var ALL_SVG_TAGS = addToSet({}, svg$1);
+  const MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
+  const HTML_INTEGRATION_POINTS = addToSet({}, ["foreignobject", "desc", "title", "annotation-xml"]);
+  const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ["title", "style", "font", "a", "script"]);
+  const ALL_SVG_TAGS = addToSet({}, svg$1);
   addToSet(ALL_SVG_TAGS, svgFilters);
   addToSet(ALL_SVG_TAGS, svgDisallowed);
-  var ALL_MATHML_TAGS = addToSet({}, mathMl$1);
+  const ALL_MATHML_TAGS = addToSet({}, mathMl$1);
   addToSet(ALL_MATHML_TAGS, mathMlDisallowed);
-  var _checkValidNamespace = function _checkValidNamespace2(element) {
-    var parent = getParentNode(element);
+  const _checkValidNamespace = function _checkValidNamespace2(element) {
+    let parent = getParentNode(element);
     if (!parent || !parent.tagName) {
       parent = {
         namespaceURI: NAMESPACE,
         tagName: "template"
       };
     }
-    var tagName = stringToLowerCase(element.tagName);
-    var parentTagName = stringToLowerCase(parent.tagName);
+    const tagName = stringToLowerCase(element.tagName);
+    const parentTagName = stringToLowerCase(parent.tagName);
     if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
       return false;
     }
@@ -18547,7 +18517,7 @@ function createDOMPurify() {
     }
     return false;
   };
-  var _forceRemove = function _forceRemove2(node) {
+  const _forceRemove = function _forceRemove2(node) {
     arrayPush(DOMPurify.removed, {
       element: node
     });
@@ -18557,7 +18527,7 @@ function createDOMPurify() {
       node.remove();
     }
   };
-  var _removeAttribute = function _removeAttribute2(name32, node) {
+  const _removeAttribute = function _removeAttribute2(name32, node) {
     try {
       arrayPush(DOMPurify.removed, {
         attribute: node.getAttributeNode(name32),
@@ -18584,19 +18554,19 @@ function createDOMPurify() {
       }
     }
   };
-  var _initDocument = function _initDocument2(dirty) {
-    var doc;
-    var leadingWhitespace;
+  const _initDocument = function _initDocument2(dirty) {
+    let doc;
+    let leadingWhitespace;
     if (FORCE_BODY) {
       dirty = "<remove></remove>" + dirty;
     } else {
-      var matches = stringMatch(dirty, /^[\r\n\t ]+/);
+      const matches = stringMatch(dirty, /^[\r\n\t ]+/);
       leadingWhitespace = matches && matches[0];
     }
     if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && NAMESPACE === HTML_NAMESPACE) {
       dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + "</body></html>";
     }
-    var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+    const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
     if (NAMESPACE === HTML_NAMESPACE) {
       try {
         doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
@@ -18610,7 +18580,7 @@ function createDOMPurify() {
       } catch (_) {
       }
     }
-    var body = doc.body || doc.documentElement;
+    const body = doc.body || doc.documentElement;
     if (dirty && leadingWhitespace) {
       body.insertBefore(document2.createTextNode(leadingWhitespace), body.childNodes[0] || null);
     }
@@ -18619,31 +18589,31 @@ function createDOMPurify() {
     }
     return WHOLE_DOCUMENT ? doc.documentElement : body;
   };
-  var _createIterator = function _createIterator2(root) {
+  const _createIterator = function _createIterator2(root) {
     return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter2.SHOW_ELEMENT | NodeFilter2.SHOW_COMMENT | NodeFilter2.SHOW_TEXT, null, false);
   };
-  var _isClobbered = function _isClobbered2(elm) {
+  const _isClobbered = function _isClobbered2(elm) {
     return elm instanceof HTMLFormElement && (typeof elm.nodeName !== "string" || typeof elm.textContent !== "string" || typeof elm.removeChild !== "function" || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== "function" || typeof elm.setAttribute !== "function" || typeof elm.namespaceURI !== "string" || typeof elm.insertBefore !== "function" || typeof elm.hasChildNodes !== "function");
   };
-  var _isNode = function _isNode2(object2) {
-    return _typeof(Node) === "object" ? object2 instanceof Node : object2 && _typeof(object2) === "object" && typeof object2.nodeType === "number" && typeof object2.nodeName === "string";
+  const _isNode = function _isNode2(object2) {
+    return typeof Node === "object" ? object2 instanceof Node : object2 && typeof object2 === "object" && typeof object2.nodeType === "number" && typeof object2.nodeName === "string";
   };
-  var _executeHook = function _executeHook2(entryPoint, currentNode, data) {
+  const _executeHook = function _executeHook2(entryPoint, currentNode, data) {
     if (!hooks[entryPoint]) {
       return;
     }
-    arrayForEach(hooks[entryPoint], function(hook) {
+    arrayForEach(hooks[entryPoint], (hook) => {
       hook.call(DOMPurify, currentNode, data, CONFIG);
     });
   };
-  var _sanitizeElements = function _sanitizeElements2(currentNode) {
-    var content;
+  const _sanitizeElements = function _sanitizeElements2(currentNode) {
+    let content;
     _executeHook("beforeSanitizeElements", currentNode, null);
     if (_isClobbered(currentNode)) {
       _forceRemove(currentNode);
       return true;
     }
-    var tagName = transformCaseFunc(currentNode.nodeName);
+    const tagName = transformCaseFunc(currentNode.nodeName);
     _executeHook("uponSanitizeElement", currentNode, {
       tagName,
       allowedTags: ALLOWED_TAGS
@@ -18660,11 +18630,11 @@ function createDOMPurify() {
           return false;
       }
       if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
-        var parentNode = getParentNode(currentNode) || currentNode.parentNode;
-        var childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+        const parentNode = getParentNode(currentNode) || currentNode.parentNode;
+        const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
         if (childNodes && parentNode) {
-          var childCount = childNodes.length;
-          for (var i = childCount - 1; i >= 0; --i) {
+          const childCount = childNodes.length;
+          for (let i = childCount - 1; i >= 0; --i) {
             parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));
           }
         }
@@ -18676,15 +18646,15 @@ function createDOMPurify() {
       _forceRemove(currentNode);
       return true;
     }
-    if ((tagName === "noscript" || tagName === "noembed") && regExpTest(/<\/no(script|embed)/i, currentNode.innerHTML)) {
+    if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
       _forceRemove(currentNode);
       return true;
     }
     if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {
       content = currentNode.textContent;
-      content = stringReplace(content, MUSTACHE_EXPR$1, " ");
-      content = stringReplace(content, ERB_EXPR$1, " ");
-      content = stringReplace(content, TMPLIT_EXPR$1, " ");
+      content = stringReplace(content, MUSTACHE_EXPR2, " ");
+      content = stringReplace(content, ERB_EXPR2, " ");
+      content = stringReplace(content, TMPLIT_EXPR2, " ");
       if (currentNode.textContent !== content) {
         arrayPush(DOMPurify.removed, {
           element: currentNode.cloneNode()
@@ -18695,13 +18665,13 @@ function createDOMPurify() {
     _executeHook("afterSanitizeElements", currentNode, null);
     return false;
   };
-  var _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
+  const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
     if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) {
       return false;
     }
-    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR$1, lcName))
+    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR2, lcName))
       ;
-    else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$1, lcName))
+    else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR2, lcName))
       ;
     else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
       if (_basicCustomElementTest(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) || lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value)))
@@ -18711,33 +18681,34 @@ function createDOMPurify() {
       }
     } else if (URI_SAFE_ATTRIBUTES[lcName])
       ;
-    else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE$1, "")))
+    else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE2, "")))
       ;
     else if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag])
       ;
-    else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$1, stringReplace(value, ATTR_WHITESPACE$1, "")))
+    else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA2, stringReplace(value, ATTR_WHITESPACE2, "")))
       ;
-    else if (!value)
-      ;
-    else {
+    else if (value) {
       return false;
-    }
+    } else
+      ;
     return true;
   };
-  var _basicCustomElementTest = function _basicCustomElementTest2(tagName) {
+  const _basicCustomElementTest = function _basicCustomElementTest2(tagName) {
     return tagName.indexOf("-") > 0;
   };
-  var _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
-    var attr;
-    var value;
-    var lcName;
-    var l;
+  const _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
+    let attr;
+    let value;
+    let lcName;
+    let l;
     _executeHook("beforeSanitizeAttributes", currentNode, null);
-    var attributes = currentNode.attributes;
+    const {
+      attributes
+    } = currentNode;
     if (!attributes) {
       return;
     }
-    var hookEvent = {
+    const hookEvent = {
       attrName: "",
       attrValue: "",
       keepAttr: true,
@@ -18746,7 +18717,10 @@ function createDOMPurify() {
     l = attributes.length;
     while (l--) {
       attr = attributes[l];
-      var _attr = attr, name32 = _attr.name, namespaceURI = _attr.namespaceURI;
+      const {
+        name: name32,
+        namespaceURI
+      } = attr;
       value = name32 === "value" ? attr.value : stringTrim(attr.value);
       lcName = transformCaseFunc(name32);
       hookEvent.attrName = lcName;
@@ -18767,11 +18741,11 @@ function createDOMPurify() {
         continue;
       }
       if (SAFE_FOR_TEMPLATES) {
-        value = stringReplace(value, MUSTACHE_EXPR$1, " ");
-        value = stringReplace(value, ERB_EXPR$1, " ");
-        value = stringReplace(value, TMPLIT_EXPR$1, " ");
+        value = stringReplace(value, MUSTACHE_EXPR2, " ");
+        value = stringReplace(value, ERB_EXPR2, " ");
+        value = stringReplace(value, TMPLIT_EXPR2, " ");
       }
-      var lcTag = transformCaseFunc(currentNode.nodeName);
+      const lcTag = transformCaseFunc(currentNode.nodeName);
       if (!_isValidAttribute(lcTag, lcName, value)) {
         continue;
       }
@@ -18779,17 +18753,19 @@ function createDOMPurify() {
         _removeAttribute(name32, currentNode);
         value = SANITIZE_NAMED_PROPS_PREFIX + value;
       }
-      if (trustedTypesPolicy && _typeof(trustedTypes) === "object" && typeof trustedTypes.getAttributeType === "function") {
+      if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") {
         if (namespaceURI)
           ;
         else {
           switch (trustedTypes.getAttributeType(lcTag, lcName)) {
-            case "TrustedHTML":
+            case "TrustedHTML": {
               value = trustedTypesPolicy.createHTML(value);
               break;
-            case "TrustedScriptURL":
+            }
+            case "TrustedScriptURL": {
               value = trustedTypesPolicy.createScriptURL(value);
               break;
+            }
           }
         }
       }
@@ -18805,9 +18781,9 @@ function createDOMPurify() {
     }
     _executeHook("afterSanitizeAttributes", currentNode, null);
   };
-  var _sanitizeShadowDOM = function _sanitizeShadowDOM2(fragment) {
-    var shadowNode;
-    var shadowIterator = _createIterator(fragment);
+  const _sanitizeShadowDOM = function _sanitizeShadowDOM2(fragment) {
+    let shadowNode;
+    const shadowIterator = _createIterator(fragment);
     _executeHook("beforeSanitizeShadowDOM", fragment, null);
     while (shadowNode = shadowIterator.nextNode()) {
       _executeHook("uponSanitizeShadowNode", shadowNode, null);
@@ -18822,23 +18798,23 @@ function createDOMPurify() {
     _executeHook("afterSanitizeShadowDOM", fragment, null);
   };
   DOMPurify.sanitize = function(dirty) {
-    var cfg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    var body;
-    var importedNode;
-    var currentNode;
-    var returnNode;
+    let cfg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    let body;
+    let importedNode;
+    let currentNode;
+    let returnNode;
     IS_EMPTY_INPUT = !dirty;
     if (IS_EMPTY_INPUT) {
       dirty = "<!-->";
     }
     if (typeof dirty !== "string" && !_isNode(dirty)) {
-      if (typeof dirty.toString !== "function") {
-        throw typeErrorCreate("toString is not a function");
-      } else {
+      if (typeof dirty.toString === "function") {
         dirty = dirty.toString();
         if (typeof dirty !== "string") {
           throw typeErrorCreate("dirty is not a string, aborting");
         }
+      } else {
+        throw typeErrorCreate("toString is not a function");
       }
     }
     if (!DOMPurify.isSupported) {
@@ -18853,7 +18829,7 @@ function createDOMPurify() {
     }
     if (IN_PLACE) {
       if (dirty.nodeName) {
-        var tagName = transformCaseFunc(dirty.nodeName);
+        const tagName = transformCaseFunc(dirty.nodeName);
         if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
           throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
         }
@@ -18880,7 +18856,7 @@ function createDOMPurify() {
     if (body && FORCE_BODY) {
       _forceRemove(body.firstChild);
     }
-    var nodeIterator = _createIterator(IN_PLACE ? dirty : body);
+    const nodeIterator = _createIterator(IN_PLACE ? dirty : body);
     while (currentNode = nodeIterator.nextNode()) {
       if (_sanitizeElements(currentNode)) {
         continue;
@@ -18902,19 +18878,19 @@ function createDOMPurify() {
       } else {
         returnNode = body;
       }
-      if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmod) {
+      if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {
         returnNode = importNode.call(originalDocument, returnNode, true);
       }
       return returnNode;
     }
-    var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+    let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
     if (WHOLE_DOCUMENT && ALLOWED_TAGS["!doctype"] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
       serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
     }
     if (SAFE_FOR_TEMPLATES) {
-      serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$1, " ");
-      serializedHTML = stringReplace(serializedHTML, ERB_EXPR$1, " ");
-      serializedHTML = stringReplace(serializedHTML, TMPLIT_EXPR$1, " ");
+      serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR2, " ");
+      serializedHTML = stringReplace(serializedHTML, ERB_EXPR2, " ");
+      serializedHTML = stringReplace(serializedHTML, TMPLIT_EXPR2, " ");
     }
     return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
   };
@@ -18930,8 +18906,8 @@ function createDOMPurify() {
     if (!CONFIG) {
       _parseConfig({});
     }
-    var lcTag = transformCaseFunc(tag);
-    var lcName = transformCaseFunc(attr);
+    const lcTag = transformCaseFunc(tag);
+    const lcName = transformCaseFunc(attr);
     return _isValidAttribute(lcTag, lcName, value);
   };
   DOMPurify.addHook = function(entryPoint, hookFunction) {
@@ -18956,21 +18932,26 @@ function createDOMPurify() {
   };
   return DOMPurify;
 }
-var entries, setPrototypeOf, isFrozen, getPrototypeOf, getOwnPropertyDescriptor, freeze, seal, create17, _ref, apply, construct, arrayForEach, arrayPop, arrayPush, stringToLowerCase, stringToString, stringMatch, stringReplace, stringIndexOf, stringTrim, regExpTest, typeErrorCreate, html$1, svg$1, svgFilters, svgDisallowed, mathMl$1, mathMlDisallowed, text, html, svg, mathMl, xml, MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR, DATA_ATTR, ARIA_ATTR, IS_ALLOWED_URI, IS_SCRIPT_OR_DATA, ATTR_WHITESPACE, DOCTYPE_NAME, getGlobal, _createTrustedTypesPolicy, purify, dompurify_default;
+var entries, setPrototypeOf, isFrozen, getPrototypeOf, getOwnPropertyDescriptor, freeze, seal, create17, apply, construct, arrayForEach, arrayPop, arrayPush, stringToLowerCase, stringToString, stringMatch, stringReplace, stringIndexOf, stringTrim, regExpTest, typeErrorCreate, html$1, svg$1, svgFilters, svgDisallowed, mathMl$1, mathMlDisallowed, text, html, svg, mathMl, xml, MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR, DATA_ATTR, ARIA_ATTR, IS_ALLOWED_URI, IS_SCRIPT_OR_DATA, ATTR_WHITESPACE, DOCTYPE_NAME, EXPRESSIONS, getGlobal, _createTrustedTypesPolicy, purify, dompurify_default;
 var init_dompurify = __esm({
   "static/js/dompurify.js"() {
     "use strict";
-    entries = Object.entries;
-    setPrototypeOf = Object.setPrototypeOf;
-    isFrozen = Object.isFrozen;
-    getPrototypeOf = Object.getPrototypeOf;
-    getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
-    freeze = Object.freeze;
-    seal = Object.seal;
-    create17 = Object.create;
-    _ref = typeof Reflect !== "undefined" && Reflect;
-    apply = _ref.apply;
-    construct = _ref.construct;
+    ({
+      entries,
+      setPrototypeOf,
+      isFrozen,
+      getPrototypeOf,
+      getOwnPropertyDescriptor
+    } = Object);
+    ({
+      freeze,
+      seal,
+      create: create17
+    } = Object);
+    ({
+      apply,
+      construct
+    } = typeof Reflect !== "undefined" && Reflect);
     if (!apply) {
       apply = function apply2(fun, thisValue, args) {
         return fun.apply(thisValue, args);
@@ -18988,7 +18969,7 @@ var init_dompurify = __esm({
     }
     if (!construct) {
       construct = function construct2(Func, args) {
-        return _construct(Func, _toConsumableArray(args));
+        return new Func(...args);
       };
     }
     arrayForEach = unapply(Array.prototype.forEach);
@@ -19004,9 +18985,9 @@ var init_dompurify = __esm({
     typeErrorCreate = unconstruct(TypeError);
     html$1 = freeze(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "section", "select", "shadow", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]);
     svg$1 = freeze(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]);
-    svgFilters = freeze(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]);
-    svgDisallowed = freeze(["animate", "color-profile", "cursor", "discard", "fedropshadow", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]);
-    mathMl$1 = freeze(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover"]);
+    svgFilters = freeze(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]);
+    svgDisallowed = freeze(["animate", "color-profile", "cursor", "discard", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]);
+    mathMl$1 = freeze(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "mprescripts"]);
     mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]);
     text = freeze(["#text"]);
     html = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "pattern", "placeholder", "playsinline", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "xmlns", "slot"]);
@@ -19018,29 +18999,39 @@ var init_dompurify = __esm({
     TMPLIT_EXPR = seal(/\${[\w\W]*}/gm);
     DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/);
     ARIA_ATTR = seal(/^aria-[\-\w]+$/);
-    IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i);
+    IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i);
     IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
     ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g);
     DOCTYPE_NAME = seal(/^html$/i);
-    getGlobal = function getGlobal2() {
-      return typeof window === "undefined" ? null : window;
-    };
-    _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes, document2) {
-      if (_typeof(trustedTypes) !== "object" || typeof trustedTypes.createPolicy !== "function") {
+    EXPRESSIONS = /* @__PURE__ */ Object.freeze({
+      __proto__: null,
+      MUSTACHE_EXPR,
+      ERB_EXPR,
+      TMPLIT_EXPR,
+      DATA_ATTR,
+      ARIA_ATTR,
+      IS_ALLOWED_URI,
+      IS_SCRIPT_OR_DATA,
+      ATTR_WHITESPACE,
+      DOCTYPE_NAME
+    });
+    getGlobal = () => typeof window === "undefined" ? null : window;
+    _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes, purifyHostElement) {
+      if (typeof trustedTypes !== "object" || typeof trustedTypes.createPolicy !== "function") {
         return null;
       }
-      var suffix = null;
-      var ATTR_NAME = "data-tt-policy-suffix";
-      if (document2.currentScript && document2.currentScript.hasAttribute(ATTR_NAME)) {
-        suffix = document2.currentScript.getAttribute(ATTR_NAME);
+      let suffix = null;
+      const ATTR_NAME = "data-tt-policy-suffix";
+      if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
+        suffix = purifyHostElement.getAttribute(ATTR_NAME);
       }
-      var policyName = "dompurify" + (suffix ? "#" + suffix : "");
+      const policyName = "dompurify" + (suffix ? "#" + suffix : "");
       try {
         return trustedTypes.createPolicy(policyName, {
-          createHTML: function createHTML(html2) {
+          createHTML(html2) {
             return html2;
           },
-          createScriptURL: function createScriptURL(scriptUrl) {
+          createScriptURL(scriptUrl) {
             return scriptUrl;
           }
         });
@@ -24152,7 +24143,7 @@ var init_ViewletLayout = __esm({
       $SashPanel.id = "SashPanel";
       const $Viewlet = document.createElement("div");
       $Viewlet.id = "Workbench";
-      $Viewlet.className = "Viewlet Layout";
+      $Viewlet.className = "Viewlet Layout Workbench";
       $Viewlet.role = Application;
       $Viewlet.append($SashSideBar, $SashPanel);
       const browser = getBrowser();
@@ -28414,12 +28405,10 @@ var init_ViewletTitleBarMenuBarEvents = __esm({
       handleMouseOut3(uid, index);
     };
     getIndex3 = ($Target) => {
-      switch ($Target.className) {
-        case "TitleBarTopLevelEntry":
-          return getNodeIndex($Target);
-        default:
-          return -1;
+      if ($Target.classList.contains("TitleBarTopLevelEntry")) {
+        return getNodeIndex($Target);
       }
+      return -1;
     };
     handleClick17 = (event) => {
       const { button, target } = event;
@@ -28467,7 +28456,7 @@ __export(ViewletTitleBarMenuBar_exports, {
   setFocusedIndex: () => setFocusedIndex8,
   setMenus: () => setMenus
 });
-var activeId4, create74, attachEvents25, dispose23, focus19, create$TopLevelEntry, setFocusedIndex8, openMenu, closeMenu2, setEntries, create$Menu2, setMenus;
+var activeId4, activeClassName2, create74, attachEvents25, dispose23, focus19, create$TopLevelEntry, setFocusedIndex8, openMenu, closeMenu2, setEntries, create$Menu2, setMenus;
 var init_ViewletTitleBarMenuBar = __esm({
   "src/parts/ViewletTitleBarMenuBar/ViewletTitleBarMenuBar.js"() {
     "use strict";
@@ -28484,6 +28473,7 @@ var init_ViewletTitleBarMenuBar = __esm({
     init_Widget();
     init_ViewletTitleBarMenuBarEvents();
     activeId4 = "TitleBarEntryActive";
+    activeClassName2 = "TitleBarEntryActive";
     create74 = () => {
       const $TitleBarMenuBar = document.createElement("div");
       $TitleBarMenuBar.id = "TitleBarMenuBar";
@@ -28516,7 +28506,6 @@ var init_ViewletTitleBarMenuBar = __esm({
       $TitleBarTopLevelEntry.ariaHasPopup = True;
       $TitleBarTopLevelEntry.ariaExpanded = False;
       $TitleBarTopLevelEntry.role = MenuItem;
-      $TitleBarTopLevelEntry.style.width = `${item.width}px`;
       if (item.keyboardShortCut) {
         $TitleBarTopLevelEntry.ariaKeyShortcuts = item.keyboardShortCut;
       }
@@ -28538,6 +28527,7 @@ var init_ViewletTitleBarMenuBar = __esm({
         $Child.ariaExpanded = False;
         $Child.removeAttribute(AriaOwns);
         $Child.removeAttribute("id");
+        $Child.classList.remove(activeClassName2);
         const $Wrapper = $Child.firstChild;
         $Wrapper.remove();
         $Child.append($Wrapper.firstChild);
@@ -28546,6 +28536,7 @@ var init_ViewletTitleBarMenuBar = __esm({
         const $Child = $TitleBarMenuBar.children[focusIndex3];
         const $Node = $Child.firstChild;
         $Child.id = activeId4;
+        $Child.classList.add(activeClassName2);
         const $Label = document.createElement("div");
         $Label.className = "TitleBarTopLevelEntryLabel";
         $Label.append($Node);
@@ -30658,6 +30649,6 @@ var send2 = send;
 export {
   send2 as send
 };
-/*! @license DOMPurify 3.0.1 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.0.1/LICENSE */
+/*! @license DOMPurify 3.0.4 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.0.4/LICENSE */
 /*! MIT License © Sindre Sorhus */
 //# sourceMappingURL=rendererProcessMain.js.map