/*
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
if you want to view the source, please visit the github repository of this plugin
*/

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// node_modules/obsidian-typings/dist/implementations.cjs
var require_implementations = __commonJS({
  "node_modules/obsidian-typings/dist/implementations.cjs"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var implementations_exports = {};
    __export2(implementations_exports, {
      CustomArrayDictImpl: () => CustomArrayDictImpl,
      InternalPluginName: () => InternalPluginName,
      constructApp: () => constructApp,
      constructInternalPlugin: () => constructInternalPlugin,
      constructInternalPlugins: () => constructInternalPlugins,
      constructTFile: () => constructTFile,
      constructTFolder: () => constructTFolder,
      createTFileInstance: () => createTFileInstance,
      createTFolderInstance: () => createTFolderInstance,
      isEmbedCache: () => isEmbedCache,
      isFrontmatterLinkCache: () => isFrontmatterLinkCache,
      isLinkCache: () => isLinkCache,
      isReferenceCache: () => isReferenceCache,
      parentFolderPath: () => parentFolderPath2
    });
    module2.exports = __toCommonJS2(implementations_exports);
    function parentFolderPath2(path) {
      return path.replace(/\/?[^\/]*$/, "") || "/";
    }
    var import_obsidian5 = require("obsidian");
    function constructTFolder(vault, path) {
      return new import_obsidian5.TFolder(vault, path);
    }
    function createTFolderInstance(vault, path) {
      let folder = vault.getFolderByPath(path);
      if (folder) {
        return folder;
      }
      folder = constructTFolder(vault, path);
      folder.parent = createTFolderInstance(vault, parentFolderPath2(path));
      folder.deleted = true;
      return folder;
    }
    var CustomArrayDictImpl = class {
      data = /* @__PURE__ */ new Map();
      add(key, value) {
        let values = this.get(key);
        if (!values) {
          values = [];
          this.data.set(key, values);
        }
        if (!values.includes(value)) {
          values.push(value);
        }
      }
      remove(key, value) {
        const values = this.get(key);
        if (!values) {
          return;
        }
        values.remove(value);
        if (values.length === 0) {
          this.clear(key);
        }
      }
      get(key) {
        return this.data.get(key) || null;
      }
      keys() {
        return Array.from(this.data.keys());
      }
      clear(key) {
        this.data.delete(key);
      }
      clearAll() {
        this.data.clear();
      }
      contains(key, value) {
        return !!this.get(key)?.contains(value);
      }
      count() {
        let ans = 0;
        for (const key in this.keys()) {
          ans += this.get(key)?.length ?? 0;
        }
        return ans;
      }
    };
    var InternalPluginName = {
      AudioRecorder: "audio-recorder",
      Backlink: "backlink",
      Bookmarks: "bookmarks",
      Canvas: "canvas",
      CommandPalette: "command-palette",
      DailyNotes: "daily-notes",
      EditorStatus: "editor-status",
      FileExplorer: "file-explorer",
      FileRecovery: "file-recovery",
      GlobalSearch: "global-search",
      Graph: "graph",
      MarkdownImporter: "markdown-importer",
      NoteComposer: "note-composer",
      OutgoingLink: "outgoing-link",
      Outline: "outline",
      PagePreview: "page-preview",
      Properties: "properties",
      Publish: "publish",
      RandomNote: "random-note",
      SlashCommand: "slash-command",
      Slides: "slides",
      Switcher: "switcher",
      Sync: "sync",
      TagPane: "tag-pane",
      Templates: "templates",
      WordCount: "word-count",
      Workspaces: "workspaces",
      ZkPrefixer: "zk-prefixer"
    };
    var import_obsidian22 = require("obsidian");
    function constructTFile(vault, path) {
      return new import_obsidian22.TFile(vault, path);
    }
    function createTFileInstance(vault, path) {
      let file = vault.getFileByPath(path);
      if (file) {
        return file;
      }
      file = constructTFile(vault, path);
      file.parent = createTFolderInstance(vault, parentFolderPath2(path));
      file.deleted = true;
      return file;
    }
    function isReferenceCache(reference) {
      return !!reference.position;
    }
    function isEmbedCache(reference) {
      return isReferenceCache(reference) && reference.original[0] === "!";
    }
    function isFrontmatterLinkCache(reference) {
      return !!reference.key;
    }
    function isLinkCache(reference) {
      return isReferenceCache(reference) && reference.original[0] !== "!";
    }
    function constructInternalPlugins(app) {
      return new app.internalPlugins.constructor(app);
    }
    function constructInternalPlugin(app, instance, internalPlugins) {
      const anyPlugin = Object.values(app.internalPlugins.plugins)[0];
      if (!anyPlugin) {
        throw new Error("No internal plugin found");
      }
      return new anyPlugin.constructor(app, instance, internalPlugins);
    }
    var import_obsidian32 = require("obsidian");
    function constructApp(adapter, appId) {
      return new import_obsidian32.App(adapter, appId);
    }
  }
});

// node_modules/path-browserify/index.js
var require_path_browserify = __commonJS({
  "node_modules/path-browserify/index.js"(exports2, module2) {
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    function assertPath(path) {
      if (typeof path !== "string") {
        throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
      }
    }
    function normalizeStringPosix(path, allowAboveRoot) {
      var res = "";
      var lastSegmentLength = 0;
      var lastSlash = -1;
      var dots = 0;
      var code;
      for (var i = 0; i <= path.length; ++i) {
        if (i < path.length)
          code = path.charCodeAt(i);
        else if (code === 47)
          break;
        else
          code = 47;
        if (code === 47) {
          if (lastSlash === i - 1 || dots === 1) {
          } else if (lastSlash !== i - 1 && dots === 2) {
            if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
              if (res.length > 2) {
                var lastSlashIndex = res.lastIndexOf("/");
                if (lastSlashIndex !== res.length - 1) {
                  if (lastSlashIndex === -1) {
                    res = "";
                    lastSegmentLength = 0;
                  } else {
                    res = res.slice(0, lastSlashIndex);
                    lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
                  }
                  lastSlash = i;
                  dots = 0;
                  continue;
                }
              } else if (res.length === 2 || res.length === 1) {
                res = "";
                lastSegmentLength = 0;
                lastSlash = i;
                dots = 0;
                continue;
              }
            }
            if (allowAboveRoot) {
              if (res.length > 0)
                res += "/..";
              else
                res = "..";
              lastSegmentLength = 2;
            }
          } else {
            if (res.length > 0)
              res += "/" + path.slice(lastSlash + 1, i);
            else
              res = path.slice(lastSlash + 1, i);
            lastSegmentLength = i - lastSlash - 1;
          }
          lastSlash = i;
          dots = 0;
        } else if (code === 46 && dots !== -1) {
          ++dots;
        } else {
          dots = -1;
        }
      }
      return res;
    }
    function _format(sep, pathObject) {
      var dir = pathObject.dir || pathObject.root;
      var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
      if (!dir) {
        return base;
      }
      if (dir === pathObject.root) {
        return dir + base;
      }
      return dir + sep + base;
    }
    var posix = {
      // path.resolve([from ...], to)
      resolve: function resolve() {
        var resolvedPath = "";
        var resolvedAbsolute = false;
        var cwd;
        for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
          var path;
          if (i >= 0)
            path = arguments[i];
          else {
            if (cwd === void 0)
              cwd = __process3.cwd();
            path = cwd;
          }
          assertPath(path);
          if (path.length === 0) {
            continue;
          }
          resolvedPath = path + "/" + resolvedPath;
          resolvedAbsolute = path.charCodeAt(0) === 47;
        }
        resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
        if (resolvedAbsolute) {
          if (resolvedPath.length > 0)
            return "/" + resolvedPath;
          else
            return "/";
        } else if (resolvedPath.length > 0) {
          return resolvedPath;
        } else {
          return ".";
        }
      },
      normalize: function normalize(path) {
        assertPath(path);
        if (path.length === 0) return ".";
        var isAbsolute = path.charCodeAt(0) === 47;
        var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
        path = normalizeStringPosix(path, !isAbsolute);
        if (path.length === 0 && !isAbsolute) path = ".";
        if (path.length > 0 && trailingSeparator) path += "/";
        if (isAbsolute) return "/" + path;
        return path;
      },
      isAbsolute: function isAbsolute(path) {
        assertPath(path);
        return path.length > 0 && path.charCodeAt(0) === 47;
      },
      join: function join3() {
        if (arguments.length === 0)
          return ".";
        var joined;
        for (var i = 0; i < arguments.length; ++i) {
          var arg = arguments[i];
          assertPath(arg);
          if (arg.length > 0) {
            if (joined === void 0)
              joined = arg;
            else
              joined += "/" + arg;
          }
        }
        if (joined === void 0)
          return ".";
        return posix.normalize(joined);
      },
      relative: function relative(from, to) {
        assertPath(from);
        assertPath(to);
        if (from === to) return "";
        from = posix.resolve(from);
        to = posix.resolve(to);
        if (from === to) return "";
        var fromStart = 1;
        for (; fromStart < from.length; ++fromStart) {
          if (from.charCodeAt(fromStart) !== 47)
            break;
        }
        var fromEnd = from.length;
        var fromLen = fromEnd - fromStart;
        var toStart = 1;
        for (; toStart < to.length; ++toStart) {
          if (to.charCodeAt(toStart) !== 47)
            break;
        }
        var toEnd = to.length;
        var toLen = toEnd - toStart;
        var length = fromLen < toLen ? fromLen : toLen;
        var lastCommonSep = -1;
        var i = 0;
        for (; i <= length; ++i) {
          if (i === length) {
            if (toLen > length) {
              if (to.charCodeAt(toStart + i) === 47) {
                return to.slice(toStart + i + 1);
              } else if (i === 0) {
                return to.slice(toStart + i);
              }
            } else if (fromLen > length) {
              if (from.charCodeAt(fromStart + i) === 47) {
                lastCommonSep = i;
              } else if (i === 0) {
                lastCommonSep = 0;
              }
            }
            break;
          }
          var fromCode = from.charCodeAt(fromStart + i);
          var toCode = to.charCodeAt(toStart + i);
          if (fromCode !== toCode)
            break;
          else if (fromCode === 47)
            lastCommonSep = i;
        }
        var out = "";
        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
          if (i === fromEnd || from.charCodeAt(i) === 47) {
            if (out.length === 0)
              out += "..";
            else
              out += "/..";
          }
        }
        if (out.length > 0)
          return out + to.slice(toStart + lastCommonSep);
        else {
          toStart += lastCommonSep;
          if (to.charCodeAt(toStart) === 47)
            ++toStart;
          return to.slice(toStart);
        }
      },
      _makeLong: function _makeLong(path) {
        return path;
      },
      dirname: function dirname3(path) {
        assertPath(path);
        if (path.length === 0) return ".";
        var code = path.charCodeAt(0);
        var hasRoot = code === 47;
        var end = -1;
        var matchedSlash = true;
        for (var i = path.length - 1; i >= 1; --i) {
          code = path.charCodeAt(i);
          if (code === 47) {
            if (!matchedSlash) {
              end = i;
              break;
            }
          } else {
            matchedSlash = false;
          }
        }
        if (end === -1) return hasRoot ? "/" : ".";
        if (hasRoot && end === 1) return "//";
        return path.slice(0, end);
      },
      basename: function basename4(path, ext) {
        if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
        assertPath(path);
        var start = 0;
        var end = -1;
        var matchedSlash = true;
        var i;
        if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
          if (ext.length === path.length && ext === path) return "";
          var extIdx = ext.length - 1;
          var firstNonSlashEnd = -1;
          for (i = path.length - 1; i >= 0; --i) {
            var code = path.charCodeAt(i);
            if (code === 47) {
              if (!matchedSlash) {
                start = i + 1;
                break;
              }
            } else {
              if (firstNonSlashEnd === -1) {
                matchedSlash = false;
                firstNonSlashEnd = i + 1;
              }
              if (extIdx >= 0) {
                if (code === ext.charCodeAt(extIdx)) {
                  if (--extIdx === -1) {
                    end = i;
                  }
                } else {
                  extIdx = -1;
                  end = firstNonSlashEnd;
                }
              }
            }
          }
          if (start === end) end = firstNonSlashEnd;
          else if (end === -1) end = path.length;
          return path.slice(start, end);
        } else {
          for (i = path.length - 1; i >= 0; --i) {
            if (path.charCodeAt(i) === 47) {
              if (!matchedSlash) {
                start = i + 1;
                break;
              }
            } else if (end === -1) {
              matchedSlash = false;
              end = i + 1;
            }
          }
          if (end === -1) return "";
          return path.slice(start, end);
        }
      },
      extname: function extname4(path) {
        assertPath(path);
        var startDot = -1;
        var startPart = 0;
        var end = -1;
        var matchedSlash = true;
        var preDotState = 0;
        for (var i = path.length - 1; i >= 0; --i) {
          var code = path.charCodeAt(i);
          if (code === 47) {
            if (!matchedSlash) {
              startPart = i + 1;
              break;
            }
            continue;
          }
          if (end === -1) {
            matchedSlash = false;
            end = i + 1;
          }
          if (code === 46) {
            if (startDot === -1)
              startDot = i;
            else if (preDotState !== 1)
              preDotState = 1;
          } else if (startDot !== -1) {
            preDotState = -1;
          }
        }
        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
          return "";
        }
        return path.slice(startDot, end);
      },
      format: function format(pathObject) {
        if (pathObject === null || typeof pathObject !== "object") {
          throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
        }
        return _format("/", pathObject);
      },
      parse: function parse(path) {
        assertPath(path);
        var ret = { root: "", dir: "", base: "", ext: "", name: "" };
        if (path.length === 0) return ret;
        var code = path.charCodeAt(0);
        var isAbsolute = code === 47;
        var start;
        if (isAbsolute) {
          ret.root = "/";
          start = 1;
        } else {
          start = 0;
        }
        var startDot = -1;
        var startPart = 0;
        var end = -1;
        var matchedSlash = true;
        var i = path.length - 1;
        var preDotState = 0;
        for (; i >= start; --i) {
          code = path.charCodeAt(i);
          if (code === 47) {
            if (!matchedSlash) {
              startPart = i + 1;
              break;
            }
            continue;
          }
          if (end === -1) {
            matchedSlash = false;
            end = i + 1;
          }
          if (code === 46) {
            if (startDot === -1) startDot = i;
            else if (preDotState !== 1) preDotState = 1;
          } else if (startDot !== -1) {
            preDotState = -1;
          }
        }
        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
          if (end !== -1) {
            if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
            else ret.base = ret.name = path.slice(startPart, end);
          }
        } else {
          if (startPart === 0 && isAbsolute) {
            ret.name = path.slice(1, startDot);
            ret.base = path.slice(1, end);
          } else {
            ret.name = path.slice(startPart, startDot);
            ret.base = path.slice(startPart, end);
          }
          ret.ext = path.slice(startDot, end);
        }
        if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
        else if (isAbsolute) ret.dir = "/";
        return ret;
      },
      sep: "/",
      delimiter: ":",
      win32: null,
      posix: null
    };
    posix.posix = posix;
    module2.exports = posix;
  }
});

