@nextcloud/files 3.9.2 → 3.10.1

package/dist/index.mjs

@@ -1,15 +1,9 @@
-import { getLoggerBuilder } from "@nextcloud/logger";
-import { getCurrentUser, onRequestTokenUpdate, getRequestToken } from "@nextcloud/auth";
-import { join, basename, extname, dirname } from "path";
-import { encodePath } from "@nextcloud/paths";
-import { generateRemoteUrl } from "@nextcloud/router";
-import { CancelablePromise } from "cancelable-promise";
-import { createClient, getPatcher } from "webdav";
-import { isPublicShare, getSharingToken } from "@nextcloud/sharing/public";
+import { o as logger } from "./chunks/dav-Co9y-hkg.mjs";
+import { q, F, s, N, t, P, c, l, m, n, a, g, p, b, r, d, h, f, k, j, e, i } from "./chunks/dav-Co9y-hkg.mjs";
 import { getCapabilities } from "@nextcloud/capabilities";
+import { extname, basename } from "path";
 import { getCanonicalLocale, getLanguage } from "@nextcloud/l10n";
 import { TypedEventTarget } from "typescript-event-target";
-const logger = getLoggerBuilder().setApp("@nextcloud/files").detectUser().build();
 var NewMenuEntryCategory = /* @__PURE__ */ ((NewMenuEntryCategory2) => {
   NewMenuEntryCategory2[NewMenuEntryCategory2["UploadFromDevice"] = 0] = "UploadFromDevice";
   NewMenuEntryCategory2[NewMenuEntryCategory2["CreateNew"] = 1] = "CreateNew";
@@ -117,6 +111,9 @@ class FileAction {
   get default() {
     return this._action.default;
   }
+  get destructive() {
+    return this._action.destructive;
+  }
   get inline() {
     return this._action.inline;
   }
@@ -148,6 +145,9 @@ class FileAction {
     if ("order" in action && typeof action.order !== "number") {
       throw new Error("Invalid order");
     }
+    if (action.destructive !== void 0 && typeof action.destructive !== "boolean") {
+      throw new Error("Invalid destructive flag");
+    }
     if ("parent" in action && typeof action.parent !== "string") {
       throw new Error("Invalid parent");
     }
@@ -180,6 +180,67 @@ const getFileActions = function() {
   }
   return window._nc_fileactions;
 };
+class FileListAction {
+  _action;
+  constructor(action) {
+    this.validateAction(action);
+    this._action = action;
+  }
+  get id() {
+    return this._action.id;
+  }
+  get displayName() {
+    return this._action.displayName;
+  }
+  get iconSvgInline() {
+    return this._action.iconSvgInline;
+  }
+  get order() {
+    return this._action.order;
+  }
+  get enabled() {
+    return this._action.enabled;
+  }
+  get exec() {
+    return this._action.exec;
+  }
+  validateAction(action) {
+    if (!action.id || typeof action.id !== "string") {
+      throw new Error("Invalid id");
+    }
+    if (!action.displayName || typeof action.displayName !== "function") {
+      throw new Error("Invalid displayName function");
+    }
+    if ("iconSvgInline" in action && typeof action.iconSvgInline !== "function") {
+      throw new Error("Invalid iconSvgInline function");
+    }
+    if ("order" in action && typeof action.order !== "number") {
+      throw new Error("Invalid order");
+    }
+    if ("enabled" in action && typeof action.enabled !== "function") {
+      throw new Error("Invalid enabled function");
+    }
+    if (!action.exec || typeof action.exec !== "function") {
+      throw new Error("Invalid exec function");
+    }
+  }
+}
+const registerFileListAction = (action) => {
+  if (typeof window._nc_filelistactions === "undefined") {
+    window._nc_filelistactions = [];
+  }
+  if (window._nc_filelistactions.find((listAction) => listAction.id === action.id)) {
+    logger.error(`FileListAction with id "${action.id}" is already registered`, { action });
+    return;
+  }
+  window._nc_filelistactions.push(action);
+};
+const getFileListActions = () => {
+  if (typeof window._nc_filelistactions === "undefined") {
+    window._nc_filelistactions = [];
+  }
+  return window._nc_filelistactions;
+};
 class Header {
   _header;
   constructor(header) {
@@ -237,655 +298,6 @@ const getFileListHeaders = function() {
   }
   return window._nc_filelistheader;
 };
-var Permission = /* @__PURE__ */ ((Permission2) => {
-  Permission2[Permission2["NONE"] = 0] = "NONE";
-  Permission2[Permission2["CREATE"] = 4] = "CREATE";
-  Permission2[Permission2["READ"] = 1] = "READ";
-  Permission2[Permission2["UPDATE"] = 2] = "UPDATE";
-  Permission2[Permission2["DELETE"] = 8] = "DELETE";
-  Permission2[Permission2["SHARE"] = 16] = "SHARE";
-  Permission2[Permission2["ALL"] = 31] = "ALL";
-  return Permission2;
-})(Permission || {});
-const defaultDavProperties = [
-  "d:getcontentlength",
-  "d:getcontenttype",
-  "d:getetag",
-  "d:getlastmodified",
-  "d:creationdate",
-  "d:displayname",
-  "d:quota-available-bytes",
-  "d:resourcetype",
-  "nc:has-preview",
-  "nc:is-encrypted",
-  "nc:mount-type",
-  "oc:comments-unread",
-  "oc:favorite",
-  "oc:fileid",
-  "oc:owner-display-name",
-  "oc:owner-id",
-  "oc:permissions",
-  "oc:size"
-];
-const defaultDavNamespaces = {
-  d: "DAV:",
-  nc: "http://nextcloud.org/ns",
-  oc: "http://owncloud.org/ns",
-  ocs: "http://open-collaboration-services.org/ns"
-};
-const registerDavProperty = function(prop, namespace = { nc: "http://nextcloud.org/ns" }) {
-  if (typeof window._nc_dav_properties === "undefined") {
-    window._nc_dav_properties = [...defaultDavProperties];
-    window._nc_dav_namespaces = { ...defaultDavNamespaces };
-  }
-  const namespaces = { ...window._nc_dav_namespaces, ...namespace };
-  if (window._nc_dav_properties.find((search) => search === prop)) {
-    logger.warn(`${prop} already registered`, { prop });
-    return false;
-  }
-  if (prop.startsWith("<") || prop.split(":").length !== 2) {
-    logger.error(`${prop} is not valid. See example: 'oc:fileid'`, { prop });
-    return false;
-  }
-  const ns = prop.split(":")[0];
-  if (!namespaces[ns]) {
-    logger.error(`${prop} namespace unknown`, { prop, namespaces });
-    return false;
-  }
-  window._nc_dav_properties.push(prop);
-  window._nc_dav_namespaces = namespaces;
-  return true;
-};
-const getDavProperties = function() {
-  if (typeof window._nc_dav_properties === "undefined") {
-    window._nc_dav_properties = [...defaultDavProperties];
-  }
-  return window._nc_dav_properties.map((prop) => `<${prop} />`).join(" ");
-};
-const getDavNameSpaces = function() {
-  if (typeof window._nc_dav_namespaces === "undefined") {
-    window._nc_dav_namespaces = { ...defaultDavNamespaces };
-  }
-  return Object.keys(window._nc_dav_namespaces).map((ns) => `xmlns:${ns}="${window._nc_dav_namespaces?.[ns]}"`).join(" ");
-};
-const davGetDefaultPropfind = function() {
-  return `<?xml version="1.0"?>
-		<d:propfind ${getDavNameSpaces()}>
-			<d:prop>
-				${getDavProperties()}
-			</d:prop>
-		</d:propfind>`;
-};
-const davGetFavoritesReport = function() {
-  return `<?xml version="1.0"?>
-		<oc:filter-files ${getDavNameSpaces()}>
-			<d:prop>
-				${getDavProperties()}
-			</d:prop>
-			<oc:filter-rules>
-				<oc:favorite>1</oc:favorite>
-			</oc:filter-rules>
-		</oc:filter-files>`;
-};
-const davGetRecentSearch = function(lastModified) {
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<d:searchrequest ${getDavNameSpaces()}
-	xmlns:ns="https://github.com/icewind1991/SearchDAV/ns">
-	<d:basicsearch>
-		<d:select>
-			<d:prop>
-				${getDavProperties()}
-			</d:prop>
-		</d:select>
-		<d:from>
-			<d:scope>
-				<d:href>/files/${getCurrentUser()?.uid}/</d:href>
-				<d:depth>infinity</d:depth>
-			</d:scope>
-		</d:from>
-		<d:where>
-			<d:and>
-				<d:or>
-					<d:not>
-						<d:eq>
-							<d:prop>
-								<d:getcontenttype/>
-							</d:prop>
-							<d:literal>httpd/unix-directory</d:literal>
-						</d:eq>
-					</d:not>
-					<d:eq>
-						<d:prop>
-							<oc:size/>
-						</d:prop>
-						<d:literal>0</d:literal>
-					</d:eq>
-				</d:or>
-				<d:gt>
-					<d:prop>
-						<d:getlastmodified/>
-					</d:prop>
-					<d:literal>${lastModified}</d:literal>
-				</d:gt>
-			</d:and>
-		</d:where>
-		<d:orderby>
-			<d:order>
-				<d:prop>
-					<d:getlastmodified/>
-				</d:prop>
-				<d:descending/>
-			</d:order>
-		</d:orderby>
-		<d:limit>
-			<d:nresults>100</d:nresults>
-			<ns:firstresult>0</ns:firstresult>
-		</d:limit>
-	</d:basicsearch>
-</d:searchrequest>`;
-};
-const davParsePermissions = function(permString = "") {
-  let permissions = Permission.NONE;
-  if (!permString) {
-    return permissions;
-  }
-  if (permString.includes("C") || permString.includes("K")) {
-    permissions |= Permission.CREATE;
-  }
-  if (permString.includes("G")) {
-    permissions |= Permission.READ;
-  }
-  if (permString.includes("W") || permString.includes("N") || permString.includes("V")) {
-    permissions |= Permission.UPDATE;
-  }
-  if (permString.includes("D")) {
-    permissions |= Permission.DELETE;
-  }
-  if (permString.includes("R")) {
-    permissions |= Permission.SHARE;
-  }
-  return permissions;
-};
-var FileType = /* @__PURE__ */ ((FileType2) => {
-  FileType2["Folder"] = "folder";
-  FileType2["File"] = "file";
-  return FileType2;
-})(FileType || {});
-const isDavRessource = function(source, davService) {
-  return source.match(davService) !== null;
-};
-const validateData = (data, davService) => {
-  if (data.id && typeof data.id !== "number") {
-    throw new Error("Invalid id type of value");
-  }
-  if (!data.source) {
-    throw new Error("Missing mandatory source");
-  }
-  try {
-    new URL(data.source);
-  } catch (e) {
-    throw new Error("Invalid source format, source must be a valid URL");
-  }
-  if (!data.source.startsWith("http")) {
-    throw new Error("Invalid source format, only http(s) is supported");
-  }
-  if (data.displayname && typeof data.displayname !== "string") {
-    throw new Error("Invalid displayname type");
-  }
-  if (data.mtime && !(data.mtime instanceof Date)) {
-    throw new Error("Invalid mtime type");
-  }
-  if (data.crtime && !(data.crtime instanceof Date)) {
-    throw new Error("Invalid crtime type");
-  }
-  if (!data.mime || typeof data.mime !== "string" || !data.mime.match(/^[-\w.]+\/[-+\w.]+$/gi)) {
-    throw new Error("Missing or invalid mandatory mime");
-  }
-  if ("size" in data && typeof data.size !== "number" && data.size !== void 0) {
-    throw new Error("Invalid size type");
-  }
-  if ("permissions" in data && data.permissions !== void 0 && !(typeof data.permissions === "number" && data.permissions >= Permission.NONE && data.permissions <= Permission.ALL)) {
-    throw new Error("Invalid permissions");
-  }
-  if (data.owner && data.owner !== null && typeof data.owner !== "string") {
-    throw new Error("Invalid owner type");
-  }
-  if (data.attributes && typeof data.attributes !== "object") {
-    throw new Error("Invalid attributes type");
-  }
-  if (data.root && typeof data.root !== "string") {
-    throw new Error("Invalid root type");
-  }
-  if (data.root && !data.root.startsWith("/")) {
-    throw new Error("Root must start with a leading slash");
-  }
-  if (data.root && !data.source.includes(data.root)) {
-    throw new Error("Root must be part of the source");
-  }
-  if (data.root && isDavRessource(data.source, davService)) {
-    const service = data.source.match(davService)[0];
-    if (!data.source.includes(join(service, data.root))) {
-      throw new Error("The root must be relative to the service. e.g /files/emma");
-    }
-  }
-  if (data.status && !Object.values(NodeStatus).includes(data.status)) {
-    throw new Error("Status must be a valid NodeStatus");
-  }
-};
-var NodeStatus = /* @__PURE__ */ ((NodeStatus2) => {
-  NodeStatus2["NEW"] = "new";
-  NodeStatus2["FAILED"] = "failed";
-  NodeStatus2["LOADING"] = "loading";
-  NodeStatus2["LOCKED"] = "locked";
-  return NodeStatus2;
-})(NodeStatus || {});
-class Node {
-  _data;
-  _attributes;
-  _knownDavService = /(remote|public)\.php\/(web)?dav/i;
-  readonlyAttributes = Object.entries(Object.getOwnPropertyDescriptors(Node.prototype)).filter((e) => typeof e[1].get === "function" && e[0] !== "__proto__").map((e) => e[0]);
-  handler = {
-    set: (target, prop, value) => {
-      if (this.readonlyAttributes.includes(prop)) {
-        return false;
-      }
-      return Reflect.set(target, prop, value);
-    },
-    deleteProperty: (target, prop) => {
-      if (this.readonlyAttributes.includes(prop)) {
-        return false;
-      }
-      return Reflect.deleteProperty(target, prop);
-    },
-    // TODO: This is deprecated and only needed for files v3
-    get: (target, prop, receiver) => {
-      if (this.readonlyAttributes.includes(prop)) {
-        logger.warn(`Accessing "Node.attributes.${prop}" is deprecated, access it directly on the Node instance.`);
-        return Reflect.get(this, prop);
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  };
-  constructor(data, davService) {
-    validateData(data, davService || this._knownDavService);
-    this._data = {
-      // TODO: Remove with next major release, this is just for compatibility
-      displayname: data.attributes?.displayname,
-      ...data,
-      attributes: {}
-    };
-    this._attributes = new Proxy(this._data.attributes, this.handler);
-    this.update(data.attributes ?? {});
-    if (davService) {
-      this._knownDavService = davService;
-    }
-  }
-  /**
-   * Get the source url to this object
-   * There is no setter as the source is not meant to be changed manually.
-   * You can use the rename or move method to change the source.
-   */
-  get source() {
-    return this._data.source.replace(/\/$/i, "");
-  }
-  /**
-   * Get the encoded source url to this object for requests purposes
-   */
-  get encodedSource() {
-    const { origin } = new URL(this.source);
-    return origin + encodePath(this.source.slice(origin.length));
-  }
-  /**
-   * Get this object name
-   * There is no setter as the source is not meant to be changed manually.
-   * You can use the rename or move method to change the source.
-   */
-  get basename() {
-    return basename(this.source);
-  }
-  /**
-   * The nodes displayname
-   * By default the display name and the `basename` are identical,
-   * but it is possible to have a different name. This happens
-   * on the files app for example for shared folders.
-   */
-  get displayname() {
-    return this._data.displayname || this.basename;
-  }
-  /**
-   * Set the displayname
-   */
-  set displayname(displayname) {
-    this._data.displayname = displayname;
-  }
-  /**
-   * Get this object's extension
-   * There is no setter as the source is not meant to be changed manually.
-   * You can use the rename or move method to change the source.
-   */
-  get extension() {
-    return extname(this.source);
-  }
-  /**
-   * Get the directory path leading to this object
-   * Will use the relative path to root if available
-   *
-   * There is no setter as the source is not meant to be changed manually.
-   * You can use the rename or move method to change the source.
-   */
-  get dirname() {
-    if (this.root) {
-      let source = this.source;
-      if (this.isDavRessource) {
-        source = source.split(this._knownDavService).pop();
-      }
-      const firstMatch = source.indexOf(this.root);
-      const root = this.root.replace(/\/$/, "");
-      return dirname(source.slice(firstMatch + root.length) || "/");
-    }
-    const url = new URL(this.source);
-    return dirname(url.pathname);
-  }
-  /**
-   * Get the file mime
-   * There is no setter as the mime is not meant to be changed
-   */
-  get mime() {
-    return this._data.mime;
-  }
-  /**
-   * Get the file modification time
-   */
-  get mtime() {
-    return this._data.mtime;
-  }
-  /**
-   * Set the file modification time
-   */
-  set mtime(mtime) {
-    this._data.mtime = mtime;
-  }
-  /**
-   * Get the file creation time
-   * There is no setter as the creation time is not meant to be changed
-   */
-  get crtime() {
-    return this._data.crtime;
-  }
-  /**
-   * Get the file size
-   */
-  get size() {
-    return this._data.size;
-  }
-  /**
-   * Set the file size
-   */
-  set size(size) {
-    this.updateMtime();
-    this._data.size = size;
-  }
-  /**
-   * Get the file attribute
-   * This contains all additional attributes not provided by the Node class
-   */
-  get attributes() {
-    return this._attributes;
-  }
-  /**
-   * Get the file permissions
-   */
-  get permissions() {
-    if (this.owner === null && !this.isDavRessource) {
-      return Permission.READ;
-    }
-    return this._data.permissions !== void 0 ? this._data.permissions : Permission.NONE;
-  }
-  /**
-   * Set the file permissions
-   */
-  set permissions(permissions) {
-    this.updateMtime();
-    this._data.permissions = permissions;
-  }
-  /**
-   * Get the file owner
-   * There is no setter as the owner is not meant to be changed
-   */
-  get owner() {
-    if (!this.isDavRessource) {
-      return null;
-    }
-    return this._data.owner;
-  }
-  /**
-   * Is this a dav-related ressource ?
-   */
-  get isDavRessource() {
-    return isDavRessource(this.source, this._knownDavService);
-  }
-  /**
-   * Get the dav root of this object
-   * There is no setter as the root is not meant to be changed
-   */
-  get root() {
-    if (this._data.root) {
-      return this._data.root.replace(/^(.+)\/$/, "$1");
-    }
-    if (this.isDavRessource) {
-      const root = dirname(this.source);
-      return root.split(this._knownDavService).pop() || null;
-    }
-    return null;
-  }
-  /**
-   * Get the absolute path of this object relative to the root
-   */
-  get path() {
-    if (this.root) {
-      let source = this.source;
-      if (this.isDavRessource) {
-        source = source.split(this._knownDavService).pop();
-      }
-      const firstMatch = source.indexOf(this.root);
-      const root = this.root.replace(/\/$/, "");
-      return source.slice(firstMatch + root.length) || "/";
-    }
-    return (this.dirname + "/" + this.basename).replace(/\/\//g, "/");
-  }
-  /**
-   * Get the node id if defined.
-   * There is no setter as the fileid is not meant to be changed
-   */
-  get fileid() {
-    return this._data?.id;
-  }
-  /**
-   * Get the node status.
-   */
-  get status() {
-    return this._data?.status;
-  }
-  /**
-   * Set the node status.
-   */
-  set status(status) {
-    this._data.status = status;
-  }
-  /**
-   * Move the node to a new destination
-   *
-   * @param {string} destination the new source.
-   * e.g. https://cloud.domain.com/remote.php/dav/files/emma/Photos/picture.jpg
-   */
-  move(destination) {
-    validateData({ ...this._data, source: destination }, this._knownDavService);
-    const oldBasename = this.basename;
-    this._data.source = destination;
-    if (this.displayname === oldBasename && this.basename !== oldBasename) {
-      this.displayname = this.basename;
-    }
-    this.updateMtime();
-  }
-  /**
-   * Rename the node
-   * This aliases the move method for easier usage
-   *
-   * @param basename The new name of the node
-   */
-  rename(basename2) {
-    if (basename2.includes("/")) {
-      throw new Error("Invalid basename");
-    }
-    this.move(dirname(this.source) + "/" + basename2);
-  }
-  /**
-   * Update the mtime if exists
-   */
-  updateMtime() {
-    if (this._data.mtime) {
-      this._data.mtime = /* @__PURE__ */ new Date();
-    }
-  }
-  /**
-   * Update the attributes of the node
-   * Warning, updating attributes will NOT automatically update the mtime.
-   *
-   * @param attributes The new attributes to update on the Node attributes
-   */
-  update(attributes) {
-    for (const [name, value] of Object.entries(attributes)) {
-      try {
-        if (value === void 0) {
-          delete this.attributes[name];
-        } else {
-          this.attributes[name] = value;
-        }
-      } catch (e) {
-        if (e instanceof TypeError) {
-          continue;
-        }
-        throw e;
-      }
-    }
-  }
-}
-class File extends Node {
-  get type() {
-    return FileType.File;
-  }
-}
-class Folder extends Node {
-  constructor(data) {
-    super({
-      ...data,
-      mime: "httpd/unix-directory"
-    });
-  }
-  get type() {
-    return FileType.Folder;
-  }
-  get extension() {
-    return null;
-  }
-  get mime() {
-    return "httpd/unix-directory";
-  }
-}
-function davGetRootPath() {
-  if (isPublicShare()) {
-    return `/files/${getSharingToken()}`;
-  }
-  return `/files/${getCurrentUser()?.uid}`;
-}
-const davRootPath = davGetRootPath();
-function davGetRemoteURL() {
-  const url = generateRemoteUrl("dav");
-  if (isPublicShare()) {
-    return url.replace("remote.php", "public.php");
-  }
-  return url;
-}
-const davRemoteURL = davGetRemoteURL();
-const davGetClient = function(remoteURL = davRemoteURL, headers = {}) {
-  const client = createClient(remoteURL, { headers });
-  function setHeaders(token) {
-    client.setHeaders({
-      ...headers,
-      // Add this so the server knows it is an request from the browser
-      "X-Requested-With": "XMLHttpRequest",
-      // Inject user auth
-      requesttoken: token ?? ""
-    });
-  }
-  onRequestTokenUpdate(setHeaders);
-  setHeaders(getRequestToken());
-  const patcher = getPatcher();
-  patcher.patch("fetch", (url, options) => {
-    const headers2 = options.headers;
-    if (headers2?.method) {
-      options.method = headers2.method;
-      delete headers2.method;
-    }
-    return fetch(url, options);
-  });
-  return client;
-};
-const getFavoriteNodes = (davClient, path = "/", davRoot = davRootPath) => {
-  const controller = new AbortController();
-  return new CancelablePromise(async (resolve, reject, onCancel) => {
-    onCancel(() => controller.abort());
-    try {
-      const contentsResponse = await davClient.getDirectoryContents(`${davRoot}${path}`, {
-        signal: controller.signal,
-        details: true,
-        data: davGetFavoritesReport(),
-        headers: {
-          // see davGetClient for patched webdav client
-          method: "REPORT"
-        },
-        includeSelf: true
-      });
-      const nodes = contentsResponse.data.filter((node) => node.filename !== path).map((result) => davResultToNode(result, davRoot));
-      resolve(nodes);
-    } catch (error) {
-      reject(error);
-    }
-  });
-};
-const davResultToNode = function(node, filesRoot = davRootPath, remoteURL = davRemoteURL) {
-  let userId = getCurrentUser()?.uid;
-  if (isPublicShare()) {
-    userId = userId ?? "anonymous";
-  } else if (!userId) {
-    throw new Error("No user id found");
-  }
-  const props = node.props;
-  const permissions = davParsePermissions(props?.permissions);
-  const owner = String(props?.["owner-id"] || userId);
-  const id = props.fileid || 0;
-  const nodeData = {
-    id,
-    source: `${remoteURL}${node.filename}`,
-    mtime: new Date(Date.parse(node.lastmod)),
-    mime: node.mime || "application/octet-stream",
-    // Manually cast to work around for https://github.com/perry-mitchell/webdav-client/pull/380
-    displayname: props.displayname !== void 0 ? String(props.displayname) : void 0,
-    size: props?.size || Number.parseInt(props.getcontentlength || "0"),
-    // The fileid is set to -1 for failed requests
-    status: id < 0 ? NodeStatus.FAILED : void 0,
-    permissions,
-    owner,
-    root: filesRoot,
-    attributes: {
-      ...node,
-      ...props,
-      hasPreview: props?.["has-preview"]
-    }
-  };
-  delete nodeData.attributes?.props;
-  return node.type === "file" ? new File(nodeData) : new Folder(nodeData);
-};
 var InvalidFilenameErrorReason = /* @__PURE__ */ ((InvalidFilenameErrorReason2) => {
   InvalidFilenameErrorReason2["ReservedName"] = "reserved name";
   InvalidFilenameErrorReason2["Character"] = "character";
@@ -964,16 +376,16 @@ function isFilenameValid(filename) {
 }
 function getUniqueName(name, otherNames, options) {
   const opts = {
-    suffix: (n) => `(${n})`,
+    suffix: (n2) => `(${n2})`,
     ignoreFileExtension: false,
     ...options
   };
   let newName = name;
-  let i = 1;
+  let i2 = 1;
   while (otherNames.includes(newName)) {
     const ext = opts.ignoreFileExtension ? "" : extname(name);
     const base = basename(name, ext);
-    newName = `${base} ${opts.suffix(i++)}${ext}`;
+    newName = `${base} ${opts.suffix(i2++)}${ext}`;
   }
   return newName;
 }
@@ -1001,7 +413,7 @@ function formatFileSize(size, skipSmallSizes = false, binaryPrefixes = false, ba
 function parseFileSize(value, forceBinary = false) {
   try {
     value = `${value}`.toLocaleLowerCase().replaceAll(/\s+/g, "").replaceAll(",", ".");
-  } catch (e) {
+  } catch (e2) {
     return null;
   }
   const match = value.match(/^([0-9]*(\.[0-9]*)?)([kmgtp]?)(i?)b?$/);
@@ -1039,9 +451,9 @@ function orderBy(collection, identifiers2, orders) {
       usage: "sort"
     }
   );
-  return [...collection].sort((a, b) => {
+  return [...collection].sort((a2, b2) => {
     for (const [index, identifier] of identifiers2.entries()) {
-      const value = collator.compare(stringify(identifier(a)), stringify(identifier(b)));
+      const value = collator.compare(stringify(identifier(a2)), stringify(identifier(b2)));
       if (value !== 0) {
         return value * sorting[index];
       }
@@ -1072,7 +484,7 @@ function sortNodes(nodes, options = {}) {
     // 3: Use sorting mode if NOT basename (to be able to use display name too)
     ...sortingOptions.sortingMode !== "basename" ? [(v) => v[sortingOptions.sortingMode]] : [],
     // 4: Use display name if available, fallback to name
-    (v) => basename2(v.attributes?.displayname || v.basename),
+    (v) => basename2(v.displayname || v.attributes?.displayname || v.basename),
     // 5: Finally, use basename if all previous sorting methods failed
     (v) => v.basename
   ];
@@ -1223,15 +635,15 @@ var util$3 = {};
   exports.isEmptyObject = function(obj) {
     return Object.keys(obj).length === 0;
   };
-  exports.merge = function(target, a, arrayMode) {
-    if (a) {
-      const keys = Object.keys(a);
+  exports.merge = function(target, a2, arrayMode) {
+    if (a2) {
+      const keys = Object.keys(a2);
       const len = keys.length;
-      for (let i = 0; i < len; i++) {
+      for (let i2 = 0; i2 < len; i2++) {
         if (arrayMode === "strict") {
-          target[keys[i]] = [a[keys[i]]];
+          target[keys[i2]] = [a2[keys[i2]]];
         } else {
-          target[keys[i]] = a[keys[i]];
+          target[keys[i2]] = a2[keys[i2]];
         }
       }
     }
@@ -1261,31 +673,31 @@ validator$2.validate = function(xmlData, options) {
   if (xmlData[0] === "\uFEFF") {
     xmlData = xmlData.substr(1);
   }
-  for (let i = 0; i < xmlData.length; i++) {
-    if (xmlData[i] === "<" && xmlData[i + 1] === "?") {
-      i += 2;
-      i = readPI(xmlData, i);
-      if (i.err) return i;
-    } else if (xmlData[i] === "<") {
-      let tagStartPos = i;
-      i++;
-      if (xmlData[i] === "!") {
-        i = readCommentAndCDATA(xmlData, i);
+  for (let i2 = 0; i2 < xmlData.length; i2++) {
+    if (xmlData[i2] === "<" && xmlData[i2 + 1] === "?") {
+      i2 += 2;
+      i2 = readPI(xmlData, i2);
+      if (i2.err) return i2;
+    } else if (xmlData[i2] === "<") {
+      let tagStartPos = i2;
+      i2++;
+      if (xmlData[i2] === "!") {
+        i2 = readCommentAndCDATA(xmlData, i2);
         continue;
       } else {
         let closingTag = false;
-        if (xmlData[i] === "/") {
+        if (xmlData[i2] === "/") {
           closingTag = true;
-          i++;
+          i2++;
         }
         let tagName = "";
-        for (; i < xmlData.length && xmlData[i] !== ">" && xmlData[i] !== " " && xmlData[i] !== "	" && xmlData[i] !== "\n" && xmlData[i] !== "\r"; i++) {
-          tagName += xmlData[i];
+        for (; i2 < xmlData.length && xmlData[i2] !== ">" && xmlData[i2] !== " " && xmlData[i2] !== "	" && xmlData[i2] !== "\n" && xmlData[i2] !== "\r"; i2++) {
+          tagName += xmlData[i2];
         }
         tagName = tagName.trim();
         if (tagName[tagName.length - 1] === "/") {
           tagName = tagName.substring(0, tagName.length - 1);
-          i--;
+          i2--;
         }
         if (!validateTagName(tagName)) {
           let msg;
@@ -1294,16 +706,16 @@ validator$2.validate = function(xmlData, options) {
           } else {
             msg = "Tag '" + tagName + "' is an invalid name.";
           }
-          return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i));
+          return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i2));
         }
-        const result = readAttributeStr(xmlData, i);
+        const result = readAttributeStr(xmlData, i2);
         if (result === false) {
-          return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i));
+          return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i2));
         }
         let attrStr = result.value;
-        i = result.index;
+        i2 = result.index;
         if (attrStr[attrStr.length - 1] === "/") {
-          const attrStrStart = i - attrStr.length;
+          const attrStrStart = i2 - attrStr.length;
           attrStr = attrStr.substring(0, attrStr.length - 1);
           const isValid = validateAttributeString(attrStr, options);
           if (isValid === true) {
@@ -1313,7 +725,7 @@ validator$2.validate = function(xmlData, options) {
           }
         } else if (closingTag) {
           if (!result.tagClosed) {
-            return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
+            return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i2));
           } else if (attrStr.trim().length > 0) {
             return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
           } else if (tags.length === 0) {
@@ -1335,48 +747,48 @@ validator$2.validate = function(xmlData, options) {
         } else {
           const isValid = validateAttributeString(attrStr, options);
           if (isValid !== true) {
-            return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
+            return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i2 - attrStr.length + isValid.err.line));
           }
           if (reachedRoot === true) {
-            return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i));
+            return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i2));
           } else if (options.unpairedTags.indexOf(tagName) !== -1) ;
           else {
             tags.push({ tagName, tagStartPos });
           }
           tagFound = true;
         }
-        for (i++; i < xmlData.length; i++) {
-          if (xmlData[i] === "<") {
-            if (xmlData[i + 1] === "!") {
-              i++;
-              i = readCommentAndCDATA(xmlData, i);
+        for (i2++; i2 < xmlData.length; i2++) {
+          if (xmlData[i2] === "<") {
+            if (xmlData[i2 + 1] === "!") {
+              i2++;
+              i2 = readCommentAndCDATA(xmlData, i2);
               continue;
-            } else if (xmlData[i + 1] === "?") {
-              i = readPI(xmlData, ++i);
-              if (i.err) return i;
+            } else if (xmlData[i2 + 1] === "?") {
+              i2 = readPI(xmlData, ++i2);
+              if (i2.err) return i2;
             } else {
               break;
             }
-          } else if (xmlData[i] === "&") {
-            const afterAmp = validateAmpersand(xmlData, i);
+          } else if (xmlData[i2] === "&") {
+            const afterAmp = validateAmpersand(xmlData, i2);
             if (afterAmp == -1)
-              return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
-            i = afterAmp;
+              return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i2));
+            i2 = afterAmp;
           } else {
-            if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {
-              return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i));
+            if (reachedRoot === true && !isWhiteSpace(xmlData[i2])) {
+              return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i2));
             }
           }
         }
-        if (xmlData[i] === "<") {
-          i--;
+        if (xmlData[i2] === "<") {
+          i2--;
         }
       }
     } else {
-      if (isWhiteSpace(xmlData[i])) {
+      if (isWhiteSpace(xmlData[i2])) {
         continue;
       }
-      return getErrorObject("InvalidChar", "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
+      return getErrorObject("InvalidChar", "char '" + xmlData[i2] + "' is not expected.", getLineNumberForPosition(xmlData, i2));
     }
   }
   if (!tagFound) {
@@ -1384,88 +796,88 @@ validator$2.validate = function(xmlData, options) {
   } else if (tags.length == 1) {
     return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
   } else if (tags.length > 0) {
-    return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t2) => t2.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
+    return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t3) => t3.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
   }
   return true;
 };
 function isWhiteSpace(char) {
   return char === " " || char === "	" || char === "\n" || char === "\r";
 }
-function readPI(xmlData, i) {
-  const start = i;
-  for (; i < xmlData.length; i++) {
-    if (xmlData[i] == "?" || xmlData[i] == " ") {
-      const tagname = xmlData.substr(start, i - start);
-      if (i > 5 && tagname === "xml") {
-        return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i));
-      } else if (xmlData[i] == "?" && xmlData[i + 1] == ">") {
-        i++;
+function readPI(xmlData, i2) {
+  const start = i2;
+  for (; i2 < xmlData.length; i2++) {
+    if (xmlData[i2] == "?" || xmlData[i2] == " ") {
+      const tagname = xmlData.substr(start, i2 - start);
+      if (i2 > 5 && tagname === "xml") {
+        return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i2));
+      } else if (xmlData[i2] == "?" && xmlData[i2 + 1] == ">") {
+        i2++;
         break;
       } else {
         continue;
       }
     }
   }
-  return i;
+  return i2;
 }
-function readCommentAndCDATA(xmlData, i) {
-  if (xmlData.length > i + 5 && xmlData[i + 1] === "-" && xmlData[i + 2] === "-") {
-    for (i += 3; i < xmlData.length; i++) {
-      if (xmlData[i] === "-" && xmlData[i + 1] === "-" && xmlData[i + 2] === ">") {
-        i += 2;
+function readCommentAndCDATA(xmlData, i2) {
+  if (xmlData.length > i2 + 5 && xmlData[i2 + 1] === "-" && xmlData[i2 + 2] === "-") {
+    for (i2 += 3; i2 < xmlData.length; i2++) {
+      if (xmlData[i2] === "-" && xmlData[i2 + 1] === "-" && xmlData[i2 + 2] === ">") {
+        i2 += 2;
         break;
       }
     }
-  } else if (xmlData.length > i + 8 && xmlData[i + 1] === "D" && xmlData[i + 2] === "O" && xmlData[i + 3] === "C" && xmlData[i + 4] === "T" && xmlData[i + 5] === "Y" && xmlData[i + 6] === "P" && xmlData[i + 7] === "E") {
+  } else if (xmlData.length > i2 + 8 && xmlData[i2 + 1] === "D" && xmlData[i2 + 2] === "O" && xmlData[i2 + 3] === "C" && xmlData[i2 + 4] === "T" && xmlData[i2 + 5] === "Y" && xmlData[i2 + 6] === "P" && xmlData[i2 + 7] === "E") {
     let angleBracketsCount = 1;
-    for (i += 8; i < xmlData.length; i++) {
-      if (xmlData[i] === "<") {
+    for (i2 += 8; i2 < xmlData.length; i2++) {
+      if (xmlData[i2] === "<") {
         angleBracketsCount++;
-      } else if (xmlData[i] === ">") {
+      } else if (xmlData[i2] === ">") {
         angleBracketsCount--;
         if (angleBracketsCount === 0) {
           break;
         }
       }
     }
-  } else if (xmlData.length > i + 9 && xmlData[i + 1] === "[" && xmlData[i + 2] === "C" && xmlData[i + 3] === "D" && xmlData[i + 4] === "A" && xmlData[i + 5] === "T" && xmlData[i + 6] === "A" && xmlData[i + 7] === "[") {
-    for (i += 8; i < xmlData.length; i++) {
-      if (xmlData[i] === "]" && xmlData[i + 1] === "]" && xmlData[i + 2] === ">") {
-        i += 2;
+  } else if (xmlData.length > i2 + 9 && xmlData[i2 + 1] === "[" && xmlData[i2 + 2] === "C" && xmlData[i2 + 3] === "D" && xmlData[i2 + 4] === "A" && xmlData[i2 + 5] === "T" && xmlData[i2 + 6] === "A" && xmlData[i2 + 7] === "[") {
+    for (i2 += 8; i2 < xmlData.length; i2++) {
+      if (xmlData[i2] === "]" && xmlData[i2 + 1] === "]" && xmlData[i2 + 2] === ">") {
+        i2 += 2;
         break;
       }
     }
   }
-  return i;
+  return i2;
 }
 const doubleQuote = '"';
 const singleQuote = "'";
-function readAttributeStr(xmlData, i) {
+function readAttributeStr(xmlData, i2) {
   let attrStr = "";
   let startChar = "";
   let tagClosed = false;
-  for (; i < xmlData.length; i++) {
-    if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
+  for (; i2 < xmlData.length; i2++) {
+    if (xmlData[i2] === doubleQuote || xmlData[i2] === singleQuote) {
       if (startChar === "") {
-        startChar = xmlData[i];
-      } else if (startChar !== xmlData[i]) ;
+        startChar = xmlData[i2];
+      } else if (startChar !== xmlData[i2]) ;
       else {
         startChar = "";
       }
-    } else if (xmlData[i] === ">") {
+    } else if (xmlData[i2] === ">") {
       if (startChar === "") {
         tagClosed = true;
         break;
       }
     }
-    attrStr += xmlData[i];
+    attrStr += xmlData[i2];
   }
   if (startChar !== "") {
     return false;
   }
   return {
     value: attrStr,
-    index: i,
+    index: i2,
     tagClosed
   };
 }
@@ -1473,57 +885,57 @@ const validAttrStrRegxp = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\
 function validateAttributeString(attrStr, options) {
   const matches = util$2.getAllMatches(attrStr, validAttrStrRegxp);
   const attrNames = {};
-  for (let i = 0; i < matches.length; i++) {
-    if (matches[i][1].length === 0) {
-      return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i]));
-    } else if (matches[i][3] !== void 0 && matches[i][4] === void 0) {
-      return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
-    } else if (matches[i][3] === void 0 && !options.allowBooleanAttributes) {
-      return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i]));
-    }
-    const attrName = matches[i][2];
+  for (let i2 = 0; i2 < matches.length; i2++) {
+    if (matches[i2][1].length === 0) {
+      return getErrorObject("InvalidAttr", "Attribute '" + matches[i2][2] + "' has no space in starting.", getPositionFromMatch(matches[i2]));
+    } else if (matches[i2][3] !== void 0 && matches[i2][4] === void 0) {
+      return getErrorObject("InvalidAttr", "Attribute '" + matches[i2][2] + "' is without value.", getPositionFromMatch(matches[i2]));
+    } else if (matches[i2][3] === void 0 && !options.allowBooleanAttributes) {
+      return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i2][2] + "' is not allowed.", getPositionFromMatch(matches[i2]));
+    }
+    const attrName = matches[i2][2];
     if (!validateAttrName(attrName)) {
-      return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
+      return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i2]));
     }
     if (!attrNames.hasOwnProperty(attrName)) {
       attrNames[attrName] = 1;
     } else {
-      return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
+      return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i2]));
     }
   }
   return true;
 }
-function validateNumberAmpersand(xmlData, i) {
+function validateNumberAmpersand(xmlData, i2) {
   let re2 = /\d/;
-  if (xmlData[i] === "x") {
-    i++;
+  if (xmlData[i2] === "x") {
+    i2++;
     re2 = /[\da-fA-F]/;
   }
-  for (; i < xmlData.length; i++) {
-    if (xmlData[i] === ";")
-      return i;
-    if (!xmlData[i].match(re2))
+  for (; i2 < xmlData.length; i2++) {
+    if (xmlData[i2] === ";")
+      return i2;
+    if (!xmlData[i2].match(re2))
       break;
   }
   return -1;
 }
-function validateAmpersand(xmlData, i) {
-  i++;
-  if (xmlData[i] === ";")
+function validateAmpersand(xmlData, i2) {
+  i2++;
+  if (xmlData[i2] === ";")
     return -1;
-  if (xmlData[i] === "#") {
-    i++;
-    return validateNumberAmpersand(xmlData, i);
+  if (xmlData[i2] === "#") {
+    i2++;
+    return validateNumberAmpersand(xmlData, i2);
   }
   let count = 0;
-  for (; i < xmlData.length; i++, count++) {
-    if (xmlData[i].match(/\w/) && count < 20)
+  for (; i2 < xmlData.length; i2++, count++) {
+    if (xmlData[i2].match(/\w/) && count < 20)
       continue;
-    if (xmlData[i] === ";")
+    if (xmlData[i2] === ";")
       break;
     return -1;
   }
-  return i;
+  return i2;
 }
 function getErrorObject(code, message, lineNumber) {
   return {
@@ -1623,33 +1035,33 @@ class XmlNode {
 }
 var xmlNode$1 = XmlNode;
 const util$1 = util$3;
-function readDocType$1(xmlData, i) {
+function readDocType$1(xmlData, i2) {
   const entities = {};
-  if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
-    i = i + 9;
+  if (xmlData[i2 + 3] === "O" && xmlData[i2 + 4] === "C" && xmlData[i2 + 5] === "T" && xmlData[i2 + 6] === "Y" && xmlData[i2 + 7] === "P" && xmlData[i2 + 8] === "E") {
+    i2 = i2 + 9;
     let angleBracketsCount = 1;
     let hasBody = false, comment = false;
     let exp = "";
-    for (; i < xmlData.length; i++) {
-      if (xmlData[i] === "<" && !comment) {
-        if (hasBody && isEntity(xmlData, i)) {
-          i += 7;
-          [entityName, val, i] = readEntityExp(xmlData, i + 1);
+    for (; i2 < xmlData.length; i2++) {
+      if (xmlData[i2] === "<" && !comment) {
+        if (hasBody && isEntity(xmlData, i2)) {
+          i2 += 7;
+          [entityName, val, i2] = readEntityExp(xmlData, i2 + 1);
           if (val.indexOf("&") === -1)
             entities[validateEntityName(entityName)] = {
               regx: RegExp(`&${entityName};`, "g"),
               val
             };
-        } else if (hasBody && isElement(xmlData, i)) i += 8;
-        else if (hasBody && isAttlist(xmlData, i)) i += 8;
-        else if (hasBody && isNotation(xmlData, i)) i += 9;
+        } else if (hasBody && isElement(xmlData, i2)) i2 += 8;
+        else if (hasBody && isAttlist(xmlData, i2)) i2 += 8;
+        else if (hasBody && isNotation(xmlData, i2)) i2 += 9;
         else if (isComment) comment = true;
         else throw new Error("Invalid DOCTYPE");
         angleBracketsCount++;
         exp = "";
-      } else if (xmlData[i] === ">") {
+      } else if (xmlData[i2] === ">") {
         if (comment) {
-          if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
+          if (xmlData[i2 - 1] === "-" && xmlData[i2 - 2] === "-") {
             comment = false;
             angleBracketsCount--;
           }
@@ -1659,10 +1071,10 @@ function readDocType$1(xmlData, i) {
         if (angleBracketsCount === 0) {
           break;
         }
-      } else if (xmlData[i] === "[") {
+      } else if (xmlData[i2] === "[") {
         hasBody = true;
       } else {
-        exp += xmlData[i];
+        exp += xmlData[i2];
       }
     }
     if (angleBracketsCount !== 0) {
@@ -1671,40 +1083,40 @@ function readDocType$1(xmlData, i) {
   } else {
     throw new Error(`Invalid Tag instead of DOCTYPE`);
   }
-  return { entities, i };
+  return { entities, i: i2 };
 }
-function readEntityExp(xmlData, i) {
+function readEntityExp(xmlData, i2) {
   let entityName2 = "";
-  for (; i < xmlData.length && (xmlData[i] !== "'" && xmlData[i] !== '"'); i++) {
-    entityName2 += xmlData[i];
+  for (; i2 < xmlData.length && (xmlData[i2] !== "'" && xmlData[i2] !== '"'); i2++) {
+    entityName2 += xmlData[i2];
   }
   entityName2 = entityName2.trim();
   if (entityName2.indexOf(" ") !== -1) throw new Error("External entites are not supported");
-  const startChar = xmlData[i++];
+  const startChar = xmlData[i2++];
   let val2 = "";
-  for (; i < xmlData.length && xmlData[i] !== startChar; i++) {
-    val2 += xmlData[i];
+  for (; i2 < xmlData.length && xmlData[i2] !== startChar; i2++) {
+    val2 += xmlData[i2];
   }
-  return [entityName2, val2, i];
+  return [entityName2, val2, i2];
 }
-function isComment(xmlData, i) {
-  if (xmlData[i + 1] === "!" && xmlData[i + 2] === "-" && xmlData[i + 3] === "-") return true;
+function isComment(xmlData, i2) {
+  if (xmlData[i2 + 1] === "!" && xmlData[i2 + 2] === "-" && xmlData[i2 + 3] === "-") return true;
   return false;
 }
-function isEntity(xmlData, i) {
-  if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "N" && xmlData[i + 4] === "T" && xmlData[i + 5] === "I" && xmlData[i + 6] === "T" && xmlData[i + 7] === "Y") return true;
+function isEntity(xmlData, i2) {
+  if (xmlData[i2 + 1] === "!" && xmlData[i2 + 2] === "E" && xmlData[i2 + 3] === "N" && xmlData[i2 + 4] === "T" && xmlData[i2 + 5] === "I" && xmlData[i2 + 6] === "T" && xmlData[i2 + 7] === "Y") return true;
   return false;
 }
-function isElement(xmlData, i) {
-  if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "L" && xmlData[i + 4] === "E" && xmlData[i + 5] === "M" && xmlData[i + 6] === "E" && xmlData[i + 7] === "N" && xmlData[i + 8] === "T") return true;
+function isElement(xmlData, i2) {
+  if (xmlData[i2 + 1] === "!" && xmlData[i2 + 2] === "E" && xmlData[i2 + 3] === "L" && xmlData[i2 + 4] === "E" && xmlData[i2 + 5] === "M" && xmlData[i2 + 6] === "E" && xmlData[i2 + 7] === "N" && xmlData[i2 + 8] === "T") return true;
   return false;
 }
-function isAttlist(xmlData, i) {
-  if (xmlData[i + 1] === "!" && xmlData[i + 2] === "A" && xmlData[i + 3] === "T" && xmlData[i + 4] === "T" && xmlData[i + 5] === "L" && xmlData[i + 6] === "I" && xmlData[i + 7] === "S" && xmlData[i + 8] === "T") return true;
+function isAttlist(xmlData, i2) {
+  if (xmlData[i2 + 1] === "!" && xmlData[i2 + 2] === "A" && xmlData[i2 + 3] === "T" && xmlData[i2 + 4] === "T" && xmlData[i2 + 5] === "L" && xmlData[i2 + 6] === "I" && xmlData[i2 + 7] === "S" && xmlData[i2 + 8] === "T") return true;
   return false;
 }
-function isNotation(xmlData, i) {
-  if (xmlData[i + 1] === "!" && xmlData[i + 2] === "N" && xmlData[i + 3] === "O" && xmlData[i + 4] === "T" && xmlData[i + 5] === "A" && xmlData[i + 6] === "T" && xmlData[i + 7] === "I" && xmlData[i + 8] === "O" && xmlData[i + 9] === "N") return true;
+function isNotation(xmlData, i2) {
+  if (xmlData[i2 + 1] === "!" && xmlData[i2 + 2] === "N" && xmlData[i2 + 3] === "O" && xmlData[i2 + 4] === "T" && xmlData[i2 + 5] === "A" && xmlData[i2 + 6] === "T" && xmlData[i2 + 7] === "I" && xmlData[i2 + 8] === "O" && xmlData[i2 + 9] === "N") return true;
   return false;
 }
 function validateEntityName(name) {
@@ -1854,8 +1266,8 @@ let OrderedObjParser$1 = class OrderedObjParser {
 };
 function addExternalEntities(externalEntities) {
   const entKeys = Object.keys(externalEntities);
-  for (let i = 0; i < entKeys.length; i++) {
-    const ent = entKeys[i];
+  for (let i2 = 0; i2 < entKeys.length; i2++) {
+    const ent = entKeys[i2];
     this.lastEntities[ent] = {
       regex: new RegExp("&" + ent + ";", "g"),
       val: externalEntities[ent]
@@ -1906,12 +1318,12 @@ function buildAttributesMap(attrStr, jPath, tagName) {
     const matches = util.getAllMatches(attrStr, attrsRegx);
     const len = matches.length;
     const attrs = {};
-    for (let i = 0; i < len; i++) {
-      const attrName = this.resolveNameSpace(matches[i][1]);
+    for (let i2 = 0; i2 < len; i2++) {
+      const attrName = this.resolveNameSpace(matches[i2][1]);
       if (this.ignoreAttributesFn(attrName, jPath)) {
         continue;
       }
-      let oldVal = matches[i][4];
+      let oldVal = matches[i2][4];
       let aName = this.options.attributeNamePrefix + attrName;
       if (attrName.length) {
         if (this.options.transformAttributeName) {
@@ -1957,12 +1369,12 @@ const parseXml = function(xmlData) {
   let currentNode = xmlObj;
   let textData = "";
   let jPath = "";
-  for (let i = 0; i < xmlData.length; i++) {
-    const ch = xmlData[i];
+  for (let i2 = 0; i2 < xmlData.length; i2++) {
+    const ch = xmlData[i2];
     if (ch === "<") {
-      if (xmlData[i + 1] === "/") {
-        const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
-        let tagName = xmlData.substring(i + 2, closeIndex).trim();
+      if (xmlData[i2 + 1] === "/") {
+        const closeIndex = findClosingIndex(xmlData, ">", i2, "Closing Tag is not closed.");
+        let tagName = xmlData.substring(i2 + 2, closeIndex).trim();
         if (this.options.removeNSPrefix) {
           const colonIndex = tagName.indexOf(":");
           if (colonIndex !== -1) {
@@ -1989,9 +1401,9 @@ const parseXml = function(xmlData) {
         jPath = jPath.substring(0, propIndex);
         currentNode = this.tagsNodeStack.pop();
         textData = "";
-        i = closeIndex;
-      } else if (xmlData[i + 1] === "?") {
-        let tagData = readTagExp(xmlData, i, false, "?>");
+        i2 = closeIndex;
+      } else if (xmlData[i2 + 1] === "?") {
+        let tagData = readTagExp(xmlData, i2, false, "?>");
         if (!tagData) throw new Error("Pi Tag is not closed.");
         textData = this.saveTextToParentTag(textData, currentNode, jPath);
         if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) ;
@@ -2003,22 +1415,22 @@ const parseXml = function(xmlData) {
           }
           this.addChild(currentNode, childNode, jPath);
         }
-        i = tagData.closeIndex + 1;
-      } else if (xmlData.substr(i + 1, 3) === "!--") {
-        const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
+        i2 = tagData.closeIndex + 1;
+      } else if (xmlData.substr(i2 + 1, 3) === "!--") {
+        const endIndex = findClosingIndex(xmlData, "-->", i2 + 4, "Comment is not closed.");
         if (this.options.commentPropName) {
-          const comment = xmlData.substring(i + 4, endIndex - 2);
+          const comment = xmlData.substring(i2 + 4, endIndex - 2);
           textData = this.saveTextToParentTag(textData, currentNode, jPath);
           currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
         }
-        i = endIndex;
-      } else if (xmlData.substr(i + 1, 2) === "!D") {
-        const result = readDocType(xmlData, i);
+        i2 = endIndex;
+      } else if (xmlData.substr(i2 + 1, 2) === "!D") {
+        const result = readDocType(xmlData, i2);
         this.docTypeEntities = result.entities;
-        i = result.i;
-      } else if (xmlData.substr(i + 1, 2) === "![") {
-        const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
-        const tagExp = xmlData.substring(i + 9, closeIndex);
+        i2 = result.i;
+      } else if (xmlData.substr(i2 + 1, 2) === "![") {
+        const closeIndex = findClosingIndex(xmlData, "]]>", i2, "CDATA is not closed.") - 2;
+        const tagExp = xmlData.substring(i2 + 9, closeIndex);
         textData = this.saveTextToParentTag(textData, currentNode, jPath);
         let val2 = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true);
         if (val2 == void 0) val2 = "";
@@ -2027,9 +1439,9 @@ const parseXml = function(xmlData) {
         } else {
           currentNode.add(this.options.textNodeName, val2);
         }
-        i = closeIndex + 2;
+        i2 = closeIndex + 2;
       } else {
-        let result = readTagExp(xmlData, i, this.options.removeNSPrefix);
+        let result = readTagExp(xmlData, i2, this.options.removeNSPrefix);
         let tagName = result.tagName;
         const rawTagName = result.rawTagName;
         let tagExp = result.tagExp;
@@ -2061,13 +1473,13 @@ const parseXml = function(xmlData) {
             } else {
               tagExp = tagExp.substr(0, tagExp.length - 1);
             }
-            i = result.closeIndex;
+            i2 = result.closeIndex;
           } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
-            i = result.closeIndex;
+            i2 = result.closeIndex;
           } else {
             const result2 = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
             if (!result2) throw new Error(`Unexpected end of ${rawTagName}`);
-            i = result2.i;
+            i2 = result2.i;
             tagContent = result2.tagContent;
           }
           const childNode = new xmlNode(tagName);
@@ -2108,11 +1520,11 @@ const parseXml = function(xmlData) {
             currentNode = childNode;
           }
           textData = "";
-          i = closeIndex;
+          i2 = closeIndex;
         }
       }
     } else {
-      textData += xmlData[i];
+      textData += xmlData[i2];
     }
   }
   return xmlObj.child;
@@ -2172,10 +1584,10 @@ function isItStopNode(stopNodes, jPath, currentTagName) {
   }
   return false;
 }
-function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
+function tagExpWithClosingIndex(xmlData, i2, closingChar = ">") {
   let attrBoundary;
   let tagExp = "";
-  for (let index = i; index < xmlData.length; index++) {
+  for (let index = i2; index < xmlData.length; index++) {
     let ch = xmlData[index];
     if (attrBoundary) {
       if (ch === attrBoundary) attrBoundary = "";
@@ -2201,16 +1613,16 @@ function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
     tagExp += ch;
   }
 }
-function findClosingIndex(xmlData, str, i, errMsg) {
-  const closingIndex = xmlData.indexOf(str, i);
+function findClosingIndex(xmlData, str, i2, errMsg) {
+  const closingIndex = xmlData.indexOf(str, i2);
   if (closingIndex === -1) {
     throw new Error(errMsg);
   } else {
     return closingIndex + str.length - 1;
   }
 }
-function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
-  const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
+function readTagExp(xmlData, i2, removeNSPrefix, closingChar = ">") {
+  const result = tagExpWithClosingIndex(xmlData, i2 + 1, closingChar);
   if (!result) return;
   let tagExp = result.data;
   const closeIndex = result.index;
@@ -2237,41 +1649,41 @@ function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
     rawTagName
   };
 }
-function readStopNodeData(xmlData, tagName, i) {
-  const startIndex = i;
+function readStopNodeData(xmlData, tagName, i2) {
+  const startIndex = i2;
   let openTagCount = 1;
-  for (; i < xmlData.length; i++) {
-    if (xmlData[i] === "<") {
-      if (xmlData[i + 1] === "/") {
-        const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
-        let closeTagName = xmlData.substring(i + 2, closeIndex).trim();
+  for (; i2 < xmlData.length; i2++) {
+    if (xmlData[i2] === "<") {
+      if (xmlData[i2 + 1] === "/") {
+        const closeIndex = findClosingIndex(xmlData, ">", i2, `${tagName} is not closed`);
+        let closeTagName = xmlData.substring(i2 + 2, closeIndex).trim();
         if (closeTagName === tagName) {
           openTagCount--;
           if (openTagCount === 0) {
             return {
-              tagContent: xmlData.substring(startIndex, i),
+              tagContent: xmlData.substring(startIndex, i2),
               i: closeIndex
             };
           }
         }
-        i = closeIndex;
-      } else if (xmlData[i + 1] === "?") {
-        const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
-        i = closeIndex;
-      } else if (xmlData.substr(i + 1, 3) === "!--") {
-        const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
-        i = closeIndex;
-      } else if (xmlData.substr(i + 1, 2) === "![") {
-        const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
-        i = closeIndex;
+        i2 = closeIndex;
+      } else if (xmlData[i2 + 1] === "?") {
+        const closeIndex = findClosingIndex(xmlData, "?>", i2 + 1, "StopNode is not closed.");
+        i2 = closeIndex;
+      } else if (xmlData.substr(i2 + 1, 3) === "!--") {
+        const closeIndex = findClosingIndex(xmlData, "-->", i2 + 3, "StopNode is not closed.");
+        i2 = closeIndex;
+      } else if (xmlData.substr(i2 + 1, 2) === "![") {
+        const closeIndex = findClosingIndex(xmlData, "]]>", i2, "StopNode is not closed.") - 2;
+        i2 = closeIndex;
       } else {
-        const tagData = readTagExp(xmlData, i, ">");
+        const tagData = readTagExp(xmlData, i2, ">");
         if (tagData) {
           const openTagName = tagData && tagData.tagName;
           if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") {
             openTagCount++;
           }
-          i = tagData.closeIndex;
+          i2 = tagData.closeIndex;
         }
       }
     }
@@ -2299,8 +1711,8 @@ function prettify$1(node, options) {
 function compress(arr, options, jPath) {
   let text;
   const compressedObj = {};
-  for (let i = 0; i < arr.length; i++) {
-    const tagObj = arr[i];
+  for (let i2 = 0; i2 < arr.length; i2++) {
+    const tagObj = arr[i2];
     const property = propName$1(tagObj);
     let newJpath = "";
     if (jPath === void 0) newJpath = property;
@@ -2342,8 +1754,8 @@ function compress(arr, options, jPath) {
 }
 function propName$1(obj) {
   const keys = Object.keys(obj);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
+  for (let i2 = 0; i2 < keys.length; i2++) {
+    const key = keys[i2];
     if (key !== ":@") return key;
   }
 }
@@ -2351,8 +1763,8 @@ function assignAttributes(obj, attrMap, jpath, options) {
   if (attrMap) {
     const keys = Object.keys(attrMap);
     const len = keys.length;
-    for (let i = 0; i < len; i++) {
-      const atrrName = keys[i];
+    for (let i2 = 0; i2 < len; i2++) {
+      const atrrName = keys[i2];
       if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
         obj[atrrName] = [attrMap[atrrName]];
       } else {
@@ -2436,8 +1848,8 @@ function toXml(jArray, options) {
 function arrToStr(arr, options, jPath, indentation) {
   let xmlStr = "";
   let isPreviousElementTag = false;
-  for (let i = 0; i < arr.length; i++) {
-    const tagObj = arr[i];
+  for (let i2 = 0; i2 < arr.length; i2++) {
+    const tagObj = arr[i2];
     const tagName = propName(tagObj);
     if (tagName === void 0) continue;
     let newJPath = "";
@@ -2504,8 +1916,8 @@ function arrToStr(arr, options, jPath, indentation) {
 }
 function propName(obj) {
   const keys = Object.keys(obj);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
+  for (let i2 = 0; i2 < keys.length; i2++) {
+    const key = keys[i2];
     if (!obj.hasOwnProperty(key)) continue;
     if (key !== ":@") return key;
   }
@@ -2536,8 +1948,8 @@ function isStopNode(jPath, options) {
 }
 function replaceEntitiesValue(textValue, options) {
   if (textValue && textValue.length > 0 && options.processEntities) {
-    for (let i = 0; i < options.entities.length; i++) {
-      const entity = options.entities[i];
+    for (let i2 = 0; i2 < options.entities.length; i2++) {
+      const entity = options.entities[i2];
       textValue = textValue.replace(entity.regex, entity.val);
     }
   }
@@ -2557,11 +1969,11 @@ const defaultOptions = {
   suppressEmptyNode: false,
   suppressUnpairedNode: true,
   suppressBooleanAttributes: true,
-  tagValueProcessor: function(key, a) {
-    return a;
+  tagValueProcessor: function(key, a2) {
+    return a2;
   },
-  attributeValueProcessor: function(attrName, a) {
-    return a;
+  attributeValueProcessor: function(attrName, a2) {
+    return a2;
   },
   preserveOrder: false,
   commentPropName: false,
@@ -2652,8 +2064,8 @@ Builder.prototype.j2x = function(jObj, level, ajPath) {
       const arrLen = jObj[key].length;
       let listTagVal = "";
       let listTagAttr = "";
-      for (let j = 0; j < arrLen; j++) {
-        const item = jObj[key][j];
+      for (let j2 = 0; j2 < arrLen; j2++) {
+        const item = jObj[key][j2];
         if (typeof item === "undefined") ;
         else if (item === null) {
           if (key[0] === "?") val2 += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
@@ -2686,8 +2098,8 @@ Builder.prototype.j2x = function(jObj, level, ajPath) {
       if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
         const Ks = Object.keys(jObj[key]);
         const L = Ks.length;
-        for (let j = 0; j < L; j++) {
-          attrStr += this.buildAttrPairStr(Ks[j], "" + jObj[key][Ks[j]]);
+        for (let j2 = 0; j2 < L; j2++) {
+          attrStr += this.buildAttrPairStr(Ks[j2], "" + jObj[key][Ks[j2]]);
         }
       } else {
         val2 += this.processTextOrObjNode(jObj[key], key, level, ajPath);
@@ -2763,8 +2175,8 @@ Builder.prototype.buildTextValNode = function(val2, key, attrStr, level) {
 };
 Builder.prototype.replaceEntitiesValue = function(textValue) {
   if (textValue && textValue.length > 0 && this.options.processEntities) {
-    for (let i = 0; i < this.options.entities.length; i++) {
-      const entity = this.options.entities[i];
+    for (let i2 = 0; i2 < this.options.entities.length; i2++) {
+      const entity = this.options.entities[i2];
       textValue = textValue.replace(entity.regex, entity.val);
     }
   }
@@ -2889,8 +2301,8 @@ const isValidView = function(view) {
   if (!view.name || typeof view.name !== "string") {
     throw new Error("View name is required and must be a string");
   }
-  if (view.columns && view.columns.length > 0 && (!view.caption || typeof view.caption !== "string")) {
-    throw new Error("View caption is required for top-level views and must be a string");
+  if ("caption" in view && typeof view.caption !== "string") {
+    throw new Error("View caption must be a string");
   }
   if (!view.getContents || typeof view.getContents !== "function") {
     throw new Error("View getContents is required and must be a function");
@@ -2968,7 +2380,7 @@ var re$1 = { exports: {} };
   const re2 = exports.re = [];
   const safeRe = exports.safeRe = [];
   const src = exports.src = [];
-  const t2 = exports.t = {};
+  const t3 = exports.t = {};
   let R = 0;
   const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
   const safeRegexReplacements = [
@@ -2986,7 +2398,7 @@ var re$1 = { exports: {} };
     const safe = makeSafeRegex(value);
     const index = R++;
     debug2(name, index, value);
-    t2[name] = index;
+    t3[name] = index;
     src[index] = value;
     re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
     safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
@@ -2994,46 +2406,46 @@ var re$1 = { exports: {} };
   createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
   createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
   createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
-  createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`);
-  createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`);
-  createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NUMERICIDENTIFIER]}|${src[t2.NONNUMERICIDENTIFIER]})`);
-  createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NUMERICIDENTIFIERLOOSE]}|${src[t2.NONNUMERICIDENTIFIER]})`);
-  createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`);
-  createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`);
+  createToken("MAINVERSION", `(${src[t3.NUMERICIDENTIFIER]})\\.(${src[t3.NUMERICIDENTIFIER]})\\.(${src[t3.NUMERICIDENTIFIER]})`);
+  createToken("MAINVERSIONLOOSE", `(${src[t3.NUMERICIDENTIFIERLOOSE]})\\.(${src[t3.NUMERICIDENTIFIERLOOSE]})\\.(${src[t3.NUMERICIDENTIFIERLOOSE]})`);
+  createToken("PRERELEASEIDENTIFIER", `(?:${src[t3.NUMERICIDENTIFIER]}|${src[t3.NONNUMERICIDENTIFIER]})`);
+  createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t3.NUMERICIDENTIFIERLOOSE]}|${src[t3.NONNUMERICIDENTIFIER]})`);
+  createToken("PRERELEASE", `(?:-(${src[t3.PRERELEASEIDENTIFIER]}(?:\\.${src[t3.PRERELEASEIDENTIFIER]})*))`);
+  createToken("PRERELEASELOOSE", `(?:-?(${src[t3.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t3.PRERELEASEIDENTIFIERLOOSE]})*))`);
   createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
