@nextcloud/files 3.5.1 → 3.7.0

package/dist/index.mjs

@@ -6,6 +6,7 @@ import { generateRemoteUrl } from "@nextcloud/router";
 import { CancelablePromise } from "cancelable-promise";
 import { createClient, getPatcher } from "webdav";
 import { isPublicShare, getSharingToken } from "@nextcloud/sharing/public";
+import { getCapabilities } from "@nextcloud/capabilities";
 import { getCanonicalLocale, getLanguage } from "@nextcloud/l10n";
 import { TypedEventTarget } from "typescript-event-target";
 const logger = getLoggerBuilder().setApp("@nextcloud/files").detectUser().build();
@@ -428,6 +429,9 @@ const validateData = (data, davService) => {
   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");
   }
@@ -504,7 +508,12 @@ class Node {
   };
   constructor(data, davService) {
     validateData(data, davService || this._knownDavService);
-    this._data = { ...data, attributes: {} };
+    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) {
@@ -534,6 +543,21 @@ class Node {
   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.
@@ -696,7 +720,11 @@ class Node {
    */
   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();
   }
   /**
@@ -841,6 +869,8 @@ const davResultToNode = function(node, filesRoot = davRootPath, remoteURL = davR
     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,
@@ -856,16 +886,81 @@ const davResultToNode = function(node, filesRoot = davRootPath, remoteURL = davR
   delete nodeData.attributes?.props;
   return node.type === "file" ? new File(nodeData) : new Folder(nodeData);
 };
-const forbiddenCharacters = window._oc_config?.forbidden_filenames_characters ?? ["/", "\\"];
-const forbiddenFilenameRegex = window._oc_config?.blacklist_files_regex ? new RegExp(window._oc_config.blacklist_files_regex) : null;
-function isFilenameValid(filename) {
-  if (forbiddenCharacters.some((character) => filename.includes(character))) {
-    return false;
+var InvalidFilenameErrorReason = /* @__PURE__ */ ((InvalidFilenameErrorReason2) => {
+  InvalidFilenameErrorReason2["ReservedName"] = "reserved name";
+  InvalidFilenameErrorReason2["Character"] = "character";
+  InvalidFilenameErrorReason2["Extension"] = "extension";
+  return InvalidFilenameErrorReason2;
+})(InvalidFilenameErrorReason || {});
+class InvalidFilenameError extends Error {
+  constructor(options) {
+    super(`Invalid ${options.reason} '${options.segment}' in filename '${options.filename}'`, { cause: options });
   }
-  if (forbiddenFilenameRegex !== null && filename.match(forbiddenFilenameRegex)) {
-    return false;
+  /**
+   * The filename that was validated
+   */
+  get filename() {
+    return this.cause.filename;
+  }
+  /**
+   * Reason why the validation failed
+   */
+  get reason() {
+    return this.cause.reason;
+  }
+  /**
+   * Part of the filename that caused this error
+   */
+  get segment() {
+    return this.cause.segment;
+  }
+}
+function validateFilename(filename) {
+  const capabilities = getCapabilities().files;
+  const forbiddenCharacters = capabilities.forbidden_filename_characters ?? window._oc_config?.forbidden_filenames_characters ?? ["/", "\\"];
+  for (const character of forbiddenCharacters) {
+    if (filename.includes(character)) {
+      throw new InvalidFilenameError({ segment: character, reason: "character", filename });
+    }
+  }
+  filename = filename.toLocaleLowerCase();
+  const forbiddenFilenames = capabilities.forbidden_filenames ?? [".htaccess"];
+  if (forbiddenFilenames.includes(filename)) {
+    throw new InvalidFilenameError({
+      filename,
+      segment: filename,
+      reason: "reserved name"
+      /* ReservedName */
+    });
+  }
+  const endOfBasename = filename.indexOf(".", 1);
+  const basename2 = filename.substring(0, endOfBasename === -1 ? void 0 : endOfBasename);
+  const forbiddenFilenameBasenames = capabilities.forbidden_filename_basenames ?? [];
+  if (forbiddenFilenameBasenames.includes(basename2)) {
+    throw new InvalidFilenameError({
+      filename,
+      segment: basename2,
+      reason: "reserved name"
+      /* ReservedName */
+    });
+  }
+  const forbiddenFilenameExtensions = capabilities.forbidden_filename_extensions ?? [".part", ".filepart"];
+  for (const extension of forbiddenFilenameExtensions) {
+    if (filename.length > extension.length && filename.endsWith(extension)) {
+      throw new InvalidFilenameError({ segment: extension, reason: "extension", filename });
+    }
+  }
+}
+function isFilenameValid(filename) {
+  try {
+    validateFilename(filename);
+    return true;
+  } catch (error) {
+    if (error instanceof InvalidFilenameError) {
+      return false;
+    }
+    throw error;
   }
-  return true;
 }
 function getUniqueName(name, otherNames, options) {
   const opts = {
@@ -932,10 +1027,10 @@ function stringify(value) {
   }
   return String(value);
 }
-function orderBy(collection, identifiers, orders) {
-  identifiers = identifiers ?? [(value) => value];
+function orderBy(collection, identifiers2, orders) {
+  identifiers2 = identifiers2 ?? [(value) => value];
   orders = orders ?? [];
-  const sorting = identifiers.map((_, index) => (orders[index] ?? "asc") === "asc" ? 1 : -1);
+  const sorting = identifiers2.map((_, index) => (orders[index] ?? "asc") === "asc" ? 1 : -1);
   const collator = Intl.Collator(
     [getLanguage(), getCanonicalLocale()],
     {
@@ -945,7 +1040,7 @@ function orderBy(collection, identifiers, orders) {
     }
   );
   return [...collection].sort((a, b) => {
-    for (const [index, identifier] of identifiers.entries()) {
+    for (const [index, identifier] of identifiers2.entries()) {
       const value = collator.compare(stringify(identifier(a)), stringify(identifier(b)));
       if (value !== 0) {
         return value * sorting[index];
@@ -969,14 +1064,14 @@ function sortNodes(nodes, options = {}) {
     ...options
   };
   const basename2 = (name) => name.lastIndexOf(".") > 0 ? name.slice(0, name.lastIndexOf(".")) : name;
-  const identifiers = [
+  const identifiers2 = [
     // 1: Sort favorites first if enabled
     ...sortingOptions.sortFavoritesFirst ? [(v) => v.attributes?.favorite !== 1] : [],
     // 2: Sort folders first if sorting by name
     ...sortingOptions.sortFoldersFirst ? [(v) => v.type !== "folder"] : [],
-    // 3: Use sorting mode if NOT basename (to be able to use displayname too)
+    // 3: Use sorting mode if NOT basename (to be able to use display name too)
     ...sortingOptions.sortingMode !== "basename" ? [(v) => v[sortingOptions.sortingMode]] : [],
-    // 4: Use displayname if available, fallback to name
+    // 4: Use display name if available, fallback to name
     (v) => basename2(v.attributes?.displayname || v.basename),
     // 5: Finally, use basename if all previous sorting methods failed
     (v) => v.basename
@@ -995,7 +1090,7 @@ function sortNodes(nodes, options = {}) {
     // for 5: use configured sorting direction
     sortingOptions.sortingOrder
   ];
-  return orderBy(nodes, identifiers, orders);
+  return orderBy(nodes, identifiers2, orders);
 }
 class Navigation extends TypedEventTarget {
   _views = [];
@@ -1093,6 +1188,9 @@ const isValidColumn = function(column) {
   }
   return true;
 };
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
 var validator$2 = {};
 var util$3 = {};
 (function(exports) {
@@ -1286,7 +1384,7 @@ 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((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
+    return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t2) => t2.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
   }
   return true;
 };
@@ -1396,15 +1494,15 @@ function validateAttributeString(attrStr, options) {
   return true;
 }
 function validateNumberAmpersand(xmlData, i) {
-  let re = /\d/;
+  let re2 = /\d/;
   if (xmlData[i] === "x") {
     i++;
-    re = /[\da-fA-F]/;
+    re2 = /[\da-fA-F]/;
   }
   for (; i < xmlData.length; i++) {
     if (xmlData[i] === ";")
       return i;
-    if (!xmlData[i].match(re))
+    if (!xmlData[i].match(re2))
       break;
   }
   return -1;
@@ -2786,6 +2884,534 @@ const isValidView = function(view) {
   }
   return true;
 };
+const debug$1 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+};
+var debug_1 = debug$1;
+const SEMVER_SPEC_VERSION = "2.0.0";
+const MAX_LENGTH$1 = 256;
+const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+9007199254740991;
+const MAX_SAFE_COMPONENT_LENGTH = 16;
+const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6;
+const RELEASE_TYPES = [
+  "major",
+  "premajor",
+  "minor",
+  "preminor",
+  "patch",
+  "prepatch",
+  "prerelease"
+];
+var constants = {
+  MAX_LENGTH: MAX_LENGTH$1,
+  MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+  RELEASE_TYPES,
+  SEMVER_SPEC_VERSION,
+  FLAG_INCLUDE_PRERELEASE: 1,
+  FLAG_LOOSE: 2
+};
+var re$1 = { exports: {} };
+(function(module, exports) {
+  const {
+    MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2,
+    MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH2,
+    MAX_LENGTH: MAX_LENGTH2
+  } = constants;
+  const debug2 = debug_1;
+  exports = module.exports = {};
+  const re2 = exports.re = [];
+  const safeRe = exports.safeRe = [];
+  const src = exports.src = [];
+  const t2 = exports.t = {};
+  let R = 0;
+  const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+  const safeRegexReplacements = [
+    ["\\s", 1],
+    ["\\d", MAX_LENGTH2],
+    [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH2]
+  ];
+  const makeSafeRegex = (value) => {
+    for (const [token, max] of safeRegexReplacements) {
+      value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+    }
+    return value;
+  };
+  const createToken = (name, value, isGlobal) => {
+    const safe = makeSafeRegex(value);
+    const index = R++;
+    debug2(name, index, value);
+    t2[name] = index;
+    src[index] = value;
+    re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
+    safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+  };
+  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("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("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("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("LONETILDE", "(?:~>?)");
+  createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true);
+  exports.tildeTrimReplace = "$1~";
+  createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`);
+  createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`);
+  createToken("LONECARET", "(?:\\^)");
+  createToken("CARETTRIM", `(\\s*)${src[t2.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);
+  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("STAR", "(<|>)?=?\\s*\\*");
+  createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+  createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+})(re$1, re$1.exports);
+var reExports = re$1.exports;
+const looseOption = Object.freeze({ loose: true });
+const emptyOpts = Object.freeze({});
+const parseOptions$1 = (options) => {
+  if (!options) {
+    return emptyOpts;
+  }
+  if (typeof options !== "object") {
+    return looseOption;
+  }
+  return 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);
+  if (anum && bnum) {
+    a = +a;
+    b = +b;
+  }
+  return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+};
+const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
+var identifiers = {
+  compareIdentifiers: compareIdentifiers$1,
+  rcompareIdentifiers
+};
+const debug = debug_1;
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants;
+const { safeRe: re, t } = reExports;
+const parseOptions = parseOptions_1;
+const { compareIdentifiers } = identifiers;
+let SemVer$2 = class SemVer {
+  constructor(version, options) {
+    options = parseOptions(options);
+    if (version instanceof SemVer) {
+      if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+        return version;
+      } else {
+        version = version.version;
+      }
+    } else if (typeof version !== "string") {
+      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+    }
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH} characters`
+      );
+    }
+    debug("SemVer", version, options);
+    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) {
+      throw new TypeError(`Invalid Version: ${version}`);
+    }
+    this.raw = version;
+    this.major = +m[1];
+    this.minor = +m[2];
+    this.patch = +m[3];
+    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+      throw new TypeError("Invalid major version");
+    }
+    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+      throw new TypeError("Invalid minor version");
+    }
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError("Invalid patch version");
+    }
+    if (!m[4]) {
+      this.prerelease = [];
+    } else {
+      this.prerelease = m[4].split(".").map((id) => {
+        if (/^[0-9]+$/.test(id)) {
+          const num = +id;
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num;
+          }
+        }
+        return id;
+      });
+    }
+    this.build = m[5] ? m[5].split(".") : [];
+    this.format();
+  }
+  format() {
+    this.version = `${this.major}.${this.minor}.${this.patch}`;
+    if (this.prerelease.length) {
+      this.version += `-${this.prerelease.join(".")}`;
+    }
+    return this.version;
+  }
+  toString() {
+    return this.version;
+  }
+  compare(other) {
+    debug("SemVer.compare", this.version, this.options, other);
+    if (!(other instanceof SemVer)) {
+      if (typeof other === "string" && other === this.version) {
+        return 0;
+      }
+      other = new SemVer(other, this.options);
+    }
+    if (other.version === this.version) {
+      return 0;
+    }
+    return this.compareMain(other) || this.comparePre(other);
+  }
+  compareMain(other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+    return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+  }
+  comparePre(other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+    if (this.prerelease.length && !other.prerelease.length) {
+      return -1;
+    } else if (!this.prerelease.length && other.prerelease.length) {
+      return 1;
+    } else if (!this.prerelease.length && !other.prerelease.length) {
+      return 0;
+    }
+    let i = 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) {
+        return 0;
+      } else if (b === void 0) {
+        return 1;
+      } else if (a === void 0) {
+        return -1;
+      } else if (a === b) {
+        continue;
+      } else {
+        return compareIdentifiers(a, b);
+      }
+    } while (++i);
+  }
+  compareBuild(other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+    let i = 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) {
+        return 0;
+      } else if (b === void 0) {
+        return 1;
+      } else if (a === void 0) {
+        return -1;
+      } else if (a === b) {
+        continue;
+      } else {
+        return compareIdentifiers(a, b);
+      }
+    } while (++i);
+  }
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  inc(release, identifier, identifierBase) {
+    switch (release) {
+      case "premajor":
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor = 0;
+        this.major++;
+        this.inc("pre", identifier, identifierBase);
+        break;
+      case "preminor":
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor++;
+        this.inc("pre", identifier, identifierBase);
+        break;
+      case "prepatch":
+        this.prerelease.length = 0;
+        this.inc("patch", identifier, identifierBase);
+        this.inc("pre", identifier, identifierBase);
+        break;
+      case "prerelease":
+        if (this.prerelease.length === 0) {
+          this.inc("patch", identifier, identifierBase);
+        }
+        this.inc("pre", identifier, identifierBase);
+        break;
+      case "major":
+        if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+          this.major++;
+        }
+        this.minor = 0;
+        this.patch = 0;
+        this.prerelease = [];
+        break;
+      case "minor":
+        if (this.patch !== 0 || this.prerelease.length === 0) {
+          this.minor++;
+        }
+        this.patch = 0;
+        this.prerelease = [];
+        break;
+      case "patch":
+        if (this.prerelease.length === 0) {
+          this.patch++;
+        }
+        this.prerelease = [];
+        break;
+      case "pre": {
+        const base = Number(identifierBase) ? 1 : 0;
+        if (!identifier && identifierBase === false) {
+          throw new Error("invalid increment argument: identifier is empty");
+        }
+        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;
+            }
+          }
+          if (i === -1) {
+            if (identifier === this.prerelease.join(".") && identifierBase === false) {
+              throw new Error("invalid increment argument: identifier already exists");
+            }
+            this.prerelease.push(base);
+          }
+        }
+        if (identifier) {
+          let prerelease = [identifier, base];
+          if (identifierBase === false) {
+            prerelease = [identifier];
+          }
+          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = prerelease;
+            }
+          } else {
+            this.prerelease = prerelease;
+          }
+        }
+        break;
+      }
+      default:
+        throw new Error(`invalid increment argument: ${release}`);
+    }
+    this.raw = this.format();
+    if (this.build.length) {
+      this.raw += `+${this.build.join(".")}`;
+    }
+    return this;
+  }
+};
+var semver = SemVer$2;
+const SemVer$1 = semver;
+const parse$1 = (version, options, throwErrors = false) => {
+  if (version instanceof SemVer$1) {
+    return version;
+  }
+  try {
+    return new SemVer$1(version, options);
+  } catch (er) {
+    if (!throwErrors) {
+      return null;
+    }
+    throw er;
+  }
+};
+var parse_1 = parse$1;
+const parse = parse_1;
+const valid = (version, options) => {
+  const v = parse(version, options);
+  return v ? v.version : null;
+};
+var valid_1 = valid;
+const valid$1 = /* @__PURE__ */ getDefaultExportFromCjs(valid_1);
+const SemVer2 = semver;
+const major = (a, loose) => new SemVer2(a, loose).major;
+var major_1 = major;
+const major$1 = /* @__PURE__ */ getDefaultExportFromCjs(major_1);
+class ProxyBus {
+  bus;
+  constructor(bus2) {
+    if (typeof bus2.getVersion !== "function" || !valid$1(bus2.getVersion())) {
+      console.warn("Proxying an event bus with an unknown or invalid version");
+    } else if (major$1(bus2.getVersion()) !== major$1(this.getVersion())) {
+      console.warn(
+        "Proxying an event bus of version " + bus2.getVersion() + " with " + this.getVersion()
+      );
+    }
+    this.bus = bus2;
+  }
+  getVersion() {
+    return "3.3.1";
+  }
+  subscribe(name, handler) {
+    this.bus.subscribe(name, handler);
+  }
+  unsubscribe(name, handler) {
+    this.bus.unsubscribe(name, handler);
+  }
+  emit(name, event) {
+    this.bus.emit(name, event);
+  }
+}
+class SimpleBus {
+  handlers = /* @__PURE__ */ new Map();
+  getVersion() {
+    return "3.3.1";
+  }
+  subscribe(name, handler) {
+    this.handlers.set(
+      name,
+      (this.handlers.get(name) || []).concat(
+        handler
+      )
+    );
+  }
+  unsubscribe(name, handler) {
+    this.handlers.set(
+      name,
+      (this.handlers.get(name) || []).filter((h) => h !== handler)
+    );
+  }
+  emit(name, event) {
+    (this.handlers.get(name) || []).forEach((h) => {
+      try {
+        h(event);
+      } catch (e) {
+        console.error("could not invoke event listener", e);
+      }
+    });
+  }
+}
+let bus = null;
+function getBus() {
+  if (bus !== null) {
+    return bus;
+  }
+  if (typeof window === "undefined") {
+    return new Proxy({}, {
+      get: () => {
+        return () => console.error(
+          "Window not available, EventBus can not be established!"
+        );
+      }
+    });
+  }
+  if (window.OC?._eventBus && typeof window._nc_event_bus === "undefined") {
+    console.warn(
+      "found old event bus instance at OC._eventBus. Update your version!"
+    );
+    window._nc_event_bus = window.OC._eventBus;
+  }
+  if (typeof window?._nc_event_bus !== "undefined") {
+    bus = new ProxyBus(window._nc_event_bus);
+  } else {
+    bus = window._nc_event_bus = new SimpleBus();
+  }
+  return bus;
+}
+function emit(name, event) {
+  getBus().emit(name, event);
+}
+/*!
+ * SPDX-FileCopyrightText: 2023 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+class FileListFilter extends TypedEventTarget {
+  id;
+  order;
+  constructor(id, order = 100) {
+    super();
+    this.id = id;
+    this.order = order;
+  }
+  filter(nodes) {
+    throw new Error("Not implemented");
+  }
+  updateChips(chips) {
+    this.dispatchTypedEvent("update:chips", new CustomEvent("update:chips", { detail: chips }));
+  }
+  filterUpdated() {
+    this.dispatchTypedEvent("update:filter", new CustomEvent("update:filter"));
+  }
+}
+function registerFileListFilter(filter) {
+  if (!window._nc_filelist_filters) {
+    window._nc_filelist_filters = /* @__PURE__ */ new Map();
+  }
+  if (window._nc_filelist_filters.has(filter.id)) {
+    throw new Error(`File list filter "${filter.id}" already registered`);
+  }
+  window._nc_filelist_filters.set(filter.id, filter);
+  emit("files:filter:added", filter);
+}
+function unregisterFileListFilter(filterId) {
+  if (window._nc_filelist_filters && window._nc_filelist_filters.has(filterId)) {
+    window._nc_filelist_filters.delete(filterId);
+    emit("files:filter:removed", filterId);
+  }
+}
+function getFileListFilters() {
+  if (!window._nc_filelist_filters) {
+    return [];
+  }
+  return [...window._nc_filelist_filters.values()];
+}
 const addNewFileMenuEntry = function(entry) {
   const newFileMenu = getNewFileMenu();
   return newFileMenu.registerEntry(entry);
@@ -2808,10 +3434,13 @@ export {
   DefaultType,
   File,
   FileAction,
+  FileListFilter,
   FileType,
   FilesSortingMode,
   Folder,
   Header,
+  InvalidFilenameError,
+  InvalidFilenameErrorReason,
   Navigation,
   NewMenuEntryCategory,
   Node,
@@ -2836,6 +3465,7 @@ export {
   getDavProperties,
   getFavoriteNodes,
   getFileActions,
+  getFileListFilters,
   getFileListHeaders,
   getNavigation,
   getNewFileMenuEntries,
@@ -2845,7 +3475,10 @@ export {
   parseFileSize,
   registerDavProperty,
   registerFileAction,
+  registerFileListFilter,
   registerFileListHeaders,
   removeNewFileMenuEntry,
-  sortNodes
+  sortNodes,
+  unregisterFileListFilter,
+  validateFilename
 };