// node_modules/eventemitter3/index.js
var require_eventemitter3 = __commonJS({
  "node_modules/eventemitter3/index.js"(exports2, module2) {
    "use strict";
    var has = Object.prototype.hasOwnProperty;
    var prefix = "~";
    function Events() {
    }
    if (Object.create) {
      Events.prototype = /* @__PURE__ */ Object.create(null);
      if (!new Events().__proto__) prefix = false;
    }
    function EE(fn, context, once) {
      this.fn = fn;
      this.context = context;
      this.once = once || false;
    }
    function addListener(emitter, event, fn, context, once) {
      if (typeof fn !== "function") {
        throw new TypeError("The listener must be a function");
      }
      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
      else emitter._events[evt] = [emitter._events[evt], listener];
      return emitter;
    }
    function clearEvent(emitter, evt) {
      if (--emitter._eventsCount === 0) emitter._events = new Events();
      else delete emitter._events[evt];
    }
    function EventEmitter() {
      this._events = new Events();
      this._eventsCount = 0;
    }
    EventEmitter.prototype.eventNames = function eventNames() {
      var names = [], events, name;
      if (this._eventsCount === 0) return names;
      for (name in events = this._events) {
        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
      }
      if (Object.getOwnPropertySymbols) {
        return names.concat(Object.getOwnPropertySymbols(events));
      }
      return names;
    };
    EventEmitter.prototype.listeners = function listeners(event) {
      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
      if (!handlers) return [];
      if (handlers.fn) return [handlers.fn];
      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
        ee[i] = handlers[i].fn;
      }
      return ee;
    };
    EventEmitter.prototype.listenerCount = function listenerCount(event) {
      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
      if (!listeners) return 0;
      if (listeners.fn) return 1;
      return listeners.length;
    };
    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
      var evt = prefix ? prefix + event : event;
      if (!this._events[evt]) return false;
      var listeners = this._events[evt], len = arguments.length, args, i;
      if (listeners.fn) {
        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
        switch (len) {
          case 1:
            return listeners.fn.call(listeners.context), true;
          case 2:
            return listeners.fn.call(listeners.context, a1), true;
          case 3:
            return listeners.fn.call(listeners.context, a1, a2), true;
          case 4:
            return listeners.fn.call(listeners.context, a1, a2, a3), true;
          case 5:
            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
          case 6:
            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
        }
        for (i = 1, args = new Array(len - 1); i < len; i++) {
          args[i - 1] = arguments[i];
        }
        listeners.fn.apply(listeners.context, args);
      } else {
        var length = listeners.length, j;
        for (i = 0; i < length; i++) {
          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
          switch (len) {
            case 1:
              listeners[i].fn.call(listeners[i].context);
              break;
            case 2:
              listeners[i].fn.call(listeners[i].context, a1);
              break;
            case 3:
              listeners[i].fn.call(listeners[i].context, a1, a2);
              break;
            case 4:
              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
              break;
            default:
              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
                args[j - 1] = arguments[j];
              }
              listeners[i].fn.apply(listeners[i].context, args);
          }
        }
      }
      return true;
    };
    EventEmitter.prototype.on = function on(event, fn, context) {
      return addListener(this, event, fn, context, false);
    };
    EventEmitter.prototype.once = function once(event, fn, context) {
      return addListener(this, event, fn, context, true);
    };
    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
      var evt = prefix ? prefix + event : event;
      if (!this._events[evt]) return this;
      if (!fn) {
        clearEvent(this, evt);
        return this;
      }
      var listeners = this._events[evt];
      if (listeners.fn) {
        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
          clearEvent(this, evt);
        }
      } else {
        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
            events.push(listeners[i]);
          }
        }
        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
        else clearEvent(this, evt);
      }
      return this;
    };
    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
      var evt;
      if (event) {
        evt = prefix ? prefix + event : event;
        if (this._events[evt]) clearEvent(this, evt);
      } else {
        this._events = new Events();
        this._eventsCount = 0;
      }
      return this;
    };
    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
    EventEmitter.prefixed = prefix;
    EventEmitter.EventEmitter = EventEmitter;
    if ("undefined" !== typeof module2) {
      module2.exports = EventEmitter;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/Error.cjs
var require_Error = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/Error.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Error_exports = {};
    __export2(Error_exports, {
      emitAsyncErrorEvent: () => emitAsyncErrorEvent,
      errorToString: () => errorToString,
      getStackTrace: () => getStackTrace,
      printError: () => printError,
      registerAsyncErrorEventHandler: () => registerAsyncErrorEventHandler,
      throwExpression: () => throwExpression3
    });
    module2.exports = __toCommonJS2(Error_exports);
    var import_eventemitter3 = require_eventemitter3();
    var ASYNC_ERROR_EVENT = "asyncError";
    var asyncErrorEventEmitter = new import_eventemitter3.EventEmitter();
    asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);
    function emitAsyncErrorEvent(asyncError) {
      asyncErrorEventEmitter.emit(ASYNC_ERROR_EVENT, asyncError);
    }
    function errorToString(error) {
      return parseErrorEntries(error).map((entry) => "  ".repeat(entry.level) + entry.message).join("\n");
    }
    function getStackTrace() {
      const stack = new Error().stack ?? "";
      const lines = stack.split("\n");
      return lines.slice(2).join("\n");
    }
    function printError(error) {
      const entries = parseErrorEntries(error);
      for (const entry of entries) {
        if (entry.shouldClearAnsiSequence) {
          console.error(`\x1B[0m${entry.message}\x1B[0m`);
        } else {
          console.error(entry.message);
        }
      }
    }
    function registerAsyncErrorEventHandler(handler) {
      asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);
      return () => asyncErrorEventEmitter.off(ASYNC_ERROR_EVENT, handler);
    }
    function throwExpression3(error) {
      throw error;
    }
    function handleAsyncError(asyncError) {
      printError(new Error("An unhandled error occurred executing async operation", { cause: asyncError }));
    }
    function parseErrorEntries(error, level = 0, entries = []) {
      if (error === void 0) {
        return entries;
      }
      if (!(error instanceof Error)) {
        let str = "";
        if (error === null) {
          str = "(null)";
        } else if (typeof error === "string") {
          str = error;
        } else {
          str = JSON.stringify(error);
        }
        entries.push({ level, message: str });
        return entries;
      }
      const title = `${error.name}: ${error.message}`;
      entries.push({ level, message: title, shouldClearAnsiSequence: true });
      if (error.stack) {
        const restStack = error.stack.startsWith(title) ? error.stack.slice(title.length + 1) : error.stack;
        entries.push({ level, message: `Error stack:
${restStack}` });
      }
      if (error.cause !== void 0) {
        entries.push({ level, message: "Caused by:" });
        parseErrorEntries(error.cause, level + 1, entries);
      }
      return entries;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/RegExp.cjs
var require_RegExp = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/RegExp.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var RegExp_exports = {};
    __export2(RegExp_exports, {
      escapeRegExp: () => escapeRegExp2
    });
    module2.exports = __toCommonJS2(RegExp_exports);
    function escapeRegExp2(str) {
      return str.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/ValueProvider.cjs
var require_ValueProvider = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/ValueProvider.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var ValueProvider_exports = {};
    __export2(ValueProvider_exports, {
      resolveValue: () => resolveValue
    });
    module2.exports = __toCommonJS2(ValueProvider_exports);
    async function resolveValue(provider, ...args) {
      if (isFunction(provider)) {
        return await provider(...args);
      } else {
        return provider;
      }
    }
    function isFunction(value) {
      return typeof value === "function";
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/String.cjs
var require_String = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/String.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var String_exports = {};
    __export2(String_exports, {
      ensureEndsWith: () => ensureEndsWith,
      ensureStartsWith: () => ensureStartsWith,
      escape: () => escape,
      insertAt: () => insertAt,
      makeValidVariableName: () => makeValidVariableName,
      normalize: () => normalize,
      replace: () => replace,
      replaceAllAsync: () => replaceAllAsync,
      trimEnd: () => trimEnd,
      trimStart: () => trimStart,
      unescape: () => unescape
    });
    module2.exports = __toCommonJS2(String_exports);
    var import_Error3 = require_Error();
    var import_RegExp2 = require_RegExp();
    var import_ValueProvider = require_ValueProvider();
    var ESCAPE_MAP = {
      "\n": "\\n",
      "\r": "\\r",
      "	": "\\t",
      "\b": "\\b",
      "\f": "\\f",
      "'": "\\'",
      '"': '\\"',
      "\\": "\\\\"
    };
    var UNESCAPE_MAP = {};
    for (const [key, value] of Object.entries(ESCAPE_MAP)) {
      UNESCAPE_MAP[value] = key;
    }
    function ensureEndsWith(str, suffix) {
      return str.endsWith(suffix) ? str : str + suffix;
    }
    function ensureStartsWith(str, prefix) {
      return str.startsWith(prefix) ? str : prefix + str;
    }
    function escape(str) {
      return replace(str, ESCAPE_MAP);
    }
    function insertAt(str, substring, startIndex, endIndex) {
      endIndex ??= startIndex;
      return str.slice(0, startIndex) + substring + str.slice(endIndex);
    }
    function makeValidVariableName(str) {
      return str.replace(/[^a-zA-Z0-9_]/g, "_");
    }
    function normalize(str) {
      return str.replace(/\u00A0|\u202F/g, " ").normalize("NFC");
    }
    function replace(str, replacementsMap) {
      const regExp = new RegExp(Object.keys(replacementsMap).map((source) => (0, import_RegExp2.escapeRegExp)(source)).join("|"), "g");
      return str.replaceAll(regExp, (source) => replacementsMap[source] ?? (0, import_Error3.throwExpression)(new Error(`Unexpected replacement source: ${source}`)));
    }
    async function replaceAllAsync(str, searchValue, replacer) {
      const replacementPromises = [];
      str.replaceAll(searchValue, (substring, ...args) => {
        replacementPromises.push((0, import_ValueProvider.resolveValue)(replacer, substring, ...args));
        return substring;
      });
      const replacements = await Promise.all(replacementPromises);
      return str.replaceAll(searchValue, () => replacements.shift() ?? (0, import_Error3.throwExpression)(new Error("Unexpected empty replacement")));
    }
    function trimEnd(str, suffix, validate) {
      if (str.endsWith(suffix)) {
        return str.slice(0, -suffix.length);
      }
      if (validate) {
        throw new Error(`String ${str} does not end with suffix ${suffix}`);
      }
      return str;
    }
    function trimStart(str, prefix, validate) {
      if (str.startsWith(prefix)) {
        return str.slice(prefix.length);
      }
      if (validate) {
        throw new Error(`String ${str} does not start with prefix ${prefix}`);
      }
      return str;
    }
    function unescape(str) {
      return replace(str, UNESCAPE_MAP);
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/Path.cjs
var require_Path = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/Path.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __create2 = Object.create;
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
      // If the importer is in node compatibility mode or this is not an ESM
      // file that has been converted to a CommonJS file using a Babel-
      // compatible transform (i.e. "__esModule" has not been set), then set
      // "default" to the CommonJS "module.exports" for node compatibility.
      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
      mod
    ));
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Path_exports = {};
    __export2(Path_exports, {
      basename: () => basename4,
      delimiter: () => delimiter,
      dirname: () => dirname3,
      extname: () => extname4,
      format: () => format,
      getDirname: () => getDirname,
      getFilename: () => getFilename,
      isAbsolute: () => isAbsolute,
      join: () => join3,
      makeFileName: () => makeFileName4,
      normalize: () => normalize,
      normalizeIfRelative: () => normalizeIfRelative,
      parse: () => parse,
      posix: () => posix,
      relative: () => relative,
      resolve: () => resolve,
      sep: () => sep,
      toPosixBuffer: () => toPosixBuffer,
      toPosixPath: () => toPosixPath
    });
    module2.exports = __toCommonJS2(Path_exports);
    var import_path_browserify = __toESM2(require_path_browserify(), 1);
    var import_String = require_String();
    var WINDOWS_POSIX_LIKE_PATH_REG_EXP = /[a-zA-Z]:\/[^:]*$/;
    var posix = import_path_browserify.default.posix;
    var delimiter = posix.delimiter;
    var sep = import_path_browserify.default.posix.sep;
    var basename4 = posix.basename;
    var dirname3 = posix.dirname;
    var extname4 = posix.extname;
    var format = posix.format;
    function isAbsolute(path2) {
      return posix.isAbsolute(path2) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path2)?.[0] === path2;
    }
    var join3 = posix.join;
    var normalize = posix.normalize;
    var parse = posix.parse;
    var relative = posix.relative;
    function getDirname(importMetaUrl) {
      return dirname3(getFilename(importMetaUrl));
    }
    function getFilename(importMetaUrl) {
      return resolve(new URL(importMetaUrl).pathname);
    }
    function makeFileName4(fileName, extension) {
      return extension ? `${fileName}.${extension}` : fileName;
    }
    function normalizeIfRelative(path2) {
      if (path2.startsWith("/") || path2.includes(":")) {
        return path2;
      }
      return (0, import_String.ensureStartsWith)(path2, "./");
    }
    function resolve(...pathSegments) {
      let path2 = posix.resolve(...pathSegments);
      path2 = toPosixPath(path2);
      const match = WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path2);
      return match?.[0] ?? path2;
    }
    function toPosixBuffer(buffer) {
      return Buffer.from(toPosixPath(buffer.toString()));
    }
    function toPosixPath(path2) {
      return path2.replace(/\\/g, "/");
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/FileSystem.cjs
var require_FileSystem = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/FileSystem.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var FileSystem_exports = {};
    __export2(FileSystem_exports, {
      CANVAS_FILE_EXTENSION: () => CANVAS_FILE_EXTENSION,
      MARKDOWN_FILE_EXTENSION: () => MARKDOWN_FILE_EXTENSION,
      checkExtension: () => checkExtension,
      getAbstractFile: () => getAbstractFile,
      getAbstractFileOrNull: () => getAbstractFileOrNull2,
      getFile: () => getFile,
      getFileOrNull: () => getFileOrNull,
      getFolder: () => getFolder,
      getFolderOrNull: () => getFolderOrNull,
      getMarkdownFiles: () => getMarkdownFiles,
      getOrCreateFile: () => getOrCreateFile,
      getOrCreateFolder: () => getOrCreateFolder,
      getPath: () => getPath,
      isAbstractFile: () => isAbstractFile,
      isCanvasFile: () => isCanvasFile2,
      isFile: () => isFile,
      isFolder: () => isFolder,
      isMarkdownFile: () => isMarkdownFile,
      isNote: () => isNote4,
      trimMarkdownExtension: () => trimMarkdownExtension
    });
    module2.exports = __toCommonJS2(FileSystem_exports);
    var import_obsidian5 = require("obsidian");
    var import_implementations2 = require_implementations();
    var import_Path5 = require_Path();
    var import_String = require_String();
    var MARKDOWN_FILE_EXTENSION = "md";
    var CANVAS_FILE_EXTENSION = "canvas";
    function checkExtension(pathOrFile, extension) {
      if (pathOrFile === null) {
        return false;
      }
      return (0, import_Path5.extname)(getPath(pathOrFile)).toLowerCase().slice(1) === extension.toLowerCase();
    }
    function getAbstractFile(app, pathOrFile, insensitive) {
      const file = getAbstractFileOrNull2(app, pathOrFile, insensitive);
      if (!file) {
        throw new Error(`Abstract file not found: ${pathOrFile}`);
      }
      return file;
    }
    function getAbstractFileOrNull2(app, pathOrFile, insensitive) {
      if (pathOrFile === null) {
        return null;
      }
      if (pathOrFile === "." || pathOrFile === "") {
        return app.vault.getRoot();
      }
      if (isAbstractFile(pathOrFile)) {
        return pathOrFile;
      }
      if (insensitive) {
        return app.vault.getAbstractFileByPathInsensitive(pathOrFile);
      }
      return app.vault.getAbstractFileByPath(pathOrFile);
    }
    function getFile(app, pathOrFile, allowNonExisting, insensitive) {
      let file = getFileOrNull(app, pathOrFile, insensitive);
      if (!file) {
        if (allowNonExisting) {
          file = (0, import_implementations2.createTFileInstance)(app.vault, pathOrFile);
        } else {
          throw new Error(`File not found: ${pathOrFile}`);
        }
      }
      return file;
    }
    function getFileOrNull(app, pathOrFile, insensitive) {
      const file = getAbstractFileOrNull2(app, pathOrFile, insensitive);
      if (isFile(file)) {
        return file;
      }
      return null;
    }
    function getFolder(app, pathOrFolder, allowNonExisting, insensitive) {
      let folder = getFolderOrNull(app, pathOrFolder, insensitive);
      if (!folder) {
        if (allowNonExisting) {
          folder = (0, import_implementations2.createTFolderInstance)(app.vault, pathOrFolder);
        } else {
          throw new Error(`Folder not found: ${pathOrFolder}`);
        }
      }
      return folder;
    }
    function getFolderOrNull(app, pathOrFolder, insensitive) {
      const folder = getAbstractFileOrNull2(app, pathOrFolder, insensitive);
      if (isFolder(folder)) {
        return folder;
      }
      return null;
    }
    function getMarkdownFiles(app, pathOrFolder, isRecursive) {
      const folder = getFolder(app, pathOrFolder);
      let markdownFiles = [];
      if (!isRecursive) {
        markdownFiles = folder.children.filter((file) => isMarkdownFile(file));
      } else {
        import_obsidian5.Vault.recurseChildren(folder, (abstractFile) => {
          if (isMarkdownFile(abstractFile)) {
            markdownFiles.push(abstractFile);
          }
        });
      }
      markdownFiles = markdownFiles.sort((a, b) => a.path.localeCompare(b.path));
      return markdownFiles;
    }
    async function getOrCreateFile(app, path) {
      const file = getFileOrNull(app, path);
      if (file) {
        return file;
      }
      const folderPath = (0, import_implementations2.parentFolderPath)(path);
      await getOrCreateFolder(app, folderPath);
      return await app.vault.create(path, "");
    }
    async function getOrCreateFolder(app, path) {
      const folder = getFolderOrNull(app, path);
      if (folder) {
        return folder;
      }
      return await app.vault.createFolder(path);
    }
    function getPath(pathOrFile) {
      return isAbstractFile(pathOrFile) ? pathOrFile.path : pathOrFile;
    }
    function isAbstractFile(file) {
      return file instanceof import_obsidian5.TAbstractFile;
    }
    function isCanvasFile2(pathOrFile) {
      return checkExtension(pathOrFile, CANVAS_FILE_EXTENSION);
    }
    function isFile(file) {
      return file instanceof import_obsidian5.TFile;
    }
    function isFolder(file) {
      return file instanceof import_obsidian5.TFolder;
    }
    function isMarkdownFile(pathOrFile) {
      return checkExtension(pathOrFile, MARKDOWN_FILE_EXTENSION);
    }
    function isNote4(pathOrFile) {
      return isMarkdownFile(pathOrFile) || isCanvasFile2(pathOrFile);
    }
    function trimMarkdownExtension(file) {
      if (!isMarkdownFile(file)) {
        return file.path;
      }
      return (0, import_String.trimEnd)(file.path, "." + MARKDOWN_FILE_EXTENSION);
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/AttachmentPath.cjs
var require_AttachmentPath = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/AttachmentPath.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var AttachmentPath_exports = {};
    __export2(AttachmentPath_exports, {
      getAttachmentFilePath: () => getAttachmentFilePath,
      getAttachmentFolderPath: () => getAttachmentFolderPath2,
      getAvailablePathForAttachments: () => getAvailablePathForAttachments2,
      hasOwnAttachmentFolder: () => hasOwnAttachmentFolder
    });
    module2.exports = __toCommonJS2(AttachmentPath_exports);
    var import_implementations2 = require_implementations();
    var import_Path5 = require_Path();
    var import_String = require_String();
    var import_FileSystem4 = require_FileSystem();
    async function getAttachmentFilePath(app, attachmentPathOrFile, notePathOrFile) {
      const attachmentPath = (0, import_FileSystem4.getPath)(attachmentPathOrFile);
      const notePath = (0, import_FileSystem4.getPath)(notePathOrFile);
      const note = (0, import_FileSystem4.getFile)(app, notePath, true);
      const ext = (0, import_Path5.extname)(attachmentPath);
      const fileName = (0, import_Path5.basename)(attachmentPath, ext);
      const internalFn = app.vault.getAvailablePathForAttachments;
      if (internalFn.isExtended) {
        return internalFn(fileName, ext.slice(1), note, true);
      }
      return await getAvailablePathForAttachments2(app, fileName, ext.slice(1), note, true);
    }
    async function getAttachmentFolderPath2(app, notePathOrFile) {
      return (0, import_implementations2.parentFolderPath)(await getAttachmentFilePath(app, "DUMMY_FILE.pdf", notePathOrFile));
    }
    async function getAvailablePathForAttachments2(app, filename, extension, file, skipFolderCreation) {
      let attachmentFolderPath = app.vault.getConfig("attachmentFolderPath");
      const isCurrentFolder = attachmentFolderPath === "." || attachmentFolderPath === "./";
      let relativePath = null;
      if (attachmentFolderPath.startsWith("./")) {
        relativePath = (0, import_String.trimStart)(attachmentFolderPath, "./");
      }
      if (isCurrentFolder) {
        attachmentFolderPath = file ? file.parent?.path ?? "" : "";
      } else if (relativePath) {
        attachmentFolderPath = (file ? file.parent?.getParentPrefix() ?? "" : "") + relativePath;
      }
      attachmentFolderPath = (0, import_String.normalize)(normalizeSlashes(attachmentFolderPath));
      filename = (0, import_String.normalize)(normalizeSlashes(filename));
      let folder = (0, import_FileSystem4.getFolderOrNull)(app, attachmentFolderPath, true);
      if (!folder && relativePath) {
        if (!skipFolderCreation) {
          folder = await app.vault.createFolder(attachmentFolderPath);
        } else {
          folder = (0, import_FileSystem4.getFolder)(app, attachmentFolderPath, true);
        }
      }
      const prefix = folder?.getParentPrefix() ?? "";
      return app.vault.getAvailablePath(prefix + filename, extension);
    }
    async function hasOwnAttachmentFolder(app, path) {
      const attachmentFolderPath = await getAttachmentFolderPath2(app, path);
      const dummyAttachmentFolderPath = await getAttachmentFolderPath2(app, (0, import_Path5.join)((0, import_Path5.dirname)(path), "DUMMY_FILE.md"));
      return attachmentFolderPath !== dummyAttachmentFolderPath;
    }
    function normalizeSlashes(path) {
      path = path.replace(/([\\/])+/g, "/");
      path = path.replace(/(^\/+|\/+$)/g, "");
      return path || "/";
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/Function.cjs
var require_Function = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/Function.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Function_exports = {};
    __export2(Function_exports, {
      noop: () => noop,
      noopAsync: () => noopAsync,
      omitAsyncReturnType: () => omitAsyncReturnType,
      omitReturnType: () => omitReturnType
    });
    module2.exports = __toCommonJS2(Function_exports);
    function noop() {
    }
    async function noopAsync() {
    }
    function omitAsyncReturnType(fn) {
      return async (...args) => {
        await fn(...args);
      };
    }
    function omitReturnType(fn) {
      return (...args) => {
        fn(...args);
      };
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Plugin/PluginSettings.cjs
var require_PluginSettings = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Plugin/PluginSettings.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var PluginSettings_exports = {};
    __export2(PluginSettings_exports, {
      clonePluginSettings: () => clonePluginSettings,
      loadPluginSettings: () => loadPluginSettings2
    });
    module2.exports = __toCommonJS2(PluginSettings_exports);
    function clonePluginSettings(defaultPluginSettingsFactory, settings) {
      return loadPluginSettings2(defaultPluginSettingsFactory, settings);
    }
    function loadPluginSettings2(defaultPluginSettingsFactory, data) {
      const defaultPluginSettings = defaultPluginSettingsFactory();
      if (data && typeof data === "object") {
        const record = data;
        for (const [key, value] of Object.entries(record)) {
          if (key in defaultPluginSettings) {
            defaultPluginSettings[key] = value;
          }
        }
      }
      return defaultPluginSettings;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Plugin/PluginBase.cjs
var require_PluginBase = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Plugin/PluginBase.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var PluginBase_exports = {};
    __export2(PluginBase_exports, {
      PluginBase: () => PluginBase2
    });
    module2.exports = __toCommonJS2(PluginBase_exports);
    var import_obsidian5 = require("obsidian");
    var import_Error3 = require_Error();
    var import_Function = require_Function();
    var import_PluginSettings2 = require_PluginSettings();
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    var PluginBase2 = class extends import_obsidian5.Plugin {
      /**
       * Gets a copy of the current plugin settings.
       *
       * @returns A copy of the plugin settings.
       */
      get settingsCopy() {
        return (0, import_PluginSettings2.clonePluginSettings)(this.createDefaultPluginSettings.bind(this), this.settings);
      }
      /**
       * Gets the AbortSignal used for aborting long-running operations.
       *
       * @returns The abort signal.
       */
      get abortSignal() {
        return this._abortSignal;
      }
      /**
       * Gets the plugin settings.
       *
       * @returns The plugin settings.
       */
      get settings() {
        return this._settings;
      }
      _abortSignal;
      _settings;
      notice;
      /**
       * Called when the plugin is loaded
       */
      async onload() {
        this.register((0, import_Error3.registerAsyncErrorEventHandler)(() => {
          this.showNotice("An unhandled error occurred. Please check the console for more information.");
        }));
        await this.loadSettings();
        const pluginSettingsTab = this.createPluginSettingsTab();
        if (pluginSettingsTab) {
          this.addSettingTab(pluginSettingsTab);
        }
        const abortController = new AbortController();
        this._abortSignal = abortController.signal;
        this.register(() => {
          abortController.abort();
        });
        await this.onloadComplete();
        this.app.workspace.onLayoutReady(this.onLayoutReady.bind(this));
      }
      /**
       * Saves the new plugin settings.
       *
       * @param newSettings - The new settings to save.
       * @returns A promise that resolves when the settings are saved.
       */
      async saveSettings(newSettings) {
        this._settings = (0, import_PluginSettings2.clonePluginSettings)(this.createDefaultPluginSettings.bind(this), newSettings);
        await this.saveData(this.settings);
      }
      /**
       * Called when the layout is ready. This method can be overridden by subclasses to perform actions once
       * the layout is ready.
       *
       * @returns A promise or void indicating the completion of the layout setup.
       */
      onLayoutReady() {
        (0, import_Function.noop)();
      }
      /**
       * Called when the plugin loading is complete. This method must be implemented by subclasses to perform
       * any additional setup required after loading is complete.
       *
       * @returns A promise or void indicating the completion of the load process.
       */
      onloadComplete() {
        (0, import_Function.noop)();
      }
      /**
       * Parses the provided settings data and returns the parsed `PluginSettings`.
       *
       * @param data - The raw data to be parsed into `PluginSettings`.
       * @returns A promise that resolves to `PluginSettings` or the settings directly.
       */
      parseSettings(data) {
        return (0, import_PluginSettings2.loadPluginSettings)(this.createDefaultPluginSettings.bind(this), data);
      }
      /**
       * Displays a notice message to the user.
       *
       * @param message - The message to display.
       */
      showNotice(message) {
        if (this.notice) {
          this.notice.hide();
        }
        this.notice = new import_obsidian5.Notice(`${this.manifest.name}
${message}`);
      }
      /**
       * Loads the plugin settings from the saved data.
       *
       * @returns A promise that resolves when the settings are loaded.
       */
      async loadSettings() {
        const data = await this.loadData();
        this._settings = await this.parseSettings(data);
      }
    };
  }
});

// node_modules/monkey-around/dist/index.cjs
var require_dist = __commonJS({
  "node_modules/monkey-around/dist/index.cjs"(exports2) {
    "use strict";
    function around2(obj, factories) {
      const removers = Object.keys(factories).map((key) => around12(obj, key, factories[key]));
      return removers.length === 1 ? removers[0] : function() {
        removers.forEach((r) => r());
      };
    }
    function around12(obj, method, createWrapper) {
      const inherited = obj[method], hadOwn = obj.hasOwnProperty(method), original = hadOwn ? inherited : function() {
        return Object.getPrototypeOf(obj)[method].apply(this, arguments);
      };
      let current = createWrapper(original);
      if (inherited)
        Object.setPrototypeOf(current, inherited);
      Object.setPrototypeOf(wrapper, current);
      obj[method] = wrapper;
      return remove;
      function wrapper(...args) {
        if (current === original && obj[method] === wrapper)
          remove();
        return current.apply(this, args);
      }
      function remove() {
        if (obj[method] === wrapper) {
          if (hadOwn)
            obj[method] = original;
          else
            delete obj[method];
        }
        if (current === original)
          return;
        current = original;
        Object.setPrototypeOf(wrapper, inherited || Function);
      }
    }
    function dedupe(key, oldFn, newFn) {
      check[key] = key;
      return check;
      function check(...args) {
        return (oldFn[key] === key ? oldFn : newFn).apply(this, args);
      }
    }
    function after(promise, cb) {
      return promise.then(cb, cb);
    }
    function serialize(asyncFunction) {
      let lastRun = Promise.resolve();
      function wrapper(...args) {
        return lastRun = new Promise((res, rej) => {
          after(lastRun, () => {
            asyncFunction.apply(this, args).then(res, rej);
          });
        });
      }
      wrapper.after = function() {
        return lastRun = new Promise((res, rej) => {
          after(lastRun, res);
        });
      };
      return wrapper;
    }
    exports2.after = after;
    exports2.around = around2;
    exports2.dedupe = dedupe;
    exports2.serialize = serialize;
  }
});

// node_modules/obsidian-dev-utils/dist/lib/Object.cjs
var require_Object = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/Object.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Object_exports = {};
    __export2(Object_exports, {
      assignWithNonEnumerableProperties: () => assignWithNonEnumerableProperties,
      cloneWithNonEnumerableProperties: () => cloneWithNonEnumerableProperties,
      deepEqual: () => deepEqual,
      getNestedPropertyValue: () => getNestedPropertyValue,
      getPrototypeOf: () => getPrototypeOf,
      nameof: () => nameof,
      setNestedPropertyValue: () => setNestedPropertyValue,
      toJson: () => toJson2
    });
    module2.exports = __toCommonJS2(Object_exports);
    var import_Error3 = require_Error();
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    function assignWithNonEnumerableProperties(target, ...sources) {
      return _assignWithNonEnumerableProperties(target, ...sources);
    }
    function cloneWithNonEnumerableProperties(obj) {
      return Object.create(getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
    }
    function deepEqual(a, b) {
      if (a === b) {
        return true;
      }
      if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
        return false;
      }
      const keysA = Object.keys(a);
      const keysB = Object.keys(b);
      if (keysA.length !== keysB.length) {
        return false;
      }
      const aRecord = a;
      const bRecord = b;
      for (const key of keysA) {
        if (!keysB.includes(key) || !deepEqual(aRecord[key], bRecord[key])) {
          return false;
        }
      }
      return true;
    }
    function getNestedPropertyValue(obj, path) {
      let node = obj;
      const keys = path.split(".");
      for (const key of keys) {
        if (node === void 0) {
          return void 0;
        }
        node = node[key];
      }
      return node;
    }
    function getPrototypeOf(instance) {
      if (instance === void 0 || instance === null) {
        return instance;
      }
      return Object.getPrototypeOf(instance);
    }
    function nameof(name) {
      return name;
    }
    function setNestedPropertyValue(obj, path, value) {
      const error = new Error(`Property path ${path} not found`);
      let node = obj;
      const keys = path.split(".");
      for (const key of keys.slice(0, -1)) {
        if (node === void 0) {
          throw error;
        }
        node = node[key];
      }
      const lastKey = keys.at(-1);
      if (node === void 0 || lastKey === void 0) {
        throw error;
      }
      node[lastKey] = value;
    }
    function toJson2(value, options = {}) {
      const {
        shouldHandleFunctions = false,
        space = 2
      } = options;
      if (!shouldHandleFunctions) {
        return JSON.stringify(value, null, space);
      }
      const functionTexts = [];
      const replacer = (_, value2) => {
        if (typeof value2 === "function") {
          const index = functionTexts.length;
          functionTexts.push(value2.toString());
          return `__FUNCTION_${index.toString()}`;
        }
        return value2;
      };
      let json = JSON.stringify(value, replacer, space);
      json = json.replaceAll(/"__FUNCTION_(\d+)"/g, (_, indexStr) => functionTexts[parseInt(indexStr)] ?? (0, import_Error3.throwExpression)(new Error(`Function with index ${indexStr} not found`)));
      return json;
    }
    function _assignWithNonEnumerableProperties(target, ...sources) {
      for (const source of sources) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      }
      const sourcePrototypes = sources.map((source) => getPrototypeOf(source)).filter((proto) => !!proto);
      if (sourcePrototypes.length > 0) {
        const targetPrototype = _assignWithNonEnumerableProperties({}, getPrototypeOf(target), ...sourcePrototypes);
        Object.setPrototypeOf(target, targetPrototype);
      }
      return target;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/App.cjs
var require_App = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/App.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var App_exports = {};
    __export2(App_exports, {
      ValueWrapper: () => ValueWrapper,
      getApp: () => getApp,
      getObsidianDevUtilsState: () => getObsidianDevUtilsState
    });
    module2.exports = __toCommonJS2(App_exports);
    var ValueWrapper = class {
      constructor(value) {
        this.value = value;
      }
    };
    function getApp() {
      let canRequire;
      try {
        globalThis.require.resolve("obsidian/app");
        canRequire = true;
      } catch {
        canRequire = false;
      }
      if (canRequire) {
        return globalThis.require("obsidian/app");
      }
      const app = globalThis.app;
      if (app) {
        return app;
      }
      throw new Error("Obsidian app not found");
    }
    function getObsidianDevUtilsState(app, key, defaultValue) {
      const sharedStateWrapper = app;
      const sharedState = sharedStateWrapper.obsidianDevUtilsState ??= {};
      return sharedState[key] ??= new ValueWrapper(defaultValue);
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/FrontMatter.cjs
var require_FrontMatter = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/FrontMatter.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var FrontMatter_exports = {};
    __export2(FrontMatter_exports, {
      parseFrontMatter: () => parseFrontMatter,
      setFrontMatter: () => setFrontMatter
    });
    module2.exports = __toCommonJS2(FrontMatter_exports);
    var import_obsidian5 = require("obsidian");
    var import_String = require_String();
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    function parseFrontMatter(content) {
      const frontMatterInfo = (0, import_obsidian5.getFrontMatterInfo)(content);
      return (0, import_obsidian5.parseYaml)(frontMatterInfo.frontmatter) ?? {};
    }
    function setFrontMatter(content, newFrontMatter) {
      const frontMatterInfo = (0, import_obsidian5.getFrontMatterInfo)(content);
      if (Object.keys(newFrontMatter).length === 0) {
        return content.slice(frontMatterInfo.contentStart);
      }
      const newFrontMatterStr = (0, import_obsidian5.stringifyYaml)(newFrontMatter);
      return frontMatterInfo.exists ? (0, import_String.insertAt)(content, newFrontMatterStr, frontMatterInfo.from, frontMatterInfo.to) : "---\n" + newFrontMatterStr + "---\n" + content;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/Async.cjs
var require_Async = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/Async.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Async_exports = {};
    __export2(Async_exports, {
      addErrorHandler: () => addErrorHandler,
      asyncFilter: () => asyncFilter,
      asyncFlatMap: () => asyncFlatMap,
      asyncMap: () => asyncMap,
      convertAsyncToSync: () => convertAsyncToSync2,
      convertSyncToAsync: () => convertSyncToAsync,
      invokeAsyncSafely: () => invokeAsyncSafely,
      marksAsTerminateRetry: () => marksAsTerminateRetry,
      retryWithTimeout: () => retryWithTimeout,
      runWithTimeout: () => runWithTimeout,
      sleep: () => sleep,
      timeout: () => timeout,
      toArray: () => toArray
    });
    module2.exports = __toCommonJS2(Async_exports);
    var import_Error3 = require_Error();
    async function addErrorHandler(asyncFn) {
      try {
        await asyncFn();
      } catch (asyncError) {
        (0, import_Error3.emitAsyncErrorEvent)(asyncError);
      }
    }
    async function asyncFilter(arr, predicate) {
      const predicateResults = await asyncMap(arr, predicate);
      return arr.filter((_, index) => predicateResults[index]);
    }
    async function asyncFlatMap(arr, callback) {
      return (await asyncMap(arr, callback)).flat();
    }
    async function asyncMap(arr, callback) {
      return await Promise.all(arr.map(callback));
    }
    function convertAsyncToSync2(asyncFunc) {
      return (...args) => {
        invokeAsyncSafely(() => asyncFunc(...args));
      };
    }
    function convertSyncToAsync(syncFn) {
      return (...args) => Promise.resolve().then(() => syncFn(...args));
    }
    function invokeAsyncSafely(asyncFn) {
      void addErrorHandler(asyncFn);
    }
    function marksAsTerminateRetry(error) {
      return Object.assign(error, { __terminateRetry: true });
    }
    async function retryWithTimeout(fn, retryOptions = {}) {
      const stackTrace = (0, import_Error3.getStackTrace)();
      const DEFAULT_RETRY_OPTIONS = {
        retryDelayInMilliseconds: 100,
        shouldRetryOnError: true,
        timeoutInMilliseconds: 5e3
      };
      const overriddenOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
      await runWithTimeout(overriddenOptions.timeoutInMilliseconds, async () => {
        let attempt = 0;
        for (; ; ) {
          attempt++;
          let isSuccess;
          try {
            isSuccess = await fn();
          } catch (error) {
            if (!overriddenOptions.shouldRetryOnError || error.__terminateRetry) {
              throw error;
            }
            (0, import_Error3.printError)(error);
            isSuccess = false;
          }
          if (isSuccess) {
            if (attempt > 1) {
              console.debug(`Retry completed successfully after ${attempt.toString()} attempts`);
            }
            return;
          }
          console.debug(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${overriddenOptions.retryDelayInMilliseconds.toString()} milliseconds`, {
            fn,
            stackTrace
          });
          await sleep(overriddenOptions.retryDelayInMilliseconds);
        }
      });
    }
    async function runWithTimeout(timeoutInMilliseconds, fn) {
      let timedOut = false;
      let result = null;
      await Promise.race([run(), timeout2()]);
      if (timedOut) {
        console.error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`, { fn });
        throw new Error("Timed out");
      }
      return result;
      async function run() {
        result = await fn();
        timedOut = false;
      }
      async function timeout2() {
        await sleep(timeoutInMilliseconds);
        timedOut = true;
      }
    }
    async function sleep(milliseconds) {
      await new Promise((resolve) => setTimeout(resolve, milliseconds));
    }
    async function timeout(timeoutInMilliseconds) {
      await sleep(timeoutInMilliseconds);
      throw new Error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`);
    }
    async function toArray(iter) {
      const arr = [];
      for await (const item of iter) {
        arr.push(item);
      }
      return arr;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Reference.cjs
var require_Reference = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Reference.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Reference_exports = {};
    __export2(Reference_exports, {
      referenceToFileChange: () => referenceToFileChange2,
      sortReferences: () => sortReferences
    });
    module2.exports = __toCommonJS2(Reference_exports);
    var import_implementations2 = require_implementations();
    function referenceToFileChange2(reference, newContent) {
      if ((0, import_implementations2.isReferenceCache)(reference)) {
        return {
          endIndex: reference.position.end.offset,
          newContent,
          oldContent: reference.original,
          startIndex: reference.position.start.offset
        };
      } else if ((0, import_implementations2.isFrontmatterLinkCache)(reference)) {
        return {
          frontMatterKey: reference.key,
          newContent,
          oldContent: reference.original
        };
      }
      throw new Error("Unknown link type");
    }
    function sortReferences(references) {
      return references.sort((a, b) => {
        if ((0, import_implementations2.isFrontmatterLinkCache)(a) && (0, import_implementations2.isFrontmatterLinkCache)(b)) {
          return a.key.localeCompare(b.key);
        }
        if ((0, import_implementations2.isReferenceCache)(a) && (0, import_implementations2.isReferenceCache)(b)) {
          return a.position.start.offset - b.position.start.offset;
        }
        return (0, import_implementations2.isFrontmatterLinkCache)(a) ? 1 : -1;
      });
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/MetadataCache.cjs
var require_MetadataCache = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/MetadataCache.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var MetadataCache_exports = {};
    __export2(MetadataCache_exports, {
      ensureMetadataCacheReady: () => ensureMetadataCacheReady,
      getAllLinks: () => getAllLinks2,
      getBacklinksForFileOrPath: () => getBacklinksForFileOrPath,
      getBacklinksForFileSafe: () => getBacklinksForFileSafe2,
      getBacklinksMap: () => getBacklinksMap,
      getCacheSafe: () => getCacheSafe2,
      getFrontMatterSafe: () => getFrontMatterSafe,
      registerFile: () => registerFile,
      tempRegisterFileAndRun: () => tempRegisterFileAndRun
    });
    module2.exports = __toCommonJS2(MetadataCache_exports);
    var import_obsidian5 = require("obsidian");
    var import_implementations2 = require_implementations();
    var import_Async2 = require_Async();
    var import_Function = require_Function();
    var import_Object2 = require_Object();
    var import_FileSystem4 = require_FileSystem();
    var import_FrontMatter = require_FrontMatter();
    var import_Reference2 = require_Reference();
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    async function ensureMetadataCacheReady(app) {
      for (const [path, cache] of Object.entries(app.metadataCache.fileCache)) {
        if (!cache.hash) {
          continue;
        }
        if (app.metadataCache.metadataCache[cache.hash]) {
          continue;
        }
        await getCacheSafe2(app, path);
      }
    }
    function getAllLinks2(cache) {
      let links = [];
      if (cache.links) {
        links.push(...cache.links);
      }
      if (cache.embeds) {
        links.push(...cache.embeds);
      }
      if (cache.frontmatterLinks) {
        links.push(...cache.frontmatterLinks);
      }
      (0, import_Reference2.sortReferences)(links);
      links = links.filter((link, index) => {
        if (index === 0) {
          return true;
        }
        const previousLink = links[index - 1];
        if (!previousLink) {
          return true;
        }
        if ((0, import_implementations2.isReferenceCache)(link) && (0, import_implementations2.isReferenceCache)(previousLink)) {
          return link.position.start.offset !== previousLink.position.start.offset;
        }
        if ((0, import_implementations2.isFrontmatterLinkCache)(link) && (0, import_implementations2.isFrontmatterLinkCache)(previousLink)) {
          return link.key !== previousLink.key;
        }
        return true;
      });
      return links;
    }
    function getBacklinksForFileOrPath(app, pathOrFile) {
      const file = (0, import_FileSystem4.getFile)(app, pathOrFile, true);
      return tempRegisterFileAndRun(app, file, () => app.metadataCache.getBacklinksForFile(file));
    }
    async function getBacklinksForFileSafe2(app, pathOrFile, retryOptions = {}) {
      const safeOverload = app.metadataCache.getBacklinksForFile.safe;
      if (safeOverload) {
        return safeOverload(pathOrFile);
      }
      const DEFAULT_RETRY_OPTIONS = { timeoutInMilliseconds: 6e4 };
      const overriddenOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
      let backlinks = null;
      await (0, import_Async2.retryWithTimeout)(async () => {
        const file = (0, import_FileSystem4.getFile)(app, pathOrFile);
        await ensureMetadataCacheReady(app);
        backlinks = getBacklinksForFileOrPath(app, file);
        for (const notePath of backlinks.keys()) {
          const note = (0, import_FileSystem4.getFileOrNull)(app, notePath);
          if (!note) {
            return false;
          }
          await saveNote(app, note);
          const content = await app.vault.read(note);
          const frontMatter = (0, import_FrontMatter.parseFrontMatter)(content);
          const links = backlinks.get(notePath);
          if (!links) {
            return false;
          }
          for (const link of links) {
            let actualLink;
            if ((0, import_implementations2.isReferenceCache)(link)) {
              actualLink = content.slice(link.position.start.offset, link.position.end.offset);
            } else if ((0, import_implementations2.isFrontmatterLinkCache)(link)) {
              const linkValue = (0, import_Object2.getNestedPropertyValue)(frontMatter, link.key);
              if (typeof linkValue !== "string") {
                return false;
              }
              actualLink = linkValue;
            } else {
              return true;
            }
            if (actualLink !== link.original) {
              return false;
            }
          }
        }
        return true;
      }, overriddenOptions);
      return backlinks;
    }
    async function getBacklinksMap(app, pathOrFiles, retryOptions = {}) {
      const map = /* @__PURE__ */ new Map();
      for (const pathOrFile of pathOrFiles) {
        const customArrayDict = await getBacklinksForFileSafe2(app, pathOrFile, retryOptions);
        for (const path of customArrayDict.keys()) {
          const mapLinks = map.get(path) ?? [];
          const pathLinks = customArrayDict.get(path) ?? [];
          mapLinks.push(...pathLinks);
          map.set(path, mapLinks);
        }
      }
      return map;
    }
    async function getCacheSafe2(app, fileOrPath, retryOptions = {}) {
      const DEFAULT_RETRY_OPTIONS = { timeoutInMilliseconds: 6e4 };
      const overriddenOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
      let cache = null;
      await (0, import_Async2.retryWithTimeout)(async () => {
        const file = (0, import_FileSystem4.getFileOrNull)(app, fileOrPath);
        if (!file || file.deleted) {
          cache = null;
          return true;
        }
        await saveNote(app, file);
        const fileInfo = app.metadataCache.getFileInfo(file.path);
        const stat = await app.vault.adapter.stat(file.path);
        if (!fileInfo) {
          console.debug(`File cache info for ${file.path} is missing`);
          return false;
        } else if (!stat) {
          console.debug(`File stat for ${file.path} is missing`);
          return false;
        } else if (file.stat.mtime < stat.mtime) {
          app.vault.onChange("modified", file.path, void 0, stat);
          console.debug(`Cached timestamp for ${file.path} is from ${new Date(file.stat.mtime).toString()} which is older than the file system modification timestamp ${new Date(stat.mtime).toString()}`);
          return false;
        } else if (fileInfo.mtime < stat.mtime) {
          console.debug(`File cache info for ${file.path} is from ${new Date(fileInfo.mtime).toString()} which is older than the file modification timestamp ${new Date(stat.mtime).toString()}`);
          return false;
        } else {
          cache = app.metadataCache.getFileCache(file);
          if (!cache) {
            console.debug(`File cache for ${file.path} is missing`);
            return false;
          } else {
            return true;
          }
        }
      }, overriddenOptions);
      return cache;
    }
    async function getFrontMatterSafe(app, pathOrFile) {
      const cache = await getCacheSafe2(app, pathOrFile);
      return cache?.frontmatter ?? {};
    }
    function registerFile(app, file) {
      if (!file.deleted) {
        return import_Function.noop;
      }
      const deletedPaths = [];
      let deletedFile = file;
      while (deletedFile.deleted) {
        deletedPaths.push(deletedFile.path);
        app.vault.fileMap[deletedFile.path] = deletedFile;
        deletedFile = deletedFile.parent ?? (0, import_FileSystem4.getFolder)(app, (0, import_implementations2.parentFolderPath)(deletedFile.path), true);
      }
      if ((0, import_FileSystem4.isFile)(file)) {
        app.metadataCache.uniqueFileLookup.add(file.name.toLowerCase(), file);
      }
      return () => {
        for (const path of deletedPaths) {
          delete app.vault.fileMap[path];
        }
        if ((0, import_FileSystem4.isFile)(file)) {
          app.metadataCache.uniqueFileLookup.remove(file.name.toLowerCase(), file);
        }
      };
    }
    function tempRegisterFileAndRun(app, file, fn) {
      const unregister = registerFile(app, file);
      try {
        return fn();
      } finally {
        unregister();
      }
    }
    async function saveNote(app, pathOrFile) {
      if (!(0, import_FileSystem4.isMarkdownFile)(pathOrFile)) {
        return;
      }
      const path = (0, import_FileSystem4.getPath)(pathOrFile);
      for (const leaf of app.workspace.getLeavesOfType("markdown")) {
        if (leaf.view instanceof import_obsidian5.MarkdownView && leaf.view.file?.path === path) {
          await leaf.view.save();
        }
      }
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Vault.cjs
var require_Vault = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Vault.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Vault_exports = {};
    __export2(Vault_exports, {
      copySafe: () => copySafe2,
      createFolderSafe: () => createFolderSafe2,
      createTempFile: () => createTempFile,
      createTempFolder: () => createTempFolder,
      deleteEmptyFolderHierarchy: () => deleteEmptyFolderHierarchy2,
      deleteSafe: () => deleteSafe,
      getAvailablePath: () => getAvailablePath,
      getMarkdownFilesSorted: () => getMarkdownFilesSorted,
      getNoteFilesSorted: () => getNoteFilesSorted,
      getSafeRenamePath: () => getSafeRenamePath,
      isEmptyFolder: () => isEmptyFolder,
      listSafe: () => listSafe,
      process: () => process3,
      renameSafe: () => renameSafe2
    });
    module2.exports = __toCommonJS2(Vault_exports);
    var import_obsidian5 = require("obsidian");
    var import_implementations2 = require_implementations();
    var import_Async2 = require_Async();
    var import_Error3 = require_Error();
    var import_Function = require_Function();
    var import_Path5 = require_Path();
    var import_ValueProvider = require_ValueProvider();
    var import_FileSystem4 = require_FileSystem();
    var import_MetadataCache2 = require_MetadataCache();
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    async function copySafe2(app, oldPathOrFile, newPath) {
      const file = (0, import_FileSystem4.getFile)(app, oldPathOrFile);
      const newFolderPath = (0, import_implementations2.parentFolderPath)(newPath);
      await createFolderSafe2(app, newFolderPath);
      const newAvailablePath = getAvailablePath(app, newPath);
      try {
        await app.vault.copy(file, newAvailablePath);
      } catch (e) {
        if (!await app.vault.exists(newAvailablePath)) {
          throw e;
        }
      }
      return newAvailablePath;
    }
    async function createFolderSafe2(app, path) {
      if (await app.vault.adapter.exists(path)) {
        return false;
      }
      try {
        await app.vault.createFolder(path);
        return true;
      } catch (e) {
        if (!await app.vault.exists(path)) {
          throw e;
        }
        return true;
      }
    }
    async function createTempFile(app, path) {
      let file = (0, import_FileSystem4.getFileOrNull)(app, path);
      if (file) {
        return import_Function.noopAsync;
      }
      const folderCleanup = await createTempFolder(app, (0, import_implementations2.parentFolderPath)(path));
      try {
        await app.vault.create(path, "");
      } catch (e) {
        if (!await app.vault.exists(path)) {
          throw e;
        }
      }
      file = (0, import_FileSystem4.getFile)(app, path);
      return async () => {
        if (!file.deleted) {
          await app.fileManager.trashFile(file);
        }
        await folderCleanup();
      };
    }
    async function createTempFolder(app, path) {
      let folder = (0, import_FileSystem4.getFolderOrNull)(app, path);
      if (folder) {
        return import_Function.noopAsync;
      }
      const dirPath = (0, import_implementations2.parentFolderPath)(path);
      await createTempFolder(app, dirPath);
      const folderCleanup = await createTempFolder(app, (0, import_implementations2.parentFolderPath)(path));
      await createFolderSafe2(app, path);
      folder = (0, import_FileSystem4.getFolder)(app, path);
      return async () => {
        if (!folder.deleted) {
          await app.fileManager.trashFile(folder);
        }
        await folderCleanup();
      };
    }
    async function deleteEmptyFolderHierarchy2(app, pathOrFolder) {
      let folder = (0, import_FileSystem4.getFolderOrNull)(app, pathOrFolder);
      while (folder) {
        if (!await isEmptyFolder(app, folder)) {
          return;
        }
        const parent = folder.parent;
        await deleteSafe(app, folder.path);
        folder = parent;
      }
    }
    async function deleteSafe(app, pathOrFile, deletedNotePath, shouldReportUsedAttachments, shouldDeleteEmptyFolders) {
      const file = (0, import_FileSystem4.getAbstractFileOrNull)(app, pathOrFile);
      if (!file) {
        return false;
      }
      let canDelete = (0, import_FileSystem4.isFile)(file) || (shouldDeleteEmptyFolders ?? true);
      if ((0, import_FileSystem4.isFile)(file)) {
        const backlinks = await (0, import_MetadataCache2.getBacklinksForFileSafe)(app, file);
        if (deletedNotePath) {
          backlinks.clear(deletedNotePath);
        }
        if (backlinks.count() !== 0) {
          if (shouldReportUsedAttachments) {
            new import_obsidian5.Notice(`Attachment ${file.path} is still used by other notes. It will not be deleted.`);
          }
          canDelete = false;
        }
      } else if ((0, import_FileSystem4.isFolder)(file)) {
        const listedFiles = await listSafe(app, file);
        for (const child of [...listedFiles.files, ...listedFiles.folders]) {
          canDelete &&= await deleteSafe(app, child, deletedNotePath, shouldReportUsedAttachments);
        }
        canDelete &&= await isEmptyFolder(app, file);
      }
      if (canDelete) {
        try {
          await app.fileManager.trashFile(file);
        } catch (e) {
          if (await app.vault.exists(file.path)) {
            (0, import_Error3.printError)(new Error(`Failed to delete ${file.path}`, { cause: e }));
            canDelete = false;
          }
        }
      }
      return canDelete;
    }
    function getAvailablePath(app, path) {
      const ext = (0, import_Path5.extname)(path);
      return app.vault.getAvailablePath((0, import_Path5.join)((0, import_Path5.dirname)(path), (0, import_Path5.basename)(path, ext)), ext.slice(1));
    }
    function getMarkdownFilesSorted(app) {
      return app.vault.getMarkdownFiles().sort((a, b) => a.path.localeCompare(b.path));
    }
    function getNoteFilesSorted(app) {
      return app.vault.getAllLoadedFiles().filter((file) => (0, import_FileSystem4.isFile)(file) && (0, import_FileSystem4.isNote)(file)).sort((a, b) => a.path.localeCompare(b.path));
    }
    function getSafeRenamePath(app, oldPathOrFile, newPath) {
      const oldPath = (0, import_FileSystem4.getPath)(oldPathOrFile);
      if (app.vault.adapter.insensitive) {
        let folderPath = (0, import_Path5.dirname)(newPath);
        let nonExistingPath = (0, import_Path5.basename)(newPath);
        let folder = null;
        for (; ; ) {
          folder = (0, import_FileSystem4.getFolderOrNull)(app, folderPath, true);
          if (folder) {
            break;
          }
          nonExistingPath = (0, import_Path5.join)((0, import_Path5.basename)(folderPath), nonExistingPath);
          folderPath = (0, import_Path5.dirname)(folderPath);
        }
        newPath = (0, import_Path5.join)(folder.getParentPrefix(), nonExistingPath);
      }
      if (oldPath.toLowerCase() === newPath.toLowerCase()) {
        return newPath;
      }
      return getAvailablePath(app, newPath);
    }
    async function isEmptyFolder(app, pathOrFolder) {
      const listedFiles = await listSafe(app, (0, import_FileSystem4.getPath)(pathOrFolder));
      return listedFiles.files.length === 0 && listedFiles.folders.length === 0;
    }
    async function listSafe(app, pathOrFolder) {
      const path = (0, import_FileSystem4.getPath)(pathOrFolder);
      const EMPTY = { files: [], folders: [] };
      if ((await app.vault.adapter.stat(path))?.type !== "folder") {
        return EMPTY;
      }
      try {
        return await app.vault.adapter.list(path);
      } catch (e) {
        if (await app.vault.exists(path)) {
          throw e;
        }
        return EMPTY;
      }
    }
    async function process3(app, pathOrFile, newContentProvider, retryOptions = {}) {
      const file = (0, import_FileSystem4.getFile)(app, pathOrFile);
      const DEFAULT_RETRY_OPTIONS = { timeoutInMilliseconds: 6e4 };
      const overriddenOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
      await (0, import_Async2.retryWithTimeout)(async () => {
        if (file.deleted) {
          throw (0, import_Async2.marksAsTerminateRetry)(new Error(`File ${file.path} is deleted`));
        }
        const oldContent = await app.vault.read(file);
        const newContent = await (0, import_ValueProvider.resolveValue)(newContentProvider, oldContent);
        if (newContent === null) {
          return false;
        }
        let success = true;
        await app.vault.process(file, (content) => {
          if (content !== oldContent) {
            console.warn("Content has changed since it was read. Retrying...", {
              actualContent: content,
              expectedContent: oldContent,
              path: file.path
            });
            success = false;
            return content;
          }
          return newContent;
        });
        return success;
      }, overriddenOptions);
    }
    async function renameSafe2(app, oldPathOrFile, newPath) {
      const oldFile = (0, import_FileSystem4.getFile)(app, oldPathOrFile, false, true);
      const newAvailablePath = getSafeRenamePath(app, oldPathOrFile, newPath);
      if (oldFile.path.toLowerCase() === newAvailablePath.toLowerCase()) {
        if (oldFile.path !== newPath) {
          await app.vault.rename(oldFile, newAvailablePath);
        }
        return newAvailablePath;
      }
      const newFolderPath = (0, import_implementations2.parentFolderPath)(newAvailablePath);
      await createFolderSafe2(app, newFolderPath);
      try {
        await app.vault.rename(oldFile, newAvailablePath);
      } catch (e) {
        if (!await app.vault.exists(newAvailablePath) || await app.vault.exists(oldFile.path)) {
          throw e;
        }
      }
      return newAvailablePath;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/FileChange.cjs
var require_FileChange = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/FileChange.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var FileChange_exports = {};
    __export2(FileChange_exports, {
      applyFileChanges: () => applyFileChanges2,
      isContentChange: () => isContentChange,
      isFrontmatterChange: () => isFrontmatterChange
    });
    module2.exports = __toCommonJS2(FileChange_exports);
    var import_Object2 = require_Object();
    var import_ValueProvider = require_ValueProvider();
    var import_FileSystem4 = require_FileSystem();
    var import_FrontMatter = require_FrontMatter();
    var import_Vault3 = require_Vault();
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    async function applyFileChanges2(app, pathOrFile, changesProvider, retryOptions = {}) {
      const DEFAULT_RETRY_OPTIONS = { timeoutInMilliseconds: 6e4 };
      const overriddenOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
      await (0, import_Vault3.process)(app, pathOrFile, async (content) => {
        let changes = await (0, import_ValueProvider.resolveValue)(changesProvider);
        const frontMatter = (0, import_FrontMatter.parseFrontMatter)(content);
        for (const change of changes) {
          if (isContentChange(change)) {
            const actualContent = content.slice(change.startIndex, change.endIndex);
            if (actualContent !== change.oldContent) {
              console.warn("Content mismatch", {
                actualContent,
                endIndex: change.endIndex,
                expectedContent: change.oldContent,
                path: (0, import_FileSystem4.getPath)(pathOrFile),
                startIndex: change.startIndex
              });
              return null;
            }
          } else if (isFrontmatterChange(change)) {
            const actualContent = (0, import_Object2.getNestedPropertyValue)(frontMatter, change.frontMatterKey);
            if (actualContent !== change.oldContent) {
              console.warn("Content mismatch", {
                actualContent,
                expectedContent: change.oldContent,
                frontMatterKey: change.frontMatterKey,
                path: (0, import_FileSystem4.getPath)(pathOrFile)
              });
              return null;
            }
          }
        }
        changes.sort((a, b) => {
          if (isContentChange(a) && isContentChange(b)) {
            return a.startIndex - b.startIndex;
          }
          if (isFrontmatterChange(a) && isFrontmatterChange(b)) {
            return a.frontMatterKey.localeCompare(b.frontMatterKey);
          }
          return isContentChange(a) ? -1 : 1;
        });
        changes = changes.filter((change, index) => {
          if (change.oldContent === change.newContent) {
            return false;
          }
          if (index === 0) {
            return true;
          }
          return !(0, import_Object2.deepEqual)(change, changes[index - 1]);
        });
        for (let i = 1; i < changes.length; i++) {
          const change = changes[i];
          if (!change) {
            continue;
          }
          const previousChange = changes[i - 1];
          if (!previousChange) {
            continue;
          }
          if (isContentChange(previousChange) && isContentChange(change) && previousChange.endIndex && change.startIndex && previousChange.endIndex > change.startIndex) {
            console.warn("Overlapping changes", {
              change,
              previousChange
            });
            return null;
          }
        }
        let newContent = "";
        let lastIndex = 0;
        let frontMatterChanged = false;
        for (const change of changes) {
          if (isContentChange(change)) {
            newContent += content.slice(lastIndex, change.startIndex);
            newContent += change.newContent;
            lastIndex = change.endIndex;
          } else if (isFrontmatterChange(change)) {
            (0, import_Object2.setNestedPropertyValue)(frontMatter, change.frontMatterKey, change.newContent);
            frontMatterChanged = true;
          }
        }
        newContent += content.slice(lastIndex);
        if (frontMatterChanged) {
          newContent = (0, import_FrontMatter.setFrontMatter)(newContent, frontMatter);
        }
        return newContent;
      }, overriddenOptions);
    }
    function isContentChange(fileChange) {
      return fileChange.startIndex !== void 0;
    }
    function isFrontmatterChange(fileChange) {
      return fileChange.frontMatterKey !== void 0;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/ObsidianSettings.cjs
var require_ObsidianSettings = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/ObsidianSettings.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var ObsidianSettings_exports = {};
    __export2(ObsidianSettings_exports, {
      shouldUseRelativeLinks: () => shouldUseRelativeLinks,
      shouldUseWikilinks: () => shouldUseWikilinks
    });
    module2.exports = __toCommonJS2(ObsidianSettings_exports);
    function shouldUseRelativeLinks(app) {
      return app.vault.getConfig("newLinkFormat") === "relative";
    }
    function shouldUseWikilinks(app) {
      return !app.vault.getConfig("useMarkdownLinks");
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Link.cjs
var require_Link = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Link.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Link_exports = {};
    __export2(Link_exports, {
      convertLink: () => convertLink,
      editBacklinks: () => editBacklinks,
      editLinks: () => editLinks,
      extractLinkFile: () => extractLinkFile2,
      generateMarkdownLink: () => generateMarkdownLink,
      shouldResetAlias: () => shouldResetAlias,
      splitSubpath: () => splitSubpath,
      testAngleBrackets: () => testAngleBrackets,
      testEmbed: () => testEmbed,
      testLeadingDot: () => testLeadingDot,
      testWikilink: () => testWikilink,
      updateLink: () => updateLink2,
      updateLinksInFile: () => updateLinksInFile
    });
    module2.exports = __toCommonJS2(Link_exports);
    var import_obsidian5 = require("obsidian");
    var import_Object2 = require_Object();
    var import_Path5 = require_Path();
    var import_String = require_String();
    var import_FileChange2 = require_FileChange();
    var import_FileSystem4 = require_FileSystem();
    var import_MetadataCache2 = require_MetadataCache();
    var import_ObsidianSettings = require_ObsidianSettings();
    var import_Reference2 = require_Reference();
    var SPECIAL_LINK_SYMBOLS_REGEXP = /[\\\x00\x08\x0B\x0C\x0E-\x1F ]/g;
    var SPECIAL_MARKDOWN_LINK_SYMBOLS_REGEX = /[\\[\]<>_*~=`$]/g;
    function convertLink(options) {
      return updateLink2({
        app: options.app,
        forceMarkdownLinks: options.forceMarkdownLinks,
        link: options.link,
        oldPathOrFile: options.oldPathOrFile,
        pathOrFile: extractLinkFile2(options.app, options.link, options.sourcePathOrFile),
        renameMap: options.renameMap,
        shouldUpdateFilenameAlias: options.shouldUpdateFilenameAlias,
        sourcePathOrFile: options.sourcePathOrFile
      });
    }
    async function editBacklinks(app, pathOrFile, linkConverter, retryOptions = {}) {
      const backlinks = await (0, import_MetadataCache2.getBacklinksForFileSafe)(app, pathOrFile, retryOptions);
      for (const backlinkNotePath of backlinks.keys()) {
        const currentLinks = backlinks.get(backlinkNotePath) ?? [];
        const linkJsons = new Set(currentLinks.map((link) => (0, import_Object2.toJson)(link)));
        await editLinks(app, backlinkNotePath, (link) => {
          const linkJson = (0, import_Object2.toJson)(link);
          if (!linkJsons.has(linkJson)) {
            return;
          }
          return linkConverter(link);
        }, retryOptions);
      }
    }
    async function editLinks(app, pathOrFile, linkConverter, retryOptions = {}) {
      await (0, import_FileChange2.applyFileChanges)(app, pathOrFile, async () => {
        const cache = await (0, import_MetadataCache2.getCacheSafe)(app, pathOrFile);
        if (!cache) {
          return [];
        }
        const changes = [];
        for (const link of (0, import_MetadataCache2.getAllLinks)(cache)) {
          const newContent = await linkConverter(link);
          if (newContent === void 0) {
            continue;
          }
          changes.push((0, import_Reference2.referenceToFileChange)(link, newContent));
        }
        return changes;
      }, retryOptions);
    }
    function extractLinkFile2(app, link, notePathOrFile) {
      const { linkPath } = splitSubpath(link.link);
      return app.metadataCache.getFirstLinkpathDest(linkPath, (0, import_FileSystem4.getPath)(notePathOrFile));
    }
    function generateMarkdownLink(options) {
      const { app } = options;
      const configurableDefaultOptionsFn = app.fileManager.generateMarkdownLink.defaultOptionsFn ?? (() => ({}));
      const configurableDefaultOptions = configurableDefaultOptionsFn();
      const DEFAULT_OPTIONS = {
        allowEmptyEmbedAlias: true
      };
      options = { ...DEFAULT_OPTIONS, ...configurableDefaultOptions, ...options };
      const file = (0, import_FileSystem4.getFile)(app, options.pathOrFile, options.allowNonExistingFile);
      return (0, import_MetadataCache2.tempRegisterFileAndRun)(app, file, () => {
        const sourcePath = (0, import_FileSystem4.getPath)(options.sourcePathOrFile);
        const subpath = options.subpath ?? "";
        let alias = options.alias ?? "";
        const isEmbed = options.isEmbed ?? (options.originalLink ? testEmbed(options.originalLink) : void 0) ?? !(0, import_FileSystem4.isMarkdownFile)(file);
        const isWikilink = options.isWikilink ?? (options.originalLink ? testWikilink(options.originalLink) : void 0) ?? (0, import_ObsidianSettings.shouldUseWikilinks)(app);
        const forceRelativePath = options.forceRelativePath ?? (0, import_ObsidianSettings.shouldUseRelativeLinks)(app);
        const useLeadingDot = options.useLeadingDot ?? (options.originalLink ? testLeadingDot(options.originalLink) : void 0) ?? false;
        const useAngleBrackets = options.useAngleBrackets ?? (options.originalLink ? testAngleBrackets(options.originalLink) : void 0) ?? false;
        let linkText = file.path === sourcePath && subpath ? subpath : forceRelativePath ? (0, import_Path5.relative)((0, import_Path5.dirname)(sourcePath), isWikilink ? (0, import_FileSystem4.trimMarkdownExtension)(file) : file.path) + subpath : app.metadataCache.fileToLinktext(file, sourcePath, isWikilink) + subpath;
        if (forceRelativePath && useLeadingDot && !linkText.startsWith(".") && !linkText.startsWith("#")) {
          linkText = "./" + linkText;
        }
        const embedPrefix = isEmbed ? "!" : "";
        if (!isWikilink) {
          if (useAngleBrackets) {
            linkText = `<${linkText}>`;
          } else {
            linkText = linkText.replace(SPECIAL_LINK_SYMBOLS_REGEXP, function(specialLinkSymbol) {
              return encodeURIComponent(specialLinkSymbol);
            });
          }
          if (!alias && (!isEmbed || !options.allowEmptyEmbedAlias)) {
            alias = !options.includeAttachmentExtensionToEmbedAlias || (0, import_FileSystem4.isMarkdownFile)(file) ? file.basename : file.name;
          }
          alias = alias.replace(SPECIAL_MARKDOWN_LINK_SYMBOLS_REGEX, "\\$&");
          return `${embedPrefix}[${alias}](${linkText})`;
        } else {
          if (alias && alias.toLowerCase() === linkText.toLowerCase()) {
            linkText = alias;
            alias = "";
          }
          const aliasPart = alias ? `|${alias}` : "";
          return `${embedPrefix}[[${linkText}${aliasPart}]]`;
        }
      });
    }
    function shouldResetAlias(options) {
      const {
        app,
        displayText,
        isWikilink,
        otherPathOrFiles,
        pathOrFile,
        sourcePathOrFile
      } = options;
      if (isWikilink === false) {
        return false;
      }
      const file = (0, import_FileSystem4.getFile)(app, pathOrFile);
      if (!displayText) {
        return true;
      }
      const sourcePath = (0, import_FileSystem4.getPath)(sourcePathOrFile);
      const sourceDir = (0, import_Path5.dirname)(sourcePath);
      const aliasesToReset = /* @__PURE__ */ new Set();
      for (const pathOrFile2 of [file.path, ...otherPathOrFiles]) {
        if (!pathOrFile2) {
          continue;
        }
        const path = (0, import_FileSystem4.getPath)(pathOrFile2);
        aliasesToReset.add(path);
        aliasesToReset.add((0, import_Path5.basename)(path));
        aliasesToReset.add((0, import_Path5.relative)(sourceDir, path));
      }
      aliasesToReset.add(app.metadataCache.fileToLinktext(file, sourcePath, false));
      const cleanDisplayText = (0, import_obsidian5.normalizePath)(displayText.split(" > ")[0] ?? "").replace(/^\.\//, "").toLowerCase();
      for (const alias of aliasesToReset) {
        if (alias.toLowerCase() === cleanDisplayText) {
          return true;
        }
        const dir = (0, import_Path5.dirname)(alias);
        const base = (0, import_Path5.basename)(alias, (0, import_Path5.extname)(alias));
        if ((0, import_Path5.join)(dir, base).toLowerCase() === cleanDisplayText) {
          return true;
        }
      }
      return false;
    }
    function splitSubpath(link) {
      const parsed = (0, import_obsidian5.parseLinktext)((0, import_String.normalize)(link));
      return {
        linkPath: parsed.path,
        subpath: parsed.subpath
      };
    }
    function testAngleBrackets(link) {
      return link.includes("](<");
    }
    function testEmbed(link) {
      return link.startsWith("![");
    }
    function testLeadingDot(link) {
      return link.includes("[[./") || link.includes("](./") || link.includes("](<./");
    }
    function testWikilink(link) {
      return link.includes("[[");
    }
    function updateLink2(options) {
      const {
        app,
        forceMarkdownLinks,
        link,
        oldPathOrFile,
        pathOrFile,
        renameMap,
        shouldUpdateFilenameAlias,
        sourcePathOrFile
      } = options;
      if (!pathOrFile) {
        return link.original;
      }
      let file = (0, import_FileSystem4.getFile)(app, pathOrFile);
      const oldPath = (0, import_FileSystem4.getPath)(oldPathOrFile ?? sourcePathOrFile);
      const isWikilink = testWikilink(link.original) && forceMarkdownLinks !== true;
      const { subpath } = splitSubpath(link.link);
      const newPath = renameMap?.get(file.path);
      let alias = shouldResetAlias({
        app,
        displayText: link.displayText,
        isWikilink,
        otherPathOrFiles: [oldPath, newPath],
        pathOrFile,
        sourcePathOrFile
      }) ? void 0 : link.displayText;
      if (shouldUpdateFilenameAlias ?? true) {
        if (alias?.toLowerCase() === (0, import_Path5.basename)(oldPath, (0, import_Path5.extname)(oldPath)).toLowerCase()) {
          alias = file.basename;
        } else if (alias?.toLowerCase() === (0, import_Path5.basename)(oldPath).toLowerCase()) {
          alias = file.name;
        }
      }
      if (newPath) {
        file = (0, import_FileSystem4.getFile)(app, newPath, true);
      }
      const newLink = generateMarkdownLink({
        alias,
        app,
        isWikilink: forceMarkdownLinks ? false : void 0,
        originalLink: link.original,
        pathOrFile: file,
        sourcePathOrFile,
        subpath
      });
      return newLink;
    }
    async function updateLinksInFile(options) {
      const {
        app,
        embedOnlyLinks,
        forceMarkdownLinks,
        oldPathOrFile,
        pathOrFile,
        renameMap,
        shouldUpdateFilenameAlias
      } = options;
      await editLinks(app, pathOrFile, (link) => {
        const isEmbedLink = testEmbed(link.original);
        if (embedOnlyLinks !== void 0 && embedOnlyLinks !== isEmbedLink) {
          return;
        }
        return convertLink({
          app,
          forceMarkdownLinks,
          link,
          oldPathOrFile,
          renameMap,
          shouldUpdateFilenameAlias,
          sourcePathOrFile: pathOrFile
        });
      });
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Logger.cjs
var require_Logger = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Logger.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Logger_exports = {};
    __export2(Logger_exports, {
      invokeAsyncAndLog: () => invokeAsyncAndLog
    });
    module2.exports = __toCommonJS2(Logger_exports);
    var import_Error3 = require_Error();
    async function invokeAsyncAndLog(title, fn, stackTrace) {
      const timestampStart = Date.now();
      if (stackTrace === void 0) {
        stackTrace = (0, import_Error3.getStackTrace)().split("\n").slice(1).join("\n");
      }
      console.debug(`${title}:start`, {
        fn,
        stackTrace,
        timestampStart
      });
      try {
        await fn();
        const timestampEnd = Date.now();
        console.debug(`${title}:end`, {
          duration: timestampEnd - timestampStart,
          timestampEnd,
          timestampStart
        });
      } catch (error) {
        const timestampEnd = Date.now();
        console.debug(`${title}:error`, {
          duration: timestampEnd - timestampStart,
          error,
          timestampEnd: Date.now(),
          timestampStart
        });
        throw error;
      }
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Queue.cjs
var require_Queue = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Queue.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Queue_exports = {};
    __export2(Queue_exports, {
      addToQueue: () => addToQueue2,
      addToQueueAndWait: () => addToQueueAndWait,
      flushQueue: () => flushQueue
    });
    module2.exports = __toCommonJS2(Queue_exports);
    var import_Async2 = require_Async();
    var import_Error3 = require_Error();
    var import_Function = require_Function();
    var import_App = require_App();
    var import_Logger = require_Logger();
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    function addToQueue2(app, fn, timeoutInMilliseconds) {
      void addToQueueAndWait(app, fn, timeoutInMilliseconds);
    }
    async function addToQueueAndWait(app, fn, timeoutInMilliseconds) {
      const DEFAULT_TIMEOUT_IN_MILLISECONDS = 6e4;
      timeoutInMilliseconds ??= DEFAULT_TIMEOUT_IN_MILLISECONDS;
      const stackTrace = (0, import_Error3.getStackTrace)();
      const queue = getQueue(app).value;
      queue.items.push({ fn, stackTrace, timeoutInMilliseconds });
      queue.promise = queue.promise.then(() => processNextQueueItem(app));
      await queue.promise;
    }
    async function flushQueue(app) {
      await addToQueueAndWait(app, import_Function.noop);
    }
    function getQueue(app) {
      return (0, import_App.getObsidianDevUtilsState)(app, "queue", { items: [], promise: Promise.resolve() });
    }
    async function processNextQueueItem(app) {
      const queue = getQueue(app).value;
      const item = queue.items[0];
      if (!item) {
        return;
      }
      await (0, import_Async2.addErrorHandler)(() => (0, import_Async2.runWithTimeout)(item.timeoutInMilliseconds, () => (0, import_Logger.invokeAsyncAndLog)(processNextQueueItem.name, item.fn, item.stackTrace)));
      queue.items.shift();
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/RenameDeleteHandler.cjs
var require_RenameDeleteHandler = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/RenameDeleteHandler.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var RenameDeleteHandler_exports = {};
    __export2(RenameDeleteHandler_exports, {
      registerRenameDeleteHandlers: () => registerRenameDeleteHandlers2
    });
    module2.exports = __toCommonJS2(RenameDeleteHandler_exports);
    var import_monkey_around2 = require_dist();
    var import_obsidian5 = require("obsidian");
    var import_Error3 = require_Error();
    var import_Function = require_Function();
    var import_Object2 = require_Object();
    var import_Path5 = require_Path();
    var import_App = require_App();
    var import_AttachmentPath5 = require_AttachmentPath();
    var import_FileSystem4 = require_FileSystem();
    var import_Link2 = require_Link();
    var import_MetadataCache2 = require_MetadataCache();
    var import_Queue2 = require_Queue();
    var import_Vault3 = require_Vault();
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    var deletedMetadataCacheMap = /* @__PURE__ */ new Map();
    var handledRenames = /* @__PURE__ */ new Set();
    function registerRenameDeleteHandlers2(plugin, settingsBuilder) {
      const renameDeleteHandlersMap = getRenameDeleteHandlersMap(plugin.app);
      const pluginId = plugin.manifest.id;
      renameDeleteHandlersMap.set(pluginId, settingsBuilder);
      logRegisteredHandlers(plugin.app);
      plugin.register(() => {
        renameDeleteHandlersMap.delete(pluginId);
        logRegisteredHandlers(plugin.app);
      });
      const app = plugin.app;
      plugin.registerEvent(
        app.vault.on("delete", (file) => {
          if (!shouldInvokeHandler(app, pluginId)) {
            return;
          }
          const path = file.path;
          (0, import_Queue2.addToQueue)(app, () => handleDelete(app, path));
        })
      );
      plugin.registerEvent(
        app.vault.on("rename", (file, oldPath) => {
          if (!shouldInvokeHandler(app, pluginId)) {
            return;
          }
          if (!(0, import_FileSystem4.isFile)(file)) {
            return;
          }
          const newPath = file.path;
          handleRename(app, oldPath, newPath);
        })
      );
      plugin.registerEvent(
        app.metadataCache.on("deleted", (file, prevCache) => {
          handleMetadataDeleted(app, file, prevCache);
        })
      );
    }
    async function fillRenameMap(app, oldPath, newPath, renameMap) {
      renameMap.set(oldPath, newPath);
      if (!(0, import_FileSystem4.isNote)(oldPath)) {
        return;
      }
      const settings = getSettings(app);
      const oldAttachmentFolderPath = await (0, import_AttachmentPath5.getAttachmentFolderPath)(app, oldPath);
      const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder ? await (0, import_AttachmentPath5.getAttachmentFolderPath)(app, newPath) : oldAttachmentFolderPath;
      const oldAttachmentFolder = (0, import_FileSystem4.getFolderOrNull)(app, oldAttachmentFolderPath);
      if (!oldAttachmentFolder) {
        return;
      }
      if (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {
        return;
      }
      const oldAttachmentFiles = [];
      if (!await (0, import_AttachmentPath5.hasOwnAttachmentFolder)(app, oldPath)) {
        const oldCache = await (0, import_MetadataCache2.getCacheSafe)(app, oldPath);
        if (!oldCache) {
          return;
        }
        for (const oldLink of (0, import_MetadataCache2.getAllLinks)(oldCache)) {
          const oldAttachmentFile = (0, import_Link2.extractLinkFile)(app, oldLink, oldPath);
          if (!oldAttachmentFile) {
            continue;
          }
          if (oldAttachmentFile.path.startsWith(oldAttachmentFolderPath)) {
            const oldAttachmentBacklinks = await (0, import_MetadataCache2.getBacklinksForFileSafe)(app, oldAttachmentFile);
            if (oldAttachmentBacklinks.keys().length === 1) {
              oldAttachmentFiles.push(oldAttachmentFile);
            }
          }
        }
      } else {
        import_obsidian5.Vault.recurseChildren(oldAttachmentFolder, (oldAttachmentFile) => {
          if ((0, import_FileSystem4.isFile)(oldAttachmentFile)) {
            oldAttachmentFiles.push(oldAttachmentFile);
          }
        });
      }
      const oldBasename = (0, import_Path5.basename)(oldPath, (0, import_Path5.extname)(oldPath));
      const newBasename = (0, import_Path5.basename)(newPath, (0, import_Path5.extname)(newPath));
      for (const oldAttachmentFile of oldAttachmentFiles) {
        if ((0, import_FileSystem4.isNote)(oldAttachmentFile)) {
          continue;
        }
        const relativePath = (0, import_Path5.relative)(oldAttachmentFolderPath, oldAttachmentFile.path);
        const newDir = (0, import_Path5.join)(newAttachmentFolderPath, (0, import_Path5.dirname)(relativePath));
        const newChildBasename = settings.shouldRenameAttachmentFiles ? oldAttachmentFile.basename.replaceAll(oldBasename, newBasename) : oldAttachmentFile.basename;
        let newChildPath = (0, import_Path5.join)(newDir, (0, import_Path5.makeFileName)(newChildBasename, oldAttachmentFile.extension));
        if (oldAttachmentFile.path === newChildPath) {
          continue;
        }
        if (settings.shouldDeleteConflictingAttachments) {
          const newChildFile = (0, import_FileSystem4.getFileOrNull)(app, newChildPath);
          if (newChildFile) {
            await app.fileManager.trashFile(newChildFile);
          }
        } else {
          newChildPath = app.vault.getAvailablePath((0, import_Path5.join)(newDir, newChildBasename), oldAttachmentFile.extension);
        }
        renameMap.set(oldAttachmentFile.path, newChildPath);
      }
    }
    function getRenameDeleteHandlersMap(app) {
      return (0, import_App.getObsidianDevUtilsState)(app, "renameDeleteHandlersMap", /* @__PURE__ */ new Map()).value;
    }
    function getSettings(app) {
      const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);
      const settingsBuilders = Array.from(renameDeleteHandlersMap.values()).reverse();
      const settings = {};
      for (const settingsBuilder of settingsBuilders) {
        const newSettings = settingsBuilder();
        for (const [key, value] of Object.entries(newSettings)) {
          settings[key] ||= value;
        }
      }
      return settings;
    }
    async function handleDelete(app, path) {
      console.debug(`Handle Delete ${path}`);
      if (!(0, import_FileSystem4.isNote)(path)) {
        return;
      }
      const settings = getSettings(app);
      if (!settings.shouldDeleteOrphanAttachments) {
        return;
      }
      const cache = deletedMetadataCacheMap.get(path);
      deletedMetadataCacheMap.delete(path);
      if (cache) {
        const links = (0, import_MetadataCache2.getAllLinks)(cache);
        for (const link of links) {
          const attachmentFile = (0, import_Link2.extractLinkFile)(app, link, path);
          if (!attachmentFile) {
            continue;
          }
          if ((0, import_FileSystem4.isNote)(attachmentFile)) {
            continue;
          }
          await (0, import_Vault3.deleteSafe)(app, attachmentFile, path, settings.shouldDeleteEmptyFolders);
        }
      }
      const attachmentFolderPath = await (0, import_AttachmentPath5.getAttachmentFolderPath)(app, path);
      const attachmentFolder = (0, import_FileSystem4.getFolderOrNull)(app, attachmentFolderPath);
      if (!attachmentFolder) {
        return;
      }
      if (!await (0, import_AttachmentPath5.hasOwnAttachmentFolder)(app, path)) {
        return;
      }
      await (0, import_Vault3.deleteSafe)(app, attachmentFolder, path, false, settings.shouldDeleteEmptyFolders);
    }
    function handleMetadataDeleted(app, file, prevCache) {
      const settings = getSettings(app);
      if (!settings.shouldDeleteOrphanAttachments) {
        return;
      }
      if ((0, import_FileSystem4.isMarkdownFile)(file) && prevCache) {
        deletedMetadataCacheMap.set(file.path, prevCache);
      }
    }
    function handleRename(app, oldPath, newPath) {
      const key = makeKey(oldPath, newPath);
      console.debug(`Handle Rename ${key}`);
      if (handledRenames.has(key)) {
        handledRenames.delete(key);
        return;
      }
      const backlinks = (0, import_MetadataCache2.getBacklinksForFileOrPath)(app, oldPath);
      (0, import_Queue2.addToQueue)(app, () => handleRenameAsync(app, oldPath, newPath, backlinks));
    }
    async function handleRenameAsync(app, oldPath, newPath, backlinks) {
      if (app.vault.adapter.insensitive && oldPath.toLowerCase() === newPath.toLowerCase()) {
        const tempPath = (0, import_Path5.join)((0, import_Path5.dirname)(newPath), "__temp__" + (0, import_Path5.basename)(newPath));
        await renameHandled(app, newPath, tempPath);
        await handleRenameAsync(app, oldPath, tempPath, backlinks);
        await app.vault.rename((0, import_FileSystem4.getFile)(app, tempPath), newPath);
        return;
      }
      const restoreUpdateAllLinks = (0, import_monkey_around2.around)(app.fileManager, {
        updateAllLinks: () => import_Function.noopAsync
      });
      try {
        const renameMap = /* @__PURE__ */ new Map();
        await fillRenameMap(app, oldPath, newPath, renameMap);
        const backlinksMap = /* @__PURE__ */ new Map();
        initBacklinksMap(backlinks.data, renameMap, backlinksMap, oldPath);
        for (const attachmentOldPath of renameMap.keys()) {
          if (attachmentOldPath === oldPath) {
            continue;
          }
          const currentBacklinksMap = await (0, import_MetadataCache2.getBacklinksMap)(app, [attachmentOldPath]);
          initBacklinksMap(currentBacklinksMap, renameMap, backlinksMap, attachmentOldPath);
        }
        const parentFolders = /* @__PURE__ */ new Set();
        for (const [oldRelatedPath, newRelatedPath] of renameMap.entries()) {
          if (oldRelatedPath === oldPath) {
            continue;
          }
          const fixedNewRelatedPath = await renameHandled(app, oldRelatedPath, newRelatedPath);
          renameMap.set(oldRelatedPath, fixedNewRelatedPath);
          parentFolders.add((0, import_Path5.dirname)(oldRelatedPath));
        }
        const settings = getSettings(app);
        if (settings.shouldDeleteEmptyFolders) {
          for (const parentFolder of parentFolders) {
            await (0, import_Vault3.deleteEmptyFolderHierarchy)(app, parentFolder);
          }
        }
        for (const [newBacklinkPath, linkJsonToPathMap] of backlinksMap.entries()) {
          await (0, import_Link2.editLinks)(app, newBacklinkPath, (link) => {
            const oldRelatedPath = linkJsonToPathMap.get((0, import_Object2.toJson)(link));
            if (!oldRelatedPath) {
              return;
            }
            const newRelatedPath = renameMap.get(oldRelatedPath);
            if (!newRelatedPath) {
              return;
            }
            return (0, import_Link2.updateLink)({
              app,
              link,
              oldPathOrFile: oldRelatedPath,
              pathOrFile: newRelatedPath,
              renameMap,
              shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases,
              sourcePathOrFile: newBacklinkPath
            });
          });
        }
        if ((0, import_FileSystem4.isCanvasFile)(newPath)) {
          await (0, import_Vault3.process)(app, newPath, (content) => {
            let canvasData;
            try {
              canvasData = JSON.parse(content);
            } catch (e) {
              (0, import_Error3.printError)(new Error(`Failed to parse canvas data for ${newPath}`, { cause: e }));
              return content;
            }
            for (const node of canvasData.nodes) {
              if (node.type !== "file") {
                continue;
              }
              const newPath2 = renameMap.get(node.file);
              if (!newPath2) {
                continue;
              }
              node.file = newPath2;
            }
            return (0, import_Object2.toJson)(canvasData);
          });
        } else if ((0, import_FileSystem4.isMarkdownFile)(newPath)) {
          await (0, import_Link2.updateLinksInFile)({
            app,
            oldPathOrFile: oldPath,
            pathOrFile: newPath,
            renameMap,
            shouldUpdateFilenameAlias: settings.shouldUpdateFilenameAliases
          });
        }
      } finally {
        restoreUpdateAllLinks();
        const orphanKeys = Array.from(handledRenames);
        (0, import_Queue2.addToQueue)(app, () => {
          for (const key of orphanKeys) {
            handledRenames.delete(key);
          }
        });
      }
    }
    function initBacklinksMap(currentBacklinksMap, renameMap, backlinksMap, path) {
      for (const [backlinkPath, links] of currentBacklinksMap.entries()) {
        const newBacklinkPath = renameMap.get(backlinkPath) ?? backlinkPath;
        const linkJsonToPathMap = backlinksMap.get(newBacklinkPath) ?? /* @__PURE__ */ new Map();
        backlinksMap.set(newBacklinkPath, linkJsonToPathMap);
        for (const link of links) {
          linkJsonToPathMap.set((0, import_Object2.toJson)(link), path);
        }
      }
    }
    function logRegisteredHandlers(app) {
      const renameDeleteHandlersMap = getRenameDeleteHandlersMap(app);
      console.debug(`Plugins with registered rename/delete handlers: ${Array.from(renameDeleteHandlersMap.keys()).join(", ")}`);
    }
    function makeKey(oldPath, newPath) {
      return `${oldPath} -> ${newPath}`;
    }
    async function renameHandled(app, oldPath, newPath) {
      newPath = (0, import_Vault3.getSafeRenamePath)(app, oldPath, newPath);
      if (oldPath === newPath) {
        return newPath;
      }
      const key = makeKey(oldPath, newPath);
      handledRenames.add(key);
      newPath = await (0, import_Vault3.renameSafe)(app, oldPath, newPath);
      return newPath;
    }
    function shouldInvokeHandler(app, pluginId) {
      const renameDeleteHandlerPluginIds = getRenameDeleteHandlersMap(app);
      const mainPluginId = Array.from(renameDeleteHandlerPluginIds.keys())[0];
      if (mainPluginId !== pluginId) {
        return false;
      }
      return true;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/DocumentFragment.cjs
var require_DocumentFragment = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/DocumentFragment.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var DocumentFragment_exports = {};
    __export2(DocumentFragment_exports, {
      appendCodeBlock: () => appendCodeBlock3
    });
    module2.exports = __toCommonJS2(DocumentFragment_exports);
    function appendCodeBlock3(fragment, code) {
      fragment.appendChild(createSpan({ cls: "markdown-rendered code" }, (span) => {
        span.style.fontWeight = "bold";
        span.appendChild(createEl("code", { text: code }));
      }));
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Modal/Confirm.cjs
var require_Confirm = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Modal/Confirm.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Confirm_exports = {};
    __export2(Confirm_exports, {
      confirm: () => confirm2
    });
    module2.exports = __toCommonJS2(Confirm_exports);
    var import_obsidian5 = require("obsidian");
    var ConfirmModal = class extends import_obsidian5.Modal {
      constructor(options, resolve) {
        super(options.app);
        this.resolve = resolve;
        const DEFAULT_OPTIONS = {
          app: options.app,
          cancelButtonStyles: {},
          cancelButtonText: "Cancel",
          message: "",
          okButtonStyles: {
            marginRight: "10px",
            marginTop: "20px"
          },
          okButtonText: "OK",
          title: ""
        };
        this.options = { ...DEFAULT_OPTIONS, ...options };
      }
      isConfirmed = false;
      options;
      onClose() {
        this.resolve(this.isConfirmed);
      }
      onOpen() {
        this.titleEl.setText(this.options.title);
        const paragraph = this.contentEl.createEl("p");
        paragraph.setText(this.options.message);
        const okButton = new import_obsidian5.ButtonComponent(this.contentEl);
        okButton.setButtonText(this.options.okButtonText);
        okButton.setCta();
        okButton.onClick(() => {
          this.isConfirmed = true;
          this.close();
        });
        Object.assign(okButton.buttonEl.style, this.options.okButtonStyles);
        const cancelButton = new import_obsidian5.ButtonComponent(this.contentEl);
        cancelButton.setButtonText(this.options.cancelButtonText);
        cancelButton.onClick(this.close.bind(this));
        Object.assign(okButton.buttonEl.style, this.options.okButtonStyles);
      }
    };
    async function confirm2(options) {
      return new Promise((resolve) => {
        const modal = new ConfirmModal(options, resolve);
        modal.open();
      });
    }
  }
});

// node_modules/moment/moment.js
var require_moment = __commonJS({
  "node_modules/moment/moment.js"(exports2, module2) {
    var __process3 = globalThis["process"] ?? {
      "cwd": () => "/",
      "env": {},
      "platform": "android"
    };
    (function(global, factory) {
      typeof exports2 === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : global.moment = factory();
    })(exports2, function() {
      "use strict";
      var hookCallback;
      function hooks() {
        return hookCallback.apply(null, arguments);
      }
      function setHookCallback(callback) {
        hookCallback = callback;
      }
      function isArray(input) {
        return input instanceof Array || Object.prototype.toString.call(input) === "[object Array]";
      }
      function isObject(input) {
        return input != null && Object.prototype.toString.call(input) === "[object Object]";
      }
      function hasOwnProp(a, b) {
        return Object.prototype.hasOwnProperty.call(a, b);
      }
      function isObjectEmpty(obj) {
        if (Object.getOwnPropertyNames) {
          return Object.getOwnPropertyNames(obj).length === 0;
        } else {
          var k;
          for (k in obj) {
            if (hasOwnProp(obj, k)) {
              return false;
            }
          }
          return true;
        }
      }
      function isUndefined(input) {
        return input === void 0;
      }
      function isNumber(input) {
        return typeof input === "number" || Object.prototype.toString.call(input) === "[object Number]";
      }
      function isDate(input) {
        return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
      }
      function map(arr, fn) {
        var res = [], i, arrLen = arr.length;
        for (i = 0; i < arrLen; ++i) {
          res.push(fn(arr[i], i));
        }
        return res;
      }
      function extend2(a, b) {
        for (var i in b) {
          if (hasOwnProp(b, i)) {
            a[i] = b[i];
          }
        }
        if (hasOwnProp(b, "toString")) {
          a.toString = b.toString;
        }
        if (hasOwnProp(b, "valueOf")) {
          a.valueOf = b.valueOf;
        }
        return a;
      }
      function createUTC(input, format2, locale2, strict) {
        return createLocalOrUTC(input, format2, locale2, strict, true).utc();
      }
      function defaultParsingFlags() {
        return {
          empty: false,
          unusedTokens: [],
          unusedInput: [],
          overflow: -2,
          charsLeftOver: 0,
          nullInput: false,
          invalidEra: null,
          invalidMonth: null,
          invalidFormat: false,
          userInvalidated: false,
          iso: false,
          parsedDateParts: [],
          era: null,
          meridiem: null,
          rfc2822: false,
          weekdayMismatch: false
        };
      }
      function getParsingFlags(m) {
        if (m._pf == null) {
          m._pf = defaultParsingFlags();
        }
        return m._pf;
      }
      var some;
      if (Array.prototype.some) {
        some = Array.prototype.some;
      } else {
        some = function(fun) {
          var t = Object(this), len = t.length >>> 0, i;
          for (i = 0; i < len; i++) {
            if (i in t && fun.call(this, t[i], i, t)) {
              return true;
            }
          }
          return false;
        };
      }
      function isValid(m) {
        var flags = null, parsedParts = false, isNowValid = m._d && !isNaN(m._d.getTime());
        if (isNowValid) {
          flags = getParsingFlags(m);
          parsedParts = some.call(flags.parsedDateParts, function(i) {
            return i != null;
          });
          isNowValid = flags.overflow < 0 && !flags.empty && !flags.invalidEra && !flags.invalidMonth && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts);
          if (m._strict) {
            isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === void 0;
          }
        }
        if (Object.isFrozen == null || !Object.isFrozen(m)) {
          m._isValid = isNowValid;
        } else {
          return isNowValid;
        }
        return m._isValid;
      }
      function createInvalid(flags) {
        var m = createUTC(NaN);
        if (flags != null) {
          extend2(getParsingFlags(m), flags);
        } else {
          getParsingFlags(m).userInvalidated = true;
        }
        return m;
      }
      var momentProperties = hooks.momentProperties = [], updateInProgress = false;
      function copyConfig(to2, from2) {
        var i, prop, val, momentPropertiesLen = momentProperties.length;
        if (!isUndefined(from2._isAMomentObject)) {
          to2._isAMomentObject = from2._isAMomentObject;
        }
        if (!isUndefined(from2._i)) {
          to2._i = from2._i;
        }
        if (!isUndefined(from2._f)) {
          to2._f = from2._f;
        }
        if (!isUndefined(from2._l)) {
          to2._l = from2._l;
        }
        if (!isUndefined(from2._strict)) {
          to2._strict = from2._strict;
        }
        if (!isUndefined(from2._tzm)) {
          to2._tzm = from2._tzm;
        }
        if (!isUndefined(from2._isUTC)) {
          to2._isUTC = from2._isUTC;
        }
        if (!isUndefined(from2._offset)) {
          to2._offset = from2._offset;
        }
        if (!isUndefined(from2._pf)) {
          to2._pf = getParsingFlags(from2);
        }
        if (!isUndefined(from2._locale)) {
          to2._locale = from2._locale;
        }
        if (momentPropertiesLen > 0) {
          for (i = 0; i < momentPropertiesLen; i++) {
            prop = momentProperties[i];
            val = from2[prop];
            if (!isUndefined(val)) {
              to2[prop] = val;
            }
          }
        }
        return to2;
      }
      function Moment(config) {
        copyConfig(this, config);
        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
        if (!this.isValid()) {
          this._d = /* @__PURE__ */ new Date(NaN);
        }
        if (updateInProgress === false) {
          updateInProgress = true;
          hooks.updateOffset(this);
          updateInProgress = false;
        }
      }
      function isMoment(obj) {
        return obj instanceof Moment || obj != null && obj._isAMomentObject != null;
      }
      function warn(msg) {
        if (hooks.suppressDeprecationWarnings === false && typeof console !== "undefined" && console.warn) {
          console.warn("Deprecation warning: " + msg);
        }
      }
      function deprecate(msg, fn) {
        var firstTime = true;
        return extend2(function() {
          if (hooks.deprecationHandler != null) {
            hooks.deprecationHandler(null, msg);
          }
          if (firstTime) {
            var args = [], arg, i, key, argLen = arguments.length;
            for (i = 0; i < argLen; i++) {
              arg = "";
              if (typeof arguments[i] === "object") {
                arg += "\n[" + i + "] ";
                for (key in arguments[0]) {
                  if (hasOwnProp(arguments[0], key)) {
                    arg += key + ": " + arguments[0][key] + ", ";
                  }
                }
                arg = arg.slice(0, -2);
              } else {
                arg = arguments[i];
              }
              args.push(arg);
            }
            warn(
              msg + "\nArguments: " + Array.prototype.slice.call(args).join("") + "\n" + new Error().stack
            );
            firstTime = false;
          }
          return fn.apply(this, arguments);
        }, fn);
      }
      var deprecations = {};
      function deprecateSimple(name, msg) {
        if (hooks.deprecationHandler != null) {
          hooks.deprecationHandler(name, msg);
        }
        if (!deprecations[name]) {
          warn(msg);
          deprecations[name] = true;
        }
      }
      hooks.suppressDeprecationWarnings = false;
      hooks.deprecationHandler = null;
      function isFunction(input) {
        return typeof Function !== "undefined" && input instanceof Function || Object.prototype.toString.call(input) === "[object Function]";
      }
      function set(config) {
        var prop, i;
        for (i in config) {
          if (hasOwnProp(config, i)) {
            prop = config[i];
            if (isFunction(prop)) {
              this[i] = prop;
            } else {
              this["_" + i] = prop;
            }
          }
        }
        this._config = config;
        this._dayOfMonthOrdinalParseLenient = new RegExp(
          (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + "|" + /\d{1,2}/.source
        );
      }
      function mergeConfigs(parentConfig, childConfig) {
        var res = extend2({}, parentConfig), prop;
        for (prop in childConfig) {
          if (hasOwnProp(childConfig, prop)) {
            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
              res[prop] = {};
              extend2(res[prop], parentConfig[prop]);
              extend2(res[prop], childConfig[prop]);
            } else if (childConfig[prop] != null) {
              res[prop] = childConfig[prop];
            } else {
              delete res[prop];
            }
          }
        }
        for (prop in parentConfig) {
          if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject(parentConfig[prop])) {
            res[prop] = extend2({}, res[prop]);
          }
        }
        return res;
      }
      function Locale(config) {
        if (config != null) {
          this.set(config);
        }
      }
      var keys;
      if (Object.keys) {
        keys = Object.keys;
      } else {
        keys = function(obj) {
          var i, res = [];
          for (i in obj) {
            if (hasOwnProp(obj, i)) {
              res.push(i);
            }
          }
          return res;
        };
      }
      var defaultCalendar = {
        sameDay: "[Today at] LT",
        nextDay: "[Tomorrow at] LT",
        nextWeek: "dddd [at] LT",
        lastDay: "[Yesterday at] LT",
        lastWeek: "[Last] dddd [at] LT",
        sameElse: "L"
      };
      function calendar(key, mom, now2) {
        var output = this._calendar[key] || this._calendar["sameElse"];
        return isFunction(output) ? output.call(mom, now2) : output;
      }
      function zeroFill(number, targetLength, forceSign) {
        var absNumber = "" + Math.abs(number), zerosToFill = targetLength - absNumber.length, sign2 = number >= 0;
        return (sign2 ? forceSign ? "+" : "" : "-") + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
      }
      var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g, localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, formatFunctions = {}, formatTokenFunctions = {};
      function addFormatToken(token2, padded, ordinal2, callback) {
        var func = callback;
        if (typeof callback === "string") {
          func = function() {
            return this[callback]();
          };
        }
        if (token2) {
          formatTokenFunctions[token2] = func;
        }
        if (padded) {
          formatTokenFunctions[padded[0]] = function() {
            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
          };
        }
        if (ordinal2) {
          formatTokenFunctions[ordinal2] = function() {
            return this.localeData().ordinal(
              func.apply(this, arguments),
              token2
            );
          };
        }
      }
      function removeFormattingTokens(input) {
        if (input.match(/\[[\s\S]/)) {
          return input.replace(/^\[|\]$/g, "");
        }
        return input.replace(/\\/g, "");
      }
      function makeFormatFunction(format2) {
        var array = format2.match(formattingTokens), i, length;
        for (i = 0, length = array.length; i < length; i++) {
          if (formatTokenFunctions[array[i]]) {
            array[i] = formatTokenFunctions[array[i]];
          } else {
            array[i] = removeFormattingTokens(array[i]);
          }
        }
        return function(mom) {
          var output = "", i2;
          for (i2 = 0; i2 < length; i2++) {
            output += isFunction(array[i2]) ? array[i2].call(mom, format2) : array[i2];
          }
          return output;
        };
      }
      function formatMoment(m, format2) {
        if (!m.isValid()) {
          return m.localeData().invalidDate();
        }
        format2 = expandFormat(format2, m.localeData());
        formatFunctions[format2] = formatFunctions[format2] || makeFormatFunction(format2);
        return formatFunctions[format2](m);
      }
      function expandFormat(format2, locale2) {
        var i = 5;
        function replaceLongDateFormatTokens(input) {
          return locale2.longDateFormat(input) || input;
        }
        localFormattingTokens.lastIndex = 0;
        while (i >= 0 && localFormattingTokens.test(format2)) {
          format2 = format2.replace(
            localFormattingTokens,
            replaceLongDateFormatTokens
          );
          localFormattingTokens.lastIndex = 0;
          i -= 1;
        }
        return format2;
      }
      var defaultLongDateFormat = {
        LTS: "h:mm:ss A",
        LT: "h:mm A",
        L: "MM/DD/YYYY",
        LL: "MMMM D, YYYY",
        LLL: "MMMM D, YYYY h:mm A",
        LLLL: "dddd, MMMM D, YYYY h:mm A"
      };
      function longDateFormat(key) {
        var format2 = this._longDateFormat[key], formatUpper = this._longDateFormat[key.toUpperCase()];
        if (format2 || !formatUpper) {
          return format2;
        }
        this._longDateFormat[key] = formatUpper.match(formattingTokens).map(function(tok) {
          if (tok === "MMMM" || tok === "MM" || tok === "DD" || tok === "dddd") {
            return tok.slice(1);
          }
          return tok;
        }).join("");
        return this._longDateFormat[key];
      }
      var defaultInvalidDate = "Invalid date";
      function invalidDate() {
        return this._invalidDate;
      }
      var defaultOrdinal = "%d", defaultDayOfMonthOrdinalParse = /\d{1,2}/;
      function ordinal(number) {
        return this._ordinal.replace("%d", number);
      }
      var defaultRelativeTime = {
        future: "in %s",
        past: "%s ago",
        s: "a few seconds",
        ss: "%d seconds",
        m: "a minute",
        mm: "%d minutes",
        h: "an hour",
        hh: "%d hours",
        d: "a day",
        dd: "%d days",
        w: "a week",
        ww: "%d weeks",
        M: "a month",
        MM: "%d months",
        y: "a year",
        yy: "%d years"
      };
      function relativeTime(number, withoutSuffix, string, isFuture) {
        var output = this._relativeTime[string];
        return isFunction(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);
      }
      function pastFuture(diff2, output) {
        var format2 = this._relativeTime[diff2 > 0 ? "future" : "past"];
        return isFunction(format2) ? format2(output) : format2.replace(/%s/i, output);
      }
      var aliases = {
        D: "date",
        dates: "date",
        date: "date",
        d: "day",
        days: "day",
        day: "day",
        e: "weekday",
        weekdays: "weekday",
        weekday: "weekday",
        E: "isoWeekday",
        isoweekdays: "isoWeekday",
        isoweekday: "isoWeekday",
        DDD: "dayOfYear",
        dayofyears: "dayOfYear",
        dayofyear: "dayOfYear",
        h: "hour",
        hours: "hour",
        hour: "hour",
        ms: "millisecond",
        milliseconds: "millisecond",
        millisecond: "millisecond",
        m: "minute",
        minutes: "minute",
        minute: "minute",
        M: "month",
        months: "month",
        month: "month",
        Q: "quarter",
        quarters: "quarter",
        quarter: "quarter",
        s: "second",
        seconds: "second",
        second: "second",
        gg: "weekYear",
        weekyears: "weekYear",
        weekyear: "weekYear",
        GG: "isoWeekYear",
        isoweekyears: "isoWeekYear",
        isoweekyear: "isoWeekYear",
        w: "week",
        weeks: "week",
        week: "week",
        W: "isoWeek",
        isoweeks: "isoWeek",
        isoweek: "isoWeek",
        y: "year",
        years: "year",
        year: "year"
      };
      function normalizeUnits(units) {
        return typeof units === "string" ? aliases[units] || aliases[units.toLowerCase()] : void 0;
      }
      function normalizeObjectUnits(inputObject) {
        var normalizedInput = {}, normalizedProp, prop;
        for (prop in inputObject) {
          if (hasOwnProp(inputObject, prop)) {
            normalizedProp = normalizeUnits(prop);
            if (normalizedProp) {
              normalizedInput[normalizedProp] = inputObject[prop];
            }
          }
        }
        return normalizedInput;
      }
      var priorities = {
        date: 9,
        day: 11,
        weekday: 11,
        isoWeekday: 11,
        dayOfYear: 4,
        hour: 13,
        millisecond: 16,
        minute: 14,
        month: 8,
        quarter: 7,
        second: 15,
        weekYear: 1,
        isoWeekYear: 1,
        week: 5,
        isoWeek: 5,
        year: 1
      };
      function getPrioritizedUnits(unitsObj) {
        var units = [], u;
        for (u in unitsObj) {
          if (hasOwnProp(unitsObj, u)) {
            units.push({ unit: u, priority: priorities[u] });
          }
        }
        units.sort(function(a, b) {
          return a.priority - b.priority;
        });
        return units;
      }
      var match1 = /\d/, match2 = /\d\d/, match3 = /\d{3}/, match4 = /\d{4}/, match6 = /[+-]?\d{6}/, match1to2 = /\d\d?/, match3to4 = /\d\d\d\d?/, match5to6 = /\d\d\d\d\d\d?/, match1to3 = /\d{1,3}/, match1to4 = /\d{1,4}/, match1to6 = /[+-]?\d{1,6}/, matchUnsigned = /\d+/, matchSigned = /[+-]?\d+/, matchOffset = /Z|[+-]\d\d:?\d\d/gi, matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i, match1to2NoLeadingZero = /^[1-9]\d?/, match1to2HasZero = /^([1-9]\d|\d)/, regexes;
      regexes = {};
      function addRegexToken(token2, regex, strictRegex) {
        regexes[token2] = isFunction(regex) ? regex : function(isStrict, localeData2) {
          return isStrict && strictRegex ? strictRegex : regex;
        };
      }
      function getParseRegexForToken(token2, config) {
        if (!hasOwnProp(regexes, token2)) {
          return new RegExp(unescapeFormat(token2));
        }
        return regexes[token2](config._strict, config._locale);
      }
      function unescapeFormat(s) {
        return regexEscape(
          s.replace("\\", "").replace(
            /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
            function(matched, p1, p2, p3, p4) {
              return p1 || p2 || p3 || p4;
            }
          )
        );
      }
      function regexEscape(s) {
        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
      }
      function absFloor(number) {
        if (number < 0) {
          return Math.ceil(number) || 0;
        } else {
          return Math.floor(number);
        }
      }
      function toInt(argumentForCoercion) {
        var coercedNumber = +argumentForCoercion, value = 0;
        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
          value = absFloor(coercedNumber);
        }
        return value;
      }
      var tokens = {};
      function addParseToken(token2, callback) {
        var i, func = callback, tokenLen;
        if (typeof token2 === "string") {
          token2 = [token2];
        }
        if (isNumber(callback)) {
          func = function(input, array) {
            array[callback] = toInt(input);
          };
        }
        tokenLen = token2.length;
        for (i = 0; i < tokenLen; i++) {
          tokens[token2[i]] = func;
        }
      }
      function addWeekParseToken(token2, callback) {
        addParseToken(token2, function(input, array, config, token3) {
          config._w = config._w || {};
          callback(input, config._w, config, token3);
        });
      }
      function addTimeToArrayFromToken(token2, input, config) {
        if (input != null && hasOwnProp(tokens, token2)) {
          tokens[token2](input, config._a, config, token2);
        }
      }
      function isLeapYear(year) {
        return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
      }
      var YEAR = 0, MONTH = 1, DATE = 2, HOUR = 3, MINUTE = 4, SECOND = 5, MILLISECOND = 6, WEEK = 7, WEEKDAY = 8;
      addFormatToken("Y", 0, 0, function() {
        var y = this.year();
        return y <= 9999 ? zeroFill(y, 4) : "+" + y;
      });
      addFormatToken(0, ["YY", 2], 0, function() {
        return this.year() % 100;
      });
      addFormatToken(0, ["YYYY", 4], 0, "year");
      addFormatToken(0, ["YYYYY", 5], 0, "year");
      addFormatToken(0, ["YYYYYY", 6, true], 0, "year");
      addRegexToken("Y", matchSigned);
      addRegexToken("YY", match1to2, match2);
      addRegexToken("YYYY", match1to4, match4);
      addRegexToken("YYYYY", match1to6, match6);
      addRegexToken("YYYYYY", match1to6, match6);
      addParseToken(["YYYYY", "YYYYYY"], YEAR);
      addParseToken("YYYY", function(input, array) {
        array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
      });
      addParseToken("YY", function(input, array) {
        array[YEAR] = hooks.parseTwoDigitYear(input);
      });
      addParseToken("Y", function(input, array) {
        array[YEAR] = parseInt(input, 10);
      });
      function daysInYear(year) {
        return isLeapYear(year) ? 366 : 365;
      }
      hooks.parseTwoDigitYear = function(input) {
        return toInt(input) + (toInt(input) > 68 ? 1900 : 2e3);
      };
      var getSetYear = makeGetSet("FullYear", true);
      function getIsLeapYear() {
        return isLeapYear(this.year());
      }
      function makeGetSet(unit, keepTime) {
        return function(value) {
          if (value != null) {
            set$1(this, unit, value);
            hooks.updateOffset(this, keepTime);
            return this;
          } else {
            return get(this, unit);
          }
        };
      }
      function get(mom, unit) {
        if (!mom.isValid()) {
          return NaN;
        }
        var d = mom._d, isUTC = mom._isUTC;
        switch (unit) {
          case "Milliseconds":
            return isUTC ? d.getUTCMilliseconds() : d.getMilliseconds();
          case "Seconds":
            return isUTC ? d.getUTCSeconds() : d.getSeconds();
          case "Minutes":
            return isUTC ? d.getUTCMinutes() : d.getMinutes();
          case "Hours":
            return isUTC ? d.getUTCHours() : d.getHours();
          case "Date":
            return isUTC ? d.getUTCDate() : d.getDate();
          case "Day":
            return isUTC ? d.getUTCDay() : d.getDay();
          case "Month":
            return isUTC ? d.getUTCMonth() : d.getMonth();
          case "FullYear":
            return isUTC ? d.getUTCFullYear() : d.getFullYear();
          default:
            return NaN;
        }
      }
      function set$1(mom, unit, value) {
        var d, isUTC, year, month, date;
        if (!mom.isValid() || isNaN(value)) {
          return;
        }
        d = mom._d;
        isUTC = mom._isUTC;
        switch (unit) {
          case "Milliseconds":
            return void (isUTC ? d.setUTCMilliseconds(value) : d.setMilliseconds(value));
          case "Seconds":
            return void (isUTC ? d.setUTCSeconds(value) : d.setSeconds(value));
          case "Minutes":
            return void (isUTC ? d.setUTCMinutes(value) : d.setMinutes(value));
          case "Hours":
            return void (isUTC ? d.setUTCHours(value) : d.setHours(value));
          case "Date":
            return void (isUTC ? d.setUTCDate(value) : d.setDate(value));
          // case 'Day': // Not real
          //    return void (isUTC ? d.setUTCDay(value) : d.setDay(value));
          // case 'Month': // Not used because we need to pass two variables
          //     return void (isUTC ? d.setUTCMonth(value) : d.setMonth(value));
          case "FullYear":
            break;
          // See below ...
          default:
            return;
        }
        year = value;
        month = mom.month();
        date = mom.date();
        date = date === 29 && month === 1 && !isLeapYear(year) ? 28 : date;
        void (isUTC ? d.setUTCFullYear(year, month, date) : d.setFullYear(year, month, date));
      }
      function stringGet(units) {
        units = normalizeUnits(units);
        if (isFunction(this[units])) {
          return this[units]();
        }
        return this;
      }
      function stringSet(units, value) {
        if (typeof units === "object") {
          units = normalizeObjectUnits(units);
          var prioritized = getPrioritizedUnits(units), i, prioritizedLen = prioritized.length;
          for (i = 0; i < prioritizedLen; i++) {
            this[prioritized[i].unit](units[prioritized[i].unit]);
          }
        } else {
          units = normalizeUnits(units);
          if (isFunction(this[units])) {
            return this[units](value);
          }
        }
        return this;
      }
      function mod(n, x) {
        return (n % x + x) % x;
      }
      var indexOf;
      if (Array.prototype.indexOf) {
        indexOf = Array.prototype.indexOf;
      } else {
        indexOf = function(o) {
          var i;
          for (i = 0; i < this.length; ++i) {
            if (this[i] === o) {
              return i;
            }
          }
          return -1;
        };
      }
      function daysInMonth(year, month) {
        if (isNaN(year) || isNaN(month)) {
          return NaN;
        }
        var modMonth = mod(month, 12);
        year += (month - modMonth) / 12;
        return modMonth === 1 ? isLeapYear(year) ? 29 : 28 : 31 - modMonth % 7 % 2;
      }
      addFormatToken("M", ["MM", 2], "Mo", function() {
        return this.month() + 1;
      });
      addFormatToken("MMM", 0, 0, function(format2) {
        return this.localeData().monthsShort(this, format2);
      });
      addFormatToken("MMMM", 0, 0, function(format2) {
        return this.localeData().months(this, format2);
      });
      addRegexToken("M", match1to2, match1to2NoLeadingZero);
      addRegexToken("MM", match1to2, match2);
      addRegexToken("MMM", function(isStrict, locale2) {
        return locale2.monthsShortRegex(isStrict);
      });
      addRegexToken("MMMM", function(isStrict, locale2) {
        return locale2.monthsRegex(isStrict);
      });
      addParseToken(["M", "MM"], function(input, array) {
        array[MONTH] = toInt(input) - 1;
      });
      addParseToken(["MMM", "MMMM"], function(input, array, config, token2) {
        var month = config._locale.monthsParse(input, token2, config._strict);
        if (month != null) {
          array[MONTH] = month;
        } else {
          getParsingFlags(config).invalidMonth = input;
        }
      });
      var defaultLocaleMonths = "January_February_March_April_May_June_July_August_September_October_November_December".split(
        "_"
      ), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord;
      function localeMonths(m, format2) {
        if (!m) {
          return isArray(this._months) ? this._months : this._months["standalone"];
        }
        return isArray(this._months) ? this._months[m.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format2) ? "format" : "standalone"][m.month()];
      }
      function localeMonthsShort(m, format2) {
        if (!m) {
          return isArray(this._monthsShort) ? this._monthsShort : this._monthsShort["standalone"];
        }
        return isArray(this._monthsShort) ? this._monthsShort[m.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format2) ? "format" : "standalone"][m.month()];
      }
      function handleStrictParse(monthName, format2, strict) {
        var i, ii, mom, llc = monthName.toLocaleLowerCase();
        if (!this._monthsParse) {
          this._monthsParse = [];
          this._longMonthsParse = [];
          this._shortMonthsParse = [];
          for (i = 0; i < 12; ++i) {
            mom = createUTC([2e3, i]);
            this._shortMonthsParse[i] = this.monthsShort(
              mom,
              ""
            ).toLocaleLowerCase();
            this._longMonthsParse[i] = this.months(mom, "").toLocaleLowerCase();
          }
        }
        if (strict) {
          if (format2 === "MMM") {
            ii = indexOf.call(this._shortMonthsParse, llc);
            return ii !== -1 ? ii : null;
          } else {
            ii = indexOf.call(this._longMonthsParse, llc);
            return ii !== -1 ? ii : null;
          }
        } else {
          if (format2 === "MMM") {
            ii = indexOf.call(this._shortMonthsParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._longMonthsParse, llc);
            return ii !== -1 ? ii : null;
          } else {
            ii = indexOf.call(this._longMonthsParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._shortMonthsParse, llc);
            return ii !== -1 ? ii : null;
          }
        }
      }
      function localeMonthsParse(monthName, format2, strict) {
        var i, mom, regex;
        if (this._monthsParseExact) {
          return handleStrictParse.call(this, monthName, format2, strict);
        }
        if (!this._monthsParse) {
          this._monthsParse = [];
          this._longMonthsParse = [];
          this._shortMonthsParse = [];
        }
        for (i = 0; i < 12; i++) {
          mom = createUTC([2e3, i]);
          if (strict && !this._longMonthsParse[i]) {
            this._longMonthsParse[i] = new RegExp(
              "^" + this.months(mom, "").replace(".", "") + "$",
              "i"
            );
            this._shortMonthsParse[i] = new RegExp(
              "^" + this.monthsShort(mom, "").replace(".", "") + "$",
              "i"
            );
          }
          if (!strict && !this._monthsParse[i]) {
            regex = "^" + this.months(mom, "") + "|^" + this.monthsShort(mom, "");
            this._monthsParse[i] = new RegExp(regex.replace(".", ""), "i");
          }
          if (strict && format2 === "MMMM" && this._longMonthsParse[i].test(monthName)) {
            return i;
          } else if (strict && format2 === "MMM" && this._shortMonthsParse[i].test(monthName)) {
            return i;
          } else if (!strict && this._monthsParse[i].test(monthName)) {
            return i;
          }
        }
      }
      function setMonth(mom, value) {
        if (!mom.isValid()) {
          return mom;
        }
        if (typeof value === "string") {
          if (/^\d+$/.test(value)) {
            value = toInt(value);
          } else {
            value = mom.localeData().monthsParse(value);
            if (!isNumber(value)) {
              return mom;
            }
          }
        }
        var month = value, date = mom.date();
        date = date < 29 ? date : Math.min(date, daysInMonth(mom.year(), month));
        void (mom._isUTC ? mom._d.setUTCMonth(month, date) : mom._d.setMonth(month, date));
        return mom;
      }
      function getSetMonth(value) {
        if (value != null) {
          setMonth(this, value);
          hooks.updateOffset(this, true);
          return this;
        } else {
          return get(this, "Month");
        }
      }
      function getDaysInMonth() {
        return daysInMonth(this.year(), this.month());
      }
      function monthsShortRegex(isStrict) {
        if (this._monthsParseExact) {
          if (!hasOwnProp(this, "_monthsRegex")) {
            computeMonthsParse.call(this);
          }
          if (isStrict) {
            return this._monthsShortStrictRegex;
          } else {
            return this._monthsShortRegex;
          }
        } else {
          if (!hasOwnProp(this, "_monthsShortRegex")) {
            this._monthsShortRegex = defaultMonthsShortRegex;
          }
          return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex;
        }
      }
      function monthsRegex(isStrict) {
        if (this._monthsParseExact) {
          if (!hasOwnProp(this, "_monthsRegex")) {
            computeMonthsParse.call(this);
          }
          if (isStrict) {
            return this._monthsStrictRegex;
          } else {
            return this._monthsRegex;
          }
        } else {
          if (!hasOwnProp(this, "_monthsRegex")) {
            this._monthsRegex = defaultMonthsRegex;
          }
          return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex;
        }
      }
      function computeMonthsParse() {
        function cmpLenRev(a, b) {
          return b.length - a.length;
        }
        var shortPieces = [], longPieces = [], mixedPieces = [], i, mom, shortP, longP;
        for (i = 0; i < 12; i++) {
          mom = createUTC([2e3, i]);
          shortP = regexEscape(this.monthsShort(mom, ""));
          longP = regexEscape(this.months(mom, ""));
          shortPieces.push(shortP);
          longPieces.push(longP);
          mixedPieces.push(longP);
          mixedPieces.push(shortP);
        }
        shortPieces.sort(cmpLenRev);
        longPieces.sort(cmpLenRev);
        mixedPieces.sort(cmpLenRev);
        this._monthsRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
        this._monthsShortRegex = this._monthsRegex;
        this._monthsStrictRegex = new RegExp(
          "^(" + longPieces.join("|") + ")",
          "i"
        );
        this._monthsShortStrictRegex = new RegExp(
          "^(" + shortPieces.join("|") + ")",
          "i"
        );
      }
      function createDate(y, m, d, h, M, s, ms) {
        var date;
        if (y < 100 && y >= 0) {
          date = new Date(y + 400, m, d, h, M, s, ms);
          if (isFinite(date.getFullYear())) {
            date.setFullYear(y);
          }
        } else {
          date = new Date(y, m, d, h, M, s, ms);
        }
        return date;
      }
      function createUTCDate(y) {
        var date, args;
        if (y < 100 && y >= 0) {
          args = Array.prototype.slice.call(arguments);
          args[0] = y + 400;
          date = new Date(Date.UTC.apply(null, args));
          if (isFinite(date.getUTCFullYear())) {
            date.setUTCFullYear(y);
          }
        } else {
          date = new Date(Date.UTC.apply(null, arguments));
        }
        return date;
      }
      function firstWeekOffset(year, dow, doy) {
        var fwd = 7 + dow - doy, fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
        return -fwdlw + fwd - 1;
      }
      function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
        var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear;
        if (dayOfYear <= 0) {
          resYear = year - 1;
          resDayOfYear = daysInYear(resYear) + dayOfYear;
        } else if (dayOfYear > daysInYear(year)) {
          resYear = year + 1;
          resDayOfYear = dayOfYear - daysInYear(year);
        } else {
          resYear = year;
          resDayOfYear = dayOfYear;
        }
        return {
          year: resYear,
          dayOfYear: resDayOfYear
        };
      }
      function weekOfYear(mom, dow, doy) {
        var weekOffset = firstWeekOffset(mom.year(), dow, doy), week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, resWeek, resYear;
        if (week < 1) {
          resYear = mom.year() - 1;
          resWeek = week + weeksInYear(resYear, dow, doy);
        } else if (week > weeksInYear(mom.year(), dow, doy)) {
          resWeek = week - weeksInYear(mom.year(), dow, doy);
          resYear = mom.year() + 1;
        } else {
          resYear = mom.year();
          resWeek = week;
        }
        return {
          week: resWeek,
          year: resYear
        };
      }
      function weeksInYear(year, dow, doy) {
        var weekOffset = firstWeekOffset(year, dow, doy), weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
      }
      addFormatToken("w", ["ww", 2], "wo", "week");
      addFormatToken("W", ["WW", 2], "Wo", "isoWeek");
      addRegexToken("w", match1to2, match1to2NoLeadingZero);
      addRegexToken("ww", match1to2, match2);
      addRegexToken("W", match1to2, match1to2NoLeadingZero);
      addRegexToken("WW", match1to2, match2);
      addWeekParseToken(
        ["w", "ww", "W", "WW"],
        function(input, week, config, token2) {
          week[token2.substr(0, 1)] = toInt(input);
        }
      );
      function localeWeek(mom) {
        return weekOfYear(mom, this._week.dow, this._week.doy).week;
      }
      var defaultLocaleWeek = {
        dow: 0,
        // Sunday is the first day of the week.
        doy: 6
        // The week that contains Jan 6th is the first week of the year.
      };
      function localeFirstDayOfWeek() {
        return this._week.dow;
      }
      function localeFirstDayOfYear() {
        return this._week.doy;
      }
      function getSetWeek(input) {
        var week = this.localeData().week(this);
        return input == null ? week : this.add((input - week) * 7, "d");
      }
      function getSetISOWeek(input) {
        var week = weekOfYear(this, 1, 4).week;
        return input == null ? week : this.add((input - week) * 7, "d");
      }
      addFormatToken("d", 0, "do", "day");
      addFormatToken("dd", 0, 0, function(format2) {
        return this.localeData().weekdaysMin(this, format2);
      });
      addFormatToken("ddd", 0, 0, function(format2) {
        return this.localeData().weekdaysShort(this, format2);
      });
      addFormatToken("dddd", 0, 0, function(format2) {
        return this.localeData().weekdays(this, format2);
      });
      addFormatToken("e", 0, 0, "weekday");
      addFormatToken("E", 0, 0, "isoWeekday");
      addRegexToken("d", match1to2);
      addRegexToken("e", match1to2);
      addRegexToken("E", match1to2);
      addRegexToken("dd", function(isStrict, locale2) {
        return locale2.weekdaysMinRegex(isStrict);
      });
      addRegexToken("ddd", function(isStrict, locale2) {
        return locale2.weekdaysShortRegex(isStrict);
      });
      addRegexToken("dddd", function(isStrict, locale2) {
        return locale2.weekdaysRegex(isStrict);
      });
      addWeekParseToken(["dd", "ddd", "dddd"], function(input, week, config, token2) {
        var weekday = config._locale.weekdaysParse(input, token2, config._strict);
        if (weekday != null) {
          week.d = weekday;
        } else {
          getParsingFlags(config).invalidWeekday = input;
        }
      });
      addWeekParseToken(["d", "e", "E"], function(input, week, config, token2) {
        week[token2] = toInt(input);
      });
      function parseWeekday(input, locale2) {
        if (typeof input !== "string") {
          return input;
        }
        if (!isNaN(input)) {
          return parseInt(input, 10);
        }
        input = locale2.weekdaysParse(input);
        if (typeof input === "number") {
          return input;
        }
        return null;
      }
      function parseIsoWeekday(input, locale2) {
        if (typeof input === "string") {
          return locale2.weekdaysParse(input) % 7 || 7;
        }
        return isNaN(input) ? null : input;
      }
      function shiftWeekdays(ws, n) {
        return ws.slice(n, 7).concat(ws.slice(0, n));
      }
      var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord;
      function localeWeekdays(m, format2) {
        var weekdays = isArray(this._weekdays) ? this._weekdays : this._weekdays[m && m !== true && this._weekdays.isFormat.test(format2) ? "format" : "standalone"];
        return m === true ? shiftWeekdays(weekdays, this._week.dow) : m ? weekdays[m.day()] : weekdays;
      }
      function localeWeekdaysShort(m) {
        return m === true ? shiftWeekdays(this._weekdaysShort, this._week.dow) : m ? this._weekdaysShort[m.day()] : this._weekdaysShort;
      }
      function localeWeekdaysMin(m) {
        return m === true ? shiftWeekdays(this._weekdaysMin, this._week.dow) : m ? this._weekdaysMin[m.day()] : this._weekdaysMin;
      }
      function handleStrictParse$1(weekdayName, format2, strict) {
        var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
        if (!this._weekdaysParse) {
          this._weekdaysParse = [];
          this._shortWeekdaysParse = [];
          this._minWeekdaysParse = [];
          for (i = 0; i < 7; ++i) {
            mom = createUTC([2e3, 1]).day(i);
            this._minWeekdaysParse[i] = this.weekdaysMin(
              mom,
              ""
            ).toLocaleLowerCase();
            this._shortWeekdaysParse[i] = this.weekdaysShort(
              mom,
              ""
            ).toLocaleLowerCase();
            this._weekdaysParse[i] = this.weekdays(mom, "").toLocaleLowerCase();
          }
        }
        if (strict) {
          if (format2 === "dddd") {
            ii = indexOf.call(this._weekdaysParse, llc);
            return ii !== -1 ? ii : null;
          } else if (format2 === "ddd") {
            ii = indexOf.call(this._shortWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          } else {
            ii = indexOf.call(this._minWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          }
        } else {
          if (format2 === "dddd") {
            ii = indexOf.call(this._weekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._shortWeekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._minWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          } else if (format2 === "ddd") {
            ii = indexOf.call(this._shortWeekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._weekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._minWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          } else {
            ii = indexOf.call(this._minWeekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._weekdaysParse, llc);
            if (ii !== -1) {
              return ii;
            }
            ii = indexOf.call(this._shortWeekdaysParse, llc);
            return ii !== -1 ? ii : null;
          }
        }
      }
      function localeWeekdaysParse(weekdayName, format2, strict) {
        var i, mom, regex;
        if (this._weekdaysParseExact) {
          return handleStrictParse$1.call(this, weekdayName, format2, strict);
        }
        if (!this._weekdaysParse) {
          this._weekdaysParse = [];
          this._minWeekdaysParse = [];
          this._shortWeekdaysParse = [];
          this._fullWeekdaysParse = [];
        }
        for (i = 0; i < 7; i++) {
          mom = createUTC([2e3, 1]).day(i);
          if (strict && !this._fullWeekdaysParse[i]) {
            this._fullWeekdaysParse[i] = new RegExp(
              "^" + this.weekdays(mom, "").replace(".", "\\.?") + "$",
              "i"
            );
            this._shortWeekdaysParse[i] = new RegExp(
              "^" + this.weekdaysShort(mom, "").replace(".", "\\.?") + "$",
              "i"
            );
            this._minWeekdaysParse[i] = new RegExp(
              "^" + this.weekdaysMin(mom, "").replace(".", "\\.?") + "$",
              "i"
            );
          }
          if (!this._weekdaysParse[i]) {
            regex = "^" + this.weekdays(mom, "") + "|^" + this.weekdaysShort(mom, "") + "|^" + this.weekdaysMin(mom, "");
            this._weekdaysParse[i] = new RegExp(regex.replace(".", ""), "i");
          }
          if (strict && format2 === "dddd" && this._fullWeekdaysParse[i].test(weekdayName)) {
            return i;
          } else if (strict && format2 === "ddd" && this._shortWeekdaysParse[i].test(weekdayName)) {
            return i;
          } else if (strict && format2 === "dd" && this._minWeekdaysParse[i].test(weekdayName)) {
            return i;
          } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
            return i;
          }
        }
      }
      function getSetDayOfWeek(input) {
        if (!this.isValid()) {
          return input != null ? this : NaN;
        }
        var day = get(this, "Day");
        if (input != null) {
          input = parseWeekday(input, this.localeData());
          return this.add(input - day, "d");
        } else {
          return day;
        }
      }
      function getSetLocaleDayOfWeek(input) {
        if (!this.isValid()) {
          return input != null ? this : NaN;
        }
        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
        return input == null ? weekday : this.add(input - weekday, "d");
      }
      function getSetISODayOfWeek(input) {
        if (!this.isValid()) {
          return input != null ? this : NaN;
        }
        if (input != null) {
          var weekday = parseIsoWeekday(input, this.localeData());
          return this.day(this.day() % 7 ? weekday : weekday - 7);
        } else {
          return this.day() || 7;
        }
      }
      function weekdaysRegex(isStrict) {
        if (this._weekdaysParseExact) {
          if (!hasOwnProp(this, "_weekdaysRegex")) {
            computeWeekdaysParse.call(this);
          }
          if (isStrict) {
            return this._weekdaysStrictRegex;
          } else {
            return this._weekdaysRegex;
          }
        } else {
          if (!hasOwnProp(this, "_weekdaysRegex")) {
            this._weekdaysRegex = defaultWeekdaysRegex;
          }
          return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex;
        }
      }
      function weekdaysShortRegex(isStrict) {
        if (this._weekdaysParseExact) {
          if (!hasOwnProp(this, "_weekdaysRegex")) {
            computeWeekdaysParse.call(this);
          }
          if (isStrict) {
            return this._weekdaysShortStrictRegex;
          } else {
            return this._weekdaysShortRegex;
          }
        } else {
          if (!hasOwnProp(this, "_weekdaysShortRegex")) {
            this._weekdaysShortRegex = defaultWeekdaysShortRegex;
          }
          return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
        }
      }
      function weekdaysMinRegex(isStrict) {
        if (this._weekdaysParseExact) {
          if (!hasOwnProp(this, "_weekdaysRegex")) {
            computeWeekdaysParse.call(this);
          }
          if (isStrict) {
            return this._weekdaysMinStrictRegex;
          } else {
            return this._weekdaysMinRegex;
          }
        } else {
          if (!hasOwnProp(this, "_weekdaysMinRegex")) {
            this._weekdaysMinRegex = defaultWeekdaysMinRegex;
          }
          return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
        }
      }
      function computeWeekdaysParse() {
        function cmpLenRev(a, b) {
          return b.length - a.length;
        }
        var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], i, mom, minp, shortp, longp;
        for (i = 0; i < 7; i++) {
          mom = createUTC([2e3, 1]).day(i);
          minp = regexEscape(this.weekdaysMin(mom, ""));
          shortp = regexEscape(this.weekdaysShort(mom, ""));
          longp = regexEscape(this.weekdays(mom, ""));
          minPieces.push(minp);
          shortPieces.push(shortp);
          longPieces.push(longp);
          mixedPieces.push(minp);
          mixedPieces.push(shortp);
          mixedPieces.push(longp);
        }
        minPieces.sort(cmpLenRev);
        shortPieces.sort(cmpLenRev);
        longPieces.sort(cmpLenRev);
        mixedPieces.sort(cmpLenRev);
        this._weekdaysRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
        this._weekdaysShortRegex = this._weekdaysRegex;
        this._weekdaysMinRegex = this._weekdaysRegex;
        this._weekdaysStrictRegex = new RegExp(
          "^(" + longPieces.join("|") + ")",
          "i"
        );
        this._weekdaysShortStrictRegex = new RegExp(
          "^(" + shortPieces.join("|") + ")",
          "i"
        );
        this._weekdaysMinStrictRegex = new RegExp(
          "^(" + minPieces.join("|") + ")",
          "i"
        );
      }
      function hFormat() {
        return this.hours() % 12 || 12;
      }
      function kFormat() {
        return this.hours() || 24;
      }
      addFormatToken("H", ["HH", 2], 0, "hour");
      addFormatToken("h", ["hh", 2], 0, hFormat);
      addFormatToken("k", ["kk", 2], 0, kFormat);
      addFormatToken("hmm", 0, 0, function() {
        return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2);
      });
      addFormatToken("hmmss", 0, 0, function() {
        return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
      });
      addFormatToken("Hmm", 0, 0, function() {
        return "" + this.hours() + zeroFill(this.minutes(), 2);
      });
      addFormatToken("Hmmss", 0, 0, function() {
        return "" + this.hours() + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);
      });
      function meridiem(token2, lowercase) {
        addFormatToken(token2, 0, 0, function() {
          return this.localeData().meridiem(
            this.hours(),
            this.minutes(),
            lowercase
          );
        });
      }
      meridiem("a", true);
      meridiem("A", false);
      function matchMeridiem(isStrict, locale2) {
        return locale2._meridiemParse;
      }
      addRegexToken("a", matchMeridiem);
      addRegexToken("A", matchMeridiem);
      addRegexToken("H", match1to2, match1to2HasZero);
      addRegexToken("h", match1to2, match1to2NoLeadingZero);
      addRegexToken("k", match1to2, match1to2NoLeadingZero);
      addRegexToken("HH", match1to2, match2);
      addRegexToken("hh", match1to2, match2);
      addRegexToken("kk", match1to2, match2);
      addRegexToken("hmm", match3to4);
      addRegexToken("hmmss", match5to6);
      addRegexToken("Hmm", match3to4);
      addRegexToken("Hmmss", match5to6);
      addParseToken(["H", "HH"], HOUR);
      addParseToken(["k", "kk"], function(input, array, config) {
        var kInput = toInt(input);
        array[HOUR] = kInput === 24 ? 0 : kInput;
      });
      addParseToken(["a", "A"], function(input, array, config) {
        config._isPm = config._locale.isPM(input);
        config._meridiem = input;
      });
      addParseToken(["h", "hh"], function(input, array, config) {
        array[HOUR] = toInt(input);
        getParsingFlags(config).bigHour = true;
      });
      addParseToken("hmm", function(input, array, config) {
        var pos = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos));
        array[MINUTE] = toInt(input.substr(pos));
        getParsingFlags(config).bigHour = true;
      });
      addParseToken("hmmss", function(input, array, config) {
        var pos1 = input.length - 4, pos2 = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos1));
        array[MINUTE] = toInt(input.substr(pos1, 2));
        array[SECOND] = toInt(input.substr(pos2));
        getParsingFlags(config).bigHour = true;
      });
      addParseToken("Hmm", function(input, array, config) {
        var pos = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos));
        array[MINUTE] = toInt(input.substr(pos));
      });
      addParseToken("Hmmss", function(input, array, config) {
        var pos1 = input.length - 4, pos2 = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos1));
        array[MINUTE] = toInt(input.substr(pos1, 2));
        array[SECOND] = toInt(input.substr(pos2));
      });
      function localeIsPM(input) {
        return (input + "").toLowerCase().charAt(0) === "p";
      }
      var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i, getSetHour = makeGetSet("Hours", true);
      function localeMeridiem(hours2, minutes2, isLower) {
        if (hours2 > 11) {
          return isLower ? "pm" : "PM";
        } else {
          return isLower ? "am" : "AM";
        }
      }
      var baseConfig = {
        calendar: defaultCalendar,
        longDateFormat: defaultLongDateFormat,
        invalidDate: defaultInvalidDate,
        ordinal: defaultOrdinal,
        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
        relativeTime: defaultRelativeTime,
        months: defaultLocaleMonths,
        monthsShort: defaultLocaleMonthsShort,
        week: defaultLocaleWeek,
        weekdays: defaultLocaleWeekdays,
        weekdaysMin: defaultLocaleWeekdaysMin,
        weekdaysShort: defaultLocaleWeekdaysShort,
        meridiemParse: defaultLocaleMeridiemParse
      };
      var locales = {}, localeFamilies = {}, globalLocale;
      function commonPrefix(arr1, arr2) {
        var i, minl = Math.min(arr1.length, arr2.length);
        for (i = 0; i < minl; i += 1) {
          if (arr1[i] !== arr2[i]) {
            return i;
          }
        }
        return minl;
      }
      function normalizeLocale(key) {
        return key ? key.toLowerCase().replace("_", "-") : key;
      }
      function chooseLocale(names) {
        var i = 0, j, next, locale2, split;
        while (i < names.length) {
          split = normalizeLocale(names[i]).split("-");
          j = split.length;
          next = normalizeLocale(names[i + 1]);
          next = next ? next.split("-") : null;
          while (j > 0) {
            locale2 = loadLocale(split.slice(0, j).join("-"));
            if (locale2) {
              return locale2;
            }
            if (next && next.length >= j && commonPrefix(split, next) >= j - 1) {
              break;
            }
            j--;
          }
          i++;
        }
        return globalLocale;
      }
      function isLocaleNameSane(name) {
        return !!(name && name.match("^[^/\\\\]*$"));
      }
      function loadLocale(name) {
        var oldLocale = null, aliasedRequire;
        if (locales[name] === void 0 && typeof module2 !== "undefined" && module2 && module2.exports && isLocaleNameSane(name)) {
          try {
            oldLocale = globalLocale._abbr;
            aliasedRequire = require;
            aliasedRequire("./locale/" + name);
            getSetGlobalLocale(oldLocale);
          } catch (e) {
            locales[name] = null;
          }
        }
        return locales[name];
      }
      function getSetGlobalLocale(key, values) {
        var data;
        if (key) {
          if (isUndefined(values)) {
            data = getLocale(key);
          } else {
            data = defineLocale(key, values);
          }
          if (data) {
            globalLocale = data;
          } else {
            if (typeof console !== "undefined" && console.warn) {
              console.warn(
                "Locale " + key + " not found. Did you forget to load it?"
              );
            }
          }
        }
        return globalLocale._abbr;
      }
      function defineLocale(name, config) {
        if (config !== null) {
          var locale2, parentConfig = baseConfig;
          config.abbr = name;
          if (locales[name] != null) {
            deprecateSimple(
              "defineLocaleOverride",
              "use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."
            );
            parentConfig = locales[name]._config;
          } else if (config.parentLocale != null) {
            if (locales[config.parentLocale] != null) {
              parentConfig = locales[config.parentLocale]._config;
            } else {
              locale2 = loadLocale(config.parentLocale);
              if (locale2 != null) {
                parentConfig = locale2._config;
              } else {
                if (!localeFamilies[config.parentLocale]) {
                  localeFamilies[config.parentLocale] = [];
                }
                localeFamilies[config.parentLocale].push({
                  name,
                  config
                });
                return null;
              }
            }
          }
          locales[name] = new Locale(mergeConfigs(parentConfig, config));
          if (localeFamilies[name]) {
            localeFamilies[name].forEach(function(x) {
              defineLocale(x.name, x.config);
            });
          }
          getSetGlobalLocale(name);
          return locales[name];
        } else {
          delete locales[name];
          return null;
        }
      }
      function updateLocale(name, config) {
        if (config != null) {
          var locale2, tmpLocale, parentConfig = baseConfig;
          if (locales[name] != null && locales[name].parentLocale != null) {
            locales[name].set(mergeConfigs(locales[name]._config, config));
          } else {
            tmpLocale = loadLocale(name);
            if (tmpLocale != null) {
              parentConfig = tmpLocale._config;
            }
            config = mergeConfigs(parentConfig, config);
            if (tmpLocale == null) {
              config.abbr = name;
            }
            locale2 = new Locale(config);
            locale2.parentLocale = locales[name];
            locales[name] = locale2;
          }
          getSetGlobalLocale(name);
        } else {
          if (locales[name] != null) {
            if (locales[name].parentLocale != null) {
              locales[name] = locales[name].parentLocale;
              if (name === getSetGlobalLocale()) {
                getSetGlobalLocale(name);
              }
            } else if (locales[name] != null) {
              delete locales[name];
            }
          }
        }
        return locales[name];
      }
      function getLocale(key) {
        var locale2;
        if (key && key._locale && key._locale._abbr) {
          key = key._locale._abbr;
        }
        if (!key) {
          return globalLocale;
        }
        if (!isArray(key)) {
          locale2 = loadLocale(key);
          if (locale2) {
            return locale2;
          }
          key = [key];
        }
        return chooseLocale(key);
      }
      function listLocales() {
        return keys(locales);
      }
      function checkOverflow(m) {
        var overflow, a = m._a;
        if (a && getParsingFlags(m).overflow === -2) {
          overflow = a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : a[HOUR] < 0 || a[HOUR] > 24 || a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0) ? HOUR : a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : -1;
          if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
            overflow = DATE;
          }
          if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
            overflow = WEEK;
          }
          if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
            overflow = WEEKDAY;
          }
          getParsingFlags(m).overflow = overflow;
        }
        return m;
      }
      var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, tzRegex = /Z|[+-]\d\d(?::?\d\d)?/, isoDates = [
        ["YYYYYY-MM-DD", /[+-]\d{6}-\d\d-\d\d/],
        ["YYYY-MM-DD", /\d{4}-\d\d-\d\d/],
        ["GGGG-[W]WW-E", /\d{4}-W\d\d-\d/],
        ["GGGG-[W]WW", /\d{4}-W\d\d/, false],
        ["YYYY-DDD", /\d{4}-\d{3}/],
        ["YYYY-MM", /\d{4}-\d\d/, false],
        ["YYYYYYMMDD", /[+-]\d{10}/],
        ["YYYYMMDD", /\d{8}/],
        ["GGGG[W]WWE", /\d{4}W\d{3}/],
        ["GGGG[W]WW", /\d{4}W\d{2}/, false],
        ["YYYYDDD", /\d{7}/],
        ["YYYYMM", /\d{6}/, false],
        ["YYYY", /\d{4}/, false]
      ], isoTimes = [
        ["HH:mm:ss.SSSS", /\d\d:\d\d:\d\d\.\d+/],
        ["HH:mm:ss,SSSS", /\d\d:\d\d:\d\d,\d+/],
        ["HH:mm:ss", /\d\d:\d\d:\d\d/],
        ["HH:mm", /\d\d:\d\d/],
        ["HHmmss.SSSS", /\d\d\d\d\d\d\.\d+/],
        ["HHmmss,SSSS", /\d\d\d\d\d\d,\d+/],
        ["HHmmss", /\d\d\d\d\d\d/],
        ["HHmm", /\d\d\d\d/],
        ["HH", /\d\d/]
      ], aspNetJsonRegex = /^\/?Date\((-?\d+)/i, rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/, obsOffsets = {
        UT: 0,
        GMT: 0,
        EDT: -4 * 60,
        EST: -5 * 60,
        CDT: -5 * 60,
        CST: -6 * 60,
        MDT: -6 * 60,
        MST: -7 * 60,
        PDT: -7 * 60,
        PST: -8 * 60
      };
      function configFromISO(config) {
        var i, l, string = config._i, match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), allowTime, dateFormat, timeFormat, tzFormat, isoDatesLen = isoDates.length, isoTimesLen = isoTimes.length;
        if (match) {
          getParsingFlags(config).iso = true;
          for (i = 0, l = isoDatesLen; i < l; i++) {
            if (isoDates[i][1].exec(match[1])) {
              dateFormat = isoDates[i][0];
              allowTime = isoDates[i][2] !== false;
              break;
            }
          }
          if (dateFormat == null) {
            config._isValid = false;
            return;
          }
          if (match[3]) {
            for (i = 0, l = isoTimesLen; i < l; i++) {
              if (isoTimes[i][1].exec(match[3])) {
                timeFormat = (match[2] || " ") + isoTimes[i][0];
                break;
              }
            }
            if (timeFormat == null) {
              config._isValid = false;
              return;
            }
          }
          if (!allowTime && timeFormat != null) {
            config._isValid = false;
            return;
          }
          if (match[4]) {
            if (tzRegex.exec(match[4])) {
              tzFormat = "Z";
            } else {
              config._isValid = false;
              return;
            }
          }
          config._f = dateFormat + (timeFormat || "") + (tzFormat || "");
          configFromStringAndFormat(config);
        } else {
          config._isValid = false;
        }
      }
      function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
        var result = [
          untruncateYear(yearStr),
          defaultLocaleMonthsShort.indexOf(monthStr),
          parseInt(dayStr, 10),
          parseInt(hourStr, 10),
          parseInt(minuteStr, 10)
        ];
        if (secondStr) {
          result.push(parseInt(secondStr, 10));
        }
        return result;
      }
      function untruncateYear(yearStr) {
        var year = parseInt(yearStr, 10);
        if (year <= 49) {
          return 2e3 + year;
        } else if (year <= 999) {
          return 1900 + year;
        }
        return year;
      }
      function preprocessRFC2822(s) {
        return s.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").replace(/^\s\s*/, "").replace(/\s\s*$/, "");
      }
      function checkWeekday(weekdayStr, parsedInput, config) {
        if (weekdayStr) {
          var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), weekdayActual = new Date(
            parsedInput[0],
            parsedInput[1],
            parsedInput[2]
          ).getDay();
          if (weekdayProvided !== weekdayActual) {
            getParsingFlags(config).weekdayMismatch = true;
            config._isValid = false;
            return false;
          }
        }
        return true;
      }
      function calculateOffset(obsOffset, militaryOffset, numOffset) {
        if (obsOffset) {
          return obsOffsets[obsOffset];
        } else if (militaryOffset) {
          return 0;
        } else {
          var hm = parseInt(numOffset, 10), m = hm % 100, h = (hm - m) / 100;
          return h * 60 + m;
        }
      }
      function configFromRFC2822(config) {
        var match = rfc2822.exec(preprocessRFC2822(config._i)), parsedArray;
        if (match) {
          parsedArray = extractFromRFC2822Strings(
            match[4],
            match[3],
            match[2],
            match[5],
            match[6],
            match[7]
          );
          if (!checkWeekday(match[1], parsedArray, config)) {
            return;
          }
          config._a = parsedArray;
          config._tzm = calculateOffset(match[8], match[9], match[10]);
          config._d = createUTCDate.apply(null, config._a);
          config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
          getParsingFlags(config).rfc2822 = true;
        } else {
          config._isValid = false;
        }
      }
      function configFromString(config) {
        var matched = aspNetJsonRegex.exec(config._i);
        if (matched !== null) {
          config._d = /* @__PURE__ */ new Date(+matched[1]);
          return;
        }
        configFromISO(config);
        if (config._isValid === false) {
          delete config._isValid;
        } else {
          return;
        }
        configFromRFC2822(config);
        if (config._isValid === false) {
          delete config._isValid;
        } else {
          return;
        }
        if (config._strict) {
          config._isValid = false;
        } else {
          hooks.createFromInputFallback(config);
        }
      }
      hooks.createFromInputFallback = deprecate(
        "value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",
        function(config) {
          config._d = /* @__PURE__ */ new Date(config._i + (config._useUTC ? " UTC" : ""));
        }
      );
      function defaults(a, b, c) {
        if (a != null) {
          return a;
        }
        if (b != null) {
          return b;
        }
        return c;
      }
      function currentDateArray(config) {
        var nowValue = new Date(hooks.now());
        if (config._useUTC) {
          return [
            nowValue.getUTCFullYear(),
            nowValue.getUTCMonth(),
            nowValue.getUTCDate()
          ];
        }
        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
      }
      function configFromArray(config) {
        var i, date, input = [], currentDate, expectedWeekday, yearToUse;
        if (config._d) {
          return;
        }
        currentDate = currentDateArray(config);
        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
          dayOfYearFromWeekInfo(config);
        }
        if (config._dayOfYear != null) {
          yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
          if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
            getParsingFlags(config)._overflowDayOfYear = true;
          }
          date = createUTCDate(yearToUse, 0, config._dayOfYear);
          config._a[MONTH] = date.getUTCMonth();
          config._a[DATE] = date.getUTCDate();
        }
        for (i = 0; i < 3 && config._a[i] == null; ++i) {
          config._a[i] = input[i] = currentDate[i];
        }
        for (; i < 7; i++) {
          config._a[i] = input[i] = config._a[i] == null ? i === 2 ? 1 : 0 : config._a[i];
        }
        if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) {
          config._nextDay = true;
          config._a[HOUR] = 0;
        }
        config._d = (config._useUTC ? createUTCDate : createDate).apply(
          null,
          input
        );
        expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
        if (config._tzm != null) {
          config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
        }
        if (config._nextDay) {
          config._a[HOUR] = 24;
        }
        if (config._w && typeof config._w.d !== "undefined" && config._w.d !== expectedWeekday) {
          getParsingFlags(config).weekdayMismatch = true;
        }
      }
      function dayOfYearFromWeekInfo(config) {
        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
        w = config._w;
        if (w.GG != null || w.W != null || w.E != null) {
          dow = 1;
          doy = 4;
          weekYear = defaults(
            w.GG,
            config._a[YEAR],
            weekOfYear(createLocal(), 1, 4).year
          );
          week = defaults(w.W, 1);
          weekday = defaults(w.E, 1);
          if (weekday < 1 || weekday > 7) {
            weekdayOverflow = true;
          }
        } else {
          dow = config._locale._week.dow;
          doy = config._locale._week.doy;
          curWeek = weekOfYear(createLocal(), dow, doy);
          weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
          week = defaults(w.w, curWeek.week);
          if (w.d != null) {
            weekday = w.d;
            if (weekday < 0 || weekday > 6) {
              weekdayOverflow = true;
            }
          } else if (w.e != null) {
            weekday = w.e + dow;
            if (w.e < 0 || w.e > 6) {
              weekdayOverflow = true;
            }
          } else {
            weekday = dow;
          }
        }
        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
          getParsingFlags(config)._overflowWeeks = true;
        } else if (weekdayOverflow != null) {
          getParsingFlags(config)._overflowWeekday = true;
        } else {
          temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
          config._a[YEAR] = temp.year;
          config._dayOfYear = temp.dayOfYear;
        }
      }
      hooks.ISO_8601 = function() {
      };
      hooks.RFC_2822 = function() {
      };
      function configFromStringAndFormat(config) {
        if (config._f === hooks.ISO_8601) {
          configFromISO(config);
          return;
        }
        if (config._f === hooks.RFC_2822) {
          configFromRFC2822(config);
          return;
        }
        config._a = [];
        getParsingFlags(config).empty = true;
        var string = "" + config._i, i, parsedInput, tokens2, token2, skipped, stringLength = string.length, totalParsedInputLength = 0, era, tokenLen;
        tokens2 = expandFormat(config._f, config._locale).match(formattingTokens) || [];
        tokenLen = tokens2.length;
        for (i = 0; i < tokenLen; i++) {
          token2 = tokens2[i];
          parsedInput = (string.match(getParseRegexForToken(token2, config)) || [])[0];
          if (parsedInput) {
            skipped = string.substr(0, string.indexOf(parsedInput));
            if (skipped.length > 0) {
              getParsingFlags(config).unusedInput.push(skipped);
            }
            string = string.slice(
              string.indexOf(parsedInput) + parsedInput.length
            );
            totalParsedInputLength += parsedInput.length;
          }
          if (formatTokenFunctions[token2]) {
            if (parsedInput) {
              getParsingFlags(config).empty = false;
            } else {
              getParsingFlags(config).unusedTokens.push(token2);
            }
            addTimeToArrayFromToken(token2, parsedInput, config);
          } else if (config._strict && !parsedInput) {
            getParsingFlags(config).unusedTokens.push(token2);
          }
        }
        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
        if (string.length > 0) {
          getParsingFlags(config).unusedInput.push(string);
        }
        if (config._a[HOUR] <= 12 && getParsingFlags(config).bigHour === true && config._a[HOUR] > 0) {
          getParsingFlags(config).bigHour = void 0;
        }
        getParsingFlags(config).parsedDateParts = config._a.slice(0);
        getParsingFlags(config).meridiem = config._meridiem;
        config._a[HOUR] = meridiemFixWrap(
          config._locale,
          config._a[HOUR],
          config._meridiem
        );
        era = getParsingFlags(config).era;
        if (era !== null) {
          config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
        }
        configFromArray(config);
        checkOverflow(config);
      }
      function meridiemFixWrap(locale2, hour, meridiem2) {
        var isPm;
        if (meridiem2 == null) {
          return hour;
        }
        if (locale2.meridiemHour != null) {
          return locale2.meridiemHour(hour, meridiem2);
        } else if (locale2.isPM != null) {
          isPm = locale2.isPM(meridiem2);
          if (isPm && hour < 12) {
            hour += 12;
          }
          if (!isPm && hour === 12) {
            hour = 0;
          }
          return hour;
        } else {
          return hour;
        }
      }
      function configFromStringAndArray(config) {
        var tempConfig, bestMoment, scoreToBeat, i, currentScore, validFormatFound, bestFormatIsValid = false, configfLen = config._f.length;
        if (configfLen === 0) {
          getParsingFlags(config).invalidFormat = true;
          config._d = /* @__PURE__ */ new Date(NaN);
          return;
        }
        for (i = 0; i < configfLen; i++) {
          currentScore = 0;
          validFormatFound = false;
          tempConfig = copyConfig({}, config);
          if (config._useUTC != null) {
            tempConfig._useUTC = config._useUTC;
          }
          tempConfig._f = config._f[i];
          configFromStringAndFormat(tempConfig);
          if (isValid(tempConfig)) {
            validFormatFound = true;
          }
          currentScore += getParsingFlags(tempConfig).charsLeftOver;
          currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
          getParsingFlags(tempConfig).score = currentScore;
          if (!bestFormatIsValid) {
            if (scoreToBeat == null || currentScore < scoreToBeat || validFormatFound) {
              scoreToBeat = currentScore;
              bestMoment = tempConfig;
              if (validFormatFound) {
                bestFormatIsValid = true;
              }
            }
          } else {
            if (currentScore < scoreToBeat) {
              scoreToBeat = currentScore;
              bestMoment = tempConfig;
            }
          }
        }
        extend2(config, bestMoment || tempConfig);
      }
      function configFromObject(config) {
        if (config._d) {
          return;
        }
        var i = normalizeObjectUnits(config._i), dayOrDate = i.day === void 0 ? i.date : i.day;
        config._a = map(
          [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],
          function(obj) {
            return obj && parseInt(obj, 10);
          }
        );
        configFromArray(config);
      }
      function createFromConfig(config) {
        var res = new Moment(checkOverflow(prepareConfig(config)));
        if (res._nextDay) {
          res.add(1, "d");
          res._nextDay = void 0;
        }
        return res;
      }
      function prepareConfig(config) {
        var input = config._i, format2 = config._f;
        config._locale = config._locale || getLocale(config._l);
        if (input === null || format2 === void 0 && input === "") {
          return createInvalid({ nullInput: true });
        }
        if (typeof input === "string") {
          config._i = input = config._locale.preparse(input);
        }
        if (isMoment(input)) {
          return new Moment(checkOverflow(input));
        } else if (isDate(input)) {
          config._d = input;
        } else if (isArray(format2)) {
          configFromStringAndArray(config);
        } else if (format2) {
          configFromStringAndFormat(config);
        } else {
          configFromInput(config);
        }
        if (!isValid(config)) {
          config._d = null;
        }
        return config;
      }
      function configFromInput(config) {
        var input = config._i;
        if (isUndefined(input)) {
          config._d = new Date(hooks.now());
        } else if (isDate(input)) {
          config._d = new Date(input.valueOf());
        } else if (typeof input === "string") {
          configFromString(config);
        } else if (isArray(input)) {
          config._a = map(input.slice(0), function(obj) {
            return parseInt(obj, 10);
          });
          configFromArray(config);
        } else if (isObject(input)) {
          configFromObject(config);
        } else if (isNumber(input)) {
          config._d = new Date(input);
        } else {
          hooks.createFromInputFallback(config);
        }
      }
      function createLocalOrUTC(input, format2, locale2, strict, isUTC) {
        var c = {};
        if (format2 === true || format2 === false) {
          strict = format2;
          format2 = void 0;
        }
        if (locale2 === true || locale2 === false) {
          strict = locale2;
          locale2 = void 0;
        }
        if (isObject(input) && isObjectEmpty(input) || isArray(input) && input.length === 0) {
          input = void 0;
        }
        c._isAMomentObject = true;
        c._useUTC = c._isUTC = isUTC;
        c._l = locale2;
        c._i = input;
        c._f = format2;
        c._strict = strict;
        return createFromConfig(c);
      }
      function createLocal(input, format2, locale2, strict) {
        return createLocalOrUTC(input, format2, locale2, strict, false);
      }
      var prototypeMin = deprecate(
        "moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",
        function() {
          var other = createLocal.apply(null, arguments);
          if (this.isValid() && other.isValid()) {
            return other < this ? this : other;
          } else {
            return createInvalid();
          }
        }
      ), prototypeMax = deprecate(
        "moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",
        function() {
          var other = createLocal.apply(null, arguments);
          if (this.isValid() && other.isValid()) {
            return other > this ? this : other;
          } else {
            return createInvalid();
          }
        }
      );
      function pickBy(fn, moments) {
        var res, i;
        if (moments.length === 1 && isArray(moments[0])) {
          moments = moments[0];
        }
        if (!moments.length) {
          return createLocal();
        }
        res = moments[0];
        for (i = 1; i < moments.length; ++i) {
          if (!moments[i].isValid() || moments[i][fn](res)) {
            res = moments[i];
          }
        }
        return res;
      }
      function min() {
        var args = [].slice.call(arguments, 0);
        return pickBy("isBefore", args);
      }
      function max() {
        var args = [].slice.call(arguments, 0);
        return pickBy("isAfter", args);
      }
      var now = function() {
        return Date.now ? Date.now() : +/* @__PURE__ */ new Date();
      };
      var ordering = [
        "year",
        "quarter",
        "month",
        "week",
        "day",
        "hour",
        "minute",
        "second",
        "millisecond"
      ];
      function isDurationValid(m) {
        var key, unitHasDecimal = false, i, orderLen = ordering.length;
        for (key in m) {
          if (hasOwnProp(m, key) && !(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
            return false;
          }
        }
        for (i = 0; i < orderLen; ++i) {
          if (m[ordering[i]]) {
            if (unitHasDecimal) {
              return false;
            }
            if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
              unitHasDecimal = true;
            }
          }
        }
        return true;
      }
      function isValid$1() {
        return this._isValid;
      }
      function createInvalid$1() {
        return createDuration(NaN);
      }
      function Duration(duration) {
        var normalizedInput = normalizeObjectUnits(duration), years2 = normalizedInput.year || 0, quarters = normalizedInput.quarter || 0, months2 = normalizedInput.month || 0, weeks2 = normalizedInput.week || normalizedInput.isoWeek || 0, days2 = normalizedInput.day || 0, hours2 = normalizedInput.hour || 0, minutes2 = normalizedInput.minute || 0, seconds2 = normalizedInput.second || 0, milliseconds2 = normalizedInput.millisecond || 0;
        this._isValid = isDurationValid(normalizedInput);
        this._milliseconds = +milliseconds2 + seconds2 * 1e3 + // 1000
        minutes2 * 6e4 + // 1000 * 60
        hours2 * 1e3 * 60 * 60;
        this._days = +days2 + weeks2 * 7;
        this._months = +months2 + quarters * 3 + years2 * 12;
        this._data = {};
        this._locale = getLocale();
        this._bubble();
      }
      function isDuration(obj) {
        return obj instanceof Duration;
      }
      function absRound(number) {
        if (number < 0) {
          return Math.round(-1 * number) * -1;
        } else {
          return Math.round(number);
        }
      }
      function compareArrays(array1, array2, dontConvert) {
        var len = Math.min(array1.length, array2.length), lengthDiff = Math.abs(array1.length - array2.length), diffs = 0, i;
        for (i = 0; i < len; i++) {
          if (dontConvert && array1[i] !== array2[i] || !dontConvert && toInt(array1[i]) !== toInt(array2[i])) {
            diffs++;
          }
        }
        return diffs + lengthDiff;
      }
      function offset(token2, separator) {
        addFormatToken(token2, 0, 0, function() {
          var offset2 = this.utcOffset(), sign2 = "+";
          if (offset2 < 0) {
            offset2 = -offset2;
            sign2 = "-";
          }
          return sign2 + zeroFill(~~(offset2 / 60), 2) + separator + zeroFill(~~offset2 % 60, 2);
        });
      }
      offset("Z", ":");
      offset("ZZ", "");
      addRegexToken("Z", matchShortOffset);
      addRegexToken("ZZ", matchShortOffset);
      addParseToken(["Z", "ZZ"], function(input, array, config) {
        config._useUTC = true;
        config._tzm = offsetFromString(matchShortOffset, input);
      });
      var chunkOffset = /([\+\-]|\d\d)/gi;
      function offsetFromString(matcher, string) {
        var matches = (string || "").match(matcher), chunk, parts, minutes2;
        if (matches === null) {
          return null;
        }
        chunk = matches[matches.length - 1] || [];
        parts = (chunk + "").match(chunkOffset) || ["-", 0, 0];
        minutes2 = +(parts[1] * 60) + toInt(parts[2]);
        return minutes2 === 0 ? 0 : parts[0] === "+" ? minutes2 : -minutes2;
      }
      function cloneWithOffset(input, model) {
        var res, diff2;
        if (model._isUTC) {
          res = model.clone();
          diff2 = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
          res._d.setTime(res._d.valueOf() + diff2);
          hooks.updateOffset(res, false);
          return res;
        } else {
          return createLocal(input).local();
        }
      }
      function getDateOffset(m) {
        return -Math.round(m._d.getTimezoneOffset());
      }
      hooks.updateOffset = function() {
      };
      function getSetOffset(input, keepLocalTime, keepMinutes) {
        var offset2 = this._offset || 0, localAdjust;
        if (!this.isValid()) {
          return input != null ? this : NaN;
        }
        if (input != null) {
          if (typeof input === "string") {
            input = offsetFromString(matchShortOffset, input);
            if (input === null) {
              return this;
            }
          } else if (Math.abs(input) < 16 && !keepMinutes) {
            input = input * 60;
          }
          if (!this._isUTC && keepLocalTime) {
            localAdjust = getDateOffset(this);
          }
          this._offset = input;
          this._isUTC = true;
          if (localAdjust != null) {
            this.add(localAdjust, "m");
          }
          if (offset2 !== input) {
            if (!keepLocalTime || this._changeInProgress) {
              addSubtract(
                this,
                createDuration(input - offset2, "m"),
                1,
                false
              );
            } else if (!this._changeInProgress) {
              this._changeInProgress = true;
              hooks.updateOffset(this, true);
              this._changeInProgress = null;
            }
          }
          return this;
        } else {
          return this._isUTC ? offset2 : getDateOffset(this);
        }
      }
      function getSetZone(input, keepLocalTime) {
        if (input != null) {
          if (typeof input !== "string") {
            input = -input;
          }
          this.utcOffset(input, keepLocalTime);
          return this;
        } else {
          return -this.utcOffset();
        }
      }
      function setOffsetToUTC(keepLocalTime) {
        return this.utcOffset(0, keepLocalTime);
      }
      function setOffsetToLocal(keepLocalTime) {
        if (this._isUTC) {
          this.utcOffset(0, keepLocalTime);
          this._isUTC = false;
          if (keepLocalTime) {
            this.subtract(getDateOffset(this), "m");
          }
        }
        return this;
      }
      function setOffsetToParsedOffset() {
        if (this._tzm != null) {
          this.utcOffset(this._tzm, false, true);
        } else if (typeof this._i === "string") {
          var tZone = offsetFromString(matchOffset, this._i);
          if (tZone != null) {
            this.utcOffset(tZone);
          } else {
            this.utcOffset(0, true);
          }
        }
        return this;
      }
      function hasAlignedHourOffset(input) {
        if (!this.isValid()) {
          return false;
        }
        input = input ? createLocal(input).utcOffset() : 0;
        return (this.utcOffset() - input) % 60 === 0;
      }
      function isDaylightSavingTime() {
        return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset();
      }
      function isDaylightSavingTimeShifted() {
        if (!isUndefined(this._isDSTShifted)) {
          return this._isDSTShifted;
        }
        var c = {}, other;
        copyConfig(c, this);
        c = prepareConfig(c);
        if (c._a) {
          other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
          this._isDSTShifted = this.isValid() && compareArrays(c._a, other.toArray()) > 0;
        } else {
          this._isDSTShifted = false;
        }
        return this._isDSTShifted;
      }
      function isLocal() {
        return this.isValid() ? !this._isUTC : false;
      }
      function isUtcOffset() {
        return this.isValid() ? this._isUTC : false;
      }
      function isUtc() {
        return this.isValid() ? this._isUTC && this._offset === 0 : false;
      }
      var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/, isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
      function createDuration(input, key) {
        var duration = input, match = null, sign2, ret, diffRes;
        if (isDuration(input)) {
          duration = {
            ms: input._milliseconds,
            d: input._days,
            M: input._months
          };
        } else if (isNumber(input) || !isNaN(+input)) {
          duration = {};
          if (key) {
            duration[key] = +input;
          } else {
            duration.milliseconds = +input;
          }
        } else if (match = aspNetRegex.exec(input)) {
          sign2 = match[1] === "-" ? -1 : 1;
          duration = {
            y: 0,
            d: toInt(match[DATE]) * sign2,
            h: toInt(match[HOUR]) * sign2,
            m: toInt(match[MINUTE]) * sign2,
            s: toInt(match[SECOND]) * sign2,
            ms: toInt(absRound(match[MILLISECOND] * 1e3)) * sign2
            // the millisecond decimal point is included in the match
          };
        } else if (match = isoRegex.exec(input)) {
          sign2 = match[1] === "-" ? -1 : 1;
          duration = {
            y: parseIso(match[2], sign2),
            M: parseIso(match[3], sign2),
            w: parseIso(match[4], sign2),
            d: parseIso(match[5], sign2),
            h: parseIso(match[6], sign2),
            m: parseIso(match[7], sign2),
            s: parseIso(match[8], sign2)
          };
        } else if (duration == null) {
          duration = {};
        } else if (typeof duration === "object" && ("from" in duration || "to" in duration)) {
          diffRes = momentsDifference(
            createLocal(duration.from),
            createLocal(duration.to)
          );
          duration = {};
          duration.ms = diffRes.milliseconds;
          duration.M = diffRes.months;
        }
        ret = new Duration(duration);
        if (isDuration(input) && hasOwnProp(input, "_locale")) {
          ret._locale = input._locale;
        }
        if (isDuration(input) && hasOwnProp(input, "_isValid")) {
          ret._isValid = input._isValid;
        }
        return ret;
      }
      createDuration.fn = Duration.prototype;
      createDuration.invalid = createInvalid$1;
      function parseIso(inp, sign2) {
        var res = inp && parseFloat(inp.replace(",", "."));
        return (isNaN(res) ? 0 : res) * sign2;
      }
      function positiveMomentsDifference(base, other) {
        var res = {};
        res.months = other.month() - base.month() + (other.year() - base.year()) * 12;
        if (base.clone().add(res.months, "M").isAfter(other)) {
          --res.months;
        }
        res.milliseconds = +other - +base.clone().add(res.months, "M");
        return res;
      }
      function momentsDifference(base, other) {
        var res;
        if (!(base.isValid() && other.isValid())) {
          return { milliseconds: 0, months: 0 };
        }
        other = cloneWithOffset(other, base);
        if (base.isBefore(other)) {
          res = positiveMomentsDifference(base, other);
        } else {
          res = positiveMomentsDifference(other, base);
          res.milliseconds = -res.milliseconds;
          res.months = -res.months;
        }
        return res;
      }
      function createAdder(direction, name) {
        return function(val, period) {
          var dur, tmp;
          if (period !== null && !isNaN(+period)) {
            deprecateSimple(
              name,
              "moment()." + name + "(period, number) is deprecated. Please use moment()." + name + "(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."
            );
            tmp = val;
            val = period;
            period = tmp;
          }
          dur = createDuration(val, period);
          addSubtract(this, dur, direction);
          return this;
        };
      }
      function addSubtract(mom, duration, isAdding, updateOffset) {
        var milliseconds2 = duration._milliseconds, days2 = absRound(duration._days), months2 = absRound(duration._months);
        if (!mom.isValid()) {
          return;
        }
        updateOffset = updateOffset == null ? true : updateOffset;
        if (months2) {
          setMonth(mom, get(mom, "Month") + months2 * isAdding);
        }
        if (days2) {
          set$1(mom, "Date", get(mom, "Date") + days2 * isAdding);
        }
        if (milliseconds2) {
          mom._d.setTime(mom._d.valueOf() + milliseconds2 * isAdding);
        }
        if (updateOffset) {
          hooks.updateOffset(mom, days2 || months2);
        }
      }
      var add = createAdder(1, "add"), subtract = createAdder(-1, "subtract");
      function isString(input) {
        return typeof input === "string" || input instanceof String;
      }
      function isMomentInput(input) {
        return isMoment(input) || isDate(input) || isString(input) || isNumber(input) || isNumberOrStringArray(input) || isMomentInputObject(input) || input === null || input === void 0;
      }
      function isMomentInputObject(input) {
        var objectTest = isObject(input) && !isObjectEmpty(input), propertyTest = false, properties = [
          "years",
          "year",
          "y",
          "months",
          "month",
          "M",
          "days",
          "day",
          "d",
          "dates",
          "date",
          "D",
          "hours",
          "hour",
          "h",
          "minutes",
          "minute",
          "m",
          "seconds",
          "second",
          "s",
          "milliseconds",
          "millisecond",
          "ms"
        ], i, property, propertyLen = properties.length;
        for (i = 0; i < propertyLen; i += 1) {
          property = properties[i];
          propertyTest = propertyTest || hasOwnProp(input, property);
        }
        return objectTest && propertyTest;
      }
      function isNumberOrStringArray(input) {
        var arrayTest = isArray(input), dataTypeTest = false;
        if (arrayTest) {
          dataTypeTest = input.filter(function(item) {
            return !isNumber(item) && isString(input);
          }).length === 0;
        }
        return arrayTest && dataTypeTest;
      }
      function isCalendarSpec(input) {
        var objectTest = isObject(input) && !isObjectEmpty(input), propertyTest = false, properties = [
          "sameDay",
          "nextDay",
          "lastDay",
          "nextWeek",
          "lastWeek",
          "sameElse"
        ], i, property;
        for (i = 0; i < properties.length; i += 1) {
          property = properties[i];
          propertyTest = propertyTest || hasOwnProp(input, property);
        }
        return objectTest && propertyTest;
      }
      function getCalendarFormat(myMoment, now2) {
        var diff2 = myMoment.diff(now2, "days", true);
        return diff2 < -6 ? "sameElse" : diff2 < -1 ? "lastWeek" : diff2 < 0 ? "lastDay" : diff2 < 1 ? "sameDay" : diff2 < 2 ? "nextDay" : diff2 < 7 ? "nextWeek" : "sameElse";
      }
      function calendar$1(time, formats) {
        if (arguments.length === 1) {
          if (!arguments[0]) {
            time = void 0;
            formats = void 0;
          } else if (isMomentInput(arguments[0])) {
            time = arguments[0];
            formats = void 0;
          } else if (isCalendarSpec(arguments[0])) {
            formats = arguments[0];
            time = void 0;
          }
        }
        var now2 = time || createLocal(), sod = cloneWithOffset(now2, this).startOf("day"), format2 = hooks.calendarFormat(this, sod) || "sameElse", output = formats && (isFunction(formats[format2]) ? formats[format2].call(this, now2) : formats[format2]);
        return this.format(
          output || this.localeData().calendar(format2, this, createLocal(now2))
        );
      }
      function clone() {
        return new Moment(this);
      }
      function isAfter(input, units) {
        var localInput = isMoment(input) ? input : createLocal(input);
        if (!(this.isValid() && localInput.isValid())) {
          return false;
        }
        units = normalizeUnits(units) || "millisecond";
        if (units === "millisecond") {
          return this.valueOf() > localInput.valueOf();
        } else {
          return localInput.valueOf() < this.clone().startOf(units).valueOf();
        }
      }
      function isBefore(input, units) {
        var localInput = isMoment(input) ? input : createLocal(input);
        if (!(this.isValid() && localInput.isValid())) {
          return false;
        }
        units = normalizeUnits(units) || "millisecond";
        if (units === "millisecond") {
          return this.valueOf() < localInput.valueOf();
        } else {
          return this.clone().endOf(units).valueOf() < localInput.valueOf();
        }
      }
      function isBetween(from2, to2, units, inclusivity) {
        var localFrom = isMoment(from2) ? from2 : createLocal(from2), localTo = isMoment(to2) ? to2 : createLocal(to2);
        if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
          return false;
        }
        inclusivity = inclusivity || "()";
        return (inclusivity[0] === "(" ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) && (inclusivity[1] === ")" ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));
      }
      function isSame(input, units) {
        var localInput = isMoment(input) ? input : createLocal(input), inputMs;
        if (!(this.isValid() && localInput.isValid())) {
          return false;
        }
        units = normalizeUnits(units) || "millisecond";
        if (units === "millisecond") {
          return this.valueOf() === localInput.valueOf();
        } else {
          inputMs = localInput.valueOf();
          return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
        }
      }
      function isSameOrAfter(input, units) {
        return this.isSame(input, units) || this.isAfter(input, units);
      }
      function isSameOrBefore(input, units) {
        return this.isSame(input, units) || this.isBefore(input, units);
      }
      function diff(input, units, asFloat) {
        var that, zoneDelta, output;
        if (!this.isValid()) {
          return NaN;
        }
        that = cloneWithOffset(input, this);
        if (!that.isValid()) {
          return NaN;
        }
        zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
        units = normalizeUnits(units);
        switch (units) {
          case "year":
            output = monthDiff(this, that) / 12;
            break;
          case "month":
            output = monthDiff(this, that);
            break;
          case "quarter":
            output = monthDiff(this, that) / 3;
            break;
          case "second":
            output = (this - that) / 1e3;
            break;
          // 1000
          case "minute":
            output = (this - that) / 6e4;
            break;
          // 1000 * 60
          case "hour":
            output = (this - that) / 36e5;
            break;
          // 1000 * 60 * 60
          case "day":
            output = (this - that - zoneDelta) / 864e5;
            break;
          // 1000 * 60 * 60 * 24, negate dst
          case "week":
            output = (this - that - zoneDelta) / 6048e5;
            break;
          // 1000 * 60 * 60 * 24 * 7, negate dst
          default:
            output = this - that;
        }
        return asFloat ? output : absFloor(output);
      }
      function monthDiff(a, b) {
        if (a.date() < b.date()) {
          return -monthDiff(b, a);
        }
        var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()), anchor = a.clone().add(wholeMonthDiff, "months"), anchor2, adjust;
        if (b - anchor < 0) {
          anchor2 = a.clone().add(wholeMonthDiff - 1, "months");
          adjust = (b - anchor) / (anchor - anchor2);
        } else {
          anchor2 = a.clone().add(wholeMonthDiff + 1, "months");
          adjust = (b - anchor) / (anchor2 - anchor);
        }
        return -(wholeMonthDiff + adjust) || 0;
      }
      hooks.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ";
      hooks.defaultFormatUtc = "YYYY-MM-DDTHH:mm:ss[Z]";
      function toString() {
        return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
      }
      function toISOString(keepOffset) {
        if (!this.isValid()) {
          return null;
        }
        var utc = keepOffset !== true, m = utc ? this.clone().utc() : this;
        if (m.year() < 0 || m.year() > 9999) {
          return formatMoment(
            m,
            utc ? "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"
          );
        }
        if (isFunction(Date.prototype.toISOString)) {
          if (utc) {
            return this.toDate().toISOString();
          } else {
            return new Date(this.valueOf() + this.utcOffset() * 60 * 1e3).toISOString().replace("Z", formatMoment(m, "Z"));
          }
        }
        return formatMoment(
          m,
          utc ? "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYY-MM-DD[T]HH:mm:ss.SSSZ"
        );
      }
      function inspect() {
        if (!this.isValid()) {
          return "moment.invalid(/* " + this._i + " */)";
        }
        var func = "moment", zone = "", prefix, year, datetime, suffix;
        if (!this.isLocal()) {
          func = this.utcOffset() === 0 ? "moment.utc" : "moment.parseZone";
          zone = "Z";
        }
        prefix = "[" + func + '("]';
        year = 0 <= this.year() && this.year() <= 9999 ? "YYYY" : "YYYYYY";
        datetime = "-MM-DD[T]HH:mm:ss.SSS";
        suffix = zone + '[")]';
        return this.format(prefix + year + datetime + suffix);
      }
      function format(inputString) {
        if (!inputString) {
          inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
        }
        var output = formatMoment(this, inputString);
        return this.localeData().postformat(output);
      }
      function from(time, withoutSuffix) {
        if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {
          return createDuration({ to: this, from: time }).locale(this.locale()).humanize(!withoutSuffix);
        } else {
          return this.localeData().invalidDate();
        }
      }
      function fromNow(withoutSuffix) {
        return this.from(createLocal(), withoutSuffix);
      }
      function to(time, withoutSuffix) {
        if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {
          return createDuration({ from: this, to: time }).locale(this.locale()).humanize(!withoutSuffix);
        } else {
          return this.localeData().invalidDate();
        }
      }
      function toNow(withoutSuffix) {
        return this.to(createLocal(), withoutSuffix);
      }
      function locale(key) {
        var newLocaleData;
        if (key === void 0) {
          return this._locale._abbr;
        } else {
          newLocaleData = getLocale(key);
          if (newLocaleData != null) {
            this._locale = newLocaleData;
          }
          return this;
        }
      }
      var lang = deprecate(
        "moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",
        function(key) {
          if (key === void 0) {
            return this.localeData();
          } else {
            return this.locale(key);
          }
        }
      );
      function localeData() {
        return this._locale;
      }
      var MS_PER_SECOND = 1e3, MS_PER_MINUTE = 60 * MS_PER_SECOND, MS_PER_HOUR = 60 * MS_PER_MINUTE, MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
      function mod$1(dividend, divisor) {
        return (dividend % divisor + divisor) % divisor;
      }
      function localStartOfDate(y, m, d) {
        if (y < 100 && y >= 0) {
          return new Date(y + 400, m, d) - MS_PER_400_YEARS;
        } else {
          return new Date(y, m, d).valueOf();
        }
      }
      function utcStartOfDate(y, m, d) {
        if (y < 100 && y >= 0) {
          return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
        } else {
          return Date.UTC(y, m, d);
        }
      }
      function startOf(units) {
        var time, startOfDate;
        units = normalizeUnits(units);
        if (units === void 0 || units === "millisecond" || !this.isValid()) {
          return this;
        }
        startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
        switch (units) {
          case "year":
            time = startOfDate(this.year(), 0, 1);
            break;
          case "quarter":
            time = startOfDate(
              this.year(),
              this.month() - this.month() % 3,
              1
            );
            break;
          case "month":
            time = startOfDate(this.year(), this.month(), 1);
            break;
          case "week":
            time = startOfDate(
              this.year(),
              this.month(),
              this.date() - this.weekday()
            );
            break;
          case "isoWeek":
            time = startOfDate(
              this.year(),
              this.month(),
              this.date() - (this.isoWeekday() - 1)
            );
            break;
          case "day":
          case "date":
            time = startOfDate(this.year(), this.month(), this.date());
            break;
          case "hour":
            time = this._d.valueOf();
            time -= mod$1(
              time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
              MS_PER_HOUR
            );
            break;
          case "minute":
            time = this._d.valueOf();
            time -= mod$1(time, MS_PER_MINUTE);
            break;
          case "second":
            time = this._d.valueOf();
            time -= mod$1(time, MS_PER_SECOND);
            break;
        }
        this._d.setTime(time);
        hooks.updateOffset(this, true);
        return this;
      }
      function endOf(units) {
        var time, startOfDate;
        units = normalizeUnits(units);
        if (units === void 0 || units === "millisecond" || !this.isValid()) {
          return this;
        }
        startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
        switch (units) {
          case "year":
            time = startOfDate(this.year() + 1, 0, 1) - 1;
            break;
          case "quarter":
            time = startOfDate(
              this.year(),
              this.month() - this.month() % 3 + 3,
              1
            ) - 1;
            break;
          case "month":
            time = startOfDate(this.year(), this.month() + 1, 1) - 1;
            break;
          case "week":
            time = startOfDate(
              this.year(),
              this.month(),
              this.date() - this.weekday() + 7
            ) - 1;
            break;
          case "isoWeek":
            time = startOfDate(
              this.year(),
              this.month(),
              this.date() - (this.isoWeekday() - 1) + 7
            ) - 1;
            break;
          case "day":
          case "date":
            time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
            break;
          case "hour":
            time = this._d.valueOf();
            time += MS_PER_HOUR - mod$1(
              time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
              MS_PER_HOUR
            ) - 1;
            break;
          case "minute":
            time = this._d.valueOf();
            time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
            break;
          case "second":
            time = this._d.valueOf();
            time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
            break;
        }
        this._d.setTime(time);
        hooks.updateOffset(this, true);
        return this;
      }
      function valueOf() {
        return this._d.valueOf() - (this._offset || 0) * 6e4;
      }
      function unix() {
        return Math.floor(this.valueOf() / 1e3);
      }
      function toDate() {
        return new Date(this.valueOf());
      }
      function toArray() {
        var m = this;
        return [
          m.year(),
          m.month(),
          m.date(),
          m.hour(),
          m.minute(),
          m.second(),
          m.millisecond()
        ];
      }
      function toObject() {
        var m = this;
        return {
          years: m.year(),
          months: m.month(),
          date: m.date(),
          hours: m.hours(),
          minutes: m.minutes(),
          seconds: m.seconds(),
          milliseconds: m.milliseconds()
        };
      }
      function toJSON() {
        return this.isValid() ? this.toISOString() : null;
      }
      function isValid$2() {
        return isValid(this);
      }
      function parsingFlags() {
        return extend2({}, getParsingFlags(this));
      }
      function invalidAt() {
        return getParsingFlags(this).overflow;
      }
      function creationData() {
        return {
          input: this._i,
          format: this._f,
          locale: this._locale,
          isUTC: this._isUTC,
          strict: this._strict
        };
      }
      addFormatToken("N", 0, 0, "eraAbbr");
      addFormatToken("NN", 0, 0, "eraAbbr");
      addFormatToken("NNN", 0, 0, "eraAbbr");
      addFormatToken("NNNN", 0, 0, "eraName");
      addFormatToken("NNNNN", 0, 0, "eraNarrow");
      addFormatToken("y", ["y", 1], "yo", "eraYear");
      addFormatToken("y", ["yy", 2], 0, "eraYear");
      addFormatToken("y", ["yyy", 3], 0, "eraYear");
      addFormatToken("y", ["yyyy", 4], 0, "eraYear");
      addRegexToken("N", matchEraAbbr);
      addRegexToken("NN", matchEraAbbr);
      addRegexToken("NNN", matchEraAbbr);
      addRegexToken("NNNN", matchEraName);
      addRegexToken("NNNNN", matchEraNarrow);
      addParseToken(
        ["N", "NN", "NNN", "NNNN", "NNNNN"],
        function(input, array, config, token2) {
          var era = config._locale.erasParse(input, token2, config._strict);
          if (era) {
            getParsingFlags(config).era = era;
          } else {
            getParsingFlags(config).invalidEra = input;
          }
        }
      );
      addRegexToken("y", matchUnsigned);
      addRegexToken("yy", matchUnsigned);
      addRegexToken("yyy", matchUnsigned);
      addRegexToken("yyyy", matchUnsigned);
      addRegexToken("yo", matchEraYearOrdinal);
      addParseToken(["y", "yy", "yyy", "yyyy"], YEAR);
      addParseToken(["yo"], function(input, array, config, token2) {
        var match;
        if (config._locale._eraYearOrdinalRegex) {
          match = input.match(config._locale._eraYearOrdinalRegex);
        }
        if (config._locale.eraYearOrdinalParse) {
          array[YEAR] = config._locale.eraYearOrdinalParse(input, match);
        } else {
          array[YEAR] = parseInt(input, 10);
        }
      });
      function localeEras(m, format2) {
        var i, l, date, eras = this._eras || getLocale("en")._eras;
        for (i = 0, l = eras.length; i < l; ++i) {
          switch (typeof eras[i].since) {
            case "string":
              date = hooks(eras[i].since).startOf("day");
              eras[i].since = date.valueOf();
              break;
          }
          switch (typeof eras[i].until) {
            case "undefined":
              eras[i].until = Infinity;
              break;
            case "string":
              date = hooks(eras[i].until).startOf("day").valueOf();
              eras[i].until = date.valueOf();
              break;
          }
        }
        return eras;
      }
      function localeErasParse(eraName, format2, strict) {
        var i, l, eras = this.eras(), name, abbr, narrow;
        eraName = eraName.toUpperCase();
        for (i = 0, l = eras.length; i < l; ++i) {
          name = eras[i].name.toUpperCase();
          abbr = eras[i].abbr.toUpperCase();
          narrow = eras[i].narrow.toUpperCase();
          if (strict) {
            switch (format2) {
              case "N":
              case "NN":
              case "NNN":
                if (abbr === eraName) {
                  return eras[i];
                }
                break;
              case "NNNN":
                if (name === eraName) {
                  return eras[i];
                }
                break;
              case "NNNNN":
                if (narrow === eraName) {
                  return eras[i];
                }
                break;
            }
          } else if ([name, abbr, narrow].indexOf(eraName) >= 0) {
            return eras[i];
          }
        }
      }
      function localeErasConvertYear(era, year) {
        var dir = era.since <= era.until ? 1 : -1;
        if (year === void 0) {
          return hooks(era.since).year();
        } else {
          return hooks(era.since).year() + (year - era.offset) * dir;
        }
      }
      function getEraName() {
        var i, l, val, eras = this.localeData().eras();
        for (i = 0, l = eras.length; i < l; ++i) {
          val = this.clone().startOf("day").valueOf();
          if (eras[i].since <= val && val <= eras[i].until) {
            return eras[i].name;
          }
          if (eras[i].until <= val && val <= eras[i].since) {
            return eras[i].name;
          }
        }
        return "";
      }
      function getEraNarrow() {
        var i, l, val, eras = this.localeData().eras();
        for (i = 0, l = eras.length; i < l; ++i) {
          val = this.clone().startOf("day").valueOf();
          if (eras[i].since <= val && val <= eras[i].until) {
            return eras[i].narrow;
          }
          if (eras[i].until <= val && val <= eras[i].since) {
            return eras[i].narrow;
          }
        }
        return "";
      }
      function getEraAbbr() {
        var i, l, val, eras = this.localeData().eras();
        for (i = 0, l = eras.length; i < l; ++i) {
          val = this.clone().startOf("day").valueOf();
          if (eras[i].since <= val && val <= eras[i].until) {
            return eras[i].abbr;
          }
          if (eras[i].until <= val && val <= eras[i].since) {
            return eras[i].abbr;
          }
        }
        return "";
      }
      function getEraYear() {
        var i, l, dir, val, eras = this.localeData().eras();
        for (i = 0, l = eras.length; i < l; ++i) {
          dir = eras[i].since <= eras[i].until ? 1 : -1;
          val = this.clone().startOf("day").valueOf();
          if (eras[i].since <= val && val <= eras[i].until || eras[i].until <= val && val <= eras[i].since) {
            return (this.year() - hooks(eras[i].since).year()) * dir + eras[i].offset;
          }
        }
        return this.year();
      }
      function erasNameRegex(isStrict) {
        if (!hasOwnProp(this, "_erasNameRegex")) {
          computeErasParse.call(this);
        }
        return isStrict ? this._erasNameRegex : this._erasRegex;
      }
      function erasAbbrRegex(isStrict) {
        if (!hasOwnProp(this, "_erasAbbrRegex")) {
          computeErasParse.call(this);
        }
        return isStrict ? this._erasAbbrRegex : this._erasRegex;
      }
      function erasNarrowRegex(isStrict) {
        if (!hasOwnProp(this, "_erasNarrowRegex")) {
          computeErasParse.call(this);
        }
        return isStrict ? this._erasNarrowRegex : this._erasRegex;
      }
      function matchEraAbbr(isStrict, locale2) {
        return locale2.erasAbbrRegex(isStrict);
      }
      function matchEraName(isStrict, locale2) {
        return locale2.erasNameRegex(isStrict);
      }
      function matchEraNarrow(isStrict, locale2) {
        return locale2.erasNarrowRegex(isStrict);
      }
      function matchEraYearOrdinal(isStrict, locale2) {
        return locale2._eraYearOrdinalRegex || matchUnsigned;
      }
      function computeErasParse() {
        var abbrPieces = [], namePieces = [], narrowPieces = [], mixedPieces = [], i, l, erasName, erasAbbr, erasNarrow, eras = this.eras();
        for (i = 0, l = eras.length; i < l; ++i) {
          erasName = regexEscape(eras[i].name);
          erasAbbr = regexEscape(eras[i].abbr);
          erasNarrow = regexEscape(eras[i].narrow);
          namePieces.push(erasName);
          abbrPieces.push(erasAbbr);
          narrowPieces.push(erasNarrow);
          mixedPieces.push(erasName);
          mixedPieces.push(erasAbbr);
          mixedPieces.push(erasNarrow);
        }
        this._erasRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
        this._erasNameRegex = new RegExp("^(" + namePieces.join("|") + ")", "i");
        this._erasAbbrRegex = new RegExp("^(" + abbrPieces.join("|") + ")", "i");
        this._erasNarrowRegex = new RegExp(
          "^(" + narrowPieces.join("|") + ")",
          "i"
        );
      }
      addFormatToken(0, ["gg", 2], 0, function() {
        return this.weekYear() % 100;
      });
      addFormatToken(0, ["GG", 2], 0, function() {
        return this.isoWeekYear() % 100;
      });
      function addWeekYearFormatToken(token2, getter) {
        addFormatToken(0, [token2, token2.length], 0, getter);
      }
      addWeekYearFormatToken("gggg", "weekYear");
      addWeekYearFormatToken("ggggg", "weekYear");
      addWeekYearFormatToken("GGGG", "isoWeekYear");
      addWeekYearFormatToken("GGGGG", "isoWeekYear");
      addRegexToken("G", matchSigned);
      addRegexToken("g", matchSigned);
      addRegexToken("GG", match1to2, match2);
      addRegexToken("gg", match1to2, match2);
      addRegexToken("GGGG", match1to4, match4);
      addRegexToken("gggg", match1to4, match4);
      addRegexToken("GGGGG", match1to6, match6);
      addRegexToken("ggggg", match1to6, match6);
      addWeekParseToken(
        ["gggg", "ggggg", "GGGG", "GGGGG"],
        function(input, week, config, token2) {
          week[token2.substr(0, 2)] = toInt(input);
        }
      );
      addWeekParseToken(["gg", "GG"], function(input, week, config, token2) {
        week[token2] = hooks.parseTwoDigitYear(input);
      });
      function getSetWeekYear(input) {
        return getSetWeekYearHelper.call(
          this,
          input,
          this.week(),
          this.weekday() + this.localeData()._week.dow,
          this.localeData()._week.dow,
          this.localeData()._week.doy
        );
      }
      function getSetISOWeekYear(input) {
        return getSetWeekYearHelper.call(
          this,
          input,
          this.isoWeek(),
          this.isoWeekday(),
          1,
          4
        );
      }
      function getISOWeeksInYear() {
        return weeksInYear(this.year(), 1, 4);
      }
      function getISOWeeksInISOWeekYear() {
        return weeksInYear(this.isoWeekYear(), 1, 4);
      }
      function getWeeksInYear() {
        var weekInfo = this.localeData()._week;
        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
      }
      function getWeeksInWeekYear() {
        var weekInfo = this.localeData()._week;
        return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
      }
      function getSetWeekYearHelper(input, week, weekday, dow, doy) {
        var weeksTarget;
        if (input == null) {
          return weekOfYear(this, dow, doy).year;
        } else {
          weeksTarget = weeksInYear(input, dow, doy);
          if (week > weeksTarget) {
            week = weeksTarget;
          }
          return setWeekAll.call(this, input, week, weekday, dow, doy);
        }
      }
      function setWeekAll(weekYear, week, weekday, dow, doy) {
        var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
        this.year(date.getUTCFullYear());
        this.month(date.getUTCMonth());
        this.date(date.getUTCDate());
        return this;
      }
      addFormatToken("Q", 0, "Qo", "quarter");
      addRegexToken("Q", match1);
      addParseToken("Q", function(input, array) {
        array[MONTH] = (toInt(input) - 1) * 3;
      });
      function getSetQuarter(input) {
        return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
      }
      addFormatToken("D", ["DD", 2], "Do", "date");
      addRegexToken("D", match1to2, match1to2NoLeadingZero);
      addRegexToken("DD", match1to2, match2);
      addRegexToken("Do", function(isStrict, locale2) {
        return isStrict ? locale2._dayOfMonthOrdinalParse || locale2._ordinalParse : locale2._dayOfMonthOrdinalParseLenient;
      });
      addParseToken(["D", "DD"], DATE);
      addParseToken("Do", function(input, array) {
        array[DATE] = toInt(input.match(match1to2)[0]);
      });
      var getSetDayOfMonth = makeGetSet("Date", true);
      addFormatToken("DDD", ["DDDD", 3], "DDDo", "dayOfYear");
      addRegexToken("DDD", match1to3);
      addRegexToken("DDDD", match3);
      addParseToken(["DDD", "DDDD"], function(input, array, config) {
        config._dayOfYear = toInt(input);
      });
      function getSetDayOfYear(input) {
        var dayOfYear = Math.round(
          (this.clone().startOf("day") - this.clone().startOf("year")) / 864e5
        ) + 1;
        return input == null ? dayOfYear : this.add(input - dayOfYear, "d");
      }
      addFormatToken("m", ["mm", 2], 0, "minute");
      addRegexToken("m", match1to2, match1to2HasZero);
      addRegexToken("mm", match1to2, match2);
      addParseToken(["m", "mm"], MINUTE);
      var getSetMinute = makeGetSet("Minutes", false);
      addFormatToken("s", ["ss", 2], 0, "second");
      addRegexToken("s", match1to2, match1to2HasZero);
      addRegexToken("ss", match1to2, match2);
      addParseToken(["s", "ss"], SECOND);
      var getSetSecond = makeGetSet("Seconds", false);
      addFormatToken("S", 0, 0, function() {
        return ~~(this.millisecond() / 100);
      });
      addFormatToken(0, ["SS", 2], 0, function() {
        return ~~(this.millisecond() / 10);
      });
      addFormatToken(0, ["SSS", 3], 0, "millisecond");
      addFormatToken(0, ["SSSS", 4], 0, function() {
        return this.millisecond() * 10;
      });
      addFormatToken(0, ["SSSSS", 5], 0, function() {
        return this.millisecond() * 100;
      });
      addFormatToken(0, ["SSSSSS", 6], 0, function() {
        return this.millisecond() * 1e3;
      });
      addFormatToken(0, ["SSSSSSS", 7], 0, function() {
        return this.millisecond() * 1e4;
      });
      addFormatToken(0, ["SSSSSSSS", 8], 0, function() {
        return this.millisecond() * 1e5;
      });
      addFormatToken(0, ["SSSSSSSSS", 9], 0, function() {
        return this.millisecond() * 1e6;
      });
      addRegexToken("S", match1to3, match1);
      addRegexToken("SS", match1to3, match2);
      addRegexToken("SSS", match1to3, match3);
      var token, getSetMillisecond;
      for (token = "SSSS"; token.length <= 9; token += "S") {
        addRegexToken(token, matchUnsigned);
      }
      function parseMs(input, array) {
        array[MILLISECOND] = toInt(("0." + input) * 1e3);
      }
      for (token = "S"; token.length <= 9; token += "S") {
        addParseToken(token, parseMs);
      }
      getSetMillisecond = makeGetSet("Milliseconds", false);
      addFormatToken("z", 0, 0, "zoneAbbr");
      addFormatToken("zz", 0, 0, "zoneName");
      function getZoneAbbr() {
        return this._isUTC ? "UTC" : "";
      }
      function getZoneName() {
        return this._isUTC ? "Coordinated Universal Time" : "";
      }
      var proto = Moment.prototype;
      proto.add = add;
      proto.calendar = calendar$1;
      proto.clone = clone;
      proto.diff = diff;
      proto.endOf = endOf;
      proto.format = format;
      proto.from = from;
      proto.fromNow = fromNow;
      proto.to = to;
      proto.toNow = toNow;
      proto.get = stringGet;
      proto.invalidAt = invalidAt;
      proto.isAfter = isAfter;
      proto.isBefore = isBefore;
      proto.isBetween = isBetween;
      proto.isSame = isSame;
      proto.isSameOrAfter = isSameOrAfter;
      proto.isSameOrBefore = isSameOrBefore;
      proto.isValid = isValid$2;
      proto.lang = lang;
      proto.locale = locale;
      proto.localeData = localeData;
      proto.max = prototypeMax;
      proto.min = prototypeMin;
      proto.parsingFlags = parsingFlags;
      proto.set = stringSet;
      proto.startOf = startOf;
      proto.subtract = subtract;
      proto.toArray = toArray;
      proto.toObject = toObject;
      proto.toDate = toDate;
      proto.toISOString = toISOString;
      proto.inspect = inspect;
      if (typeof Symbol !== "undefined" && Symbol.for != null) {
        proto[Symbol.for("nodejs.util.inspect.custom")] = function() {
          return "Moment<" + this.format() + ">";
        };
      }
      proto.toJSON = toJSON;
      proto.toString = toString;
      proto.unix = unix;
      proto.valueOf = valueOf;
      proto.creationData = creationData;
      proto.eraName = getEraName;
      proto.eraNarrow = getEraNarrow;
      proto.eraAbbr = getEraAbbr;
      proto.eraYear = getEraYear;
      proto.year = getSetYear;
      proto.isLeapYear = getIsLeapYear;
      proto.weekYear = getSetWeekYear;
      proto.isoWeekYear = getSetISOWeekYear;
      proto.quarter = proto.quarters = getSetQuarter;
      proto.month = getSetMonth;
      proto.daysInMonth = getDaysInMonth;
      proto.week = proto.weeks = getSetWeek;
      proto.isoWeek = proto.isoWeeks = getSetISOWeek;
      proto.weeksInYear = getWeeksInYear;
      proto.weeksInWeekYear = getWeeksInWeekYear;
      proto.isoWeeksInYear = getISOWeeksInYear;
      proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
      proto.date = getSetDayOfMonth;
      proto.day = proto.days = getSetDayOfWeek;
      proto.weekday = getSetLocaleDayOfWeek;
      proto.isoWeekday = getSetISODayOfWeek;
      proto.dayOfYear = getSetDayOfYear;
      proto.hour = proto.hours = getSetHour;
      proto.minute = proto.minutes = getSetMinute;
      proto.second = proto.seconds = getSetSecond;
      proto.millisecond = proto.milliseconds = getSetMillisecond;
      proto.utcOffset = getSetOffset;
      proto.utc = setOffsetToUTC;
      proto.local = setOffsetToLocal;
      proto.parseZone = setOffsetToParsedOffset;
      proto.hasAlignedHourOffset = hasAlignedHourOffset;
      proto.isDST = isDaylightSavingTime;
      proto.isLocal = isLocal;
      proto.isUtcOffset = isUtcOffset;
      proto.isUtc = isUtc;
      proto.isUTC = isUtc;
      proto.zoneAbbr = getZoneAbbr;
      proto.zoneName = getZoneName;
      proto.dates = deprecate(
        "dates accessor is deprecated. Use date instead.",
        getSetDayOfMonth
      );
      proto.months = deprecate(
        "months accessor is deprecated. Use month instead",
        getSetMonth
      );
      proto.years = deprecate(
        "years accessor is deprecated. Use year instead",
        getSetYear
      );
      proto.zone = deprecate(
        "moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",
        getSetZone
      );
      proto.isDSTShifted = deprecate(
        "isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",
        isDaylightSavingTimeShifted
      );
      function createUnix(input) {
        return createLocal(input * 1e3);
      }
      function createInZone() {
        return createLocal.apply(null, arguments).parseZone();
      }
      function preParsePostFormat(string) {
        return string;
      }
      var proto$1 = Locale.prototype;
      proto$1.calendar = calendar;
      proto$1.longDateFormat = longDateFormat;
      proto$1.invalidDate = invalidDate;
      proto$1.ordinal = ordinal;
      proto$1.preparse = preParsePostFormat;
      proto$1.postformat = preParsePostFormat;
      proto$1.relativeTime = relativeTime;
      proto$1.pastFuture = pastFuture;
      proto$1.set = set;
      proto$1.eras = localeEras;
      proto$1.erasParse = localeErasParse;
      proto$1.erasConvertYear = localeErasConvertYear;
      proto$1.erasAbbrRegex = erasAbbrRegex;
      proto$1.erasNameRegex = erasNameRegex;
      proto$1.erasNarrowRegex = erasNarrowRegex;
      proto$1.months = localeMonths;
      proto$1.monthsShort = localeMonthsShort;
      proto$1.monthsParse = localeMonthsParse;
      proto$1.monthsRegex = monthsRegex;
      proto$1.monthsShortRegex = monthsShortRegex;
      proto$1.week = localeWeek;
      proto$1.firstDayOfYear = localeFirstDayOfYear;
      proto$1.firstDayOfWeek = localeFirstDayOfWeek;
      proto$1.weekdays = localeWeekdays;
      proto$1.weekdaysMin = localeWeekdaysMin;
      proto$1.weekdaysShort = localeWeekdaysShort;
      proto$1.weekdaysParse = localeWeekdaysParse;
      proto$1.weekdaysRegex = weekdaysRegex;
      proto$1.weekdaysShortRegex = weekdaysShortRegex;
      proto$1.weekdaysMinRegex = weekdaysMinRegex;
      proto$1.isPM = localeIsPM;
      proto$1.meridiem = localeMeridiem;
      function get$1(format2, index, field, setter) {
        var locale2 = getLocale(), utc = createUTC().set(setter, index);
        return locale2[field](utc, format2);
      }
      function listMonthsImpl(format2, index, field) {
        if (isNumber(format2)) {
          index = format2;
          format2 = void 0;
        }
        format2 = format2 || "";
        if (index != null) {
          return get$1(format2, index, field, "month");
        }
        var i, out = [];
        for (i = 0; i < 12; i++) {
          out[i] = get$1(format2, i, field, "month");
        }
        return out;
      }
      function listWeekdaysImpl(localeSorted, format2, index, field) {
        if (typeof localeSorted === "boolean") {
          if (isNumber(format2)) {
            index = format2;
            format2 = void 0;
          }
          format2 = format2 || "";
        } else {
          format2 = localeSorted;
          index = format2;
          localeSorted = false;
          if (isNumber(format2)) {
            index = format2;
            format2 = void 0;
          }
          format2 = format2 || "";
        }
        var locale2 = getLocale(), shift = localeSorted ? locale2._week.dow : 0, i, out = [];
        if (index != null) {
          return get$1(format2, (index + shift) % 7, field, "day");
        }
        for (i = 0; i < 7; i++) {
          out[i] = get$1(format2, (i + shift) % 7, field, "day");
        }
        return out;
      }
      function listMonths(format2, index) {
        return listMonthsImpl(format2, index, "months");
      }
      function listMonthsShort(format2, index) {
        return listMonthsImpl(format2, index, "monthsShort");
      }
      function listWeekdays(localeSorted, format2, index) {
        return listWeekdaysImpl(localeSorted, format2, index, "weekdays");
      }
      function listWeekdaysShort(localeSorted, format2, index) {
        return listWeekdaysImpl(localeSorted, format2, index, "weekdaysShort");
      }
      function listWeekdaysMin(localeSorted, format2, index) {
        return listWeekdaysImpl(localeSorted, format2, index, "weekdaysMin");
      }
      getSetGlobalLocale("en", {
        eras: [
          {
            since: "0001-01-01",
            until: Infinity,
            offset: 1,
            name: "Anno Domini",
            narrow: "AD",
            abbr: "AD"
          },
          {
            since: "0000-12-31",
            until: -Infinity,
            offset: 1,
            name: "Before Christ",
            narrow: "BC",
            abbr: "BC"
          }
        ],
        dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
        ordinal: function(number) {
          var b = number % 10, output = toInt(number % 100 / 10) === 1 ? "th" : b === 1 ? "st" : b === 2 ? "nd" : b === 3 ? "rd" : "th";
          return number + output;
        }
      });
      hooks.lang = deprecate(
        "moment.lang is deprecated. Use moment.locale instead.",
        getSetGlobalLocale
      );
      hooks.langData = deprecate(
        "moment.langData is deprecated. Use moment.localeData instead.",
        getLocale
      );
      var mathAbs = Math.abs;
      function abs() {
        var data = this._data;
        this._milliseconds = mathAbs(this._milliseconds);
        this._days = mathAbs(this._days);
        this._months = mathAbs(this._months);
        data.milliseconds = mathAbs(data.milliseconds);
        data.seconds = mathAbs(data.seconds);
        data.minutes = mathAbs(data.minutes);
        data.hours = mathAbs(data.hours);
        data.months = mathAbs(data.months);
        data.years = mathAbs(data.years);
        return this;
      }
      function addSubtract$1(duration, input, value, direction) {
        var other = createDuration(input, value);
        duration._milliseconds += direction * other._milliseconds;
        duration._days += direction * other._days;
        duration._months += direction * other._months;
        return duration._bubble();
      }
      function add$1(input, value) {
        return addSubtract$1(this, input, value, 1);
      }
      function subtract$1(input, value) {
        return addSubtract$1(this, input, value, -1);
      }
      function absCeil(number) {
        if (number < 0) {
          return Math.floor(number);
        } else {
          return Math.ceil(number);
        }
      }
      function bubble() {
        var milliseconds2 = this._milliseconds, days2 = this._days, months2 = this._months, data = this._data, seconds2, minutes2, hours2, years2, monthsFromDays;
        if (!(milliseconds2 >= 0 && days2 >= 0 && months2 >= 0 || milliseconds2 <= 0 && days2 <= 0 && months2 <= 0)) {
          milliseconds2 += absCeil(monthsToDays(months2) + days2) * 864e5;
          days2 = 0;
          months2 = 0;
        }
        data.milliseconds = milliseconds2 % 1e3;
        seconds2 = absFloor(milliseconds2 / 1e3);
        data.seconds = seconds2 % 60;
        minutes2 = absFloor(seconds2 / 60);
        data.minutes = minutes2 % 60;
        hours2 = absFloor(minutes2 / 60);
        data.hours = hours2 % 24;
        days2 += absFloor(hours2 / 24);
        monthsFromDays = absFloor(daysToMonths(days2));
        months2 += monthsFromDays;
        days2 -= absCeil(monthsToDays(monthsFromDays));
        years2 = absFloor(months2 / 12);
        months2 %= 12;
        data.days = days2;
        data.months = months2;
        data.years = years2;
        return this;
      }
      function daysToMonths(days2) {
        return days2 * 4800 / 146097;
      }
      function monthsToDays(months2) {
        return months2 * 146097 / 4800;
      }
      function as(units) {
        if (!this.isValid()) {
          return NaN;
        }
        var days2, months2, milliseconds2 = this._milliseconds;
        units = normalizeUnits(units);
        if (units === "month" || units === "quarter" || units === "year") {
          days2 = this._days + milliseconds2 / 864e5;
          months2 = this._months + daysToMonths(days2);
          switch (units) {
            case "month":
              return months2;
            case "quarter":
              return months2 / 3;
            case "year":
              return months2 / 12;
          }
        } else {
          days2 = this._days + Math.round(monthsToDays(this._months));
          switch (units) {
            case "week":
              return days2 / 7 + milliseconds2 / 6048e5;
            case "day":
              return days2 + milliseconds2 / 864e5;
            case "hour":
              return days2 * 24 + milliseconds2 / 36e5;
            case "minute":
              return days2 * 1440 + milliseconds2 / 6e4;
            case "second":
              return days2 * 86400 + milliseconds2 / 1e3;
            // Math.floor prevents floating point math errors here
            case "millisecond":
              return Math.floor(days2 * 864e5) + milliseconds2;
            default:
              throw new Error("Unknown unit " + units);
          }
        }
      }
      function makeAs(alias) {
        return function() {
          return this.as(alias);
        };
      }
      var asMilliseconds = makeAs("ms"), asSeconds = makeAs("s"), asMinutes = makeAs("m"), asHours = makeAs("h"), asDays = makeAs("d"), asWeeks = makeAs("w"), asMonths = makeAs("M"), asQuarters = makeAs("Q"), asYears = makeAs("y"), valueOf$1 = asMilliseconds;
      function clone$1() {
        return createDuration(this);
      }
      function get$2(units) {
        units = normalizeUnits(units);
        return this.isValid() ? this[units + "s"]() : NaN;
      }
      function makeGetter(name) {
        return function() {
          return this.isValid() ? this._data[name] : NaN;
        };
      }
      var milliseconds = makeGetter("milliseconds"), seconds = makeGetter("seconds"), minutes = makeGetter("minutes"), hours = makeGetter("hours"), days = makeGetter("days"), months = makeGetter("months"), years = makeGetter("years");
      function weeks() {
        return absFloor(this.days() / 7);
      }
      var round = Math.round, thresholds = {
        ss: 44,
        // a few seconds to seconds
        s: 45,
        // seconds to minute
        m: 45,
        // minutes to hour
        h: 22,
        // hours to day
        d: 26,
        // days to month/week
        w: null,
        // weeks to month
        M: 11
        // months to year
      };
      function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale2) {
        return locale2.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
      }
      function relativeTime$1(posNegDuration, withoutSuffix, thresholds2, locale2) {
        var duration = createDuration(posNegDuration).abs(), seconds2 = round(duration.as("s")), minutes2 = round(duration.as("m")), hours2 = round(duration.as("h")), days2 = round(duration.as("d")), months2 = round(duration.as("M")), weeks2 = round(duration.as("w")), years2 = round(duration.as("y")), a = seconds2 <= thresholds2.ss && ["s", seconds2] || seconds2 < thresholds2.s && ["ss", seconds2] || minutes2 <= 1 && ["m"] || minutes2 < thresholds2.m && ["mm", minutes2] || hours2 <= 1 && ["h"] || hours2 < thresholds2.h && ["hh", hours2] || days2 <= 1 && ["d"] || days2 < thresholds2.d && ["dd", days2];
        if (thresholds2.w != null) {
          a = a || weeks2 <= 1 && ["w"] || weeks2 < thresholds2.w && ["ww", weeks2];
        }
        a = a || months2 <= 1 && ["M"] || months2 < thresholds2.M && ["MM", months2] || years2 <= 1 && ["y"] || ["yy", years2];
        a[2] = withoutSuffix;
        a[3] = +posNegDuration > 0;
        a[4] = locale2;
        return substituteTimeAgo.apply(null, a);
      }
      function getSetRelativeTimeRounding(roundingFunction) {
        if (roundingFunction === void 0) {
          return round;
        }
        if (typeof roundingFunction === "function") {
          round = roundingFunction;
          return true;
        }
        return false;
      }
      function getSetRelativeTimeThreshold(threshold, limit) {
        if (thresholds[threshold] === void 0) {
          return false;
        }
        if (limit === void 0) {
          return thresholds[threshold];
        }
        thresholds[threshold] = limit;
        if (threshold === "s") {
          thresholds.ss = limit - 1;
        }
        return true;
      }
      function humanize(argWithSuffix, argThresholds) {
        if (!this.isValid()) {
          return this.localeData().invalidDate();
        }
        var withSuffix = false, th = thresholds, locale2, output;
        if (typeof argWithSuffix === "object") {
          argThresholds = argWithSuffix;
          argWithSuffix = false;
        }
        if (typeof argWithSuffix === "boolean") {
          withSuffix = argWithSuffix;
        }
        if (typeof argThresholds === "object") {
          th = Object.assign({}, thresholds, argThresholds);
          if (argThresholds.s != null && argThresholds.ss == null) {
            th.ss = argThresholds.s - 1;
          }
        }
        locale2 = this.localeData();
        output = relativeTime$1(this, !withSuffix, th, locale2);
        if (withSuffix) {
          output = locale2.pastFuture(+this, output);
        }
        return locale2.postformat(output);
      }
      var abs$1 = Math.abs;
      function sign(x) {
        return (x > 0) - (x < 0) || +x;
      }
      function toISOString$1() {
        if (!this.isValid()) {
          return this.localeData().invalidDate();
        }
        var seconds2 = abs$1(this._milliseconds) / 1e3, days2 = abs$1(this._days), months2 = abs$1(this._months), minutes2, hours2, years2, s, total = this.asSeconds(), totalSign, ymSign, daysSign, hmsSign;
        if (!total) {
          return "P0D";
        }
        minutes2 = absFloor(seconds2 / 60);
        hours2 = absFloor(minutes2 / 60);
        seconds2 %= 60;
        minutes2 %= 60;
        years2 = absFloor(months2 / 12);
        months2 %= 12;
        s = seconds2 ? seconds2.toFixed(3).replace(/\.?0+$/, "") : "";
        totalSign = total < 0 ? "-" : "";
        ymSign = sign(this._months) !== sign(total) ? "-" : "";
        daysSign = sign(this._days) !== sign(total) ? "-" : "";
        hmsSign = sign(this._milliseconds) !== sign(total) ? "-" : "";
        return totalSign + "P" + (years2 ? ymSign + years2 + "Y" : "") + (months2 ? ymSign + months2 + "M" : "") + (days2 ? daysSign + days2 + "D" : "") + (hours2 || minutes2 || seconds2 ? "T" : "") + (hours2 ? hmsSign + hours2 + "H" : "") + (minutes2 ? hmsSign + minutes2 + "M" : "") + (seconds2 ? hmsSign + s + "S" : "");
      }
      var proto$2 = Duration.prototype;
      proto$2.isValid = isValid$1;
      proto$2.abs = abs;
      proto$2.add = add$1;
      proto$2.subtract = subtract$1;
      proto$2.as = as;
      proto$2.asMilliseconds = asMilliseconds;
      proto$2.asSeconds = asSeconds;
      proto$2.asMinutes = asMinutes;
      proto$2.asHours = asHours;
      proto$2.asDays = asDays;
      proto$2.asWeeks = asWeeks;
      proto$2.asMonths = asMonths;
      proto$2.asQuarters = asQuarters;
      proto$2.asYears = asYears;
      proto$2.valueOf = valueOf$1;
      proto$2._bubble = bubble;
      proto$2.clone = clone$1;
      proto$2.get = get$2;
      proto$2.milliseconds = milliseconds;
      proto$2.seconds = seconds;
      proto$2.minutes = minutes;
      proto$2.hours = hours;
      proto$2.days = days;
      proto$2.weeks = weeks;
      proto$2.months = months;
      proto$2.years = years;
      proto$2.humanize = humanize;
      proto$2.toISOString = toISOString$1;
      proto$2.toString = toISOString$1;
      proto$2.toJSON = toISOString$1;
      proto$2.locale = locale;
      proto$2.localeData = localeData;
      proto$2.toIsoString = deprecate(
        "toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",
        toISOString$1
      );
      proto$2.lang = lang;
      addFormatToken("X", 0, 0, "unix");
      addFormatToken("x", 0, 0, "valueOf");
      addRegexToken("x", matchSigned);
      addRegexToken("X", matchTimestamp);
      addParseToken("X", function(input, array, config) {
        config._d = new Date(parseFloat(input) * 1e3);
      });
      addParseToken("x", function(input, array, config) {
        config._d = new Date(toInt(input));
      });
      hooks.version = "2.30.1";
      setHookCallback(createLocal);
      hooks.fn = proto;
      hooks.min = min;
      hooks.max = max;
      hooks.now = now;
      hooks.utc = createUTC;
      hooks.unix = createUnix;
      hooks.months = listMonths;
      hooks.isDate = isDate;
      hooks.locale = getSetGlobalLocale;
      hooks.invalid = createInvalid;
      hooks.duration = createDuration;
      hooks.isMoment = isMoment;
      hooks.weekdays = listWeekdays;
      hooks.parseZone = createInZone;
      hooks.localeData = getLocale;
      hooks.isDuration = isDuration;
      hooks.monthsShort = listMonthsShort;
      hooks.weekdaysMin = listWeekdaysMin;
      hooks.defineLocale = defineLocale;
      hooks.updateLocale = updateLocale;
      hooks.locales = listLocales;
      hooks.weekdaysShort = listWeekdaysShort;
      hooks.normalizeUnits = normalizeUnits;
      hooks.relativeTimeRounding = getSetRelativeTimeRounding;
      hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
      hooks.calendarFormat = getCalendarFormat;
      hooks.prototype = proto;
      hooks.HTML5_FMT = {
        DATETIME_LOCAL: "YYYY-MM-DDTHH:mm",
        // <input type="datetime-local" />
        DATETIME_LOCAL_SECONDS: "YYYY-MM-DDTHH:mm:ss",
        // <input type="datetime-local" step="1" />
        DATETIME_LOCAL_MS: "YYYY-MM-DDTHH:mm:ss.SSS",
        // <input type="datetime-local" step="0.001" />
        DATE: "YYYY-MM-DD",
        // <input type="date" />
        TIME: "HH:mm",
        // <input type="time" />
        TIME_SECONDS: "HH:mm:ss",
        // <input type="time" step="1" />
        TIME_MS: "HH:mm:ss.SSS",
        // <input type="time" step="0.001" />
        WEEK: "GGGG-[W]WW",
        // <input type="week" />
        MONTH: "YYYY-MM"
        // <input type="month" />
      };
      return hooks;
    });
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Modal/Prompt.cjs
var require_Prompt = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Modal/Prompt.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Prompt_exports = {};
    __export2(Prompt_exports, {
      prompt: () => prompt2
    });
    module2.exports = __toCommonJS2(Prompt_exports);
    var import_obsidian5 = require("obsidian");
    var PromptModal = class extends import_obsidian5.Modal {
      constructor(options, resolve) {
        super(options.app);
        this.resolve = resolve;
        const DEFAULT_OPTIONS = {
          app: options.app,
          cancelButtonStyles: {},
          cancelButtonText: "Cancel",
          defaultValue: "",
          okButtonStyles: {
            marginRight: "10px",
            marginTop: "20px"
          },
          okButtonText: "OK",
          placeholder: "",
          textBoxStyles: {
            width: "100%"
          },
          title: "",
          valueValidator: () => null
        };
        this.options = { ...DEFAULT_OPTIONS, ...options };
        this.value = options.defaultValue ?? "";
      }
      isOkClicked = false;
      options;
      value;
      onClose() {
        this.resolve(this.isOkClicked ? this.value : null);
      }
      onOpen() {
        this.titleEl.setText(this.options.title);
        const textComponent = new import_obsidian5.TextComponent(this.contentEl);
        textComponent.setValue(this.value);
        textComponent.setPlaceholder(this.options.placeholder);
        Object.assign(textComponent.inputEl.style, this.options.textBoxStyles);
        textComponent.onChange((newValue) => this.value = newValue);
        textComponent.inputEl.addEventListener("keydown", (event) => {
          if (event.key === "Enter") {
            this.handleOk(event, textComponent);
          } else if (event.key === "Escape") {
            this.close();
          }
        });
        textComponent.inputEl.addEventListener("input", () => {
          const errorMessage = this.options.valueValidator(textComponent.inputEl.value);
          textComponent.inputEl.setCustomValidity(errorMessage ?? "");
          textComponent.inputEl.reportValidity();
        });
        const okButton = new import_obsidian5.ButtonComponent(this.contentEl);
        okButton.setButtonText(this.options.okButtonText);
        okButton.setCta();
        okButton.onClick((event) => {
          this.handleOk(event, textComponent);
        });
        Object.assign(okButton.buttonEl.style, this.options.okButtonStyles);
        const cancelButton = new import_obsidian5.ButtonComponent(this.contentEl);
        cancelButton.setButtonText(this.options.cancelButtonText);
        cancelButton.onClick(this.close.bind(this));
        Object.assign(cancelButton.buttonEl.style, this.options.cancelButtonStyles);
      }
      handleOk(event, textComponent) {
        event.preventDefault();
        if (!textComponent.inputEl.checkValidity()) {
          return;
        }
        this.isOkClicked = true;
        this.close();
      }
    };
    async function prompt2(options) {
      return new Promise((resolve) => {
        const modal = new PromptModal(options, resolve);
        modal.open();
      });
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Plugin/PluginSettingsTabBase.cjs
var require_PluginSettingsTabBase = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Plugin/PluginSettingsTabBase.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var PluginSettingsTabBase_exports = {};
    __export2(PluginSettingsTabBase_exports, {
      PluginSettingsTabBase: () => PluginSettingsTabBase2
    });
    module2.exports = __toCommonJS2(PluginSettingsTabBase_exports);
    var import_obsidian5 = require("obsidian");
    var import_PluginBase2 = require_PluginBase();
    var PluginSettingsTabBase2 = class extends import_obsidian5.PluginSettingTab {
      constructor(plugin) {
        super(plugin.app, plugin);
        this.plugin = plugin;
      }
    };
  }
});