-  createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`);
-  createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`);
-  createToken("FULL", `^${src[t2.FULLPLAIN]}$`);
-  createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`);
-  createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`);
+  createToken("BUILD", `(?:\\+(${src[t3.BUILDIDENTIFIER]}(?:\\.${src[t3.BUILDIDENTIFIER]})*))`);
+  createToken("FULLPLAIN", `v?${src[t3.MAINVERSION]}${src[t3.PRERELEASE]}?${src[t3.BUILD]}?`);
+  createToken("FULL", `^${src[t3.FULLPLAIN]}$`);
+  createToken("LOOSEPLAIN", `[v=\\s]*${src[t3.MAINVERSIONLOOSE]}${src[t3.PRERELEASELOOSE]}?${src[t3.BUILD]}?`);
+  createToken("LOOSE", `^${src[t3.LOOSEPLAIN]}$`);
   createToken("GTLT", "((?:<|>)?=?)");
-  createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
-  createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`);
-  createToken("XRANGEPLAIN", `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${src[t2.PRERELEASE]})?${src[t2.BUILD]}?)?)?`);
-  createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`);
-  createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`);
-  createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`);
+  createToken("XRANGEIDENTIFIERLOOSE", `${src[t3.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+  createToken("XRANGEIDENTIFIER", `${src[t3.NUMERICIDENTIFIER]}|x|X|\\*`);
+  createToken("XRANGEPLAIN", `[v=\\s]*(${src[t3.XRANGEIDENTIFIER]})(?:\\.(${src[t3.XRANGEIDENTIFIER]})(?:\\.(${src[t3.XRANGEIDENTIFIER]})(?:${src[t3.PRERELEASE]})?${src[t3.BUILD]}?)?)?`);
+  createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:${src[t3.PRERELEASELOOSE]})?${src[t3.BUILD]}?)?)?`);
+  createToken("XRANGE", `^${src[t3.GTLT]}\\s*${src[t3.XRANGEPLAIN]}$`);
+  createToken("XRANGELOOSE", `^${src[t3.GTLT]}\\s*${src[t3.XRANGEPLAINLOOSE]}$`);
   createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?`);
-  createToken("COERCE", `${src[t2.COERCEPLAIN]}(?:$|[^\\d])`);
-  createToken("COERCEFULL", src[t2.COERCEPLAIN] + `(?:${src[t2.PRERELEASE]})?(?:${src[t2.BUILD]})?(?:$|[^\\d])`);
-  createToken("COERCERTL", src[t2.COERCE], true);
-  createToken("COERCERTLFULL", src[t2.COERCEFULL], true);
+  createToken("COERCE", `${src[t3.COERCEPLAIN]}(?:$|[^\\d])`);
+  createToken("COERCEFULL", src[t3.COERCEPLAIN] + `(?:${src[t3.PRERELEASE]})?(?:${src[t3.BUILD]})?(?:$|[^\\d])`);
+  createToken("COERCERTL", src[t3.COERCE], true);
+  createToken("COERCERTLFULL", src[t3.COERCEFULL], true);
   createToken("LONETILDE", "(?:~>?)");
-  createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true);
+  createToken("TILDETRIM", `(\\s*)${src[t3.LONETILDE]}\\s+`, true);
   exports.tildeTrimReplace = "$1~";
-  createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`);
-  createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`);
+  createToken("TILDE", `^${src[t3.LONETILDE]}${src[t3.XRANGEPLAIN]}$`);
+  createToken("TILDELOOSE", `^${src[t3.LONETILDE]}${src[t3.XRANGEPLAINLOOSE]}$`);
   createToken("LONECARET", "(?:\\^)");
-  createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true);
+  createToken("CARETTRIM", `(\\s*)${src[t3.LONECARET]}\\s+`, true);
   exports.caretTrimReplace = "$1^";
-  createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`);
-  createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`);
-  createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`);
-  createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`);
-  createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true);
+  createToken("CARET", `^${src[t3.LONECARET]}${src[t3.XRANGEPLAIN]}$`);
+  createToken("CARETLOOSE", `^${src[t3.LONECARET]}${src[t3.XRANGEPLAINLOOSE]}$`);
+  createToken("COMPARATORLOOSE", `^${src[t3.GTLT]}\\s*(${src[t3.LOOSEPLAIN]})$|^$`);
+  createToken("COMPARATOR", `^${src[t3.GTLT]}\\s*(${src[t3.FULLPLAIN]})$|^$`);
+  createToken("COMPARATORTRIM", `(\\s*)${src[t3.GTLT]}\\s*(${src[t3.LOOSEPLAIN]}|${src[t3.XRANGEPLAIN]})`, true);
   exports.comparatorTrimReplace = "$1$2$3";
-  createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`);
-  createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`);
+  createToken("HYPHENRANGE", `^\\s*(${src[t3.XRANGEPLAIN]})\\s+-\\s+(${src[t3.XRANGEPLAIN]})\\s*$`);
+  createToken("HYPHENRANGELOOSE", `^\\s*(${src[t3.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t3.XRANGEPLAINLOOSE]})\\s*$`);
   createToken("STAR", "(<|>)?=?\\s*\\*");
   createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
   createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
@@ -3052,23 +2464,23 @@ const parseOptions$1 = (options) => {
 };
 var parseOptions_1 = parseOptions$1;
 const numeric = /^[0-9]+$/;
-const compareIdentifiers$1 = (a, b) => {
-  const anum = numeric.test(a);
-  const bnum = numeric.test(b);
+const compareIdentifiers$1 = (a2, b2) => {
+  const anum = numeric.test(a2);
+  const bnum = numeric.test(b2);
   if (anum && bnum) {
-    a = +a;
-    b = +b;
+    a2 = +a2;
+    b2 = +b2;
   }
-  return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+  return a2 === b2 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a2 < b2 ? -1 : 1;
 };
-const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
+const rcompareIdentifiers = (a2, b2) => compareIdentifiers$1(b2, a2);
 var identifiers = {
   compareIdentifiers: compareIdentifiers$1,
   rcompareIdentifiers
 };
 const debug = debug_1;
 const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants;
-const { safeRe: re, t } = reExports;
+const { safeRe: re, t: t2 } = reExports;
 const parseOptions = parseOptions_1;
 const { compareIdentifiers } = identifiers;
 let SemVer$2 = class SemVer {
@@ -3092,14 +2504,14 @@ let SemVer$2 = class SemVer {
     this.options = options;
     this.loose = !!options.loose;
     this.includePrerelease = !!options.includePrerelease;
-    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
-    if (!m) {
+    const m2 = version.trim().match(options.loose ? re[t2.LOOSE] : re[t2.FULL]);
+    if (!m2) {
       throw new TypeError(`Invalid Version: ${version}`);
     }
     this.raw = version;
-    this.major = +m[1];
-    this.minor = +m[2];
-    this.patch = +m[3];
+    this.major = +m2[1];
+    this.minor = +m2[2];
+    this.patch = +m2[3];
     if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
       throw new TypeError("Invalid major version");
     }
@@ -3109,10 +2521,10 @@ let SemVer$2 = class SemVer {
     if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
       throw new TypeError("Invalid patch version");
     }
-    if (!m[4]) {
+    if (!m2[4]) {
       this.prerelease = [];
     } else {
-      this.prerelease = m[4].split(".").map((id) => {
+      this.prerelease = m2[4].split(".").map((id) => {
         if (/^[0-9]+$/.test(id)) {
           const num = +id;
           if (num >= 0 && num < MAX_SAFE_INTEGER) {
@@ -3122,7 +2534,7 @@ let SemVer$2 = class SemVer {
         return id;
       });
     }
-    this.build = m[5] ? m[5].split(".") : [];
+    this.build = m2[5] ? m2[5].split(".") : [];
     this.format();
   }
   format() {
@@ -3165,45 +2577,45 @@ let SemVer$2 = class SemVer {
     } else if (!this.prerelease.length && !other.prerelease.length) {
       return 0;
     }
-    let i = 0;
+    let i2 = 0;
     do {
-      const a = this.prerelease[i];
-      const b = other.prerelease[i];
-      debug("prerelease compare", i, a, b);
-      if (a === void 0 && b === void 0) {
+      const a2 = this.prerelease[i2];
+      const b2 = other.prerelease[i2];
+      debug("prerelease compare", i2, a2, b2);
+      if (a2 === void 0 && b2 === void 0) {
         return 0;
-      } else if (b === void 0) {
+      } else if (b2 === void 0) {
         return 1;
-      } else if (a === void 0) {
+      } else if (a2 === void 0) {
         return -1;
-      } else if (a === b) {
+      } else if (a2 === b2) {
         continue;
       } else {
-        return compareIdentifiers(a, b);
+        return compareIdentifiers(a2, b2);
       }
-    } while (++i);
+    } while (++i2);
   }
   compareBuild(other) {
     if (!(other instanceof SemVer)) {
       other = new SemVer(other, this.options);
     }
-    let i = 0;
+    let i2 = 0;
     do {
-      const a = this.build[i];
-      const b = other.build[i];
-      debug("build compare", i, a, b);
-      if (a === void 0 && b === void 0) {
+      const a2 = this.build[i2];
+      const b2 = other.build[i2];
+      debug("build compare", i2, a2, b2);
+      if (a2 === void 0 && b2 === void 0) {
         return 0;
-      } else if (b === void 0) {
+      } else if (b2 === void 0) {
         return 1;
-      } else if (a === void 0) {
+      } else if (a2 === void 0) {
         return -1;
-      } else if (a === b) {
+      } else if (a2 === b2) {
         continue;
       } else {
-        return compareIdentifiers(a, b);
+        return compareIdentifiers(a2, b2);
       }
-    } while (++i);
+    } while (++i2);
   }
   // preminor will bump the version up to the next minor release, and immediately
   // down to pre-release. premajor and prepatch work the same way.
@@ -3262,14 +2674,14 @@ let SemVer$2 = class SemVer {
         if (this.prerelease.length === 0) {
           this.prerelease = [base];
         } else {
-          let i = this.prerelease.length;
-          while (--i >= 0) {
-            if (typeof this.prerelease[i] === "number") {
-              this.prerelease[i]++;
-              i = -2;
+          let i2 = this.prerelease.length;
+          while (--i2 >= 0) {
+            if (typeof this.prerelease[i2] === "number") {
+              this.prerelease[i2]++;
+              i2 = -2;
             }
           }
-          if (i === -1) {
+          if (i2 === -1) {
             if (identifier === this.prerelease.join(".") && identifierBase === false) {
               throw new Error("invalid increment argument: identifier already exists");
             }
@@ -3325,7 +2737,7 @@ const valid = (version, options) => {
 var valid_1 = valid;
 const valid$1 = /* @__PURE__ */ getDefaultExportFromCjs(valid_1);
 const SemVer2 = semver;
-const major = (a, loose) => new SemVer2(a, loose).major;
+const major = (a2, loose) => new SemVer2(a2, loose).major;
 var major_1 = major;
 const major$1 = /* @__PURE__ */ getDefaultExportFromCjs(major_1);
 class ProxyBus {
@@ -3369,15 +2781,15 @@ class SimpleBus {
   unsubscribe(name, handler) {
     this.handlers.set(
       name,
-      (this.handlers.get(name) || []).filter((h) => h !== handler)
+      (this.handlers.get(name) || []).filter((h2) => h2 !== handler)
     );
   }
   emit(name, event) {
-    (this.handlers.get(name) || []).forEach((h) => {
+    (this.handlers.get(name) || []).forEach((h2) => {
       try {
-        h(event);
-      } catch (e) {
-        console.error("could not invoke event listener", e);
+        h2(event);
+      } catch (e2) {
+        console.error("could not invoke event listener", e2);
       }
     });
   }
@@ -3466,49 +2878,51 @@ const removeNewFileMenuEntry = function(entry) {
 };
 const getNewFileMenuEntries = function(context) {
   const newFileMenu = getNewFileMenu();
-  return newFileMenu.getEntries(context).sort((a, b) => {
-    if (a.order !== void 0 && b.order !== void 0 && a.order !== b.order) {
-      return a.order - b.order;
+  return newFileMenu.getEntries(context).sort((a2, b2) => {
+    if (a2.order !== void 0 && b2.order !== void 0 && a2.order !== b2.order) {
+      return a2.order - b2.order;
     }
-    return a.displayName.localeCompare(b.displayName, void 0, { numeric: true, sensitivity: "base" });
+    return a2.displayName.localeCompare(b2.displayName, void 0, { numeric: true, sensitivity: "base" });
   });
 };
 export {
   Column,
   DefaultType,
-  File,
+  q as File,
   FileAction,
+  FileListAction,
   FileListFilter,
-  FileType,
+  F as FileType,
   FilesSortingMode,
-  Folder,
+  s as Folder,
   Header,
   InvalidFilenameError,
   InvalidFilenameErrorReason,
   Navigation,
   NewMenuEntryCategory,
-  Node,
-  NodeStatus,
-  Permission,
+  N as Node,
+  t as NodeStatus,
+  P as Permission,
   View,
   addNewFileMenuEntry,
-  davGetClient,
-  davGetDefaultPropfind,
-  davGetFavoritesReport,
-  davGetRecentSearch,
-  davGetRemoteURL,
-  davGetRootPath,
-  davParsePermissions,
-  davRemoteURL,
-  davResultToNode,
-  davRootPath,
-  defaultDavNamespaces,
-  defaultDavProperties,
+  c as davGetClient,
+  l as davGetDefaultPropfind,
+  m as davGetFavoritesReport,
+  n as davGetRecentSearch,
+  a as davGetRemoteURL,
+  g as davGetRootPath,
+  p as davParsePermissions,
+  b as davRemoteURL,
+  r as davResultToNode,
+  d as davRootPath,
+  h as defaultDavNamespaces,
+  f as defaultDavProperties,
   formatFileSize,
-  getDavNameSpaces,
-  getDavProperties,
-  getFavoriteNodes,
+  k as getDavNameSpaces,
+  j as getDavProperties,
+  e as getFavoriteNodes,
   getFileActions,
+  getFileListActions,
   getFileListFilters,
   getFileListHeaders,
   getNavigation,
@@ -3517,8 +2931,9 @@ export {
   isFilenameValid,
   orderBy,
   parseFileSize,
-  registerDavProperty,
+  i as registerDavProperty,
   registerFileAction,
+  registerFileListAction,
   registerFileListFilter,
   registerFileListHeaders,
   removeNewFileMenuEntry,