@nextcloud/files 4.0.0-beta.3 → 4.0.0-beta.5

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { l as logger, F as FileType } from "./chunks/folder-6N4fHAic.mjs";
-import { a, b, N, c, P } from "./chunks/folder-6N4fHAic.mjs";
+import { l as logger, F as FileType } from "./chunks/folder-Bf-tAYWu.mjs";
+import { a, b, N, c, P } from "./chunks/folder-Bf-tAYWu.mjs";
 import { TypedEventTarget } from "typescript-event-target";
-import require$$1 from "string_decoder";
+import isSvg from "is-svg";
 import { getCapabilities } from "@nextcloud/capabilities";
-import { extname, basename } from "path";
+import { extname, basename } from "@nextcloud/paths";
 import { getCanonicalLocale, getLanguage } from "@nextcloud/l10n";
 var DefaultType = /* @__PURE__ */ ((DefaultType2) => {
   DefaultType2["DEFAULT"] = "default";
@@ -896,62 +896,6 @@ const getFileListHeaders = function() {
   }
   return window._nc_filelistheader;
 };
-class Navigation extends TypedEventTarget {
-  _views = [];
-  _currentView = null;
-  /**
-   * Register a new view on the navigation
-   * @param view The view to register
-   * @throws `Error` is thrown if a view with the same id is already registered
-   */
-  register(view) {
-    if (this._views.find((search) => search.id === view.id)) {
-      throw new Error(`View id ${view.id} is already registered`);
-    }
-    this._views.push(view);
-    this.dispatchTypedEvent("update", new CustomEvent("update"));
-  }
-  /**
-   * Remove a registered view
-   * @param id The id of the view to remove
-   */
-  remove(id) {
-    const index = this._views.findIndex((view) => view.id === id);
-    if (index !== -1) {
-      this._views.splice(index, 1);
-      this.dispatchTypedEvent("update", new CustomEvent("update"));
-    }
-  }
-  /**
-   * Set the currently active view
-   * @fires UpdateActiveViewEvent
-   * @param view New active view
-   */
-  setActive(view) {
-    this._currentView = view;
-    const event = new CustomEvent("updateActive", { detail: view });
-    this.dispatchTypedEvent("updateActive", event);
-  }
-  /**
-   * The currently active files view
-   */
-  get active() {
-    return this._currentView;
-  }
-  /**
-   * All registered views
-   */
-  get views() {
-    return this._views;
-  }
-}
-const getNavigation = function() {
-  if (typeof window._nc_navigation === "undefined") {
-    window._nc_navigation = new Navigation();
-    logger.debug("Navigation service initialized");
-  }
-  return window._nc_navigation;
-};
 class Column {
   _column;
   constructor(column) {
@@ -992,1577 +936,10 @@ const isValidColumn = function(column) {
   }
   return true;
 };
-var sax$1 = {};
-var hasRequiredSax;
-function requireSax() {
-  if (hasRequiredSax) return sax$1;
-  hasRequiredSax = 1;
-  (function(exports) {
-    (function(sax2) {
-      sax2.parser = function(strict, opt) {
-        return new SAXParser(strict, opt);
-      };
-      sax2.SAXParser = SAXParser;
-      sax2.SAXStream = SAXStream;
-      sax2.createStream = createStream;
-      sax2.MAX_BUFFER_LENGTH = 64 * 1024;
-      var buffers = [
-        "comment",
-        "sgmlDecl",
-        "textNode",
-        "tagName",
-        "doctype",
-        "procInstName",
-        "procInstBody",
-        "entity",
-        "attribName",
-        "attribValue",
-        "cdata",
-        "script"
-      ];
-      sax2.EVENTS = [
-        "text",
-        "processinginstruction",
-        "sgmldeclaration",
-        "doctype",
-        "comment",
-        "opentagstart",
-        "attribute",
-        "opentag",
-        "closetag",
-        "opencdata",
-        "cdata",
-        "closecdata",
-        "error",
-        "end",
-        "ready",
-        "script",
-        "opennamespace",
-        "closenamespace"
-      ];
-      function SAXParser(strict, opt) {
-        if (!(this instanceof SAXParser)) {
-          return new SAXParser(strict, opt);
-        }
-        var parser = this;
-        clearBuffers(parser);
-        parser.q = parser.c = "";
-        parser.bufferCheckPosition = sax2.MAX_BUFFER_LENGTH;
-        parser.opt = opt || {};
-        parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
-        parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase";
-        parser.tags = [];
-        parser.closed = parser.closedRoot = parser.sawRoot = false;
-        parser.tag = parser.error = null;
-        parser.strict = !!strict;
-        parser.noscript = !!(strict || parser.opt.noscript);
-        parser.state = S.BEGIN;
-        parser.strictEntities = parser.opt.strictEntities;
-        parser.ENTITIES = parser.strictEntities ? Object.create(sax2.XML_ENTITIES) : Object.create(sax2.ENTITIES);
-        parser.attribList = [];
-        if (parser.opt.xmlns) {
-          parser.ns = Object.create(rootNS);
-        }
-        if (parser.opt.unquotedAttributeValues === void 0) {
-          parser.opt.unquotedAttributeValues = !strict;
-        }
-        parser.trackPosition = parser.opt.position !== false;
-        if (parser.trackPosition) {
-          parser.position = parser.line = parser.column = 0;
-        }
-        emit2(parser, "onready");
-      }
-      if (!Object.create) {
-        Object.create = function(o) {
-          function F() {
-          }
-          F.prototype = o;
-          var newf = new F();
-          return newf;
-        };
-      }
-      if (!Object.keys) {
-        Object.keys = function(o) {
-          var a2 = [];
-          for (var i in o) if (o.hasOwnProperty(i)) a2.push(i);
-          return a2;
-        };
-      }
-      function checkBufferLength(parser) {
-        var maxAllowed = Math.max(sax2.MAX_BUFFER_LENGTH, 10);
-        var maxActual = 0;
-        for (var i = 0, l = buffers.length; i < l; i++) {
-          var len = parser[buffers[i]].length;
-          if (len > maxAllowed) {
-            switch (buffers[i]) {
-              case "textNode":
-                closeText(parser);
-                break;
-              case "cdata":
-                emitNode(parser, "oncdata", parser.cdata);
-                parser.cdata = "";
-                break;
-              case "script":
-                emitNode(parser, "onscript", parser.script);
-                parser.script = "";
-                break;
-              default:
-                error(parser, "Max buffer length exceeded: " + buffers[i]);
-            }
-          }
-          maxActual = Math.max(maxActual, len);
-        }
-        var m = sax2.MAX_BUFFER_LENGTH - maxActual;
-        parser.bufferCheckPosition = m + parser.position;
-      }
-      function clearBuffers(parser) {
-        for (var i = 0, l = buffers.length; i < l; i++) {
-          parser[buffers[i]] = "";
-        }
-      }
-      function flushBuffers(parser) {
-        closeText(parser);
-        if (parser.cdata !== "") {
-          emitNode(parser, "oncdata", parser.cdata);
-          parser.cdata = "";
-        }
-        if (parser.script !== "") {
-          emitNode(parser, "onscript", parser.script);
-          parser.script = "";
-        }
-      }
-      SAXParser.prototype = {
-        end: function() {
-          end(this);
-        },
-        write,
-        resume: function() {
-          this.error = null;
-          return this;
-        },
-        close: function() {
-          return this.write(null);
-        },
-        flush: function() {
-          flushBuffers(this);
-        }
-      };
-      var Stream;
-      try {
-        Stream = require("stream").Stream;
-      } catch (ex) {
-        Stream = function() {
-        };
-      }
-      if (!Stream) Stream = function() {
-      };
-      var streamWraps = sax2.EVENTS.filter(function(ev) {
-        return ev !== "error" && ev !== "end";
-      });
-      function createStream(strict, opt) {
-        return new SAXStream(strict, opt);
-      }
-      function SAXStream(strict, opt) {
-        if (!(this instanceof SAXStream)) {
-          return new SAXStream(strict, opt);
-        }
-        Stream.apply(this);
-        this._parser = new SAXParser(strict, opt);
-        this.writable = true;
-        this.readable = true;
-        var me = this;
-        this._parser.onend = function() {
-          me.emit("end");
-        };
-        this._parser.onerror = function(er) {
-          me.emit("error", er);
-          me._parser.error = null;
-        };
-        this._decoder = null;
-        streamWraps.forEach(function(ev) {
-          Object.defineProperty(me, "on" + ev, {
-            get: function() {
-              return me._parser["on" + ev];
-            },
-            set: function(h) {
-              if (!h) {
-                me.removeAllListeners(ev);
-                me._parser["on" + ev] = h;
-                return h;
-              }
-              me.on(ev, h);
-            },
-            enumerable: true,
-            configurable: false
-          });
-        });
-      }
-      SAXStream.prototype = Object.create(Stream.prototype, {
-        constructor: {
-          value: SAXStream
-        }
-      });
-      SAXStream.prototype.write = function(data) {
-        if (typeof Buffer === "function" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(data)) {
-          if (!this._decoder) {
-            var SD = require$$1.StringDecoder;
-            this._decoder = new SD("utf8");
-          }
-          data = this._decoder.write(data);
-        }
-        this._parser.write(data.toString());
-        this.emit("data", data);
-        return true;
-      };
-      SAXStream.prototype.end = function(chunk) {
-        if (chunk && chunk.length) {
-          this.write(chunk);
-        }
-        this._parser.end();
-        return true;
-      };
-      SAXStream.prototype.on = function(ev, handler) {
-        var me = this;
-        if (!me._parser["on" + ev] && streamWraps.indexOf(ev) !== -1) {
-          me._parser["on" + ev] = function() {
-            var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
-            args.splice(0, 0, ev);
-            me.emit.apply(me, args);
-          };
-        }
-        return Stream.prototype.on.call(me, ev, handler);
-      };
-      var CDATA = "[CDATA[";
-      var DOCTYPE = "DOCTYPE";
-      var XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
-      var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
-      var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE };
-      var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-      var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-      var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-      var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-      function isWhitespace(c2) {
-        return c2 === " " || c2 === "\n" || c2 === "\r" || c2 === "	";
-      }
-      function isQuote(c2) {
-        return c2 === '"' || c2 === "'";
-      }
-      function isAttribEnd(c2) {
-        return c2 === ">" || isWhitespace(c2);
-      }
-      function isMatch(regex, c2) {
-        return regex.test(c2);
-      }
-      function notMatch(regex, c2) {
-        return !isMatch(regex, c2);
-      }
-      var S = 0;
-      sax2.STATE = {
-        BEGIN: S++,
-        // leading byte order mark or whitespace
-        BEGIN_WHITESPACE: S++,
-        // leading whitespace
-        TEXT: S++,
-        // general stuff
-        TEXT_ENTITY: S++,
-        // &amp and such.
-        OPEN_WAKA: S++,
-        // <
-        SGML_DECL: S++,
-        // <!BLARG
-        SGML_DECL_QUOTED: S++,
-        // <!BLARG foo "bar
-        DOCTYPE: S++,
-        // <!DOCTYPE
-        DOCTYPE_QUOTED: S++,
-        // <!DOCTYPE "//blah
-        DOCTYPE_DTD: S++,
-        // <!DOCTYPE "//blah" [ ...
-        DOCTYPE_DTD_QUOTED: S++,
-        // <!DOCTYPE "//blah" [ "foo
-        COMMENT_STARTING: S++,
-        // <!-
-        COMMENT: S++,
-        // <!--
-        COMMENT_ENDING: S++,
-        // <!-- blah -
-        COMMENT_ENDED: S++,
-        // <!-- blah --
-        CDATA: S++,
-        // <![CDATA[ something
-        CDATA_ENDING: S++,
-        // ]
-        CDATA_ENDING_2: S++,
-        // ]]
-        PROC_INST: S++,
-        // <?hi
-        PROC_INST_BODY: S++,
-        // <?hi there
-        PROC_INST_ENDING: S++,
-        // <?hi "there" ?
-        OPEN_TAG: S++,
-        // <strong
-        OPEN_TAG_SLASH: S++,
-        // <strong /
-        ATTRIB: S++,
-        // <a
-        ATTRIB_NAME: S++,
-        // <a foo
-        ATTRIB_NAME_SAW_WHITE: S++,
-        // <a foo _
-        ATTRIB_VALUE: S++,
-        // <a foo=
-        ATTRIB_VALUE_QUOTED: S++,
-        // <a foo="bar
-        ATTRIB_VALUE_CLOSED: S++,
-        // <a foo="bar"
-        ATTRIB_VALUE_UNQUOTED: S++,
-        // <a foo=bar
-        ATTRIB_VALUE_ENTITY_Q: S++,
-        // <foo bar="&quot;"
-        ATTRIB_VALUE_ENTITY_U: S++,
-        // <foo bar=&quot
-        CLOSE_TAG: S++,
-        // </a
-        CLOSE_TAG_SAW_WHITE: S++,
-        // </a   >
-        SCRIPT: S++,
-        // <script> ...
-        SCRIPT_ENDING: S++
-        // <script> ... <
-      };
-      sax2.XML_ENTITIES = {
-        "amp": "&",
-        "gt": ">",
-        "lt": "<",
-        "quot": '"',
-        "apos": "'"
-      };
-      sax2.ENTITIES = {
-        "amp": "&",
-        "gt": ">",
-        "lt": "<",
-        "quot": '"',
-        "apos": "'",
-        "AElig": 198,
-        "Aacute": 193,
-        "Acirc": 194,
-        "Agrave": 192,
-        "Aring": 197,
-        "Atilde": 195,
-        "Auml": 196,
-        "Ccedil": 199,
-        "ETH": 208,
-        "Eacute": 201,
-        "Ecirc": 202,
-        "Egrave": 200,
-        "Euml": 203,
-        "Iacute": 205,
-        "Icirc": 206,
-        "Igrave": 204,
-        "Iuml": 207,
-        "Ntilde": 209,
-        "Oacute": 211,
-        "Ocirc": 212,
-        "Ograve": 210,
-        "Oslash": 216,
-        "Otilde": 213,
-        "Ouml": 214,
-        "THORN": 222,
-        "Uacute": 218,
-        "Ucirc": 219,
-        "Ugrave": 217,
-        "Uuml": 220,
-        "Yacute": 221,
-        "aacute": 225,
-        "acirc": 226,
-        "aelig": 230,
-        "agrave": 224,
-        "aring": 229,
-        "atilde": 227,
-        "auml": 228,
-        "ccedil": 231,
-        "eacute": 233,
-        "ecirc": 234,
-        "egrave": 232,
-        "eth": 240,
-        "euml": 235,
-        "iacute": 237,
-        "icirc": 238,
-        "igrave": 236,
-        "iuml": 239,
-        "ntilde": 241,
-        "oacute": 243,
-        "ocirc": 244,
-        "ograve": 242,
-        "oslash": 248,
-        "otilde": 245,
-        "ouml": 246,
-        "szlig": 223,
-        "thorn": 254,
-        "uacute": 250,
-        "ucirc": 251,
-        "ugrave": 249,
-        "uuml": 252,
-        "yacute": 253,
-        "yuml": 255,
-        "copy": 169,
-        "reg": 174,
-        "nbsp": 160,
-        "iexcl": 161,
-        "cent": 162,
-        "pound": 163,
-        "curren": 164,
-        "yen": 165,
-        "brvbar": 166,
-        "sect": 167,
-        "uml": 168,
-        "ordf": 170,
-        "laquo": 171,
-        "not": 172,
-        "shy": 173,
-        "macr": 175,
-        "deg": 176,
-        "plusmn": 177,
-        "sup1": 185,
-        "sup2": 178,
-        "sup3": 179,
-        "acute": 180,
-        "micro": 181,
-        "para": 182,
-        "middot": 183,
-        "cedil": 184,
-        "ordm": 186,
-        "raquo": 187,
-        "frac14": 188,
-        "frac12": 189,
-        "frac34": 190,
-        "iquest": 191,
-        "times": 215,
-        "divide": 247,
-        "OElig": 338,
-        "oelig": 339,
-        "Scaron": 352,
-        "scaron": 353,
-        "Yuml": 376,
-        "fnof": 402,
-        "circ": 710,
-        "tilde": 732,
-        "Alpha": 913,
-        "Beta": 914,
-        "Gamma": 915,
-        "Delta": 916,
-        "Epsilon": 917,
-        "Zeta": 918,
-        "Eta": 919,
-        "Theta": 920,
-        "Iota": 921,
-        "Kappa": 922,
-        "Lambda": 923,
-        "Mu": 924,
-        "Nu": 925,
-        "Xi": 926,
-        "Omicron": 927,
-        "Pi": 928,
-        "Rho": 929,
-        "Sigma": 931,
-        "Tau": 932,
-        "Upsilon": 933,
-        "Phi": 934,
-        "Chi": 935,
-        "Psi": 936,
-        "Omega": 937,
-        "alpha": 945,
-        "beta": 946,
-        "gamma": 947,
-        "delta": 948,
-        "epsilon": 949,
-        "zeta": 950,
-        "eta": 951,
-        "theta": 952,
-        "iota": 953,
-        "kappa": 954,
-        "lambda": 955,
-        "mu": 956,
-        "nu": 957,
-        "xi": 958,
-        "omicron": 959,
-        "pi": 960,
-        "rho": 961,
-        "sigmaf": 962,
-        "sigma": 963,
-        "tau": 964,
-        "upsilon": 965,
-        "phi": 966,
-        "chi": 967,
-        "psi": 968,
-        "omega": 969,
-        "thetasym": 977,
-        "upsih": 978,
-        "piv": 982,
-        "ensp": 8194,
-        "emsp": 8195,
-        "thinsp": 8201,
-        "zwnj": 8204,
-        "zwj": 8205,
-        "lrm": 8206,
-        "rlm": 8207,
-        "ndash": 8211,
-        "mdash": 8212,
-        "lsquo": 8216,
-        "rsquo": 8217,
-        "sbquo": 8218,
-        "ldquo": 8220,
-        "rdquo": 8221,
-        "bdquo": 8222,
-        "dagger": 8224,
-        "Dagger": 8225,
-        "bull": 8226,
-        "hellip": 8230,
-        "permil": 8240,
-        "prime": 8242,
-        "Prime": 8243,
-        "lsaquo": 8249,
-        "rsaquo": 8250,
-        "oline": 8254,
-        "frasl": 8260,
-        "euro": 8364,
-        "image": 8465,
-        "weierp": 8472,
-        "real": 8476,
-        "trade": 8482,
-        "alefsym": 8501,
-        "larr": 8592,
-        "uarr": 8593,
-        "rarr": 8594,
-        "darr": 8595,
-        "harr": 8596,
-        "crarr": 8629,
-        "lArr": 8656,
-        "uArr": 8657,
-        "rArr": 8658,
-        "dArr": 8659,
-        "hArr": 8660,
-        "forall": 8704,
-        "part": 8706,
-        "exist": 8707,
-        "empty": 8709,
-        "nabla": 8711,
-        "isin": 8712,
-        "notin": 8713,
-        "ni": 8715,
-        "prod": 8719,
-        "sum": 8721,
-        "minus": 8722,
-        "lowast": 8727,
-        "radic": 8730,
-        "prop": 8733,
-        "infin": 8734,
-        "ang": 8736,
-        "and": 8743,
-        "or": 8744,
-        "cap": 8745,
-        "cup": 8746,
-        "int": 8747,
-        "there4": 8756,
-        "sim": 8764,
-        "cong": 8773,
-        "asymp": 8776,
-        "ne": 8800,
-        "equiv": 8801,
-        "le": 8804,
-        "ge": 8805,
-        "sub": 8834,
-        "sup": 8835,
-        "nsub": 8836,
-        "sube": 8838,
-        "supe": 8839,
-        "oplus": 8853,
-        "otimes": 8855,
-        "perp": 8869,
-        "sdot": 8901,
-        "lceil": 8968,
-        "rceil": 8969,
-        "lfloor": 8970,
-        "rfloor": 8971,
-        "lang": 9001,
-        "rang": 9002,
-        "loz": 9674,
-        "spades": 9824,
-        "clubs": 9827,
-        "hearts": 9829,
-        "diams": 9830
-      };
-      Object.keys(sax2.ENTITIES).forEach(function(key) {
-        var e = sax2.ENTITIES[key];
-        var s2 = typeof e === "number" ? String.fromCharCode(e) : e;
-        sax2.ENTITIES[key] = s2;
-      });
-      for (var s in sax2.STATE) {
-        sax2.STATE[sax2.STATE[s]] = s;
-      }
-      S = sax2.STATE;
-      function emit2(parser, event, data) {
-        parser[event] && parser[event](data);
-      }
-      function emitNode(parser, nodeType, data) {
-        if (parser.textNode) closeText(parser);
-        emit2(parser, nodeType, data);
-      }
-      function closeText(parser) {
-        parser.textNode = textopts(parser.opt, parser.textNode);
-        if (parser.textNode) emit2(parser, "ontext", parser.textNode);
-        parser.textNode = "";
-      }
-      function textopts(opt, text) {
-        if (opt.trim) text = text.trim();
-        if (opt.normalize) text = text.replace(/\s+/g, " ");
-        return text;
-      }
-      function error(parser, er) {
-        closeText(parser);
-        if (parser.trackPosition) {
-          er += "\nLine: " + parser.line + "\nColumn: " + parser.column + "\nChar: " + parser.c;
-        }
-        er = new Error(er);
-        parser.error = er;
-        emit2(parser, "onerror", er);
-        return parser;
-      }
-      function end(parser) {
-        if (parser.sawRoot && !parser.closedRoot) strictFail(parser, "Unclosed root tag");
-        if (parser.state !== S.BEGIN && parser.state !== S.BEGIN_WHITESPACE && parser.state !== S.TEXT) {
-          error(parser, "Unexpected end");
-        }
-        closeText(parser);
-        parser.c = "";
-        parser.closed = true;
-        emit2(parser, "onend");
-        SAXParser.call(parser, parser.strict, parser.opt);
-        return parser;
-      }
-      function strictFail(parser, message) {
-        if (typeof parser !== "object" || !(parser instanceof SAXParser)) {
-          throw new Error("bad call to strictFail");
-        }
-        if (parser.strict) {
-          error(parser, message);
-        }
-      }
-      function newTag(parser) {
-        if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]();
-        var parent = parser.tags[parser.tags.length - 1] || parser;
-        var tag = parser.tag = { name: parser.tagName, attributes: {} };
-        if (parser.opt.xmlns) {
-          tag.ns = parent.ns;
-        }
-        parser.attribList.length = 0;
-        emitNode(parser, "onopentagstart", tag);
-      }
-      function qname(name, attribute) {
-        var i = name.indexOf(":");
-        var qualName = i < 0 ? ["", name] : name.split(":");
-        var prefix = qualName[0];
-        var local = qualName[1];
-        if (attribute && name === "xmlns") {
-          prefix = "xmlns";
-          local = "";
-        }
-        return { prefix, local };
-      }
-      function attrib(parser) {
-        if (!parser.strict) {
-          parser.attribName = parser.attribName[parser.looseCase]();
-        }
-        if (parser.attribList.indexOf(parser.attribName) !== -1 || parser.tag.attributes.hasOwnProperty(parser.attribName)) {
-          parser.attribName = parser.attribValue = "";
-          return;
-        }
-        if (parser.opt.xmlns) {
-          var qn = qname(parser.attribName, true);
-          var prefix = qn.prefix;
-          var local = qn.local;
-          if (prefix === "xmlns") {
-            if (local === "xml" && parser.attribValue !== XML_NAMESPACE) {
-              strictFail(
-                parser,
-                "xml: prefix must be bound to " + XML_NAMESPACE + "\nActual: " + parser.attribValue
-              );
-            } else if (local === "xmlns" && parser.attribValue !== XMLNS_NAMESPACE) {
-              strictFail(
-                parser,
-                "xmlns: prefix must be bound to " + XMLNS_NAMESPACE + "\nActual: " + parser.attribValue
-              );
-            } else {
-              var tag = parser.tag;
-              var parent = parser.tags[parser.tags.length - 1] || parser;
-              if (tag.ns === parent.ns) {
-                tag.ns = Object.create(parent.ns);
-              }
-              tag.ns[local] = parser.attribValue;
-            }
-          }
-          parser.attribList.push([parser.attribName, parser.attribValue]);
-        } else {
-          parser.tag.attributes[parser.attribName] = parser.attribValue;
-          emitNode(parser, "onattribute", {
-            name: parser.attribName,
-            value: parser.attribValue
-          });
-        }
-        parser.attribName = parser.attribValue = "";
-      }
-      function openTag(parser, selfClosing) {
-        if (parser.opt.xmlns) {
-          var tag = parser.tag;
-          var qn = qname(parser.tagName);
-          tag.prefix = qn.prefix;
-          tag.local = qn.local;
-          tag.uri = tag.ns[qn.prefix] || "";
-          if (tag.prefix && !tag.uri) {
-            strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(parser.tagName));
-            tag.uri = qn.prefix;
-          }
-          var parent = parser.tags[parser.tags.length - 1] || parser;
-          if (tag.ns && parent.ns !== tag.ns) {
-            Object.keys(tag.ns).forEach(function(p) {
-              emitNode(parser, "onopennamespace", {
-                prefix: p,
-                uri: tag.ns[p]
-              });
-            });
-          }
-          for (var i = 0, l = parser.attribList.length; i < l; i++) {
-            var nv = parser.attribList[i];
-            var name = nv[0];
-            var value = nv[1];
-            var qualName = qname(name, true);
-            var prefix = qualName.prefix;
-            var local = qualName.local;
-            var uri = prefix === "" ? "" : tag.ns[prefix] || "";
-            var a2 = {
-              name,
-              value,
-              prefix,
-              local,
-              uri
-            };
-            if (prefix && prefix !== "xmlns" && !uri) {
-              strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(prefix));
-              a2.uri = prefix;
-            }
-            parser.tag.attributes[name] = a2;
-            emitNode(parser, "onattribute", a2);
-          }
-          parser.attribList.length = 0;
-        }
-        parser.tag.isSelfClosing = !!selfClosing;
-        parser.sawRoot = true;
-        parser.tags.push(parser.tag);
-        emitNode(parser, "onopentag", parser.tag);
-        if (!selfClosing) {
-          if (!parser.noscript && parser.tagName.toLowerCase() === "script") {
-            parser.state = S.SCRIPT;
-          } else {
-            parser.state = S.TEXT;
-          }
-          parser.tag = null;
-          parser.tagName = "";
-        }
-        parser.attribName = parser.attribValue = "";
-        parser.attribList.length = 0;
-      }
-      function closeTag(parser) {
-        if (!parser.tagName) {
-          strictFail(parser, "Weird empty close tag.");
-          parser.textNode += "</>";
-          parser.state = S.TEXT;
-          return;
-        }
-        if (parser.script) {
-          if (parser.tagName !== "script") {
-            parser.script += "</" + parser.tagName + ">";
-            parser.tagName = "";
-            parser.state = S.SCRIPT;
-            return;
-          }
-          emitNode(parser, "onscript", parser.script);
-          parser.script = "";
-        }
-        var t = parser.tags.length;
-        var tagName = parser.tagName;
-        if (!parser.strict) {
-          tagName = tagName[parser.looseCase]();
-        }
-        var closeTo = tagName;
-        while (t--) {
-          var close = parser.tags[t];
-          if (close.name !== closeTo) {
-            strictFail(parser, "Unexpected close tag");
-          } else {
-            break;
-          }
-        }
-        if (t < 0) {
-          strictFail(parser, "Unmatched closing tag: " + parser.tagName);
-          parser.textNode += "</" + parser.tagName + ">";
-          parser.state = S.TEXT;
-          return;
-        }
-        parser.tagName = tagName;
-        var s2 = parser.tags.length;
-        while (s2-- > t) {
-          var tag = parser.tag = parser.tags.pop();
-          parser.tagName = parser.tag.name;
-          emitNode(parser, "onclosetag", parser.tagName);
-          var x = {};
-          for (var i in tag.ns) {
-            x[i] = tag.ns[i];
-          }
-          var parent = parser.tags[parser.tags.length - 1] || parser;
-          if (parser.opt.xmlns && tag.ns !== parent.ns) {
-            Object.keys(tag.ns).forEach(function(p) {
-              var n = tag.ns[p];
-              emitNode(parser, "onclosenamespace", { prefix: p, uri: n });
-            });
-          }
-        }
-        if (t === 0) parser.closedRoot = true;
-        parser.tagName = parser.attribValue = parser.attribName = "";
-        parser.attribList.length = 0;
-        parser.state = S.TEXT;
-      }
-      function parseEntity(parser) {
-        var entity = parser.entity;
-        var entityLC = entity.toLowerCase();
-        var num;
-        var numStr = "";
-        if (parser.ENTITIES[entity]) {
-          return parser.ENTITIES[entity];
-        }
-        if (parser.ENTITIES[entityLC]) {
-          return parser.ENTITIES[entityLC];
-        }
-        entity = entityLC;
-        if (entity.charAt(0) === "#") {
-          if (entity.charAt(1) === "x") {
-            entity = entity.slice(2);
-            num = parseInt(entity, 16);
-            numStr = num.toString(16);
-          } else {
-            entity = entity.slice(1);
-            num = parseInt(entity, 10);
-            numStr = num.toString(10);
-          }
-        }
-        entity = entity.replace(/^0+/, "");
-        if (isNaN(num) || numStr.toLowerCase() !== entity) {
-          strictFail(parser, "Invalid character entity");
-          return "&" + parser.entity + ";";
-        }
-        return String.fromCodePoint(num);
-      }
-      function beginWhiteSpace(parser, c2) {
-        if (c2 === "<") {
-          parser.state = S.OPEN_WAKA;
-          parser.startTagPosition = parser.position;
-        } else if (!isWhitespace(c2)) {
-          strictFail(parser, "Non-whitespace before first tag.");
-          parser.textNode = c2;
-          parser.state = S.TEXT;
-        }
-      }
-      function charAt(chunk, i) {
-        var result = "";
-        if (i < chunk.length) {
-          result = chunk.charAt(i);
-        }
-        return result;
-      }
-      function write(chunk) {
-        var parser = this;
-        if (this.error) {
-          throw this.error;
-        }
-        if (parser.closed) {
-          return error(
-            parser,
-            "Cannot write after close. Assign an onready handler."
-          );
-        }
-        if (chunk === null) {
-          return end(parser);
-        }
-        if (typeof chunk === "object") {
-          chunk = chunk.toString();
-        }
-        var i = 0;
-        var c2 = "";
-        while (true) {
-          c2 = charAt(chunk, i++);
-          parser.c = c2;
-          if (!c2) {
-            break;
-          }
-          if (parser.trackPosition) {
-            parser.position++;
-            if (c2 === "\n") {
-              parser.line++;
-              parser.column = 0;
-            } else {
-              parser.column++;
-            }
-          }
-          switch (parser.state) {
-            case S.BEGIN:
-              parser.state = S.BEGIN_WHITESPACE;
-              if (c2 === "\uFEFF") {
-                continue;
-              }
-              beginWhiteSpace(parser, c2);
-              continue;
-            case S.BEGIN_WHITESPACE:
-              beginWhiteSpace(parser, c2);
-              continue;
-            case S.TEXT:
-              if (parser.sawRoot && !parser.closedRoot) {
-                var starti = i - 1;
-                while (c2 && c2 !== "<" && c2 !== "&") {
-                  c2 = charAt(chunk, i++);
-                  if (c2 && parser.trackPosition) {
-                    parser.position++;
-                    if (c2 === "\n") {
-                      parser.line++;
-                      parser.column = 0;
-                    } else {
-                      parser.column++;
-                    }
-                  }
-                }
-                parser.textNode += chunk.substring(starti, i - 1);
-              }
-              if (c2 === "<" && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
-                parser.state = S.OPEN_WAKA;
-                parser.startTagPosition = parser.position;
-              } else {
-                if (!isWhitespace(c2) && (!parser.sawRoot || parser.closedRoot)) {
-                  strictFail(parser, "Text data outside of root node.");
-                }
-                if (c2 === "&") {
-                  parser.state = S.TEXT_ENTITY;
-                } else {
-                  parser.textNode += c2;
-                }
-              }
-              continue;
-            case S.SCRIPT:
-              if (c2 === "<") {
-                parser.state = S.SCRIPT_ENDING;
-              } else {
-                parser.script += c2;
-              }
-              continue;
-            case S.SCRIPT_ENDING:
-              if (c2 === "/") {
-                parser.state = S.CLOSE_TAG;
-              } else {
-                parser.script += "<" + c2;
-                parser.state = S.SCRIPT;
-              }
-              continue;
-            case S.OPEN_WAKA:
-              if (c2 === "!") {
-                parser.state = S.SGML_DECL;
-                parser.sgmlDecl = "";
-              } else if (isWhitespace(c2)) ;
-              else if (isMatch(nameStart, c2)) {
-                parser.state = S.OPEN_TAG;
-                parser.tagName = c2;
-              } else if (c2 === "/") {
-                parser.state = S.CLOSE_TAG;
-                parser.tagName = "";
-              } else if (c2 === "?") {
-                parser.state = S.PROC_INST;
-                parser.procInstName = parser.procInstBody = "";
-              } else {
-                strictFail(parser, "Unencoded <");
-                if (parser.startTagPosition + 1 < parser.position) {
-                  var pad = parser.position - parser.startTagPosition;
-                  c2 = new Array(pad).join(" ") + c2;
-                }
-                parser.textNode += "<" + c2;
-                parser.state = S.TEXT;
-              }
-              continue;
-            case S.SGML_DECL:
-              if (parser.sgmlDecl + c2 === "--") {
-                parser.state = S.COMMENT;
-                parser.comment = "";
-                parser.sgmlDecl = "";
-                continue;
-              }
-              if (parser.doctype && parser.doctype !== true && parser.sgmlDecl) {
-                parser.state = S.DOCTYPE_DTD;
-                parser.doctype += "<!" + parser.sgmlDecl + c2;
-                parser.sgmlDecl = "";
-              } else if ((parser.sgmlDecl + c2).toUpperCase() === CDATA) {
-                emitNode(parser, "onopencdata");
-                parser.state = S.CDATA;
-                parser.sgmlDecl = "";
-                parser.cdata = "";
-              } else if ((parser.sgmlDecl + c2).toUpperCase() === DOCTYPE) {
-                parser.state = S.DOCTYPE;
-                if (parser.doctype || parser.sawRoot) {
-                  strictFail(
-                    parser,
-                    "Inappropriately located doctype declaration"
-                  );
-                }
-                parser.doctype = "";
-                parser.sgmlDecl = "";
-              } else if (c2 === ">") {
-                emitNode(parser, "onsgmldeclaration", parser.sgmlDecl);
-                parser.sgmlDecl = "";
-                parser.state = S.TEXT;
-              } else if (isQuote(c2)) {
-                parser.state = S.SGML_DECL_QUOTED;
-                parser.sgmlDecl += c2;
-              } else {
-                parser.sgmlDecl += c2;
-              }
-              continue;
-            case S.SGML_DECL_QUOTED:
-              if (c2 === parser.q) {
-                parser.state = S.SGML_DECL;
-                parser.q = "";
-              }
-              parser.sgmlDecl += c2;
-              continue;
-            case S.DOCTYPE:
-              if (c2 === ">") {
-                parser.state = S.TEXT;
-                emitNode(parser, "ondoctype", parser.doctype);
-                parser.doctype = true;
-              } else {
-                parser.doctype += c2;
-                if (c2 === "[") {
-                  parser.state = S.DOCTYPE_DTD;
-                } else if (isQuote(c2)) {
-                  parser.state = S.DOCTYPE_QUOTED;
-                  parser.q = c2;
-                }
-              }
-              continue;
-            case S.DOCTYPE_QUOTED:
-              parser.doctype += c2;
-              if (c2 === parser.q) {
-                parser.q = "";
-                parser.state = S.DOCTYPE;
-              }
-              continue;
-            case S.DOCTYPE_DTD:
-              if (c2 === "]") {
-                parser.doctype += c2;
-                parser.state = S.DOCTYPE;
-              } else if (c2 === "<") {
-                parser.state = S.OPEN_WAKA;
-                parser.startTagPosition = parser.position;
-              } else if (isQuote(c2)) {
-                parser.doctype += c2;
-                parser.state = S.DOCTYPE_DTD_QUOTED;
-                parser.q = c2;
-              } else {
-                parser.doctype += c2;
-              }
-              continue;
-            case S.DOCTYPE_DTD_QUOTED:
-              parser.doctype += c2;
-              if (c2 === parser.q) {
-                parser.state = S.DOCTYPE_DTD;
-                parser.q = "";
-              }
-              continue;
-            case S.COMMENT:
-              if (c2 === "-") {
-                parser.state = S.COMMENT_ENDING;
-              } else {
-                parser.comment += c2;
-              }
-              continue;
-            case S.COMMENT_ENDING:
-              if (c2 === "-") {
-                parser.state = S.COMMENT_ENDED;
-                parser.comment = textopts(parser.opt, parser.comment);
-                if (parser.comment) {
-                  emitNode(parser, "oncomment", parser.comment);
-                }
-                parser.comment = "";
-              } else {
-                parser.comment += "-" + c2;
-                parser.state = S.COMMENT;
-              }
-              continue;
-            case S.COMMENT_ENDED:
-              if (c2 !== ">") {
-                strictFail(parser, "Malformed comment");
-                parser.comment += "--" + c2;
-                parser.state = S.COMMENT;
-              } else if (parser.doctype && parser.doctype !== true) {
-                parser.state = S.DOCTYPE_DTD;
-              } else {
-                parser.state = S.TEXT;
-              }
-              continue;
-            case S.CDATA:
-              if (c2 === "]") {
-                parser.state = S.CDATA_ENDING;
-              } else {
-                parser.cdata += c2;
-              }
-              continue;
-            case S.CDATA_ENDING:
-              if (c2 === "]") {
-                parser.state = S.CDATA_ENDING_2;
-              } else {
-                parser.cdata += "]" + c2;
-                parser.state = S.CDATA;
-              }
-              continue;
-            case S.CDATA_ENDING_2:
-              if (c2 === ">") {
-                if (parser.cdata) {
-                  emitNode(parser, "oncdata", parser.cdata);
-                }
-                emitNode(parser, "onclosecdata");
-                parser.cdata = "";
-                parser.state = S.TEXT;
-              } else if (c2 === "]") {
-                parser.cdata += "]";
-              } else {
-                parser.cdata += "]]" + c2;
-                parser.state = S.CDATA;
-              }
-              continue;
-            case S.PROC_INST:
-              if (c2 === "?") {
-                parser.state = S.PROC_INST_ENDING;
-              } else if (isWhitespace(c2)) {
-                parser.state = S.PROC_INST_BODY;
-              } else {
-                parser.procInstName += c2;
-              }
-              continue;
-            case S.PROC_INST_BODY:
-              if (!parser.procInstBody && isWhitespace(c2)) {
-                continue;
-              } else if (c2 === "?") {
-                parser.state = S.PROC_INST_ENDING;
-              } else {
-                parser.procInstBody += c2;
-              }
-              continue;
-            case S.PROC_INST_ENDING:
-              if (c2 === ">") {
-                emitNode(parser, "onprocessinginstruction", {
-                  name: parser.procInstName,
-                  body: parser.procInstBody
-                });
-                parser.procInstName = parser.procInstBody = "";
-                parser.state = S.TEXT;
-              } else {
-                parser.procInstBody += "?" + c2;
-                parser.state = S.PROC_INST_BODY;
-              }
-              continue;
-            case S.OPEN_TAG:
-              if (isMatch(nameBody, c2)) {
-                parser.tagName += c2;
-              } else {
-                newTag(parser);
-                if (c2 === ">") {
-                  openTag(parser);
-                } else if (c2 === "/") {
-                  parser.state = S.OPEN_TAG_SLASH;
-                } else {
-                  if (!isWhitespace(c2)) {
-                    strictFail(parser, "Invalid character in tag name");
-                  }
-                  parser.state = S.ATTRIB;
-                }
-              }
-              continue;
-            case S.OPEN_TAG_SLASH:
-              if (c2 === ">") {
-                openTag(parser, true);
-                closeTag(parser);
-              } else {
-                strictFail(parser, "Forward-slash in opening tag not followed by >");
-                parser.state = S.ATTRIB;
-              }
-              continue;
-            case S.ATTRIB:
-              if (isWhitespace(c2)) {
-                continue;
-              } else if (c2 === ">") {
-                openTag(parser);
-              } else if (c2 === "/") {
-                parser.state = S.OPEN_TAG_SLASH;
-              } else if (isMatch(nameStart, c2)) {
-                parser.attribName = c2;
-                parser.attribValue = "";
-                parser.state = S.ATTRIB_NAME;
-              } else {
-                strictFail(parser, "Invalid attribute name");
-              }
-              continue;
-            case S.ATTRIB_NAME:
-              if (c2 === "=") {
-                parser.state = S.ATTRIB_VALUE;
-              } else if (c2 === ">") {
-                strictFail(parser, "Attribute without value");
-                parser.attribValue = parser.attribName;
-                attrib(parser);
-                openTag(parser);
-              } else if (isWhitespace(c2)) {
-                parser.state = S.ATTRIB_NAME_SAW_WHITE;
-              } else if (isMatch(nameBody, c2)) {
-                parser.attribName += c2;
-              } else {
-                strictFail(parser, "Invalid attribute name");
-              }
-              continue;
-            case S.ATTRIB_NAME_SAW_WHITE:
-              if (c2 === "=") {
-                parser.state = S.ATTRIB_VALUE;
-              } else if (isWhitespace(c2)) {
-                continue;
-              } else {
-                strictFail(parser, "Attribute without value");
-                parser.tag.attributes[parser.attribName] = "";
-                parser.attribValue = "";
-                emitNode(parser, "onattribute", {
-                  name: parser.attribName,
-                  value: ""
-                });
-                parser.attribName = "";
-                if (c2 === ">") {
-                  openTag(parser);
-                } else if (isMatch(nameStart, c2)) {
-                  parser.attribName = c2;
-                  parser.state = S.ATTRIB_NAME;
-                } else {
-                  strictFail(parser, "Invalid attribute name");
-                  parser.state = S.ATTRIB;
-                }
-              }
-              continue;
-            case S.ATTRIB_VALUE:
-              if (isWhitespace(c2)) {
-                continue;
-              } else if (isQuote(c2)) {
-                parser.q = c2;
-                parser.state = S.ATTRIB_VALUE_QUOTED;
-              } else {
-                if (!parser.opt.unquotedAttributeValues) {
-                  error(parser, "Unquoted attribute value");
-                }
-                parser.state = S.ATTRIB_VALUE_UNQUOTED;
-                parser.attribValue = c2;
-              }
-              continue;
-            case S.ATTRIB_VALUE_QUOTED:
-              if (c2 !== parser.q) {
-                if (c2 === "&") {
-                  parser.state = S.ATTRIB_VALUE_ENTITY_Q;
-                } else {
-                  parser.attribValue += c2;
-                }
-                continue;
-              }
-              attrib(parser);
-              parser.q = "";
-              parser.state = S.ATTRIB_VALUE_CLOSED;
-              continue;
-            case S.ATTRIB_VALUE_CLOSED:
-              if (isWhitespace(c2)) {
-                parser.state = S.ATTRIB;
-              } else if (c2 === ">") {
-                openTag(parser);
-              } else if (c2 === "/") {
-                parser.state = S.OPEN_TAG_SLASH;
-              } else if (isMatch(nameStart, c2)) {
-                strictFail(parser, "No whitespace between attributes");
-                parser.attribName = c2;
-                parser.attribValue = "";
-                parser.state = S.ATTRIB_NAME;
-              } else {
-                strictFail(parser, "Invalid attribute name");
-              }
-              continue;
-            case S.ATTRIB_VALUE_UNQUOTED:
-              if (!isAttribEnd(c2)) {
-                if (c2 === "&") {
-                  parser.state = S.ATTRIB_VALUE_ENTITY_U;
-                } else {
-                  parser.attribValue += c2;
-                }
-                continue;
-              }
-              attrib(parser);
-              if (c2 === ">") {
-                openTag(parser);
-              } else {
-                parser.state = S.ATTRIB;
-              }
-              continue;
-            case S.CLOSE_TAG:
-              if (!parser.tagName) {
-                if (isWhitespace(c2)) {
-                  continue;
-                } else if (notMatch(nameStart, c2)) {
-                  if (parser.script) {
-                    parser.script += "</" + c2;
-                    parser.state = S.SCRIPT;
-                  } else {
-                    strictFail(parser, "Invalid tagname in closing tag.");
-                  }
-                } else {
-                  parser.tagName = c2;
-                }
-              } else if (c2 === ">") {
-                closeTag(parser);
-              } else if (isMatch(nameBody, c2)) {
-                parser.tagName += c2;
-              } else if (parser.script) {
-                parser.script += "</" + parser.tagName;
-                parser.tagName = "";
-                parser.state = S.SCRIPT;
-              } else {
-                if (!isWhitespace(c2)) {
-                  strictFail(parser, "Invalid tagname in closing tag");
-                }
-                parser.state = S.CLOSE_TAG_SAW_WHITE;
-              }
-              continue;
-            case S.CLOSE_TAG_SAW_WHITE:
-              if (isWhitespace(c2)) {
-                continue;
-              }
-              if (c2 === ">") {
-                closeTag(parser);
-              } else {
-                strictFail(parser, "Invalid characters in closing tag");
-              }
-              continue;
-            case S.TEXT_ENTITY:
-            case S.ATTRIB_VALUE_ENTITY_Q:
-            case S.ATTRIB_VALUE_ENTITY_U:
-              var returnState;
-              var buffer;
-              switch (parser.state) {
-                case S.TEXT_ENTITY:
-                  returnState = S.TEXT;
-                  buffer = "textNode";
-                  break;
-                case S.ATTRIB_VALUE_ENTITY_Q:
-                  returnState = S.ATTRIB_VALUE_QUOTED;
-                  buffer = "attribValue";
-                  break;
-                case S.ATTRIB_VALUE_ENTITY_U:
-                  returnState = S.ATTRIB_VALUE_UNQUOTED;
-                  buffer = "attribValue";
-                  break;
-              }
-              if (c2 === ";") {
-                var parsedEntity = parseEntity(parser);
-                if (parser.opt.unparsedEntities && !Object.values(sax2.XML_ENTITIES).includes(parsedEntity)) {
-                  parser.entity = "";
-                  parser.state = returnState;
-                  parser.write(parsedEntity);
-                } else {
-                  parser[buffer] += parsedEntity;
-                  parser.entity = "";
-                  parser.state = returnState;
-                }
-              } else if (isMatch(parser.entity.length ? entityBody : entityStart, c2)) {
-                parser.entity += c2;
-              } else {
-                strictFail(parser, "Invalid character in entity name");
-                parser[buffer] += "&" + parser.entity + c2;
-                parser.entity = "";
-                parser.state = returnState;
-              }
-              continue;
-            default: {
-              throw new Error(parser, "Unknown state: " + parser.state);
-            }
-          }
-        }
-        if (parser.position >= parser.bufferCheckPosition) {
-          checkBufferLength(parser);
-        }
-        return parser;
-      }
-      /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
-      if (!String.fromCodePoint) {
-        (function() {
-          var stringFromCharCode = String.fromCharCode;
-          var floor = Math.floor;
-          var fromCodePoint = function() {
-            var MAX_SIZE = 16384;
-            var codeUnits = [];
-            var highSurrogate;
-            var lowSurrogate;
-            var index = -1;
-            var length = arguments.length;
-            if (!length) {
-              return "";
-            }
-            var result = "";
-            while (++index < length) {
-              var codePoint = Number(arguments[index]);
-              if (!isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
-              codePoint < 0 || // not a valid Unicode code point
-              codePoint > 1114111 || // not a valid Unicode code point
-              floor(codePoint) !== codePoint) {
-                throw RangeError("Invalid code point: " + codePoint);
-              }
-              if (codePoint <= 65535) {
-                codeUnits.push(codePoint);
-              } else {
-                codePoint -= 65536;
-                highSurrogate = (codePoint >> 10) + 55296;
-                lowSurrogate = codePoint % 1024 + 56320;
-                codeUnits.push(highSurrogate, lowSurrogate);
-              }
-              if (index + 1 === length || codeUnits.length > MAX_SIZE) {
-                result += stringFromCharCode.apply(null, codeUnits);
-                codeUnits.length = 0;
-              }
-            }
-            return result;
-          };
-          if (Object.defineProperty) {
-            Object.defineProperty(String, "fromCodePoint", {
-              value: fromCodePoint,
-              configurable: true,
-              writable: true
-            });
-          } else {
-            String.fromCodePoint = fromCodePoint;
-          }
-        })();
-      }
-    })(exports);
-  })(sax$1);
-  return sax$1;
-}
-var saxExports = requireSax();
-const sax = /* @__PURE__ */ getDefaultExportFromCjs(saxExports);
-const namespaceMapping = {
-  "http://www.w3.org/2000/svg": {
-    ext: "svg",
-    mime: "image/svg+xml"
-  },
-  "http://www.w3.org/1999/xhtml": {
-    ext: "xhtml",
-    mime: "application/xhtml+xml"
-  },
-  "http://www.opengis.net/kml/2.2": {
-    ext: "kml",
-    mime: "application/vnd.google-earth.kml+xml"
-  },
-  "http://www.opengis.net/gml": {
-    ext: "gml",
-    mime: "application/gml+xml"
-  }
-};
-const rootNameMapping = {
-  rss: {
-    ext: "rss",
-    mime: "application/rss+xml"
-  },
-  "score-partwise": {
-    ext: "musicxml",
-    mime: "application/vnd.recordare.musicxml+xml"
-  },
-  svg: {
-    ext: "svg",
-    mime: "image/svg+xml"
-  }
-};
-class XmlTextDetector {
-  constructor(options) {
-    this.options = options ?? {};
-    this.firstTag = true;
-    this.onEnd = false;
-    this.parser = sax.parser(true, { xmlns: true });
-    this.nesting = 0;
-    this.parser.onerror = (e) => {
-      if (e.message.startsWith("Invalid character entity")) {
-        return;
-      }
-      this.fileType = void 0;
-      this.onEnd = true;
-    };
-    this.parser.onopentag = (node) => {
-      ++this.nesting;
-      if (!this.firstTag || this.onEnd) {
-        return;
-      }
-      this.firstTag = false;
-      if (node.uri) {
-        this.fileType = namespaceMapping[node.uri];
-      } else if (node.name) {
-        this.fileType = rootNameMapping[node.name.toLowerCase()];
-      }
-      if (this.fileType && !this.options.fullScan) {
-        this.onEnd = true;
-      }
-    };
-    this.parser.onclosetag = () => {
-      --this.nesting;
-    };
-  }
-  write(text) {
-    this.parser.write(text);
-  }
-  close() {
-    this.parser.close();
-    this.onEnd = true;
-  }
-  isValid() {
-    return this.nesting === 0;
-  }
-}
-function isSvg(string, { validate = true } = {}) {
-  if (typeof string !== "string") {
-    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
-  }
-  string = string.trim();
-  if (string.length === 0) {
-    return false;
-  }
-  const xmlTextDetector = new XmlTextDetector({ fullScan: validate });
-  if (validate) {
-    xmlTextDetector.write(string);
-    if (!xmlTextDetector.isValid()) {
-      return false;
-    }
-  } else {
-    const chunkSize = 128;
-    let offset = 0;
-    while (string.length > offset && !xmlTextDetector.onEnd) {
-      xmlTextDetector.write(string.slice(offset, Math.min(offset + chunkSize, string.length)));
-      offset += chunkSize;
-    }
-  }
-  return xmlTextDetector.fileType?.ext === "svg";
-}
 class View {
   _view;
   constructor(view) {
-    isValidView(view);
+    validateView(view);
     this._view = view;
   }
   get id() {
@@ -2629,7 +1006,7 @@ class View {
     return this._view.loadChildViews;
   }
 }
-const isValidView = function(view) {
+function validateView(view) {
   if (!view.id || typeof view.id !== "string") {
     throw new Error("View id is required and must be a string");
   }
@@ -2676,7 +1053,74 @@ const isValidView = function(view) {
   if (view.loadChildViews && typeof view.loadChildViews !== "function") {
     throw new Error("View loadChildViews must be a function");
   }
-  return true;
+}
+class Navigation extends TypedEventTarget {
+  _views = [];
+  _currentView = null;
+  /**
+   * Register a new view on the navigation
+   * @param view The view to register
+   * @throws {Error} if a view with the same id is already registered
+   * @throws {Error} if the registered view is invalid
+   */
+  register(view) {
+    if (this._views.find((search) => search.id === view.id)) {
+      throw new Error(`IView id ${view.id} is already registered`);
+    }
+    validateView(view);
+    this._views.push(view);
+    this.dispatchTypedEvent("update", new CustomEvent("update"));
+  }
+  /**
+   * Remove a registered view
+   * @param id The id of the view to remove
+   */
+  remove(id) {
+    const index = this._views.findIndex((view) => view.id === id);
+    if (index !== -1) {
+      this._views.splice(index, 1);
+      this.dispatchTypedEvent("update", new CustomEvent("update"));
+    }
+  }
+  /**
+   * Set the currently active view
+   *
+   * @param id - The id of the view to set as active
+   * @throws {Error} If no view with the given id was registered
+   * @fires UpdateActiveViewEvent
+   */
+  setActive(id) {
+    if (id === null) {
+      this._currentView = null;
+    } else {
+      const view = this._views.find(({ id: viewId }) => viewId === id);
+      if (!view) {
+        throw new Error(`No view with ${id} registered`);
+      }
+      this._currentView = view;
+    }
+    const event = new CustomEvent("updateActive", { detail: this._currentView });
+    this.dispatchTypedEvent("updateActive", event);
+  }
+  /**
+   * The currently active files view
+   */
+  get active() {
+    return this._currentView;
+  }
+  /**
+   * All registered views
+   */
+  get views() {
+    return this._views;
+  }
+}
+const getNavigation = function() {
+  if (typeof window._nc_navigation === "undefined") {
+    window._nc_navigation = new Navigation();
+    logger.debug("Navigation service initialized");
+  }
+  return window._nc_navigation;
 };
 var NewMenuEntryCategory = /* @__PURE__ */ ((NewMenuEntryCategory2) => {
   NewMenuEntryCategory2[NewMenuEntryCategory2["UploadFromDevice"] = 0] = "UploadFromDevice";
@@ -2761,6 +1205,86 @@ function getNewFileMenuEntries(context) {
     return a2.displayName.localeCompare(b2.displayName, void 0, { numeric: true, sensitivity: "base" });
   });
 }
+function registerSidebarTab(tab) {
+  validateSidebarTab(tab);
+  window._nc_files_sidebar_tabs ??= /* @__PURE__ */ new Map();
+  if (window._nc_files_sidebar_tabs.has(tab.id)) {
+    logger.warn(`Sidebar tab with id "${tab.id}" already registered. Skipping.`);
+    return;
+  }
+  window._nc_files_sidebar_tabs.set(tab.id, tab);
+  logger.debug(`New sidebar tab with id "${tab.id}" registered.`);
+}
+function getSidebarTabs() {
+  if (window._nc_files_sidebar_tabs) {
+    return [...window._nc_files_sidebar_tabs.values()];
+  }
+  return [];
+}
+function validateSidebarTab(tab) {
+  if (typeof tab !== "object") {
+    throw new Error("Sidebar tab is not an object");
+  }
+  if (!tab.id || typeof tab.id !== "string" || tab.id !== CSS.escape(tab.id)) {
+    throw new Error("Sidebar tabs need to have an id conforming to the HTML id attribute specifications");
+  }
+  if (!tab.tagName || typeof tab.tagName !== "string") {
+    throw new Error("Sidebar tabs need to have the tagName name set");
+  }
+  if (!tab.tagName.match(/^[a-z][a-z0-9-_]+$/)) {
+    throw new Error("Sidebar tabs tagName name is invalid");
+  }
+  if (!tab.displayName || typeof tab.displayName !== "string") {
+    throw new Error("Sidebar tabs need to have a name set");
+  }
+  if (typeof tab.iconSvgInline !== "string" || !isSvg(tab.iconSvgInline)) {
+    throw new Error("Sidebar tabs need to have an valid SVG icon");
+  }
+  if (typeof tab.order !== "number") {
+    throw new Error("Sidebar tabs need to have a numeric order set");
+  }
+  if (typeof tab.enabled !== "function") {
+    throw new Error('Sidebar tabs need to have an "enabled" method');
+  }
+  const tagConstructor = window.customElements.get(tab.tagName);
+  if (!tagConstructor) {
+    throw new Error("Sidebar tab element not registered");
+  }
+  if (!("setActive" in tagConstructor.prototype)) {
+    throw new Error("Sidebar tab elements must have the `setActive` method");
+  }
+}
+class SidebarProxy {
+  get available() {
+    return !!window.OCA?.Files?.Sidebar;
+  }
+  get open() {
+    return !!window.OCA?.Files?.Sidebar?.state.file;
+  }
+  setOpen(open) {
+    if (open) {
+      window.OCA?.Files?.Sidebar?.open();
+    } else {
+      window.OCA?.Files?.Sidebar?.close();
+    }
+  }
+  setActiveTab(tabId) {
+    window.OCA?.Files?.Sidebar?.setActiveTab(tabId);
+  }
+  registerTab(tab) {
+    registerSidebarTab(tab);
+  }
+  getTabs(context) {
+    const tabs = getSidebarTabs();
+    if (context) {
+      return tabs.filter((tab) => tab.enabled(context));
+    }
+    return tabs;
+  }
+}
+function getSidebar() {
+  return new SidebarProxy();
+}
 var InvalidFilenameErrorReason = /* @__PURE__ */ ((InvalidFilenameErrorReason2) => {
   InvalidFilenameErrorReason2["ReservedName"] = "reserved name";
   InvalidFilenameErrorReason2["Character"] = "character";
@@ -3001,6 +1525,7 @@ export {
   getNavigation,
   getNewFileMenu,
   getNewFileMenuEntries,
+  getSidebar,
   getUniqueName,
   isFilenameValid,
   orderBy,
@@ -3012,6 +1537,7 @@ export {
   removeNewFileMenuEntry,
   sortNodes,
   unregisterFileListFilter,
-  validateFilename
+  validateFilename,
+  validateView
 };
 //# sourceMappingURL=index.mjs.map