// node_modules/obsidian-dev-utils/dist/lib/obsidian/Plugin/ValueComponent.cjs
var require_ValueComponent = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/obsidian/Plugin/ValueComponent.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var ValueComponent_exports = {};
    __export2(ValueComponent_exports, {
      extend: () => extend2
    });
    module2.exports = __toCommonJS2(ValueComponent_exports);
    var import_obsidian5 = require("obsidian");
    var import_Object2 = require_Object();
    var ValueComponentEx = class {
      constructor(valueComponent) {
        this.valueComponent = valueComponent;
      }
      /**
       * Returns the ValueComponent with extended functionality.
       */
      asExtended() {
        return (0, import_Object2.assignWithNonEnumerableProperties)({}, this.valueComponent, this);
      }
      /**
       * Binds the ValueComponent to a property in the plugin settings.
       *
       * @typeParam Plugin - The type of the plugin that extends `PluginBase`.
       * @typeParam Property - The key of the plugin setting that the component is bound to.
       * @typeParam PluginSettings - The type of the plugin settings object.
       * @param plugin - The plugin.
       * @param property - The property key in `PluginSettings` to bind to the UI component.
       * @param options - Configuration options.
       * @returns The `ValueComponent` instance that was bound to the property.
       */
      bind(plugin, property, options) {
        const DEFAULT_OPTIONS = {
          autoSave: true,
          componentToPluginSettingsValueConverter: (value) => value,
          pluginSettingsToComponentValueConverter: (value) => value
        };
        const optionsExt = { ...DEFAULT_OPTIONS, ...options };
        const pluginExt = plugin;
        const pluginSettingsFn = () => optionsExt.pluginSettings ?? pluginExt.settingsCopy;
        const validate = (uiValue) => {
          if (!optionsExt.valueValidator) {
            return true;
          }
          uiValue ??= this.valueComponent.getValue();
          const errorMessage = optionsExt.valueValidator(uiValue);
          const validatorElement2 = getValidatorElement(this.valueComponent);
          if (validatorElement2) {
            validatorElement2.setCustomValidity(errorMessage ?? "");
            validatorElement2.reportValidity();
          }
          return !errorMessage;
        };
        this.valueComponent.setValue(optionsExt.pluginSettingsToComponentValueConverter(pluginSettingsFn()[property])).onChange(async (uiValue) => {
          if (!validate(uiValue)) {
            return;
          }
          const pluginSettings = pluginSettingsFn();
          pluginSettings[property] = optionsExt.componentToPluginSettingsValueConverter(uiValue);
          if (optionsExt.autoSave) {
            await pluginExt.saveSettings(pluginSettings);
          }
          await optionsExt.onChanged?.();
        });
        validate();
        const validatorElement = getValidatorElement(this.valueComponent);
        if (validatorElement) {
          validatorElement.addEventListener("focus", () => validate());
          validatorElement.addEventListener("blur", () => validate());
        }
        return this.asExtended();
      }
    };
    function extend2(valueComponent) {
      return new ValueComponentEx(valueComponent).asExtended();
    }
    function getValidatorElement(valueComponent) {
      if (valueComponent instanceof import_obsidian5.DropdownComponent) {
        return valueComponent.selectEl;
      }
      if (valueComponent instanceof import_obsidian5.SliderComponent) {
        return valueComponent.sliderEl;
      }
      if (valueComponent instanceof import_obsidian5.TextAreaComponent) {
        return valueComponent.inputEl;
      }
      if (valueComponent instanceof import_obsidian5.TextComponent) {
        return valueComponent.inputEl;
      }
      return null;
    }
  }
});

// node_modules/obsidian-dev-utils/dist/lib/Blob.cjs
var require_Blob = __commonJS({
  "node_modules/obsidian-dev-utils/dist/lib/Blob.cjs"(exports2, module2) {
    (function patchRequireEsmDefault() {
      const __require = require;
      require = Object.assign((id) => {
        const module3 = __require(id);
        return module3.__esModule && module3.default ? module3.default : module3;
      }, __require);
    })();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export2 = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var Blob_exports = {};
    __export2(Blob_exports, {
      base64ToArrayBuffer: () => base64ToArrayBuffer,
      blobToArrayBuffer: () => blobToArrayBuffer2,
      blobToJpegArrayBuffer: () => blobToJpegArrayBuffer2,
      isImageFile: () => isImageFile2
    });
    module2.exports = __toCommonJS2(Blob_exports);
    var import_Error3 = require_Error();
    function base64ToArrayBuffer(code) {
      const parts = code.split(";base64,");
      const raw = window.atob(parts[1] ?? (0, import_Error3.throwExpression)(new Error("Invalid base64 string")));
      const rawLength = raw.length;
      const uInt8Array = new Uint8Array(rawLength);
      for (let i = 0; i < rawLength; ++i) {
        uInt8Array[i] = raw.charCodeAt(i);
      }
      return uInt8Array.buffer;
    }
    async function blobToArrayBuffer2(blob) {
      return await new Promise((resolve) => {
        const reader = new FileReader();
        reader.onloadend = () => {
          resolve(reader.result);
        };
        reader.readAsArrayBuffer(blob);
      });
    }
    async function blobToJpegArrayBuffer2(blob, jpegQuality) {
      return new Promise((resolve) => {
        const reader = new FileReader();
        reader.onloadend = () => {
          const image = new Image();
          image.onload = () => {
            const canvas = document.createElement("canvas");
            const context = canvas.getContext("2d");
            if (!context) {
              throw new Error("Could not get 2D context.");
            }
            const imageWidth = image.width;
            const imageHeight = image.height;
            let data = "";
            canvas.width = imageWidth;
            canvas.height = imageHeight;
            context.fillStyle = "#fff";
            context.fillRect(0, 0, imageWidth, imageHeight);
            context.save();
            context.translate(imageWidth / 2, imageHeight / 2);
            context.drawImage(image, 0, 0, imageWidth, imageHeight, -imageWidth / 2, -imageHeight / 2, imageWidth, imageHeight);
            context.restore();
            data = canvas.toDataURL("image/jpeg", jpegQuality);
            const arrayBuffer = base64ToArrayBuffer(data);
            resolve(arrayBuffer);
          };
          image.src = reader.result;
        };
        reader.readAsDataURL(blob);
      });
    }
    function isImageFile2(file) {
      return file.type.startsWith("image/");
    }
  }
});

// src/main.ts
var main_exports = {};
__export(main_exports, {
  default: () => main_default
});
module.exports = __toCommonJS(main_exports);

// src/CustomAttachmentLocationPlugin.ts
var import_electron2 = require("electron");

// node_modules/monkey-around/dist/index.mjs
function around(obj, factories) {
  const removers = Object.keys(factories).map((key) => around1(obj, key, factories[key]));
  return removers.length === 1 ? removers[0] : function() {
    removers.forEach((r) => r());
  };
}
function around1(obj, method, createWrapper) {
  const inherited = obj[method], hadOwn = obj.hasOwnProperty(method), original = hadOwn ? inherited : function() {
    return Object.getPrototypeOf(obj)[method].apply(this, arguments);
  };
  let current = createWrapper(original);
  if (inherited)
    Object.setPrototypeOf(current, inherited);
  Object.setPrototypeOf(wrapper, current);
  obj[method] = wrapper;
  return remove;
  function wrapper(...args) {
    if (current === original && obj[method] === wrapper)
      remove();
    return current.apply(this, args);
  }
  function remove() {
    if (obj[method] === wrapper) {
      if (hadOwn)
        obj[method] = original;
      else
        delete obj[method];
    }
    if (current === original)
      return;
    current = original;
    Object.setPrototypeOf(wrapper, inherited || Function);
  }
}

// src/CustomAttachmentLocationPlugin.ts
var import_obsidian4 = require("obsidian");
var import_AttachmentPath3 = __toESM(require_AttachmentPath(), 1);
var import_FileSystem3 = __toESM(require_FileSystem(), 1);
var import_PluginBase = __toESM(require_PluginBase(), 1);
var import_RenameDeleteHandler = __toESM(require_RenameDeleteHandler(), 1);
var import_Vault2 = __toESM(require_Vault(), 1);
var import_Path4 = __toESM(require_Path(), 1);
var import_implementations = __toESM(require_implementations(), 1);

// src/AttachmentCollector.ts
var import_obsidian2 = require("obsidian");
var import_DocumentFragment = __toESM(require_DocumentFragment(), 1);
var import_Error2 = __toESM(require_Error(), 1);
var import_Object = __toESM(require_Object(), 1);
var import_FileChange = __toESM(require_FileChange(), 1);
var import_FileSystem = __toESM(require_FileSystem(), 1);
var import_Link = __toESM(require_Link(), 1);
var import_MetadataCache = __toESM(require_MetadataCache(), 1);
var import_Confirm = __toESM(require_Confirm(), 1);
var import_Queue = __toESM(require_Queue(), 1);
var import_Reference = __toESM(require_Reference(), 1);
var import_Vault = __toESM(require_Vault(), 1);
var import_Path2 = __toESM(require_Path(), 1);

// src/AttachmentPath.ts
var import_moment = __toESM(require_moment(), 1);
var import_obsidian = require("obsidian");
var import_Error = __toESM(require_Error(), 1);
var import_Prompt = __toESM(require_Prompt(), 1);
var import_RegExp = __toESM(require_RegExp(), 1);

// src/PathValidator.ts
var INVALID_FILENAME_PATH_CHARS_REG_EXP = /[\\/:*?"<>|]/;
var ONLY_DOTS_REG_EXP = /^\.+$/;
function validateFilename(filename) {
  filename = removeDateFormatting(filename);
  if (!filename) {
    return "File name is empty";
  }
  if (INVALID_FILENAME_PATH_CHARS_REG_EXP.test(filename)) {
    return `File name "${filename}" contains invalid symbols`;
  }
  if (ONLY_DOTS_REG_EXP.test(filename)) {
    return `File name "${filename}" contains only dots`;
  }
  return "";
}
function validatePath(path) {
  path = removeDateFormatting(path);
  if (path.startsWith("/")) {
    return "Path can't start with /";
  }
  if (path.endsWith("/")) {
    return "Path can't end with /";
  }
  const parts = path.split("/");
  for (const part of parts) {
    if (part === ".") {
      continue;
    }
    const partValidationError = validateFilename(part);
    if (partValidationError) {
      return partValidationError;
    }
  }
  return "";
}
function removeDateFormatting(str) {
  return str.replaceAll(/\$\{date:.+?\}/g, "${date}");
}

// src/Substitutions.ts
var import_Path = __toESM(require_Path(), 1);
function createSubstitutionsFromPath(path, originalCopiedFilename) {
  const folderPath = (0, import_Path.dirname)(path);
  return {
    filename: (0, import_Path.basename)(path, (0, import_Path.extname)(path)),
    foldername: (0, import_Path.basename)(folderPath),
    folderPath,
    originalCopiedFilename: originalCopiedFilename ?? ""
  };
}

// src/AttachmentPath.ts
async function getAttachmentFolderFullPathForPath(plugin, path) {
  return await getAttachmentFolderPath(plugin, createSubstitutionsFromPath(path));
}
async function getAttachmentFolderPath(plugin, substitutions) {
  return await getEarliestAttachmentFolder(plugin, plugin.settingsCopy.attachmentFolderPath, substitutions);
}
async function getEarliestAttachmentFolder(plugin, attachmentFolderTemplate, substitutions) {
  const app = plugin.app;
  const targetRegex = interpolateToDigitRegex(attachmentFolderTemplate, substitutions);
  const folders = app.vault.getAllLoadedFiles().filter((f) => f instanceof import_obsidian.TFolder).filter((f) => targetRegex.test(f.path));
  const folderStats = [];
  for (const folder of folders) {
    const stat = await app.vault.adapter.stat(folder.path);
    folderStats.push({
      ctime: stat?.ctime ?? 0,
      path: folder.path
    });
  }
  if (folderStats.length > 0) {
    return folderStats.sort((a, b) => a.ctime - b.ctime).map((f) => f.path)[0] ?? (0, import_Error.throwExpression)(new Error("No folder stat"));
  } else {
    return interpolateDateToString(plugin, attachmentFolderTemplate, substitutions);
  }
}
async function getPastedFileName(plugin, substitutions) {
  return await interpolateDateToString(plugin, plugin.settingsCopy.pastedFileName, substitutions);
}
async function interpolateDateToString(plugin, template, substitutions) {
  const dateRegExp = /\$\{date:(.*?)\}/g;
  let newPath = template.replaceAll(dateRegExp, (_, dateFormat) => (0, import_moment.default)().format(dateFormat));
  for (const [key, value] of Object.entries(substitutions)) {
    newPath = newPath.replaceAll(`\${${key}}`, value);
  }
  if (substitutions.originalCopiedFilename) {
    if (newPath.includes("${prompt}")) {
      const newFileName = await (0, import_Prompt.prompt)({
        app: plugin.app,
        defaultValue: substitutions.originalCopiedFilename,
        title: "Rename attachment file",
        valueValidator: (value) => {
          return validateFilename(value);
        }
      }) ?? substitutions.originalCopiedFilename;
      newPath = newPath.replaceAll("${prompt}", newFileName);
    }
  }
  if (plugin.settingsCopy.toLowerCase) {
    newPath = newPath.toLowerCase();
  }
  newPath = replaceWhitespace(plugin, newPath);
  newPath = newPath.replace(/\.\//, substitutions.folderPath + "/");
  return newPath;
}
function interpolateToDigitRegex(template, substitutions) {
  const dateRegExp = /\$\{date:(.*?)\}/g;
  let regExpString = template.replaceAll(dateRegExp, (_, p1) => {
    return `\\d{${p1.length.toString()}}`;
  });
  for (const [key, value] of Object.entries(substitutions)) {
    regExpString = regExpString.replaceAll(`\${${key}}`, (0, import_RegExp.escapeRegExp)(value));
  }
  return new RegExp(`^${regExpString}$`);
}
function replaceWhitespace(plugin, str) {
  if (plugin.settingsCopy.replaceWhitespace) {
    str = str.replace(/\s/g, "-");
    str = str.replace(/-{2,}/g, "-");
  }
  return str;
}

// src/AttachmentCollector.ts
var __process = globalThis["process"] ?? {
  "cwd": () => "/",
  "env": {},
  "platform": "android"
};
async function collectAttachments(plugin, note, oldPath, attachmentFilter) {
  const app = plugin.app;
  oldPath ??= note.path;
  attachmentFilter ??= () => true;
  const notice = new import_obsidian2.Notice(`Collecting attachments for ${note.path}`);
  const attachmentsMap = /* @__PURE__ */ new Map();
  const isCanvas = (0, import_FileSystem.isCanvasFile)(note);
  await (0, import_FileChange.applyFileChanges)(app, note, async () => {
    const cache = await (0, import_MetadataCache.getCacheSafe)(app, note);
    if (!cache) {
      return [];
    }
    const links = isCanvas ? await getCanvasLinks(app, note) : (0, import_MetadataCache.getAllLinks)(cache);
    const changes = [];
    for (const link of links) {
      const attachmentMoveResult = await prepareAttachmentToMove(plugin, link, note.path, oldPath);
      if (!attachmentMoveResult) {
        continue;
      }
      if (!attachmentFilter(attachmentMoveResult.oldAttachmentPath)) {
        continue;
      }
      const backlinks = await (0, import_MetadataCache.getBacklinksForFileSafe)(app, attachmentMoveResult.oldAttachmentPath);
      if (backlinks.count() > 1) {
        attachmentMoveResult.newAttachmentPath = await (0, import_Vault.copySafe)(app, attachmentMoveResult.oldAttachmentPath, attachmentMoveResult.newAttachmentPath);
      } else {
        attachmentMoveResult.newAttachmentPath = await (0, import_Vault.renameSafe)(app, attachmentMoveResult.oldAttachmentPath, attachmentMoveResult.newAttachmentPath);
        await (0, import_Vault.deleteEmptyFolderHierarchy)(app, (0, import_Path2.dirname)(attachmentMoveResult.oldAttachmentPath));
      }
      attachmentsMap.set(attachmentMoveResult.oldAttachmentPath, attachmentMoveResult.newAttachmentPath);
      if (!isCanvas) {
        const newContent = (0, import_Link.updateLink)({
          app,
          link,
          oldPathOrFile: attachmentMoveResult.oldAttachmentPath,
          pathOrFile: attachmentMoveResult.newAttachmentPath,
          sourcePathOrFile: note
        });
        changes.push((0, import_Reference.referenceToFileChange)(link, newContent));
      }
    }
    return changes;
  });
  if (isCanvas) {
    await (0, import_Vault.process)(app, note, (content) => {
      const canvasData = JSON.parse(content);
      for (const node of canvasData.nodes) {
        if (node.type !== "file") {
          continue;
        }
        const newPath = attachmentsMap.get(node.file);
        if (!newPath) {
          continue;
        }
        node.file = newPath;
      }
      return (0, import_Object.toJson)(canvasData);
    });
  }
  notice.hide();
}
function collectAttachmentsCurrentFolder(plugin, checking) {
  const note = plugin.app.workspace.getActiveFile();
  if (!(0, import_FileSystem.isNote)(note)) {
    return false;
  }
  if (!checking) {
    (0, import_Queue.addToQueue)(plugin.app, () => collectAttachmentsInFolder(plugin, note?.parent ?? (0, import_Error2.throwExpression)(new Error("Parent folder not found"))));
  }
  return true;
}
function collectAttachmentsCurrentNote(plugin, checking) {
  const note = plugin.app.workspace.getActiveFile();
  if (!note || !(0, import_FileSystem.isNote)(note)) {
    return false;
  }
  if (!checking) {
    (0, import_Queue.addToQueue)(plugin.app, () => collectAttachments(plugin, note));
  }
  return true;
}
function collectAttachmentsEntireVault(plugin) {
  (0, import_Queue.addToQueue)(plugin.app, () => collectAttachmentsInFolder(plugin, plugin.app.vault.getRoot()));
}
async function collectAttachmentsInFolder(plugin, folder) {
  if (!await (0, import_Confirm.confirm)({
    app: plugin.app,
    message: createFragment((f) => {
      f.appendText("Do you want to collect attachments for all notes in folder: ");
      (0, import_DocumentFragment.appendCodeBlock)(f, folder.path);
      f.appendText(" and all its subfolders?");
      f.createEl("br");
      f.appendText("This operation cannot be undone.");
    }),
    title: createFragment((f) => {
      (0, import_obsidian2.setIcon)(f.createSpan(), "lucide-alert-triangle");
      f.appendText(" Collect attachments in folder");
    })
  })) {
    return;
  }
  console.debug(`Collect attachments in folder: ${folder.path}`);
  const files = [];
  import_obsidian2.Vault.recurseChildren(folder, (child) => {
    if ((0, import_FileSystem.isNote)(child)) {
      files.push(child);
    }
  });
  files.sort((a, b) => a.path.localeCompare(b.path));
  const notice = new import_obsidian2.Notice("", 0);
  let i = 0;
  for (const file of files) {
    i++;
    const message = `Collecting attachments # ${i.toString()} / ${files.length.toString()} - ${file.path}`;
    notice.setMessage(message);
    await collectAttachments(plugin, file);
  }
  notice.hide();
}
async function getCanvasLinks(app, file) {
  const canvasData = await app.vault.readJson(file.path);
  const files = canvasData.nodes.filter((node) => node.type === "file").map((node) => node.file);
  return files.map((file2) => ({
    link: file2,
    original: file2,
    position: {
      end: { col: 0, line: 0, loc: 0, offset: 0 },
      start: { col: 0, line: 0, loc: 0, offset: 0 }
    }
  }));
}
async function prepareAttachmentToMove(plugin, link, newNotePath, oldNotePath) {
  const app = plugin.app;
  const oldAttachmentFile = (0, import_Link.extractLinkFile)(app, link, oldNotePath);
  if (!oldAttachmentFile) {
    return null;
  }
  if ((0, import_FileSystem.isNote)(oldAttachmentFile)) {
    return null;
  }
  const oldAttachmentPath = oldAttachmentFile.path;
  const oldAttachmentName = oldAttachmentFile.name;
  const oldNoteBaseName = (0, import_Path2.basename)(oldNotePath, (0, import_Path2.extname)(oldNotePath));
  const newNoteBaseName = (0, import_Path2.basename)(newNotePath, (0, import_Path2.extname)(newNotePath));
  let newAttachmentName;
  if (plugin.settingsCopy.renameCollectedFiles) {
    newAttachmentName = (0, import_Path2.makeFileName)(await getPastedFileName(plugin, createSubstitutionsFromPath(newNotePath, oldAttachmentFile.basename)), oldAttachmentFile.extension);
  } else if (plugin.settingsCopy.autoRenameFiles) {
    newAttachmentName = oldAttachmentName.replaceAll(oldNoteBaseName, newNoteBaseName);
  } else {
    newAttachmentName = oldAttachmentName;
  }
  const newAttachmentFolderPath = await getAttachmentFolderFullPathForPath(plugin, newNotePath);
  const newAttachmentPath = (0, import_Path2.join)(newAttachmentFolderPath, newAttachmentName);
  if (oldAttachmentPath === newAttachmentPath) {
    return null;
  }
  return {
    newAttachmentPath,
    oldAttachmentPath
  };
}

// src/CustomAttachmentLocationPluginSettings.ts
var import_PluginSettings = __toESM(require_PluginSettings(), 1);
var CustomAttachmentLocationPluginSettings = class _CustomAttachmentLocationPluginSettings {
  attachmentFolderPath = "./assets/${filename}";
  autoRenameFiles = false;
  autoRenameFolder = true;
  convertImagesOnDragAndDrop = false;
  convertImagesToJpeg = false;
  deleteOrphanAttachments = false;
  duplicateNameSeparator = " ";
  jpegQuality = 0.8;
  keepEmptyAttachmentFolders = false;
  pastedFileName = "file-${date:YYYYMMDDHHmmssSSS}";
  renameAttachmentsOnDragAndDrop = false;
  renameCollectedFiles = false;
  renameOnlyImages = true;
  renamePastedFilesWithKnownNames = false;
  replaceWhitespace = false;
  toLowerCase = false;
  static load(data) {
    const legacySettings = (0, import_PluginSettings.loadPluginSettings)(() => new LegacySettings(), data);
    let shouldSave = false;
    if (legacySettings.dateTimeFormat || legacySettings.pastedImageFileName) {
      const dateTimeFormat = legacySettings.dateTimeFormat || "YYYYMMDDHHmmssSSS";
      legacySettings.attachmentFolderPath = addDateTimeFormat(legacySettings.attachmentFolderPath, dateTimeFormat);
      legacySettings.pastedFileName = addDateTimeFormat(legacySettings.pastedFileName || legacySettings.pastedImageFileName || "file-${date}", dateTimeFormat);
      legacySettings.dateTimeFormat = "";
      legacySettings.pastedImageFileName = "";
      shouldSave = true;
    }
    const settings = (0, import_PluginSettings.loadPluginSettings)(() => new _CustomAttachmentLocationPluginSettings(), legacySettings);
    return { settings, shouldSave };
  }
};
var LegacySettings = class extends CustomAttachmentLocationPluginSettings {
  dateTimeFormat = "";
  pastedImageFileName = "";
};
function addDateTimeFormat(str, dateTimeFormat) {
  return str.replaceAll("${date}", `\${date:${dateTimeFormat}}`);
}

// src/CustomAttachmentLocationPluginSettingsTab.ts
var import_obsidian3 = require("obsidian");
var import_DocumentFragment2 = __toESM(require_DocumentFragment(), 1);
var import_PluginSettingsTabBase = __toESM(require_PluginSettingsTabBase(), 1);
var import_ValueComponent = __toESM(require_ValueComponent(), 1);
var __process2 = globalThis["process"] ?? {
  "cwd": () => "/",
  "env": {},
  "platform": "android"
};
var CustomAttachmentLocationPluginSettingsTab = class extends import_PluginSettingsTabBase.PluginSettingsTabBase {
  display() {
    this.containerEl.empty();
    new import_obsidian3.Setting(this.containerEl).setName("Location for New Attachments").setDesc(createFragment((f) => {
      f.appendText("Start with ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, ".");
      f.appendText(" to use relative path. Available variables: ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${filename}");
      f.appendText(", ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${foldername}");
      f.appendText(", ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${folderPath}");
      f.appendText(", ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${date:format}");
      f.appendText(".");
      f.appendChild(createEl("br"));
      f.appendText("Dot-folders like ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, ".attachments");
      f.appendText(" are not recommended, because Obsidian doesn't track them. You might need to use ");
      f.createEl("a", { href: "https://github.com/polyipseity/obsidian-show-hidden-files/", text: "Show Hidden Files" });
      f.appendText(" Plugin to manage them.");
    })).addText(
      (text) => (0, import_ValueComponent.extend)(text).bind(this.plugin, "attachmentFolderPath", {
        componentToPluginSettingsValueConverter(uiValue) {
          return (0, import_obsidian3.normalizePath)(uiValue);
        },
        pluginSettingsToComponentValueConverter(pluginSettingsValue) {
          return pluginSettingsValue;
        },
        valueValidator(uiValue) {
          return validatePath(uiValue);
        }
      }).setPlaceholder("./assets/${filename}")
    );
    new import_obsidian3.Setting(this.containerEl).setName("Pasted File Name").setDesc(createFragment((f) => {
      f.appendText("Available variables: ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${filename}");
      f.appendText(", ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${foldername}");
      f.appendText(", ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${date:format}");
      f.appendText(", ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${originalCopiedFilename}");
      f.appendText(", ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${prompt}");
      f.appendText(".");
    })).addText(
      (text) => (0, import_ValueComponent.extend)(text).bind(this.plugin, "pastedFileName", {
        valueValidator(uiValue) {
          return validatePath(uiValue);
        }
      }).setPlaceholder("file-${date:YYYYMMDDHHmmssSSS}")
    );
    new import_obsidian3.Setting(this.containerEl).setName("Automatically rename attachment folder").setDesc(createFragment((f) => {
      f.appendText("When renaming md files, automatically rename attachment folder if folder name contains ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${filename}");
      f.appendText(".");
    })).addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "autoRenameFolder"));
    new import_obsidian3.Setting(this.containerEl).setName("Automatically rename attachment files").setDesc(createFragment((f) => {
      f.appendText("When renaming md files, automatically rename attachment files if file name contains ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "${filename}");
      f.appendText(".");
    })).addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "autoRenameFiles"));
    new import_obsidian3.Setting(this.containerEl).setName("Replace whitespace with hyphen").setDesc("Automatically replace whitespace in attachment folder and file name with hyphens.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "replaceWhitespace"));
    new import_obsidian3.Setting(this.containerEl).setName("All lowercase names").setDesc("Automatically set all characters in folder name and pasted image name to be lowercase.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "toLowerCase"));
    new import_obsidian3.Setting(this.containerEl).setName("Convert pasted images to JPEG").setDesc("Paste images from clipboard converting them to JPEG.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "convertImagesToJpeg"));
    new import_obsidian3.Setting(this.containerEl).setName("JPEG Quality").setDesc("The smaller the quality, the greater the compression ratio.").addDropdown((dropDown) => {
      dropDown.addOptions(generateJpegQualityOptions());
      (0, import_ValueComponent.extend)(dropDown).bind(this.plugin, "jpegQuality", {
        componentToPluginSettingsValueConverter: (value) => Number(value),
        pluginSettingsToComponentValueConverter: (value) => value.toString()
      });
    });
    new import_obsidian3.Setting(this.containerEl).setName("Convert images on drag&drop").setDesc(createFragment((f) => {
      f.appendText("If enabled and ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "Convert pasted images to JPEG");
      f.appendText(" setting is enabled, images drag&dropped into the editor will be converted to JPEG.");
    })).addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "convertImagesOnDragAndDrop"));
    new import_obsidian3.Setting(this.containerEl).setName("Rename only images").setDesc(createFragment((f) => {
      f.appendText("If enabled, only image files will be renamed.");
      f.appendChild(createEl("br"));
      f.appendText("If disabled, all attachment files will be renamed.");
    })).addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "renameOnlyImages"));
    new import_obsidian3.Setting(this.containerEl).setName("Rename pasted files with known names").setDesc(createFragment((f) => {
      f.appendText("If enabled, pasted copied files with known names will be renamed.");
      f.appendChild(createEl("br"));
      f.appendText("If disabled, only clipboard image objects (e.g., screenshots) will be renamed.");
    })).addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "renamePastedFilesWithKnownNames"));
    new import_obsidian3.Setting(this.containerEl).setName("Rename attachments on drag&drop").setDesc(createFragment((f) => {
      f.appendText("If enabled, attachments dragged and dropped into the editor will be renamed according to the ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "Pasted File Name");
      f.appendText(" setting.");
    })).addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "renameAttachmentsOnDragAndDrop"));
    new import_obsidian3.Setting(this.containerEl).setName("Rename attachments on collecting").setDesc(createFragment((f) => {
      f.appendText("If enabled, attachments processed via ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "Collect attachments");
      f.appendText(" commands will be renamed according to the ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "Pasted File Name");
      f.appendText(" setting.");
    })).addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "renameCollectedFiles"));
    new import_obsidian3.Setting(this.containerEl).setName("Duplicate name separator").setDesc(createFragment((f) => {
      f.appendText("When you are pasting/dragging a file with the same name as an existing file, this separator will be added to the file name.");
      f.appendChild(createEl("br"));
      f.appendText("E.g., when you are dragging file ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "existingFile.pdf");
      f.appendText(", it will be renamed to ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "existingFile 1.pdf");
      f.appendText(", ");
      (0, import_DocumentFragment2.appendCodeBlock)(f, "existingFile 2.pdf");
      f.appendText(", etc, getting the first name available.");
    })).addText(
      (text) => (0, import_ValueComponent.extend)(text).bind(this.plugin, "duplicateNameSeparator", {
        valueValidator(uiValue) {
          return uiValue === "" ? null : validateFilename(uiValue);
        }
      }).setPlaceholder(" ")
    );
    new import_obsidian3.Setting(this.containerEl).setName("Keep empty attachment folders").setDesc("If enabled, empty attachment folders will be preserved, useful for source control purposes.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "keepEmptyAttachmentFolders"));
    new import_obsidian3.Setting(this.containerEl).setName("Delete orphan attachments").setDesc("If enabled, when the note is deleted, its orphan attachments are deleted as well.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "deleteOrphanAttachments"));
  }
};
function generateJpegQualityOptions() {
  const ans = {};
  for (let i = 1; i <= 10; i++) {
    const valueStr = (i / 10).toFixed(1);
    ans[valueStr] = valueStr;
  }
  return ans;
}

// src/PasteDropEvent.ts
var import_electron = require("electron");
var import_Async = __toESM(require_Async(), 1);
var import_Blob = __toESM(require_Blob(), 1);
var import_FileSystem2 = __toESM(require_FileSystem(), 1);
var import_Path3 = __toESM(require_Path(), 1);
var EventWrapper = class {
  constructor(event, eventType, plugin) {
    this.event = event;
    this.eventType = eventType;
    this.plugin = plugin;
  }
  async handle() {
    let handledEvent = this.event;
    if (handledEvent.handled) {
      return;
    }
    const draggable = this.plugin.app.dragManager.draggable;
    const targetType = this.getTargetType();
    if (targetType === "Unsupported" /* Unsupported */) {
      return;
    }
    console.debug(`Handle ${targetType} ${this.eventType}`);
    const noteFile = this.plugin.app.workspace.getActiveFile();
    if (!noteFile || !(0, import_FileSystem2.isNote)(noteFile)) {
      return;
    }
    const dataTransfer = this.getDataTransfer();
    if (!dataTransfer) {
      return;
    }
    if (!this.event.target) {
      return;
    }
    this.event.preventDefault();
    this.event.stopImmediatePropagation();
    const pastedEntries = Array.from(dataTransfer.items).map((item) => {
      const type = item.type;
      if (item.kind === "file") {
        const file = item.getAsFile();
        if (!file) {
          throw new Error("Could not get file from item");
        }
        return {
          file,
          type
        };
      } else if (item.kind === "string") {
        const textPromise = new Promise((resolve) => {
          item.getAsString((text) => {
            resolve(text);
          });
        });
        return {
          textPromise,
          type
        };
      } else {
        throw new Error(`Unsupported item kind ${item.kind}`);
      }
    });
    const newDataTransfer = new DataTransfer();
    for (const entry of pastedEntries) {
      if (entry.textPromise) {
        newDataTransfer.items.add(await entry.textPromise, entry.type);
      } else if (entry.file) {
        let extension = (0, import_Path3.extname)(entry.file.name).slice(1);
        const originalCopiedFileName = (0, import_Path3.basename)(entry.file.name, "." + extension);
        let fileArrayBuffer;
        if (this.shouldConvertImages() && (0, import_Blob.isImageFile)(entry.file)) {
          fileArrayBuffer = await (0, import_Blob.blobToJpegArrayBuffer)(entry.file, this.plugin.settingsCopy.jpegQuality);
          extension = "jpg";
        } else {
          fileArrayBuffer = await (0, import_Blob.blobToArrayBuffer)(entry.file);
        }
        const shouldRename = this.shouldRenameAttachments(entry.file);
        let filename = shouldRename ? await getPastedFileName(this.plugin, createSubstitutionsFromPath(noteFile.path, originalCopiedFileName)) : originalCopiedFileName;
        filename = replaceWhitespace(this.plugin, filename);
        const filePropertyBag = { type: "application/octet-stream" };
        if (!shouldRename) {
          filePropertyBag.lastModified = entry.file.lastModified;
        }
        const renamedFile = new File([new Blob([fileArrayBuffer])], (0, import_Path3.makeFileName)(filename, extension), filePropertyBag);
        if (!shouldRename) {
          Object.defineProperty(renamedFile, "path", { value: entry.file.path || (import_electron.webUtils?.getPathForFile(entry.file) ?? "") });
        }
        newDataTransfer.items.add(renamedFile);
      }
    }
    handledEvent = this.cloneWithNewDataTransfer(newDataTransfer);
    handledEvent.handled = true;
    this.plugin.app.dragManager.draggable = draggable;
    this.event.target.dispatchEvent(handledEvent);
  }
  getTargetType() {
    if (!(this.event.target instanceof HTMLElement)) {
      return "Unsupported" /* Unsupported */;
    }
    if (this.plugin.app.workspace.activeEditor?.metadataEditor?.contentEl.contains(this.event.target)) {
      return "Unsupported" /* Unsupported */;
    }
    if (this.plugin.app.workspace.activeEditor?.editor?.containerEl.contains(this.event.target)) {
      return "Note" /* Note */;
    }
    if (this.event.target.closest(".canvas-wrapper")) {
      if (this.event.target.isContentEditable) {
        return "Unsupported" /* Unsupported */;
      }
      return "Canvas" /* Canvas */;
    }
    const canvasView = this.plugin.app.workspace.getActiveFileView();
    if (this.event.target.matches("body") && canvasView?.getViewType() === "canvas" && canvasView.containerEl.closest(".mod-active")) {
      return "Canvas" /* Canvas */;
    }
    return "Unsupported" /* Unsupported */;
  }
};
var DropEventWrapper = class extends EventWrapper {
  constructor(event, plugin) {
    super(event, "Drop", plugin);
    this.event = event;
  }
  cloneWithNewDataTransfer(dataTransfer) {
    return new DragEvent("drop", {
      bubbles: this.event.bubbles,
      cancelable: this.event.cancelable,
      clientX: this.event.clientX,
      clientY: this.event.clientY,
      composed: this.event.composed,
      dataTransfer
    });
  }
  getDataTransfer() {
    return this.event.dataTransfer;
  }
  shouldConvertImages() {
    return this.plugin.settingsCopy.convertImagesToJpeg && this.plugin.settingsCopy.convertImagesOnDragAndDrop;
  }
  shouldRenameAttachments(file) {
    if (this.plugin.settingsCopy.renameOnlyImages && !(0, import_Blob.isImageFile)(file)) {
      return false;
    }
    return this.plugin.settingsCopy.renameAttachmentsOnDragAndDrop;
  }
};
var PasteEventWrapper = class extends EventWrapper {
  constructor(event, plugin) {
    super(event, "Paste", plugin);
    this.event = event;
  }
  cloneWithNewDataTransfer(dataTransfer) {
    return new ClipboardEvent("paste", {
      bubbles: this.event.bubbles,
      cancelable: this.event.cancelable,
      clipboardData: dataTransfer,
      composed: this.event.composed
    });
  }
  getDataTransfer() {
    return this.event.clipboardData;
  }
  shouldConvertImages() {
    return this.plugin.settingsCopy.convertImagesToJpeg;
  }
  shouldRenameAttachments(file) {
    if (this.plugin.settingsCopy.renameOnlyImages && !(0, import_Blob.isImageFile)(file)) {
      return false;
    }
    return file.path === "" || this.plugin.settingsCopy.renamePastedFilesWithKnownNames;
  }
};
function registerPasteDropEventHandlers(plugin) {
  const listener = (0, import_Async.convertAsyncToSync)(async (event) => handlePasteAndDrop(plugin, event));
  registerHandlersForWindow(window);
  plugin.app.workspace.on("window-open", (_, window2) => {
    registerHandlersForWindow(window2);
  });
  function registerHandlersForWindow(window2) {
    plugin.registerDomEvent(window2.document, "paste", listener, { capture: true });
    plugin.registerDomEvent(window2.document, "drop", listener, { capture: true });
  }
}
async function handlePasteAndDrop(plugin, event) {
  const eventWrapper = event.constructor.name === "ClipboardEvent" ? new PasteEventWrapper(event, plugin) : new DropEventWrapper(event, plugin);
  await eventWrapper.handle();
}

// src/CustomAttachmentLocationPlugin.ts
var CustomAttachmentLocationPlugin = class extends import_PluginBase.PluginBase {
  createDefaultPluginSettings() {
    return new CustomAttachmentLocationPluginSettings();
  }
  createPluginSettingsTab() {
    return new CustomAttachmentLocationPluginSettingsTab(this);
  }
  onLayoutReady() {
    this.register(around(this.app.vault, {
      getAvailablePath: () => this.getAvailablePath.bind(this),
      getAvailablePathForAttachments: () => {
        const extendedWrapper = {
          isExtended: true
        };
        return Object.assign(this.getAvailablePathForAttachments.bind(this), extendedWrapper);
      }
    }));
    if (import_electron2.webUtils) {
      this.register(around(import_electron2.webUtils, {
        getPathForFile: (next) => (file) => this.getPathForFile(file, next)
      }));
    }
  }
  onloadComplete() {
    (0, import_RenameDeleteHandler.registerRenameDeleteHandlers)(this, () => {
      const settings = {
        shouldDeleteEmptyFolders: !this.settings.keepEmptyAttachmentFolders,
        shouldDeleteOrphanAttachments: this.settings.deleteOrphanAttachments,
        shouldRenameAttachmentFiles: this.settings.autoRenameFiles,
        shouldRenameAttachmentFolder: this.settings.autoRenameFolder,
        shouldUpdateFilenameAliases: true,
        shouldUpdateLinks: true
      };
      return settings;
    });
    registerPasteDropEventHandlers(this);
    this.addCommand({
      checkCallback: (checking) => collectAttachmentsCurrentNote(this, checking),
      id: "collect-attachments-current-note",
      name: "Collect attachments in current note"
    });
    this.addCommand({
      checkCallback: (checking) => collectAttachmentsCurrentFolder(this, checking),
      id: "collect-attachments-current-folder",
      name: "Collect attachments in current folder"
    });
    this.addCommand({
      callback: () => {
        collectAttachmentsEntireVault(this);
      },
      id: "collect-attachments-entire-vault",
      name: "Collect attachments in entire vault"
    });
    this.registerEvent(this.app.workspace.on("file-menu", this.handleFileMenu.bind(this)));
  }
  async parseSettings(data) {
    const { settings, shouldSave } = CustomAttachmentLocationPluginSettings.load(data);
    if (shouldSave) {
      await this.saveSettings(settings);
    }
    return settings;
  }
  getAvailablePath(filename, extension) {
    let suffixNum = 0;
    for (; ; ) {
      const path = (0, import_Path4.makeFileName)(suffixNum == 0 ? filename : `${filename}${this.settings.duplicateNameSeparator}${suffixNum.toString()}`, extension);
      if (!(0, import_FileSystem3.getAbstractFileOrNull)(this.app, path, true)) {
        return path;
      }
      suffixNum++;
    }
  }
  async getAvailablePathForAttachments(filename, extension, file, skipFolderCreation) {
    let attachmentPath;
    if (!file || !(0, import_FileSystem3.isNote)(file)) {
      attachmentPath = await (0, import_AttachmentPath3.getAvailablePathForAttachments)(this.app, filename, extension, file, true);
    } else {
      const attachmentFolderFullPath = await getAttachmentFolderFullPathForPath(this, file.path);
      attachmentPath = this.app.vault.getAvailablePath((0, import_Path4.join)(attachmentFolderFullPath, filename), extension);
    }
    if (!skipFolderCreation) {
      const folderPath = (0, import_implementations.parentFolderPath)(attachmentPath);
      if (!await this.app.vault.exists(folderPath)) {
        await (0, import_Vault2.createFolderSafe)(this.app, folderPath);
        if (this.settings.keepEmptyAttachmentFolders) {
          await this.app.vault.create((0, import_Path4.join)(folderPath, ".gitkeep"), "");
        }
      }
    }
    return attachmentPath;
  }
  getPathForFile(file, next) {
    return file.path || next(file);
  }
  handleFileMenu(menu, file) {
    if (!(file instanceof import_obsidian4.TFolder)) {
      return;
    }
    menu.addItem((item) => {
      item.setTitle("Collect attachments in folder").setIcon("download").onClick(() => collectAttachmentsInFolder(this, file));
    });
  }
};

// src/main.ts
var main_default = CustomAttachmentLocationPlugin;
/*! Bundled license information:

moment/moment.js:
  (*! moment.js *)
  (*! version : 2.30.1 *)
  (*! authors : Tim Wood, Iskren Chernev, Moment.js contributors *)
  (*! license : MIT *)
  (*! momentjs.com *)
*/

/* nosourcemap */