From b12b3019682feb62a2c66351a478f7faeeb40ea1 Mon Sep 17 00:00:00 2001 From: KemoNine Date: Fri, 22 Nov 2024 14:27:30 -0500 Subject: [PATCH] setup, enable and run attachment management plugins --- .obsidian/community-plugins.json | 4 +- .../data.json | 22 + .../consistent-attachments-and-links/main.js | 4930 +++++++++ .../manifest.json | 11 + .../data.json | 18 + .../main.js | 9101 +++++++++++++++++ .../manifest.json | 11 + .obsidian/workspace.json | 66 +- Notes/Coloring Page Quick Reference.md | 4 +- Notes/Digital coloring and drawing.md | 14 +- Notes/Dot to Dot Quick Reference.md | 6 +- Notes/Krita Quick Reference.md | 16 +- Notes/Obsidian ToC.md | 2 +- Notes/_Troubleshooting The Vault.md | 6 +- Notes/__Using The Vault.md | 30 +- .../2024-09-13_16-56.png | Bin .../2024-09-13_16-56_1.png | Bin .../Blending---Darken---Layer---Fox.png | Bin .../Blending---Normal---Layer---Fox.png | Bin .../Blending---On-Top---Fox.png | Bin .../Complete---Fox-1.png | Bin .../DSC02900-3.jpg | Bin .../Palate-Layer---Fox.png | Bin .../2024-09-13_16-58.png | Bin .../2024-09-13_17-00.png | Bin .../2024-09-13_17-00_1.png | Bin .../Imagepipe_359.jpg | Bin .../Imagepipe_360.jpg | Bin .../Imagepipe_361.jpg | Bin .../{ => Obsidian ToC}/Obsidian ToC.png | Bin Notes/attachments/attachments.md | 40 +- Readme.md | 12 +- attachments/.nomedia | 1 + .../Readme}/Vault Screenshot 1.png | Bin .../Readme}/Vault Screenshot 2.png | Bin .../Readme}/Vault Screenshot 3.png | Bin .../Readme}/downloading.png | Bin .../Readme}/downloading_2.png | Bin 38 files changed, 14193 insertions(+), 101 deletions(-) create mode 100644 .obsidian/plugins/consistent-attachments-and-links/data.json create mode 100644 .obsidian/plugins/consistent-attachments-and-links/main.js create mode 100644 .obsidian/plugins/consistent-attachments-and-links/manifest.json create mode 100644 .obsidian/plugins/obsidian-custom-attachment-location/data.json create mode 100644 .obsidian/plugins/obsidian-custom-attachment-location/main.js create mode 100644 .obsidian/plugins/obsidian-custom-attachment-location/manifest.json rename Notes/attachments/{ => Coloring Page Quick Reference}/2024-09-13_16-56.png (100%) rename Notes/attachments/{ => Coloring Page Quick Reference}/2024-09-13_16-56_1.png (100%) rename Notes/attachments/{ => Digital coloring and drawing}/Blending---Darken---Layer---Fox.png (100%) rename Notes/attachments/{ => Digital coloring and drawing}/Blending---Normal---Layer---Fox.png (100%) rename Notes/attachments/{ => Digital coloring and drawing}/Blending---On-Top---Fox.png (100%) rename Notes/attachments/{ => Digital coloring and drawing}/Complete---Fox-1.png (100%) rename Notes/attachments/{ => Digital coloring and drawing}/DSC02900-3.jpg (100%) rename Notes/attachments/{ => Digital coloring and drawing}/Palate-Layer---Fox.png (100%) rename Notes/attachments/{ => Dot to Dot Quick Reference}/2024-09-13_16-58.png (100%) rename Notes/attachments/{ => Dot to Dot Quick Reference}/2024-09-13_17-00.png (100%) rename Notes/attachments/{ => Dot to Dot Quick Reference}/2024-09-13_17-00_1.png (100%) rename Notes/attachments/{ => Krita Quick Reference}/Imagepipe_359.jpg (100%) rename Notes/attachments/{ => Krita Quick Reference}/Imagepipe_360.jpg (100%) rename Notes/attachments/{ => Krita Quick Reference}/Imagepipe_361.jpg (100%) rename Notes/attachments/{ => Obsidian ToC}/Obsidian ToC.png (100%) create mode 100644 attachments/.nomedia rename {Notes/attachments => attachments/Readme}/Vault Screenshot 1.png (100%) rename {Notes/attachments => attachments/Readme}/Vault Screenshot 2.png (100%) rename {Notes/attachments => attachments/Readme}/Vault Screenshot 3.png (100%) rename {Notes/attachments => attachments/Readme}/downloading.png (100%) rename {Notes/attachments => attachments/Readme}/downloading_2.png (100%) diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json index 079fd26..68578a7 100644 --- a/.obsidian/community-plugins.json +++ b/.obsidian/community-plugins.json @@ -8,5 +8,7 @@ "automatic-table-of-contents", "obsidian-advanced-uri", "folder-notes", - "waypoint" + "waypoint", + "consistent-attachments-and-links", + "obsidian-custom-attachment-location" ] \ No newline at end of file diff --git a/.obsidian/plugins/consistent-attachments-and-links/data.json b/.obsidian/plugins/consistent-attachments-and-links/data.json new file mode 100644 index 0000000..934b410 --- /dev/null +++ b/.obsidian/plugins/consistent-attachments-and-links/data.json @@ -0,0 +1,22 @@ +{ + "autoCollectAttachments": false, + "changeNoteBacklinksAlt": true, + "consistencyReportFile": "consistency-report.md", + "deleteAttachmentsWithNote": true, + "deleteEmptyFolders": true, + "deleteExistFilesWhenMoveNote": false, + "ignoreFiles": [ + "consistency\\-report\\.md", + ".*attachments\\.md", + ".*Source\\ Materials\\.md" + ], + "ignoreFolders": [ + ".git/", + ".obsidian/", + "_Templates/", + "Attic/" + ], + "moveAttachmentsWithNote": true, + "showWarning": false, + "updateLinks": true +} \ No newline at end of file diff --git a/.obsidian/plugins/consistent-attachments-and-links/main.js b/.obsidian/plugins/consistent-attachments-and-links/main.js new file mode 100644 index 0000000..cdc71c8 --- /dev/null +++ b/.obsidian/plugins/consistent-attachments-and-links/main.js @@ -0,0 +1,4930 @@ +/* +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-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: () => omitAsyncReturnType2, + omitReturnType: () => omitReturnType + }); + module2.exports = __toCommonJS2(Function_exports); + function noop() { + } + async function noopAsync() { + } + function omitAsyncReturnType2(fn) { + return async (...args) => { + await fn(...args); + }; + } + function omitReturnType(fn) { + return (...args) => { + fn(...args); + }; + } + } +}); + +// 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: () => parentFolderPath + }); + module2.exports = __toCommonJS2(implementations_exports); + function parentFolderPath(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, parentFolderPath(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, parentFolderPath(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 __process2 = 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 = __process2.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 join2() { + 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 dirname4(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 basename(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 extname(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: () => throwExpression + }); + 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 throwExpression(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: () => escapeRegExp + }); + module2.exports = __toCommonJS2(RegExp_exports); + function escapeRegExp(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_Error = require_Error(); + var import_RegExp = 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_RegExp.escapeRegExp)(source)).join("|"), "g"); + return str.replaceAll(regExp, (source) => replacementsMap[source] ?? (0, import_Error.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_Error.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: () => basename, + delimiter: () => delimiter, + dirname: () => dirname4, + extname: () => extname, + format: () => format, + getDirname: () => getDirname, + getFilename: () => getFilename, + isAbsolute: () => isAbsolute, + join: () => join2, + makeFileName: () => makeFileName, + 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 basename = posix.basename; + var dirname4 = posix.dirname; + var extname = posix.extname; + var format = posix.format; + function isAbsolute(path2) { + return posix.isAbsolute(path2) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path2)?.[0] === path2; + } + var join2 = posix.join; + var normalize = posix.normalize; + var parse = posix.parse; + var relative = posix.relative; + function getDirname(importMetaUrl) { + return dirname4(getFilename(importMetaUrl)); + } + function getFilename(importMetaUrl) { + return resolve(new URL(importMetaUrl).pathname); + } + function makeFileName(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_EXTENSION2, + checkExtension: () => checkExtension, + getAbstractFile: () => getAbstractFile, + getAbstractFileOrNull: () => getAbstractFileOrNull, + getFile: () => getFile, + getFileOrNull: () => getFileOrNull3, + getFolder: () => getFolder, + getFolderOrNull: () => getFolderOrNull, + getMarkdownFiles: () => getMarkdownFiles, + getOrCreateFile: () => getOrCreateFile2, + getOrCreateFolder: () => getOrCreateFolder, + getPath: () => getPath, + isAbstractFile: () => isAbstractFile, + isCanvasFile: () => isCanvasFile, + isFile: () => isFile, + isFolder: () => isFolder, + isMarkdownFile: () => isMarkdownFile2, + isNote: () => isNote2, + trimMarkdownExtension: () => trimMarkdownExtension + }); + module2.exports = __toCommonJS2(FileSystem_exports); + var import_obsidian5 = require("obsidian"); + var import_implementations = require_implementations(); + var import_Path4 = require_Path(); + var import_String = require_String(); + var MARKDOWN_FILE_EXTENSION2 = "md"; + var CANVAS_FILE_EXTENSION = "canvas"; + function checkExtension(pathOrFile, extension) { + if (pathOrFile === null) { + return false; + } + return (0, import_Path4.extname)(getPath(pathOrFile)).toLowerCase().slice(1) === extension.toLowerCase(); + } + function getAbstractFile(app, pathOrFile, insensitive) { + const file = getAbstractFileOrNull(app, pathOrFile, insensitive); + if (!file) { + throw new Error(`Abstract file not found: ${pathOrFile}`); + } + return file; + } + function getAbstractFileOrNull(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 = getFileOrNull3(app, pathOrFile, insensitive); + if (!file) { + if (allowNonExisting) { + file = (0, import_implementations.createTFileInstance)(app.vault, pathOrFile); + } else { + throw new Error(`File not found: ${pathOrFile}`); + } + } + return file; + } + function getFileOrNull3(app, pathOrFile, insensitive) { + const file = getAbstractFileOrNull(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_implementations.createTFolderInstance)(app.vault, pathOrFolder); + } else { + throw new Error(`Folder not found: ${pathOrFolder}`); + } + } + return folder; + } + function getFolderOrNull(app, pathOrFolder, insensitive) { + const folder = getAbstractFileOrNull(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) => isMarkdownFile2(file)); + } else { + import_obsidian5.Vault.recurseChildren(folder, (abstractFile) => { + if (isMarkdownFile2(abstractFile)) { + markdownFiles.push(abstractFile); + } + }); + } + markdownFiles = markdownFiles.sort((a, b) => a.path.localeCompare(b.path)); + return markdownFiles; + } + async function getOrCreateFile2(app, path) { + const file = getFileOrNull3(app, path); + if (file) { + return file; + } + const folderPath = (0, import_implementations.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 isCanvasFile(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 isMarkdownFile2(pathOrFile) { + return checkExtension(pathOrFile, MARKDOWN_FILE_EXTENSION2); + } + function isNote2(pathOrFile) { + return isMarkdownFile2(pathOrFile) || isCanvasFile(pathOrFile); + } + function trimMarkdownExtension(file) { + if (!isMarkdownFile2(file)) { + return file.path; + } + return (0, import_String.trimEnd)(file.path, "." + MARKDOWN_FILE_EXTENSION2); + } + } +}); + +// 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: () => loadPluginSettings + }); + module2.exports = __toCommonJS2(PluginSettings_exports); + function clonePluginSettings(defaultPluginSettingsFactory, settings) { + return loadPluginSettings(defaultPluginSettingsFactory, settings); + } + function loadPluginSettings(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_Error = require_Error(); + var import_Function2 = require_Function(); + var import_PluginSettings = require_PluginSettings(); + var __process2 = 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_PluginSettings.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_Error.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_PluginSettings.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_Function2.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_Function2.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_PluginSettings.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/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: () => convertAsyncToSync, + convertSyncToAsync: () => convertSyncToAsync, + invokeAsyncSafely: () => invokeAsyncSafely, + marksAsTerminateRetry: () => marksAsTerminateRetry, + retryWithTimeout: () => retryWithTimeout, + runWithTimeout: () => runWithTimeout, + sleep: () => sleep, + timeout: () => timeout, + toArray: () => toArray + }); + module2.exports = __toCommonJS2(Async_exports); + var import_Error = require_Error(); + async function addErrorHandler(asyncFn) { + try { + await asyncFn(); + } catch (asyncError) { + (0, import_Error.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 convertAsyncToSync(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_Error.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_Error.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/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/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_Error = require_Error(); + async function invokeAsyncAndLog(title, fn, stackTrace) { + const timestampStart = Date.now(); + if (stackTrace === void 0) { + stackTrace = (0, import_Error.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_Async = require_Async(); + var import_Error = require_Error(); + var import_Function2 = require_Function(); + var import_App = require_App(); + var import_Logger = require_Logger(); + var __process2 = 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_Error.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_Function2.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_Async.addErrorHandler)(() => (0, import_Async.runWithTimeout)(item.timeoutInMilliseconds, () => (0, import_Logger.invokeAsyncAndLog)(processNextQueueItem.name, item.fn, item.stackTrace))); + queue.items.shift(); + } + } +}); + +// node_modules/monkey-around/dist/index.cjs +var require_dist = __commonJS({ + "node_modules/monkey-around/dist/index.cjs"(exports2) { + "use strict"; + 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); + } + } + 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 = around; + 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: () => toJson + }); + module2.exports = __toCommonJS2(Object_exports); + var import_Error = require_Error(); + var __process2 = 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 toJson(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_Error.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/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: () => getAttachmentFilePath2, + getAttachmentFolderPath: () => getAttachmentFolderPath, + getAvailablePathForAttachments: () => getAvailablePathForAttachments, + hasOwnAttachmentFolder: () => hasOwnAttachmentFolder + }); + module2.exports = __toCommonJS2(AttachmentPath_exports); + var import_implementations = require_implementations(); + var import_Path4 = require_Path(); + var import_String = require_String(); + var import_FileSystem4 = require_FileSystem(); + async function getAttachmentFilePath2(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_Path4.extname)(attachmentPath); + const fileName = (0, import_Path4.basename)(attachmentPath, ext); + const internalFn = app.vault.getAvailablePathForAttachments; + if (internalFn.isExtended) { + return internalFn(fileName, ext.slice(1), note, true); + } + return await getAvailablePathForAttachments(app, fileName, ext.slice(1), note, true); + } + async function getAttachmentFolderPath(app, notePathOrFile) { + return (0, import_implementations.parentFolderPath)(await getAttachmentFilePath2(app, "DUMMY_FILE.pdf", notePathOrFile)); + } + async function getAvailablePathForAttachments(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 getAttachmentFolderPath(app, path); + const dummyAttachmentFolderPath = await getAttachmentFolderPath(app, (0, import_Path4.join)((0, import_Path4.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/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 __process2 = 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/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_implementations = require_implementations(); + function referenceToFileChange2(reference, newContent) { + if ((0, import_implementations.isReferenceCache)(reference)) { + return { + endIndex: reference.position.end.offset, + newContent, + oldContent: reference.original, + startIndex: reference.position.start.offset + }; + } else if ((0, import_implementations.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_implementations.isFrontmatterLinkCache)(a) && (0, import_implementations.isFrontmatterLinkCache)(b)) { + return a.key.localeCompare(b.key); + } + if ((0, import_implementations.isReferenceCache)(a) && (0, import_implementations.isReferenceCache)(b)) { + return a.position.start.offset - b.position.start.offset; + } + return (0, import_implementations.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: () => getAllLinks3, + getBacklinksForFileOrPath: () => getBacklinksForFileOrPath, + getBacklinksForFileSafe: () => getBacklinksForFileSafe2, + getBacklinksMap: () => getBacklinksMap, + getCacheSafe: () => getCacheSafe3, + getFrontMatterSafe: () => getFrontMatterSafe, + registerFile: () => registerFile, + tempRegisterFileAndRun: () => tempRegisterFileAndRun + }); + module2.exports = __toCommonJS2(MetadataCache_exports); + var import_obsidian5 = require("obsidian"); + var import_implementations = require_implementations(); + var import_Async = require_Async(); + var import_Function2 = require_Function(); + var import_Object = require_Object(); + var import_FileSystem4 = require_FileSystem(); + var import_FrontMatter = require_FrontMatter(); + var import_Reference2 = require_Reference(); + var __process2 = 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 getCacheSafe3(app, path); + } + } + function getAllLinks3(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_implementations.isReferenceCache)(link) && (0, import_implementations.isReferenceCache)(previousLink)) { + return link.position.start.offset !== previousLink.position.start.offset; + } + if ((0, import_implementations.isFrontmatterLinkCache)(link) && (0, import_implementations.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_Async.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_implementations.isReferenceCache)(link)) { + actualLink = content.slice(link.position.start.offset, link.position.end.offset); + } else if ((0, import_implementations.isFrontmatterLinkCache)(link)) { + const linkValue = (0, import_Object.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 getCacheSafe3(app, fileOrPath, retryOptions = {}) { + const DEFAULT_RETRY_OPTIONS = { timeoutInMilliseconds: 6e4 }; + const overriddenOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions }; + let cache = null; + await (0, import_Async.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 getCacheSafe3(app, pathOrFile); + return cache?.frontmatter ?? {}; + } + function registerFile(app, file) { + if (!file.deleted) { + return import_Function2.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_implementations.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: () => createFolderSafe3, + createTempFile: () => createTempFile, + createTempFolder: () => createTempFolder, + deleteEmptyFolderHierarchy: () => deleteEmptyFolderHierarchy2, + deleteSafe: () => deleteSafe, + getAvailablePath: () => getAvailablePath2, + getMarkdownFilesSorted: () => getMarkdownFilesSorted2, + getNoteFilesSorted: () => getNoteFilesSorted, + getSafeRenamePath: () => getSafeRenamePath, + isEmptyFolder: () => isEmptyFolder, + listSafe: () => listSafe2, + process: () => process2, + renameSafe: () => renameSafe2 + }); + module2.exports = __toCommonJS2(Vault_exports); + var import_obsidian5 = require("obsidian"); + var import_implementations = require_implementations(); + var import_Async = require_Async(); + var import_Error = require_Error(); + var import_Function2 = require_Function(); + var import_Path4 = require_Path(); + var import_ValueProvider = require_ValueProvider(); + var import_FileSystem4 = require_FileSystem(); + var import_MetadataCache3 = require_MetadataCache(); + var __process2 = globalThis["process"] ?? { + "cwd": () => "/", + "env": {}, + "platform": "android" + }; + async function copySafe2(app, oldPathOrFile, newPath) { + const file = (0, import_FileSystem4.getFile)(app, oldPathOrFile); + const newFolderPath = (0, import_implementations.parentFolderPath)(newPath); + await createFolderSafe3(app, newFolderPath); + const newAvailablePath = getAvailablePath2(app, newPath); + try { + await app.vault.copy(file, newAvailablePath); + } catch (e) { + if (!await app.vault.exists(newAvailablePath)) { + throw e; + } + } + return newAvailablePath; + } + async function createFolderSafe3(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_Function2.noopAsync; + } + const folderCleanup = await createTempFolder(app, (0, import_implementations.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_Function2.noopAsync; + } + const dirPath = (0, import_implementations.parentFolderPath)(path); + await createTempFolder(app, dirPath); + const folderCleanup = await createTempFolder(app, (0, import_implementations.parentFolderPath)(path)); + await createFolderSafe3(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_MetadataCache3.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 listSafe2(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_Error.printError)(new Error(`Failed to delete ${file.path}`, { cause: e })); + canDelete = false; + } + } + } + return canDelete; + } + function getAvailablePath2(app, path) { + const ext = (0, import_Path4.extname)(path); + return app.vault.getAvailablePath((0, import_Path4.join)((0, import_Path4.dirname)(path), (0, import_Path4.basename)(path, ext)), ext.slice(1)); + } + function getMarkdownFilesSorted2(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_Path4.dirname)(newPath); + let nonExistingPath = (0, import_Path4.basename)(newPath); + let folder = null; + for (; ; ) { + folder = (0, import_FileSystem4.getFolderOrNull)(app, folderPath, true); + if (folder) { + break; + } + nonExistingPath = (0, import_Path4.join)((0, import_Path4.basename)(folderPath), nonExistingPath); + folderPath = (0, import_Path4.dirname)(folderPath); + } + newPath = (0, import_Path4.join)(folder.getParentPrefix(), nonExistingPath); + } + if (oldPath.toLowerCase() === newPath.toLowerCase()) { + return newPath; + } + return getAvailablePath2(app, newPath); + } + async function isEmptyFolder(app, pathOrFolder) { + const listedFiles = await listSafe2(app, (0, import_FileSystem4.getPath)(pathOrFolder)); + return listedFiles.files.length === 0 && listedFiles.folders.length === 0; + } + async function listSafe2(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 process2(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_Async.retryWithTimeout)(async () => { + if (file.deleted) { + throw (0, import_Async.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_implementations.parentFolderPath)(newAvailablePath); + await createFolderSafe3(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_Object = require_Object(); + var import_ValueProvider = require_ValueProvider(); + var import_FileSystem4 = require_FileSystem(); + var import_FrontMatter = require_FrontMatter(); + var import_Vault3 = require_Vault(); + var __process2 = 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_Object.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_Object.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_Object.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: () => extractLinkFile3, + generateMarkdownLink: () => generateMarkdownLink2, + shouldResetAlias: () => shouldResetAlias, + splitSubpath: () => splitSubpath3, + testAngleBrackets: () => testAngleBrackets, + testEmbed: () => testEmbed2, + testLeadingDot: () => testLeadingDot, + testWikilink: () => testWikilink2, + updateLink: () => updateLink, + updateLinksInFile: () => updateLinksInFile2 + }); + module2.exports = __toCommonJS2(Link_exports); + var import_obsidian5 = require("obsidian"); + var import_Object = require_Object(); + var import_Path4 = require_Path(); + var import_String = require_String(); + var import_FileChange2 = require_FileChange(); + var import_FileSystem4 = require_FileSystem(); + var import_MetadataCache3 = 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 updateLink({ + app: options.app, + forceMarkdownLinks: options.forceMarkdownLinks, + link: options.link, + oldPathOrFile: options.oldPathOrFile, + pathOrFile: extractLinkFile3(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_MetadataCache3.getBacklinksForFileSafe)(app, pathOrFile, retryOptions); + for (const backlinkNotePath of backlinks.keys()) { + const currentLinks = backlinks.get(backlinkNotePath) ?? []; + const linkJsons = new Set(currentLinks.map((link) => (0, import_Object.toJson)(link))); + await editLinks(app, backlinkNotePath, (link) => { + const linkJson = (0, import_Object.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_MetadataCache3.getCacheSafe)(app, pathOrFile); + if (!cache) { + return []; + } + const changes = []; + for (const link of (0, import_MetadataCache3.getAllLinks)(cache)) { + const newContent = await linkConverter(link); + if (newContent === void 0) { + continue; + } + changes.push((0, import_Reference2.referenceToFileChange)(link, newContent)); + } + return changes; + }, retryOptions); + } + function extractLinkFile3(app, link, notePathOrFile) { + const { linkPath } = splitSubpath3(link.link); + return app.metadataCache.getFirstLinkpathDest(linkPath, (0, import_FileSystem4.getPath)(notePathOrFile)); + } + function generateMarkdownLink2(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_MetadataCache3.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 ? testEmbed2(options.originalLink) : void 0) ?? !(0, import_FileSystem4.isMarkdownFile)(file); + const isWikilink = options.isWikilink ?? (options.originalLink ? testWikilink2(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_Path4.relative)((0, import_Path4.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_Path4.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_Path4.basename)(path)); + aliasesToReset.add((0, import_Path4.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_Path4.dirname)(alias); + const base = (0, import_Path4.basename)(alias, (0, import_Path4.extname)(alias)); + if ((0, import_Path4.join)(dir, base).toLowerCase() === cleanDisplayText) { + return true; + } + } + return false; + } + function splitSubpath3(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 testEmbed2(link) { + return link.startsWith("!["); + } + function testLeadingDot(link) { + return link.includes("[[./") || link.includes("](./") || link.includes("](<./"); + } + function testWikilink2(link) { + return link.includes("[["); + } + function updateLink(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 = testWikilink2(link.original) && forceMarkdownLinks !== true; + const { subpath } = splitSubpath3(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_Path4.basename)(oldPath, (0, import_Path4.extname)(oldPath)).toLowerCase()) { + alias = file.basename; + } else if (alias?.toLowerCase() === (0, import_Path4.basename)(oldPath).toLowerCase()) { + alias = file.name; + } + } + if (newPath) { + file = (0, import_FileSystem4.getFile)(app, newPath, true); + } + const newLink = generateMarkdownLink2({ + alias, + app, + isWikilink: forceMarkdownLinks ? false : void 0, + originalLink: link.original, + pathOrFile: file, + sourcePathOrFile, + subpath + }); + return newLink; + } + async function updateLinksInFile2(options) { + const { + app, + embedOnlyLinks, + forceMarkdownLinks, + oldPathOrFile, + pathOrFile, + renameMap, + shouldUpdateFilenameAlias + } = options; + await editLinks(app, pathOrFile, (link) => { + const isEmbedLink = testEmbed2(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/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_around = require_dist(); + var import_obsidian5 = require("obsidian"); + var import_Error = require_Error(); + var import_Function2 = require_Function(); + var import_Object = require_Object(); + var import_Path4 = require_Path(); + var import_App = require_App(); + var import_AttachmentPath2 = require_AttachmentPath(); + var import_FileSystem4 = require_FileSystem(); + var import_Link3 = require_Link(); + var import_MetadataCache3 = require_MetadataCache(); + var import_Queue2 = require_Queue(); + var import_Vault3 = require_Vault(); + var __process2 = 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_AttachmentPath2.getAttachmentFolderPath)(app, oldPath); + const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder ? await (0, import_AttachmentPath2.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_AttachmentPath2.hasOwnAttachmentFolder)(app, oldPath)) { + const oldCache = await (0, import_MetadataCache3.getCacheSafe)(app, oldPath); + if (!oldCache) { + return; + } + for (const oldLink of (0, import_MetadataCache3.getAllLinks)(oldCache)) { + const oldAttachmentFile = (0, import_Link3.extractLinkFile)(app, oldLink, oldPath); + if (!oldAttachmentFile) { + continue; + } + if (oldAttachmentFile.path.startsWith(oldAttachmentFolderPath)) { + const oldAttachmentBacklinks = await (0, import_MetadataCache3.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_Path4.basename)(oldPath, (0, import_Path4.extname)(oldPath)); + const newBasename = (0, import_Path4.basename)(newPath, (0, import_Path4.extname)(newPath)); + for (const oldAttachmentFile of oldAttachmentFiles) { + if ((0, import_FileSystem4.isNote)(oldAttachmentFile)) { + continue; + } + const relativePath = (0, import_Path4.relative)(oldAttachmentFolderPath, oldAttachmentFile.path); + const newDir = (0, import_Path4.join)(newAttachmentFolderPath, (0, import_Path4.dirname)(relativePath)); + const newChildBasename = settings.shouldRenameAttachmentFiles ? oldAttachmentFile.basename.replaceAll(oldBasename, newBasename) : oldAttachmentFile.basename; + let newChildPath = (0, import_Path4.join)(newDir, (0, import_Path4.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_Path4.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_MetadataCache3.getAllLinks)(cache); + for (const link of links) { + const attachmentFile = (0, import_Link3.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_AttachmentPath2.getAttachmentFolderPath)(app, path); + const attachmentFolder = (0, import_FileSystem4.getFolderOrNull)(app, attachmentFolderPath); + if (!attachmentFolder) { + return; + } + if (!await (0, import_AttachmentPath2.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_MetadataCache3.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_Path4.join)((0, import_Path4.dirname)(newPath), "__temp__" + (0, import_Path4.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_around.around)(app.fileManager, { + updateAllLinks: () => import_Function2.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_MetadataCache3.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_Path4.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_Link3.editLinks)(app, newBacklinkPath, (link) => { + const oldRelatedPath = linkJsonToPathMap.get((0, import_Object.toJson)(link)); + if (!oldRelatedPath) { + return; + } + const newRelatedPath = renameMap.get(oldRelatedPath); + if (!newRelatedPath) { + return; + } + return (0, import_Link3.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_Error.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_Object.toJson)(canvasData); + }); + } else if ((0, import_FileSystem4.isMarkdownFile)(newPath)) { + await (0, import_Link3.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_Object.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/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_Object = require_Object(); + var ValueComponentEx = class { + constructor(valueComponent) { + this.valueComponent = valueComponent; + } + /** + * Returns the ValueComponent with extended functionality. + */ + asExtended() { + return (0, import_Object.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; + } + } +}); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => main_default +}); +module.exports = __toCommonJS(main_exports); + +// src/ConsistentAttachmentsAndLinksPlugin.ts +var import_obsidian4 = require("obsidian"); +var import_Function = __toESM(require_Function(), 1); +var import_FileSystem3 = __toESM(require_FileSystem(), 1); +var import_PluginBase = __toESM(require_PluginBase(), 1); +var import_Queue = __toESM(require_Queue(), 1); +var import_RenameDeleteHandler = __toESM(require_RenameDeleteHandler(), 1); +var import_Vault2 = __toESM(require_Vault(), 1); +var import_Path3 = __toESM(require_Path(), 1); + +// src/ConsistentAttachmentsAndLinksPluginSettings.ts +var ConsistentAttachmentsAndLinksPluginSettings = class { + autoCollectAttachments = false; + changeNoteBacklinksAlt = true; + consistencyReportFile = "consistency-report.md"; + deleteAttachmentsWithNote = true; + deleteEmptyFolders = true; + deleteExistFilesWhenMoveNote = true; + ignoreFiles = ["consistency\\-report\\.md"]; + ignoreFolders = [".git/", ".obsidian/"]; + moveAttachmentsWithNote = true; + showWarning = true; + updateLinks = true; + getIgnoreFilesRegex() { + return this.ignoreFiles.map((file) => RegExp(file)); + } +}; + +// src/ConsistentAttachmentsAndLinksPluginSettingsTab.ts +var import_obsidian = require("obsidian"); +var import_PluginSettingsTabBase = __toESM(require_PluginSettingsTabBase(), 1); +var import_ValueComponent = __toESM(require_ValueComponent(), 1); +var ConsistentAttachmentsAndLinksPluginSettingsTab = class extends import_PluginSettingsTabBase.PluginSettingsTabBase { + display() { + this.containerEl.empty(); + new import_obsidian.Setting(this.containerEl).setName("Move Attachments with Note").setDesc("Automatically move attachments when a note is relocated. This includes attachments located in the same folder or any of its subfolders.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "moveAttachmentsWithNote")); + new import_obsidian.Setting(this.containerEl).setName("Delete Unused Attachments with Note").setDesc("Automatically remove attachments that are no longer referenced in other notes when the note is deleted.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "deleteAttachmentsWithNote")); + new import_obsidian.Setting(this.containerEl).setName("Update Links").setDesc("Automatically update links to attachments and other notes when moving notes or attachments.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "updateLinks")); + new import_obsidian.Setting(this.containerEl).setName("Delete Empty Folders").setDesc("Automatically remove empty folders after moving notes with attachments.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "deleteEmptyFolders")); + new import_obsidian.Setting(this.containerEl).setName("Delete Duplicate Attachments on Note Move").setDesc("Automatically delete attachments when moving a note if a file with the same name exists in the destination folder. If disabled, the file will be renamed and moved.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "deleteExistFilesWhenMoveNote")); + new import_obsidian.Setting(this.containerEl).setName("Update Backlink Text on Note Rename").setDesc("When a note is renamed, its linked references are automatically updated. If this option is enabled, the text of backlinks to this note will also be modified.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "changeNoteBacklinksAlt")); + new import_obsidian.Setting(this.containerEl).setName("Ignore Folders").setDesc("Specify a list of folders to ignore. Enter each folder on a new line.").addTextArea( + (textArea) => (0, import_ValueComponent.extend)(textArea).bind(this.plugin, "ignoreFolders", { + componentToPluginSettingsValueConverter: (value) => value.trim().split("\n").map((value2) => this.getNormalizedPath(value2) + "/"), + pluginSettingsToComponentValueConverter: (value) => value.join("\n") + }).setPlaceholder("Example: .git, .obsidian") + ); + new import_obsidian.Setting(this.containerEl).setName("Ignore Files").setDesc("Specify a list of files to ignore. Enter each file on a new line.").addTextArea( + (textArea) => (0, import_ValueComponent.extend)(textArea).bind(this.plugin, "ignoreFiles", { + componentToPluginSettingsValueConverter: (value) => value.trim().split("\n"), + pluginSettingsToComponentValueConverter: (value) => value.join("\n") + }).setPlaceholder("Example: consistent-report.md") + ); + new import_obsidian.Setting(this.containerEl).setName("Consistency Report Filename").setDesc("Specify the name of the file for the consistency report.").addText( + (text) => (0, import_ValueComponent.extend)(text).bind(this.plugin, "consistencyReportFile").setPlaceholder("Example: consistency-report.md") + ); + new import_obsidian.Setting(this.containerEl).setName("Auto Collect Attachments").setDesc("Automatically collect attachments when the note is edited.").addToggle((toggle) => (0, import_ValueComponent.extend)(toggle).bind(this.plugin, "autoCollectAttachments")); + } + getNormalizedPath(path) { + return path.length == 0 ? path : (0, import_obsidian.normalizePath)(path); + } +}; + +// src/files-handler.ts +var import_obsidian3 = require("obsidian"); +var import_AttachmentPath = __toESM(require_AttachmentPath(), 1); +var import_FileSystem2 = __toESM(require_FileSystem(), 1); +var import_Link2 = __toESM(require_Link(), 1); +var import_MetadataCache2 = __toESM(require_MetadataCache(), 1); +var import_Vault = __toESM(require_Vault(), 1); +var import_Path2 = __toESM(require_Path(), 1); + +// src/links-handler.ts +var import_obsidian2 = require("obsidian"); +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_Reference = __toESM(require_Reference(), 1); +var import_Path = __toESM(require_Path(), 1); +var ConsistencyCheckResult = class extends Map { + constructor(title) { + super(); + this.title = title; + } + add(notePath, link) { + if (!this.has(notePath)) { + this.set(notePath, []); + } + const arr = this.get(notePath); + if (arr) { + arr.push(link); + } + } + toString(app, reportPath) { + if (this.size > 0) { + let str = `# ${this.title} (${this.size.toString()} files) +`; + for (const notePath of this.keys()) { + const note = (0, import_FileSystem.getFileOrNull)(app, notePath); + if (!note) { + continue; + } + const linkStr = (0, import_Link.generateMarkdownLink)({ + app, + pathOrFile: note, + sourcePathOrFile: reportPath + }); + str += `${linkStr}: +`; + for (const link of this.get(notePath) ?? []) { + str += `- (line ${(link.position.start.line + 1).toString()}): \`${link.link}\` +`; + } + str += "\n\n"; + } + return str; + } else { + return `# ${this.title} +No problems found + +`; + } + } +}; +var LinksHandler = class { + constructor(app, consoleLogPrefix = "", ignoreFolders = [], ignoreFilesRegex = []) { + this.app = app; + this.consoleLogPrefix = consoleLogPrefix; + this.ignoreFolders = ignoreFolders; + this.ignoreFilesRegex = ignoreFilesRegex; + } + async checkConsistency(note, badLinks, badEmbeds, wikiLinks, wikiEmbeds) { + if (this.isPathIgnored(note.path)) { + return; + } + const cache = await (0, import_MetadataCache.getCacheSafe)(this.app, note.path); + if (!cache) { + return; + } + const links = cache.links ?? []; + const embeds = cache.embeds ?? []; + for (const link of links) { + if (!await this.isValidLink(link, note.path)) { + badLinks.add(note.path, link); + } + if ((0, import_Link.testWikilink)(link.original)) { + wikiLinks.add(note.path, link); + } + } + for (const embed of embeds) { + if (!await this.isValidLink(embed, note.path)) { + badEmbeds.add(note.path, embed); + } + if ((0, import_Link.testWikilink)(embed.original)) { + wikiEmbeds.add(note.path, embed); + } + } + } + async convertAllNoteEmbedsPathsToRelative(notePath) { + return this.convertAllNoteRefPathsToRelative(notePath, true); + } + async convertAllNoteLinksPathsToRelative(notePath) { + return this.convertAllNoteRefPathsToRelative(notePath, false); + } + async getCachedNotesThatHaveLinkToFile(filePath) { + const file = (0, import_FileSystem.getFileOrNull)(this.app, filePath); + if (!file) { + return []; + } + const backlinks = await (0, import_MetadataCache.getBacklinksForFileSafe)(this.app, file); + return backlinks.keys(); + } + getFullPathForLink(link, owningNotePath) { + ({ linkPath: link } = (0, import_Link.splitSubpath)(link)); + const parentFolder = (0, import_Path.dirname)(owningNotePath); + const fullPath = (0, import_Path.join)(parentFolder, link); + return fullPath; + } + async replaceAllNoteWikilinksWithMarkdownLinks(notePath, embedOnlyLinks) { + if (this.isPathIgnored(notePath)) { + return 0; + } + const noteFile = (0, import_FileSystem.getFileOrNull)(this.app, notePath); + if (!noteFile) { + console.warn(this.consoleLogPrefix + "can't update wikilinks in note, file not found: " + notePath); + return 0; + } + const cache = await (0, import_MetadataCache.getCacheSafe)(this.app, noteFile); + if (!cache) { + return 0; + } + const links = (embedOnlyLinks ? cache.embeds : cache.links) ?? []; + const result = links.filter((link) => (0, import_Link.testWikilink)(link.original)).length; + await (0, import_Link.updateLinksInFile)({ + app: this.app, + embedOnlyLinks, + forceMarkdownLinks: true, + oldPathOrFile: noteFile.path, + pathOrFile: noteFile, + renameMap: /* @__PURE__ */ new Map() + }); + return result; + } + async updateChangedPathsInNote(notePath, changedLinks) { + if (this.isPathIgnored(notePath)) { + return; + } + const note = (0, import_FileSystem.getFileOrNull)(this.app, notePath); + if (!note) { + console.warn(this.consoleLogPrefix + "can't update links in note, file not found: " + notePath); + return; + } + const pathChangeMap = /* @__PURE__ */ new Map(); + for (const change of changedLinks) { + pathChangeMap.set(change.oldPath, change.newPath); + } + await this.updateLinks(note, note.path, pathChangeMap); + } + async convertAllNoteRefPathsToRelative(notePath, isEmbed) { + if (this.isPathIgnored(notePath)) { + return []; + } + const note = (0, import_FileSystem.getFileOrNull)(this.app, notePath); + if (!note) { + return []; + } + const changedRefs = []; + await (0, import_FileChange.applyFileChanges)(this.app, note, async () => { + const cache = await (0, import_MetadataCache.getCacheSafe)(this.app, note); + if (!cache) { + return []; + } + const refs = (isEmbed ? cache.embeds : cache.links) ?? []; + const changes = []; + for (const ref of refs) { + const change = { + endIndex: ref.position.end.offset, + newContent: this.convertLink({ + forceRelativePath: true, + link: ref, + note, + oldNotePath: notePath + }), + oldContent: ref.original, + startIndex: ref.position.start.offset + }; + changes.push(change); + changedRefs.push({ newLink: change.newContent, old: ref }); + } + return changes; + }); + return changedRefs; + } + convertLink({ + forceRelativePath, + link, + note, + oldNotePath, + pathChangeMap + }) { + const { linkPath, subpath } = (0, import_Link.splitSubpath)(link.link); + const oldLinkPath = (0, import_Link.extractLinkFile)(this.app, link, oldNotePath)?.path ?? (0, import_Path.join)((0, import_Path.dirname)(oldNotePath), linkPath); + const newLinkPath = pathChangeMap ? pathChangeMap.get(oldLinkPath) : (0, import_Link.extractLinkFile)(this.app, link, note.path)?.path ?? (0, import_Path.join)((0, import_Path.dirname)(note.path), linkPath); + if (!newLinkPath) { + return link.original; + } + const newLinkedNote = (0, import_FileSystem.getFileOrNull)(this.app, oldLinkPath) ?? (0, import_FileSystem.getFileOrNull)(this.app, newLinkPath); + if (!newLinkedNote) { + return link.original; + } + return (0, import_Link.generateMarkdownLink)({ + alias: link.displayText, + app: this.app, + forceRelativePath, + originalLink: link.original, + pathOrFile: newLinkedNote, + sourcePathOrFile: note.path, + subpath + }); + } + isPathIgnored(path) { + if (path.startsWith("./")) { + path = path.slice(2); + } + for (const folder of this.ignoreFolders) { + if (path.startsWith(folder)) { + return true; + } + } + for (const fileRegex of this.ignoreFilesRegex) { + if (fileRegex.test(path)) { + return true; + } + } + return false; + } + async isValidLink(link, notePath) { + const { linkPath, subpath } = (0, import_Link.splitSubpath)(link.link); + let fullLinkPath; + if (!linkPath) { + fullLinkPath = notePath; + } else if (linkPath.startsWith("/")) { + fullLinkPath = (0, import_obsidian2.normalizePath)(linkPath); + } else { + fullLinkPath = (0, import_Path.join)((0, import_Path.dirname)(notePath), linkPath); + } + const file = (0, import_FileSystem.getFileOrNull)(this.app, fullLinkPath); + if (!file) { + return false; + } + if (!subpath) { + return true; + } + const ext = file.extension.toLocaleLowerCase(); + if (ext === "pdf") { + return subpath.startsWith("#page="); + } + if (ext !== import_FileSystem.MARKDOWN_FILE_EXTENSION) { + return false; + } + const cache = await (0, import_MetadataCache.getCacheSafe)(this.app, file); + if (!cache) { + return false; + } + if (subpath.startsWith("#^")) { + return Object.keys(cache.blocks ?? {}).includes(subpath.slice(2)); + } else { + return (cache.headings ?? []).map((h) => h.heading.replaceAll("#", " ")).includes(subpath.slice(1)); + } + } + async updateLinks(note, oldNotePath, pathChangeMap) { + await (0, import_FileChange.applyFileChanges)(this.app, note, async () => { + const cache = await (0, import_MetadataCache.getCacheSafe)(this.app, note); + if (!cache) { + return []; + } + const links = (0, import_MetadataCache.getAllLinks)(cache); + return links.map((link) => (0, import_Reference.referenceToFileChange)(link, this.convertLink({ + link, + note, + oldNotePath, + pathChangeMap + }))); + }); + } +}; + +// src/files-handler.ts +var FilesHandler = class { + constructor(app, lh, consoleLogPrefix = "", ignoreFolders = [], ignoreFilesRegex = [], shouldDeleteEmptyFolders = false) { + this.app = app; + this.lh = lh; + this.consoleLogPrefix = consoleLogPrefix; + this.ignoreFolders = ignoreFolders; + this.ignoreFilesRegex = ignoreFilesRegex; + this.shouldDeleteEmptyFolders = shouldDeleteEmptyFolders; + } + async collectAttachmentsForCachedNote(notePath, deleteExistFiles, deleteEmptyFolders) { + if (this.isPathIgnored(notePath)) { + return { movedAttachments: [], renamedFiles: [] }; + } + const result = { + movedAttachments: [], + renamedFiles: [] + }; + const cache = await (0, import_MetadataCache2.getCacheSafe)(this.app, notePath); + if (!cache) { + return result; + } + for (const link of (0, import_MetadataCache2.getAllLinks)(cache)) { + const { linkPath } = (0, import_Link2.splitSubpath)(link.link); + if (!linkPath) { + continue; + } + const fullPathLink = this.lh.getFullPathForLink(linkPath, notePath); + if (result.movedAttachments.findIndex((x) => x.oldPath == fullPathLink) != -1) { + continue; + } + const file = (0, import_Link2.extractLinkFile)(this.app, link, notePath); + if (!file) { + const type = (0, import_Link2.testEmbed)(link.original) ? "embed" : "link"; + console.warn(`${this.consoleLogPrefix}${notePath} has bad ${type} (file does not exist): ${linkPath}`); + continue; + } + if (!this.isAttachment(file)) { + continue; + } + const newPath = await (0, import_AttachmentPath.getAttachmentFilePath)(this.app, file.path, notePath); + if ((0, import_Path2.dirname)(newPath) === (0, import_Path2.dirname)(file.path)) { + continue; + } + const res = await this.moveAttachment(file, newPath, [notePath], deleteExistFiles, deleteEmptyFolders); + result.movedAttachments = result.movedAttachments.concat(res.movedAttachments); + result.renamedFiles = result.renamedFiles.concat(res.renamedFiles); + } + return result; + } + async deleteEmptyFolders(dirName) { + if (this.isPathIgnored(dirName)) { + return; + } + if (dirName.startsWith("./")) { + dirName = dirName.slice(2); + } + let list = await (0, import_Vault.listSafe)(this.app, dirName); + for (const folder of list.folders) { + await this.deleteEmptyFolders(folder); + } + list = await (0, import_Vault.listSafe)(this.app, dirName); + if (list.files.length == 0 && list.folders.length == 0) { + console.log(this.consoleLogPrefix + "delete empty folder: \n " + dirName); + if (await this.app.vault.exists(dirName)) { + try { + await this.app.vault.adapter.rmdir(dirName, false); + } catch (e) { + if (await this.app.vault.adapter.exists(dirName)) { + throw e; + } + } + } + } + } + async createFolderForAttachmentFromPath(filePath) { + await (0, import_Vault.createFolderSafe)(this.app, (0, import_Path2.dirname)(filePath)); + } + async deleteFile(file, deleteEmptyFolders) { + await this.app.fileManager.trashFile(file); + if (deleteEmptyFolders) { + let dir = file.parent; + while (dir && dir.children.length === 0) { + await this.app.fileManager.trashFile(dir); + dir = dir.parent; + } + } + } + isAttachment(file) { + return !(0, import_FileSystem2.isNote)(file); + } + isPathIgnored(path) { + if (path.startsWith("./")) { + path = path.slice(2); + } + for (const folder of this.ignoreFolders) { + if (path.startsWith(folder)) { + return true; + } + } + for (const fileRegex of this.ignoreFilesRegex) { + const testResult = fileRegex.test(path); + if (testResult) { + return true; + } + } + return false; + } + async moveAttachment(file, newLinkPath, parentNotePaths, deleteExistFiles, deleteEmptyFolders) { + const path = file.path; + const result = { + movedAttachments: [], + renamedFiles: [] + }; + if (this.isPathIgnored(path)) { + return result; + } + if (!this.isAttachment(file)) { + return result; + } + if (path == newLinkPath) { + console.warn(this.consoleLogPrefix + "Can't move file. Source and destination path the same."); + return result; + } + await this.createFolderForAttachmentFromPath(newLinkPath); + const linkedNotes = await this.lh.getCachedNotesThatHaveLinkToFile(path); + for (const notePath of parentNotePaths) { + linkedNotes.remove(notePath); + } + if (path !== file.path) { + console.warn(this.consoleLogPrefix + "File was moved already"); + return await this.moveAttachment(file, newLinkPath, parentNotePaths, deleteExistFiles, deleteEmptyFolders); + } + const oldFolder = file.parent; + if (linkedNotes.length == 0) { + const existFile = (0, import_FileSystem2.getFileOrNull)(this.app, newLinkPath); + if (!existFile) { + console.log(this.consoleLogPrefix + "move file [from, to]: \n " + path + "\n " + newLinkPath); + result.movedAttachments.push({ newPath: newLinkPath, oldPath: path }); + await (0, import_Vault.renameSafe)(this.app, file, newLinkPath); + } else { + if (deleteExistFiles) { + console.log(this.consoleLogPrefix + "delete file: \n " + path); + result.movedAttachments.push({ newPath: newLinkPath, oldPath: path }); + await this.deleteFile(file, deleteEmptyFolders); + } else { + const newFileCopyName = (0, import_Vault.getAvailablePath)(this.app, newLinkPath); + console.log(this.consoleLogPrefix + "copy file with new name [from, to]: \n " + path + "\n " + newFileCopyName); + result.movedAttachments.push({ newPath: newFileCopyName, oldPath: path }); + await (0, import_Vault.renameSafe)(this.app, file, newFileCopyName); + result.renamedFiles.push({ newPath: newFileCopyName, oldPath: newLinkPath }); + } + } + } else { + const existFile = (0, import_FileSystem2.getFileOrNull)(this.app, newLinkPath); + if (!existFile) { + console.log(this.consoleLogPrefix + "copy file [from, to]: \n " + path + "\n " + newLinkPath); + result.movedAttachments.push({ newPath: newLinkPath, oldPath: path }); + await (0, import_Vault.renameSafe)(this.app, file, newLinkPath); + await (0, import_Vault.copySafe)(this.app, file, path); + } else if (!deleteExistFiles) { + const newFileCopyName = (0, import_Vault.getAvailablePath)(this.app, newLinkPath); + console.log(this.consoleLogPrefix + "copy file with new name [from, to]: \n " + path + "\n " + newFileCopyName); + result.movedAttachments.push({ newPath: newFileCopyName, oldPath: file.path }); + await (0, import_Vault.renameSafe)(this.app, file, newFileCopyName); + await (0, import_Vault.copySafe)(this.app, file, path); + result.renamedFiles.push({ newPath: newFileCopyName, oldPath: newLinkPath }); + } + } + if (this.shouldDeleteEmptyFolders) { + await (0, import_Vault.deleteEmptyFolderHierarchy)(this.app, oldFolder); + } + return result; + } +}; + +// src/ConsistentAttachmentsAndLinksPlugin.ts +var __process = globalThis["process"] ?? { + "cwd": () => "/", + "env": {}, + "platform": "android" +}; +var ConsistentAttachmentsAndLinksPlugin = class extends import_PluginBase.PluginBase { + deletedNoteCache = /* @__PURE__ */ new Map(); + fh; + lh; + async saveSettings(newSettings) { + await super.saveSettings(newSettings); + this.lh = new LinksHandler( + this.app, + "Consistent Attachments and Links: ", + this.settings.ignoreFolders, + this.settings.getIgnoreFilesRegex() + ); + this.fh = new FilesHandler( + this.app, + this.lh, + "Consistent Attachments and Links: ", + this.settings.ignoreFolders, + this.settings.getIgnoreFilesRegex() + ); + } + createDefaultPluginSettings() { + return new ConsistentAttachmentsAndLinksPluginSettings(); + } + createPluginSettingsTab() { + return new ConsistentAttachmentsAndLinksPluginSettingsTab(this); + } + onloadComplete() { + if (this.settings.showWarning) { + const notice = new import_obsidian4.Notice(createFragment((f) => { + f.appendText("Starting from "); + appendCodeBlock(f, "v3.0.0"); + f.appendText(", the plugin "); + appendCodeBlock(f, "Consistent Attachments and Links"); + f.appendText(" has setting "); + appendCodeBlock(f, "Attachment Subfolder"); + f.appendText(" removed. This is a BREAKING CHANGE."); + f.appendChild(createEl("br")); + f.appendChild(createEl("a", { href: "https://github.com/dy-sh/obsidian-consistent-attachments-and-links?tab=readme-ov-file#attachment-subfolder-setting", text: "Read more" })); + }), 0); + notice.noticeEl.onClickEvent((ev) => { + (0, import_Queue.addToQueue)(this.app, async () => { + if (ev.target instanceof HTMLAnchorElement) { + window.open(ev.target.href, "_blank"); + } + this.settings.showWarning = false; + await this.saveSettings(this.settings); + }); + }); + } + this.registerEvent( + this.app.metadataCache.on("deleted", (file, prevCache) => { + if (prevCache) { + this.handleDeletedMetadata(file, prevCache); + } + }) + ); + (0, import_RenameDeleteHandler.registerRenameDeleteHandlers)(this, () => { + const settings = { + shouldDeleteConflictingAttachments: this.settings.deleteExistFilesWhenMoveNote, + shouldDeleteEmptyFolders: this.settings.deleteEmptyFolders, + shouldDeleteOrphanAttachments: this.settings.deleteAttachmentsWithNote, + shouldRenameAttachmentFolder: this.settings.moveAttachmentsWithNote, + shouldUpdateFilenameAliases: this.settings.changeNoteBacklinksAlt, + shouldUpdateLinks: this.settings.updateLinks + }; + return settings; + }); + this.addCommand({ + callback: () => this.collectAllAttachments(), + id: "collect-all-attachments", + name: "Collect All Attachments" + }); + this.addCommand({ + checkCallback: this.collectAttachmentsCurrentNote.bind(this), + id: "collect-attachments-current-note", + name: "Collect Attachments in Current Note" + }); + this.addCommand({ + callback: () => this.deleteEmptyFolders(), + id: "delete-empty-folders", + name: "Delete Empty Folders" + }); + this.addCommand({ + callback: () => this.convertAllLinkPathsToRelative(), + id: "convert-all-link-paths-to-relative", + name: "Convert All Link Paths to Relative" + }); + this.addCommand({ + checkCallback: this.convertAllLinkPathsToRelativeCurrentNote.bind(this), + id: "convert-all-link-paths-to-relative-current-note", + name: "Convert All Link Paths to Relative in Current Note" + }); + this.addCommand({ + callback: () => this.convertAllEmbedsPathsToRelative(), + id: "convert-all-embed-paths-to-relative", + name: "Convert All Embed Paths to Relative" + }); + this.addCommand({ + checkCallback: this.convertAllEmbedsPathsToRelativeCurrentNote.bind(this), + id: "convert-all-embed-paths-to-relative-current-note", + name: "Convert All Embed Paths to Relative in Current Note" + }); + this.addCommand({ + callback: () => this.replaceAllWikilinksWithMarkdownLinks(), + id: "replace-all-wikilinks-with-markdown-links", + name: "Replace All Wiki Links with Markdown Links" + }); + this.addCommand({ + checkCallback: this.replaceAllWikilinksWithMarkdownLinksCurrentNote.bind(this), + id: "replace-all-wikilinks-with-markdown-links-current-note", + name: "Replace All Wiki Links with Markdown Links in Current Note" + }); + this.addCommand({ + callback: () => this.replaceAllWikiEmbedsWithMarkdownEmbeds(), + id: "replace-all-wiki-embeds-with-markdown-embeds", + name: "Replace All Wiki Embeds with Markdown Embeds" + }); + this.addCommand({ + checkCallback: this.replaceAllWikiEmbedsWithMarkdownEmbedsCurrentNote.bind(this), + id: "replace-all-wiki-embeds-with-markdown-embeds-current-note", + name: "Replace All Wiki Embeds with Markdown Embeds in Current Note" + }); + this.addCommand({ + callback: () => this.reorganizeVault(), + id: "reorganize-vault", + name: "Reorganize Vault" + }); + this.addCommand({ + callback: () => this.checkConsistency(), + id: "check-consistency", + name: "Check Vault consistency" + }); + this.registerEvent(this.app.metadataCache.on("changed", (file) => { + (0, import_Queue.addToQueue)(this.app, () => this.handleMetadataCacheChanged(file)); + })); + this.lh = new LinksHandler( + this.app, + "Consistent Attachments and Links: ", + this.settings.ignoreFolders, + this.settings.getIgnoreFilesRegex() + ); + this.fh = new FilesHandler( + this.app, + this.lh, + "Consistent Attachments and Links: ", + this.settings.ignoreFolders, + this.settings.getIgnoreFilesRegex(), + this.settings.deleteEmptyFolders + ); + } + async checkConsistency() { + await this.saveAllOpenNotes(); + const badLinks = new ConsistencyCheckResult("Bad links"); + const badEmbeds = new ConsistencyCheckResult("Bad embeds"); + const wikiLinks = new ConsistencyCheckResult("Wiki links"); + const wikiEmbeds = new ConsistencyCheckResult("Wiki embeds"); + const notes = (0, import_Vault2.getMarkdownFilesSorted)(this.app); + let i = 0; + const notice = new import_obsidian4.Notice("", 0); + for (const note2 of notes) { + if (this.abortSignal.aborted) { + notice.hide(); + return; + } + i++; + const message = `Checking note # ${i.toString()} / ${notes.length.toString()} - ${note2.path}`; + notice.setMessage(message); + console.debug(message); + await this.lh.checkConsistency(note2, badLinks, badEmbeds, wikiLinks, wikiEmbeds); + } + notice.hide(); + const notePath = this.settings.consistencyReportFile; + const text = badLinks.toString(this.app, notePath) + badEmbeds.toString(this.app, notePath) + wikiLinks.toString(this.app, notePath) + wikiEmbeds.toString(this.app, notePath); + await (0, import_Vault2.createFolderSafe)(this.app, (0, import_Path3.dirname)(notePath)); + const note = await (0, import_FileSystem3.getOrCreateFile)(this.app, notePath); + await this.app.vault.modify(note, text); + let fileOpened = false; + this.app.workspace.iterateAllLeaves((leaf) => { + if (leaf.getDisplayText() != "" && notePath.startsWith(leaf.getDisplayText())) { + fileOpened = true; + } + }); + if (!fileOpened) { + await this.app.workspace.openLinkText(notePath, "/", false); + } + } + async collectAllAttachments() { + let movedAttachmentsCount = 0; + let processedNotesCount = 0; + await this.saveAllOpenNotes(); + const notes = (0, import_Vault2.getMarkdownFilesSorted)(this.app); + let i = 0; + const notice = new import_obsidian4.Notice("", 0); + for (const note of notes) { + if (this.abortSignal.aborted) { + notice.hide(); + return; + } + i++; + const message = `Collecting attachments # ${i.toString()} / ${notes.length.toString()} - ${note.path}`; + notice.setMessage(message); + console.debug(message); + if (this.isPathIgnored(note.path)) { + continue; + } + const result = await this.fh.collectAttachmentsForCachedNote( + note.path, + this.settings.deleteExistFilesWhenMoveNote, + this.settings.deleteEmptyFolders + ); + if (result.movedAttachments.length > 0) { + await this.lh.updateChangedPathsInNote(note.path, result.movedAttachments); + movedAttachmentsCount += result.movedAttachments.length; + processedNotesCount++; + } + } + notice.hide(); + if (movedAttachmentsCount == 0) { + new import_obsidian4.Notice("No files found that need to be moved"); + } else { + new import_obsidian4.Notice(`Moved ${movedAttachmentsCount.toString()} attachment${movedAttachmentsCount > 1 ? "s" : ""} from ${processedNotesCount.toString()} note${processedNotesCount > 1 ? "s" : ""}`); + } + } + async collectAttachments(note, isVerbose = true) { + if (this.isPathIgnored(note.path)) { + new import_obsidian4.Notice("Note path is ignored"); + return; + } + await this.saveAllOpenNotes(); + const result = await this.fh.collectAttachmentsForCachedNote( + note.path, + this.settings.deleteExistFilesWhenMoveNote, + this.settings.deleteEmptyFolders + ); + if (result.movedAttachments.length > 0) { + await this.lh.updateChangedPathsInNote(note.path, result.movedAttachments); + } + if (result.movedAttachments.length == 0) { + if (isVerbose) { + new import_obsidian4.Notice("No files found that need to be moved"); + } + } else { + new import_obsidian4.Notice(`Moved ${result.movedAttachments.length.toString()} attachment${result.movedAttachments.length > 1 ? "s" : ""}`); + } + } + collectAttachmentsCurrentNote(checking) { + const note = this.app.workspace.getActiveFile(); + if (!note || !(0, import_FileSystem3.isMarkdownFile)(note)) { + return false; + } + if (!checking) { + (0, import_Queue.addToQueue)(this.app, () => this.collectAttachments(note)); + } + return true; + } + async convertAllEmbedsPathsToRelative() { + await this.saveAllOpenNotes(); + let changedEmbedCount = 0; + let processedNotesCount = 0; + const notes = (0, import_Vault2.getMarkdownFilesSorted)(this.app); + let i = 0; + const notice = new import_obsidian4.Notice("", 0); + for (const note of notes) { + if (this.abortSignal.aborted) { + notice.hide(); + return; + } + i++; + const message = `Converting embed paths to relative # ${i.toString()} / ${notes.length.toString()} - ${note.path}`; + notice.setMessage(message); + console.debug(message); + if (this.isPathIgnored(note.path)) { + continue; + } + const result = await this.lh.convertAllNoteEmbedsPathsToRelative(note.path); + if (result.length > 0) { + changedEmbedCount += result.length; + processedNotesCount++; + } + } + notice.hide(); + if (changedEmbedCount == 0) { + new import_obsidian4.Notice("No embeds found that need to be converted"); + } else { + new import_obsidian4.Notice(`Converted ${changedEmbedCount.toString()} embed${changedEmbedCount > 1 ? "s" : ""} from ${processedNotesCount.toString()} note${processedNotesCount > 1 ? "s" : ""}`); + } + } + convertAllEmbedsPathsToRelativeCurrentNote(checking) { + const note = this.app.workspace.getActiveFile(); + if (!note || !(0, import_FileSystem3.isMarkdownFile)(note)) { + return false; + } + if (!checking) { + (0, import_Queue.addToQueue)(this.app, (0, import_Function.omitAsyncReturnType)(() => this.lh.convertAllNoteEmbedsPathsToRelative(note.path))); + } + return true; + } + async convertAllLinkPathsToRelative() { + await this.saveAllOpenNotes(); + let changedLinksCount = 0; + let processedNotesCount = 0; + const notes = (0, import_Vault2.getMarkdownFilesSorted)(this.app); + let i = 0; + const notice = new import_obsidian4.Notice("", 0); + for (const note of notes) { + if (this.abortSignal.aborted) { + notice.hide(); + return; + } + i++; + const message = `Converting link paths to relative # ${i.toString()} / ${notes.length.toString()} - ${note.path}`; + notice.setMessage(message); + console.debug(message); + if (this.isPathIgnored(note.path)) { + continue; + } + const result = await this.lh.convertAllNoteLinksPathsToRelative(note.path); + if (result.length > 0) { + changedLinksCount += result.length; + processedNotesCount++; + } + } + notice.hide(); + if (changedLinksCount == 0) { + new import_obsidian4.Notice("No links found that need to be converted"); + } else { + new import_obsidian4.Notice(`Converted ${changedLinksCount.toString()} link${changedLinksCount > 1 ? "s" : ""} from ${processedNotesCount.toString()} note${processedNotesCount > 1 ? "s" : ""}`); + } + } + convertAllLinkPathsToRelativeCurrentNote(checking) { + const note = this.app.workspace.getActiveFile(); + if (!note || !(0, import_FileSystem3.isMarkdownFile)(note)) { + return false; + } + if (!checking) { + (0, import_Queue.addToQueue)(this.app, (0, import_Function.omitAsyncReturnType)(() => this.lh.convertAllNoteLinksPathsToRelative(note.path))); + } + return true; + } + async deleteEmptyFolders() { + await this.fh.deleteEmptyFolders("/"); + } + handleDeletedMetadata(file, prevCache) { + if (!this.settings.deleteAttachmentsWithNote || this.isPathIgnored(file.path) || !(0, import_FileSystem3.isMarkdownFile)(file)) { + return; + } + this.deletedNoteCache.set(file.path, prevCache); + } + async handleMetadataCacheChanged(file) { + if (!this.settings.autoCollectAttachments) { + return; + } + const suggestionContainer = document.querySelector(".suggestion-container"); + if (suggestionContainer && suggestionContainer.style.display !== "none") { + return; + } + await this.collectAttachments(file, false); + } + isPathIgnored(path) { + if (path.startsWith("./")) { + path = path.slice(2); + } + for (const folder of this.settings.ignoreFolders) { + if (path.startsWith(folder)) { + return true; + } + } + for (const fileRegex of this.settings.getIgnoreFilesRegex()) { + if (fileRegex.test(path)) { + return true; + } + } + return false; + } + async reorganizeVault() { + await this.saveAllOpenNotes(); + await this.replaceAllWikilinksWithMarkdownLinks(); + await this.replaceAllWikiEmbedsWithMarkdownEmbeds(); + await this.convertAllEmbedsPathsToRelative(); + await this.convertAllLinkPathsToRelative(); + await this.collectAllAttachments(); + await this.deleteEmptyFolders(); + new import_obsidian4.Notice("Reorganization of the vault completed"); + } + async replaceAllWikiEmbedsWithMarkdownEmbeds() { + await this.saveAllOpenNotes(); + let changedLinksCount = 0; + let processedNotesCount = 0; + const notes = (0, import_Vault2.getMarkdownFilesSorted)(this.app); + let i = 0; + const notice = new import_obsidian4.Notice("", 0); + for (const note of notes) { + if (this.abortSignal.aborted) { + notice.hide(); + return; + } + i++; + const message = `Replacing wiki embeds with markdown embeds # ${i.toString()} / ${notes.length.toString()} - ${note.path}`; + notice.setMessage(message); + console.debug(message); + if (this.isPathIgnored(note.path)) { + continue; + } + const result = await this.lh.replaceAllNoteWikilinksWithMarkdownLinks(note.path, true); + changedLinksCount += result; + processedNotesCount++; + } + notice.hide(); + if (changedLinksCount == 0) { + new import_obsidian4.Notice("No wiki embeds found that need to be replaced"); + } else { + new import_obsidian4.Notice(`Replaced ${changedLinksCount.toString()} wiki embed${changedLinksCount > 1 ? "s" : ""} from ${processedNotesCount.toString()} note${processedNotesCount > 1 ? "s" : ""}`); + } + } + replaceAllWikiEmbedsWithMarkdownEmbedsCurrentNote(checking) { + const note = this.app.workspace.getActiveFile(); + if (!note || !(0, import_FileSystem3.isMarkdownFile)(note)) { + return false; + } + if (!checking) { + (0, import_Queue.addToQueue)(this.app, (0, import_Function.omitAsyncReturnType)(() => this.lh.replaceAllNoteWikilinksWithMarkdownLinks(note.path, true))); + } + return true; + } + async replaceAllWikilinksWithMarkdownLinks() { + await this.saveAllOpenNotes(); + let changedLinksCount = 0; + let processedNotesCount = 0; + const notes = (0, import_Vault2.getMarkdownFilesSorted)(this.app); + let i = 0; + const notice = new import_obsidian4.Notice("", 0); + for (const note of notes) { + if (this.abortSignal.aborted) { + notice.hide(); + return; + } + i++; + const message = `Replacing wikilinks with markdown links # ${i.toString()} / ${notes.length.toString()} - ${note.path}`; + notice.setMessage(message); + console.debug(message); + if (this.isPathIgnored(note.path)) { + continue; + } + const result = await this.lh.replaceAllNoteWikilinksWithMarkdownLinks(note.path, false); + changedLinksCount += result; + processedNotesCount++; + } + notice.hide(); + if (changedLinksCount == 0) { + new import_obsidian4.Notice("No wiki links found that need to be replaced"); + } else { + new import_obsidian4.Notice(`Replaced ${changedLinksCount.toString()} wikilink${changedLinksCount > 1 ? "s" : ""} from ${processedNotesCount.toString()} note${processedNotesCount > 1 ? "s" : ""}`); + } + } + replaceAllWikilinksWithMarkdownLinksCurrentNote(checking) { + const note = this.app.workspace.getActiveFile(); + if (!note || !(0, import_FileSystem3.isMarkdownFile)(note)) { + return false; + } + if (!checking) { + (0, import_Queue.addToQueue)(this.app, (0, import_Function.omitAsyncReturnType)(() => this.lh.replaceAllNoteWikilinksWithMarkdownLinks(note.path, false))); + } + return true; + } + async saveAllOpenNotes() { + for (const leaf of this.app.workspace.getLeavesOfType("markdown")) { + if (leaf.view instanceof import_obsidian4.MarkdownView) { + await leaf.view.save(); + } + } + } +}; +function appendCodeBlock(fragment, text) { + fragment.appendChild(createSpan({ cls: "markdown-rendered code" }, (span) => { + span.style.fontWeight = "bold"; + span.appendChild(createEl("code", { text })); + })); +} + +// src/main.ts +var main_default = ConsistentAttachmentsAndLinksPlugin; + +/* nosourcemap */ \ No newline at end of file diff --git a/.obsidian/plugins/consistent-attachments-and-links/manifest.json b/.obsidian/plugins/consistent-attachments-and-links/manifest.json new file mode 100644 index 0000000..1c44d6f --- /dev/null +++ b/.obsidian/plugins/consistent-attachments-and-links/manifest.json @@ -0,0 +1,11 @@ +{ + "id": "consistent-attachments-and-links", + "name": "Consistent Attachments and Links", + "version": "3.21.10", + "minAppVersion": "1.7.7", + "description": "This plugin ensures the consistency of attachments and links", + "author": "Dmitry Savosh", + "authorUrl": "https://github.com/dy-sh/", + "isDesktopOnly": false, + "fundingUrl": "https://www.buymeacoffee.com/mnaoumov" +} diff --git a/.obsidian/plugins/obsidian-custom-attachment-location/data.json b/.obsidian/plugins/obsidian-custom-attachment-location/data.json new file mode 100644 index 0000000..45b417d --- /dev/null +++ b/.obsidian/plugins/obsidian-custom-attachment-location/data.json @@ -0,0 +1,18 @@ +{ + "attachmentFolderPath": "./attachments/${filename}", + "autoRenameFiles": false, + "autoRenameFolder": false, + "convertImagesOnDragAndDrop": false, + "convertImagesToJpeg": false, + "deleteOrphanAttachments": false, + "duplicateNameSeparator": " ", + "jpegQuality": 0.8, + "keepEmptyAttachmentFolders": false, + "pastedFileName": "file-${date:YYYYMMDDHHmmssSSS}", + "renameAttachmentsOnDragAndDrop": false, + "renameCollectedFiles": false, + "renameOnlyImages": false, + "renamePastedFilesWithKnownNames": false, + "replaceWhitespace": false, + "toLowerCase": false +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-custom-attachment-location/main.js b/.obsidian/plugins/obsidian-custom-attachment-location/main.js new file mode 100644 index 0000000..ef75816 --- /dev/null +++ b/.obsidian/plugins/obsidian-custom-attachment-location/main.js @@ -0,0 +1,9101 @@ +/* +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", + // + DATETIME_LOCAL_SECONDS: "YYYY-MM-DDTHH:mm:ss", + // + DATETIME_LOCAL_MS: "YYYY-MM-DDTHH:mm:ss.SSS", + // + DATE: "YYYY-MM-DD", + // + TIME: "HH:mm", + // + TIME_SECONDS: "HH:mm:ss", + // + TIME_MS: "HH:mm:ss.SSS", + // + WEEK: "GGGG-[W]WW", + // + MONTH: "YYYY-MM" + // + }; + 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 */ \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-custom-attachment-location/manifest.json b/.obsidian/plugins/obsidian-custom-attachment-location/manifest.json new file mode 100644 index 0000000..1cfc4b0 --- /dev/null +++ b/.obsidian/plugins/obsidian-custom-attachment-location/manifest.json @@ -0,0 +1,11 @@ +{ + "id": "obsidian-custom-attachment-location", + "name": "Custom Attachment Location", + "version": "4.28.3", + "minAppVersion": "1.7.7", + "description": "Customize attachment location with variables($filename, $data, etc) like typora.", + "author": "RainCat1998", + "authorUrl": "https://github.com/RainCat1998/", + "isDesktopOnly": false, + "fundingUrl": "https://www.buymeacoffee.com/mnaoumov" +} diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json index 4300715..9ad237f 100644 --- a/.obsidian/workspace.json +++ b/.obsidian/workspace.json @@ -54,23 +54,8 @@ "icon": "lucide-file", "title": "__Dashboard" } - }, - { - "id": "7b253e232b4d6bfd", - "type": "leaf", - "state": { - "type": "markdown", - "state": { - "file": "Notes/attachments/attachments.md", - "mode": "preview", - "source": true - }, - "icon": "lucide-file", - "title": "attachments" - } } - ], - "currentTab": 3 + ] } ], "direction": "vertical" @@ -226,20 +211,38 @@ "dashboard-navigator:Open dashboard navigator": false } }, - "active": "7ee887658e4391b7", + "active": "7d5274162457b1c7", "lastOpenFiles": [ + "Notes/__Using The Vault.md", + "__Dashboard.md", + "Notes/_Troubleshooting The Vault.md", "Notes/Notes.md", + "consistency-report.md", "Notes/attachments/attachments.md", + "Notes/attachments/Vault Screenshot 3.png", + "Notes/attachments/Vault Screenshot 2.png", + "Notes/attachments/Vault Screenshot 1.png", + "Notes/attachments/Palate-Layer---Fox.png", + "Notes/attachments/Obsidian ToC.png", + "Notes/attachments/Imagepipe_361.jpg", + "Notes/attachments/Imagepipe_360.jpg", + "Notes/attachments/Imagepipe_359.jpg", + "Notes/attachments/DSC02900-3.jpg", + "Notes/attachments/downloading_2.png", + "Readme.md", + "attachments/Readme", + "attachments", + "Notes/attachments/Obsidian ToC", + "Notes/attachments/Krita Quick Reference", + "Notes/attachments/Dot to Dot Quick Reference", + "Notes/attachments/Digital coloring and drawing", + "Notes/attachments/Coloring Page Quick Reference", + "Coloring/Source Materials/Source Materials.md", "Notes/Coloring Page Quick Reference.md", "Notes/__a", "Notes/Untitled.md", "Notes/Color Palette Generator.md", "Notes/Android Drawing Apps.md", - "Notes/_Troubleshooting The Vault.md", - "Notes/__Using The Vault.md", - "__Dashboard.md", - "Readme.md", - "Coloring/Source Materials/Source Materials.md", "Zentangle/Tangles/attachments/attachments.md", "Zentangle/Practice/attachments/attachments.md", "Zentangle/In Progress/attachments/attachments.md", @@ -256,23 +259,6 @@ "Dot to Dot/Complete/attachments/attachments.md", "Coloring/Prepped/attachments/attachments.canvas", "Zentangle/Tangles/attachments", - "Drawing/Practice/attachments", - "Drawing/In Progress/attachments", - "Dot to Dot/In Progress/attachments", - "Dot to Dot/Prepped/attachments", - "Coloring/Prepped/attachments", - "Coloring/In Progress/attachments", - "Notes/attachments/Imagepipe_360.jpg", - "Notes/attachments/Imagepipe_359.jpg", - "Notes/attachments/Imagepipe_361.jpg", - "Notes/attachments/2024-09-13_17-00_1.png", - "Notes/attachments/2024-09-13_17-00.png", - "Notes/attachments/2024-09-13_16-58.png", - "Notes/attachments/2024-09-13_16-56.png", - "Notes/attachments/2024-09-13_16-56_1.png", - "kritarc", - "Resources/sessions/Zentangle.0040.ksn", - "Dot to Dot/Source Materials/TimsPrintables/bulldozer-dot-to-dot_2_thumb.png", - "Dot to Dot/Source Materials/TimsPrintables/bulldozer-dot-to-dot_1_thumb.png" + "Drawing/Practice/attachments" ] } \ No newline at end of file diff --git a/Notes/Coloring Page Quick Reference.md b/Notes/Coloring Page Quick Reference.md index a61cfb9..6a2ffac 100644 --- a/Notes/Coloring Page Quick Reference.md +++ b/Notes/Coloring Page Quick Reference.md @@ -34,6 +34,6 @@ source: N/A ## Screenshots -![](Notes/attachments/2024-09-13_16-56.png) +![](attachments/Coloring%20Page%20Quick%20Reference/2024-09-13_16-56.png) -![](Notes/attachments/2024-09-13_16-56_1.png) \ No newline at end of file +![](attachments/Coloring%20Page%20Quick%20Reference/2024-09-13_16-56_1.png) \ No newline at end of file diff --git a/Notes/Digital coloring and drawing.md b/Notes/Digital coloring and drawing.md index b532dfe..dcaec8c 100644 --- a/Notes/Digital coloring and drawing.md +++ b/Notes/Digital coloring and drawing.md @@ -7,7 +7,7 @@ created_at: "2023-02-28" source: "Unknown" --- -![](Notes/attachments/DSC02900-3.jpg) +![](attachments/Digital%20coloring%20and%20drawing/DSC02900-3.jpg) ## Changelog {#changelog} @@ -195,23 +195,23 @@ Hopefully you can do the same. ### Complete Coloring Page {#complete-coloring-page} -![](Notes/attachments/Complete---Fox-1.png) +![](attachments/Digital%20coloring%20and%20drawing/Complete---Fox-1.png) ### In Progress Coloring Page {#in-progress-coloring-page} -![](Notes/attachments/Blending---On-Top---Fox.png) +![](attachments/Digital%20coloring%20and%20drawing/Blending---On-Top---Fox.png) ### Palate Layer {#palate-layer} -![](Notes/attachments/Palate-Layer---Fox.png) +![](attachments/Digital%20coloring%20and%20drawing/Palate-Layer---Fox.png) ### Blending - Darken {#blending-darken} -![](Notes/attachments/Blending---Darken---Layer---Fox.png) +![](attachments/Digital%20coloring%20and%20drawing/Blending---Darken---Layer---Fox.png) ### Blending - Normal {#blending-normal} -![](Notes/attachments/Blending---Normal---Layer---Fox.png) +![](attachments/Digital%20coloring%20and%20drawing/Blending---Normal---Layer---Fox.png) ## Advanced Coloring With Krita {#advanced-coloring-with-krita} @@ -227,7 +227,7 @@ The below sections layout how I setup Krita overall and I leave the practical im ## Important Note -Please see [Krita Quick Reference](Notes/Krita%20Quick%20Reference.md) instead of the below for current information on using Krita with mobile devices, particularly Android devices. +Please see [Krita Quick Reference](Krita%20Quick%20Reference.md) instead of the below for current information on using Krita with mobile devices, particularly Android devices. The below is the original blog post information which may have 'skewed out of date' over time compared to the `Krita Quick Reference` note stored in this vault. diff --git a/Notes/Dot to Dot Quick Reference.md b/Notes/Dot to Dot Quick Reference.md index 99619ca..8f340c5 100644 --- a/Notes/Dot to Dot Quick Reference.md +++ b/Notes/Dot to Dot Quick Reference.md @@ -42,8 +42,8 @@ source: N/A ## Screenshots -![](Notes/attachments/2024-09-13_16-58.png) +![](attachments/Dot%20to%20Dot%20Quick%20Reference/2024-09-13_16-58.png) -![](Notes/attachments/2024-09-13_17-00.png) +![](attachments/Dot%20to%20Dot%20Quick%20Reference/2024-09-13_17-00.png) -![](Notes/attachments/2024-09-13_17-00_1.png) \ No newline at end of file +![](attachments/Dot%20to%20Dot%20Quick%20Reference/2024-09-13_17-00_1.png) \ No newline at end of file diff --git a/Notes/Krita Quick Reference.md b/Notes/Krita Quick Reference.md index e597506..0f27e44 100644 --- a/Notes/Krita Quick Reference.md +++ b/Notes/Krita Quick Reference.md @@ -24,8 +24,8 @@ title: **Table of Contents** ## Input Device Tips / Tricks -- [Drawing Tablet Quick Reference](Notes/Drawing%20Tablet%20Quick%20Reference.md) -- [Trackpad Quick Reference](Notes/Trackpad%20Quick%20Reference.md) +- [Drawing Tablet Quick Reference](Drawing%20Tablet%20Quick%20Reference.md) +- [Trackpad Quick Reference](Trackpad%20Quick%20Reference.md) ## Android Tablet Tips / Tricks @@ -101,9 +101,9 @@ The below are the main hid settings KemoNine uses with a Samsung Android tablet The following are the device configs KemoNine uses within each device's setup/config tool(s). -- [Wacom One (Small) Drawing Tablet](Notes/Drawing%20Tablet%20Quick%20Reference.md#^163d42) -- [Logitech T650 Trackpad](Notes/Trackpad%20Quick%20Reference.md#^9233aa) -- [Samsung Z Fold 4](Notes/Krita%20Quick%20Reference.md#^0f3b48) +- [Wacom One (Small) Drawing Tablet](Drawing%20Tablet%20Quick%20Reference.md#^163d42) +- [Logitech T650 Trackpad](Trackpad%20Quick%20Reference.md#^9233aa) +- [Samsung Z Fold 4](#^0f3b48) ### Krita Input Config @@ -143,12 +143,12 @@ The below are the input settings KemoNine uses within Krita ### Main Krita View With File Open -![](Notes/attachments/Imagepipe_359.jpg) +![](attachments/Krita%20Quick%20Reference/Imagepipe_359.jpg) ### Canvas View -![](Notes/attachments/Imagepipe_360.jpg) +![](attachments/Krita%20Quick%20Reference/Imagepipe_360.jpg) ### Pop-up Palette -![](Notes/attachments/Imagepipe_361.jpg) +![](attachments/Krita%20Quick%20Reference/Imagepipe_361.jpg) diff --git a/Notes/Obsidian ToC.md b/Notes/Obsidian ToC.md index dc9ff8d..8fe8933 100644 --- a/Notes/Obsidian ToC.md +++ b/Notes/Obsidian ToC.md @@ -18,4 +18,4 @@ title: **Table of Contents** To see a table of contents using built in methods: -![](Notes/attachments/Obsidian%20ToC.png) +![](attachments/Obsidian%20ToC/Obsidian%20ToC.png) diff --git a/Notes/_Troubleshooting The Vault.md b/Notes/_Troubleshooting The Vault.md index 09ca00b..30793d2 100644 --- a/Notes/_Troubleshooting The Vault.md +++ b/Notes/_Troubleshooting The Vault.md @@ -13,4 +13,8 @@ title: **Table of Contents** ## Galleries Don't Update -If the gallery pages are not updating properly, it's likely the cache the plugin uses needs to be refreshed. From the command palette, run `Note Gallery: Drop all cache and re-initialize database` to force update all galleries. \ No newline at end of file +If the gallery pages are not updating properly, it's likely the cache the plugin uses needs to be refreshed. From the command palette, run `Note Gallery: Drop all cache and re-initialize database` to force update all galleries. + +## Attachment Weirdness / Infinite Loops + +The `Consistent Attachments and Links` plugin can act strange and/or trigger an infinite loop when it encounters any folder notes that act as indexes. Check the file and folder exclusions for this plugin to ensure they are accurate and exclude all indexes. \ No newline at end of file diff --git a/Notes/__Using The Vault.md b/Notes/__Using The Vault.md index 3e74a97..7ed4d45 100644 --- a/Notes/__Using The Vault.md +++ b/Notes/__Using The Vault.md @@ -24,10 +24,16 @@ This vault is setup to automatically manage attachments. It is configured to ens This will automatically move attachments and update links when a note is moved between folders. This is especially helpful as a note moves through the various state/status folders. -You can disable this functionality by disabling the `Import Attachments+` community plugin. +You can disable this functionality by disabling the `Consistent Attachments and Links` and `Custom Attachment Location` community plugins. ## Folder Indexes +### Important + +Please note *all* folder indexes *must* be excluded from the `Consistent Attachments and Links` plugin (if enabled). These folder indexes can create an infinite loop situation when the attachment automatic management is triggered. + +This is particularly problematic when running the `Reorganize Vault` command. + ### Attachment Folders This vault is setup to have "Folder Notes" that index the contents of each `attachments` directory. These folder notes are auto-updated and are a simple index of files within a given `attachments` directory. Simply click on an `attachments` directory to open the index. @@ -42,7 +48,7 @@ The `Notes` directory contains a lot of useful information related to digital ar ### Disabling -You can completely disable the directory index functionality by disabling the `Folder Notes` and `Waypoint` plugins. When disabling these plugins, you'll need to manually delete the folder notes within each `attachments` directory as well as the folder note within the `Notes` directory. +You can completely disable the directory index functionality by disabling the `Folder Notes` and `Waypoint` plugins. When disabling these plugins, you'll need to manually delete the folder notes within each `attachments` directory, each `Source Materials` directory as well as the folder note within the `Notes` directory. If you would like to keep the folder index functionality for only a sub-set of directories, simply delete the folder note for any directories you do not want indexed. @@ -82,19 +88,19 @@ If you would like to keep the folder index functionality for only a sub-set of d - You do *not* need to manage the galleries directly - Art works should flow between sub folders as progress is made. For example: `Prepped` -> `In Progress` -> `Complete` for order - The `Ideas - Inspiration` folder does *not* have sub-folders and assumes you'll just keep a list of notes similar to the `Notes` section or adjust this area to match your preferences. -- The [__Dashboard](__Dashboard.md) is meant to be 'the starting point' and 'overview' for the whole vault +- The [\_\_Dashboard](../__Dashboard.md) is meant to be 'the starting point' and 'overview' for the whole vault ## Troubleshooting -The [Troubleshooting The Vault](Notes/_Troubleshooting%20The%20Vault.md) note includes some common scenarios that can happen as the vault is used over time. If you have problems with the vault, start with this page for troubleshooting. +The [Troubleshooting The Vault](_Troubleshooting%20The%20Vault.md) note includes some common scenarios that can happen as the vault is used over time. If you have problems with the vault, start with this page for troubleshooting. ## New Artwork General Workflow - Prep downloaded files - Convert source material to art app native format - Setup any necessary layers - - See [Coloring Page Quick Reference](Notes/Coloring%20Page%20Quick%20Reference.md) for coloring pages - - See [Dot to Dot Quick Reference](Notes/Dot%20to%20Dot%20Quick%20Reference.md) for dot to dot pages + - See [Coloring Page Quick Reference](Coloring%20Page%20Quick%20Reference.md) for coloring pages + - See [Dot to Dot Quick Reference](Dot%20to%20Dot%20Quick%20Reference.md) for dot to dot pages - Create page for artwork using the appropriate template - Link files to new artwork page as appropriate - Move artwork page to appropriate sub folder @@ -104,12 +110,12 @@ The [Troubleshooting The Vault](Notes/_Troubleshooting%20The%20Vault.md) note in ## Suggested Reading (Notes) -- [Obtaining Source Material](Notes/Obtaining%20Source%20Material.md) -- [Android Drawing Apps](Notes/Android%20Drawing%20Apps.md) -- [Krita Quick Reference](Notes/Krita%20Quick%20Reference.md) -- [Color Palette Generator](Notes/Color%20Palette%20Generator.md) -- [Coloring Page Quick Reference](Notes/Coloring%20Page%20Quick%20Reference.md) -- [Dot to Dot Quick Reference](Notes/Dot%20to%20Dot%20Quick%20Reference.md) +- [Obtaining Source Material](Obtaining%20Source%20Material.md) +- [Android Drawing Apps](Android%20Drawing%20Apps.md) +- [Krita Quick Reference](Krita%20Quick%20Reference.md) +- [Color Palette Generator](Color%20Palette%20Generator.md) +- [Coloring Page Quick Reference](Coloring%20Page%20Quick%20Reference.md) +- [Dot to Dot Quick Reference](Dot%20to%20Dot%20Quick%20Reference.md) ## Enjoy diff --git a/Notes/attachments/2024-09-13_16-56.png b/Notes/attachments/Coloring Page Quick Reference/2024-09-13_16-56.png similarity index 100% rename from Notes/attachments/2024-09-13_16-56.png rename to Notes/attachments/Coloring Page Quick Reference/2024-09-13_16-56.png diff --git a/Notes/attachments/2024-09-13_16-56_1.png b/Notes/attachments/Coloring Page Quick Reference/2024-09-13_16-56_1.png similarity index 100% rename from Notes/attachments/2024-09-13_16-56_1.png rename to Notes/attachments/Coloring Page Quick Reference/2024-09-13_16-56_1.png diff --git a/Notes/attachments/Blending---Darken---Layer---Fox.png b/Notes/attachments/Digital coloring and drawing/Blending---Darken---Layer---Fox.png similarity index 100% rename from Notes/attachments/Blending---Darken---Layer---Fox.png rename to Notes/attachments/Digital coloring and drawing/Blending---Darken---Layer---Fox.png diff --git a/Notes/attachments/Blending---Normal---Layer---Fox.png b/Notes/attachments/Digital coloring and drawing/Blending---Normal---Layer---Fox.png similarity index 100% rename from Notes/attachments/Blending---Normal---Layer---Fox.png rename to Notes/attachments/Digital coloring and drawing/Blending---Normal---Layer---Fox.png diff --git a/Notes/attachments/Blending---On-Top---Fox.png b/Notes/attachments/Digital coloring and drawing/Blending---On-Top---Fox.png similarity index 100% rename from Notes/attachments/Blending---On-Top---Fox.png rename to Notes/attachments/Digital coloring and drawing/Blending---On-Top---Fox.png diff --git a/Notes/attachments/Complete---Fox-1.png b/Notes/attachments/Digital coloring and drawing/Complete---Fox-1.png similarity index 100% rename from Notes/attachments/Complete---Fox-1.png rename to Notes/attachments/Digital coloring and drawing/Complete---Fox-1.png diff --git a/Notes/attachments/DSC02900-3.jpg b/Notes/attachments/Digital coloring and drawing/DSC02900-3.jpg similarity index 100% rename from Notes/attachments/DSC02900-3.jpg rename to Notes/attachments/Digital coloring and drawing/DSC02900-3.jpg diff --git a/Notes/attachments/Palate-Layer---Fox.png b/Notes/attachments/Digital coloring and drawing/Palate-Layer---Fox.png similarity index 100% rename from Notes/attachments/Palate-Layer---Fox.png rename to Notes/attachments/Digital coloring and drawing/Palate-Layer---Fox.png diff --git a/Notes/attachments/2024-09-13_16-58.png b/Notes/attachments/Dot to Dot Quick Reference/2024-09-13_16-58.png similarity index 100% rename from Notes/attachments/2024-09-13_16-58.png rename to Notes/attachments/Dot to Dot Quick Reference/2024-09-13_16-58.png diff --git a/Notes/attachments/2024-09-13_17-00.png b/Notes/attachments/Dot to Dot Quick Reference/2024-09-13_17-00.png similarity index 100% rename from Notes/attachments/2024-09-13_17-00.png rename to Notes/attachments/Dot to Dot Quick Reference/2024-09-13_17-00.png diff --git a/Notes/attachments/2024-09-13_17-00_1.png b/Notes/attachments/Dot to Dot Quick Reference/2024-09-13_17-00_1.png similarity index 100% rename from Notes/attachments/2024-09-13_17-00_1.png rename to Notes/attachments/Dot to Dot Quick Reference/2024-09-13_17-00_1.png diff --git a/Notes/attachments/Imagepipe_359.jpg b/Notes/attachments/Krita Quick Reference/Imagepipe_359.jpg similarity index 100% rename from Notes/attachments/Imagepipe_359.jpg rename to Notes/attachments/Krita Quick Reference/Imagepipe_359.jpg diff --git a/Notes/attachments/Imagepipe_360.jpg b/Notes/attachments/Krita Quick Reference/Imagepipe_360.jpg similarity index 100% rename from Notes/attachments/Imagepipe_360.jpg rename to Notes/attachments/Krita Quick Reference/Imagepipe_360.jpg diff --git a/Notes/attachments/Imagepipe_361.jpg b/Notes/attachments/Krita Quick Reference/Imagepipe_361.jpg similarity index 100% rename from Notes/attachments/Imagepipe_361.jpg rename to Notes/attachments/Krita Quick Reference/Imagepipe_361.jpg diff --git a/Notes/attachments/Obsidian ToC.png b/Notes/attachments/Obsidian ToC/Obsidian ToC.png similarity index 100% rename from Notes/attachments/Obsidian ToC.png rename to Notes/attachments/Obsidian ToC/Obsidian ToC.png diff --git a/Notes/attachments/attachments.md b/Notes/attachments/attachments.md index 43181e3..f17fb33 100644 --- a/Notes/attachments/attachments.md +++ b/Notes/attachments/attachments.md @@ -1,23 +1,23 @@ %% Begin Waypoint %% -- [2024-09-13_16-56_1.png](./2024-09-13_16-56_1.png) -- [2024-09-13_16-56.png](./2024-09-13_16-56.png) -- [2024-09-13_16-58.png](./2024-09-13_16-58.png) -- [2024-09-13_17-00_1.png](./2024-09-13_17-00_1.png) -- [2024-09-13_17-00.png](./2024-09-13_17-00.png) -- [Blending---Darken---Layer---Fox.png](./Blending---Darken---Layer---Fox.png) -- [Blending---Normal---Layer---Fox.png](./Blending---Normal---Layer---Fox.png) -- [Blending---On-Top---Fox.png](./Blending---On-Top---Fox.png) -- [Complete---Fox-1.png](./Complete---Fox-1.png) -- [downloading_2.png](./downloading_2.png) -- [downloading.png](./downloading.png) -- [DSC02900-3.jpg](./DSC02900-3.jpg) -- [Imagepipe_359.jpg](./Imagepipe_359.jpg) -- [Imagepipe_360.jpg](./Imagepipe_360.jpg) -- [Imagepipe_361.jpg](./Imagepipe_361.jpg) -- [Obsidian ToC.png](./Obsidian%20ToC.png) -- [Palate-Layer---Fox.png](./Palate-Layer---Fox.png) -- [Vault Screenshot 1.png](./Vault%20Screenshot%201.png) -- [Vault Screenshot 2.png](./Vault%20Screenshot%202.png) -- [Vault Screenshot 3.png](./Vault%20Screenshot%203.png) +- **Coloring Page Quick Reference** + - [2024-09-13_16-56_1.png](./Coloring%20Page%20Quick%20Reference/2024-09-13_16-56_1.png) + - [2024-09-13_16-56.png](./Coloring%20Page%20Quick%20Reference/2024-09-13_16-56.png) +- **Digital coloring and drawing** + - [Blending---Darken---Layer---Fox.png](./Digital%20coloring%20and%20drawing/Blending---Darken---Layer---Fox.png) + - [Blending---Normal---Layer---Fox.png](./Digital%20coloring%20and%20drawing/Blending---Normal---Layer---Fox.png) + - [Blending---On-Top---Fox.png](./Digital%20coloring%20and%20drawing/Blending---On-Top---Fox.png) + - [Complete---Fox-1.png](./Digital%20coloring%20and%20drawing/Complete---Fox-1.png) + - [DSC02900-3.jpg](./Digital%20coloring%20and%20drawing/DSC02900-3.jpg) + - [Palate-Layer---Fox.png](./Digital%20coloring%20and%20drawing/Palate-Layer---Fox.png) +- **Dot to Dot Quick Reference** + - [2024-09-13_16-58.png](./Dot%20to%20Dot%20Quick%20Reference/2024-09-13_16-58.png) + - [2024-09-13_17-00_1.png](./Dot%20to%20Dot%20Quick%20Reference/2024-09-13_17-00_1.png) + - [2024-09-13_17-00.png](./Dot%20to%20Dot%20Quick%20Reference/2024-09-13_17-00.png) +- **Krita Quick Reference** + - [Imagepipe_359.jpg](./Krita%20Quick%20Reference/Imagepipe_359.jpg) + - [Imagepipe_360.jpg](./Krita%20Quick%20Reference/Imagepipe_360.jpg) + - [Imagepipe_361.jpg](./Krita%20Quick%20Reference/Imagepipe_361.jpg) +- **Obsidian ToC** + - [Obsidian ToC.png](./Obsidian%20ToC/Obsidian%20ToC.png) %% End Waypoint %% \ No newline at end of file diff --git a/Readme.md b/Readme.md index 09bc0d2..2dc1b27 100644 --- a/Readme.md +++ b/Readme.md @@ -6,7 +6,7 @@ Digital art may be 'rigid' and 'not notebook friendly' but this Obsidian vault c ## Additional Details -Please see the [__Using The Vault](Notes/__Using%20The%20Vault.md) file for additional detail how this vault can be used as a digital art composition book. Please note: some links on the `__Using The Vault` page will be broken when viewed from the website but *will* work properly when opened within Obsidian. +Please see the [\_\_Using The Vault](Notes/__Using%20The%20Vault.md) file for additional detail how this vault can be used as a digital art composition book. Please note: some links on the `__Using The Vault` page will be broken when viewed from the website but *will* work properly when opened within Obsidian. There are also screenshots below showing the vault in use. @@ -27,19 +27,19 @@ This project is licensed under the [Creative Commons BY-NC 4.0 International](ht ### From GitHub (the main site) -![How to download - GitHub](Notes/attachments/downloading_2.png) +![How to download - GitHub](attachments/Readme/downloading_2.png) ### From Forgejo (KemoNine's personal site mirror) -![How to download - Forgejo](Notes/attachments/downloading.png) +![How to download - Forgejo](attachments/Readme/downloading.png) ## Screenshots ### Main Vault View -![Main Vault View](Notes/attachments/Vault%20Screenshot%201.png) +![Main Vault View](attachments/Readme/Vault%20Screenshot%201.png) ### KemoNine Zentangle View -![KemoNine Zentangle View](Notes/attachments/Vault%20Screenshot%202.png) +![KemoNine Zentangle View](attachments/Readme/Vault%20Screenshot%202.png) ### KemoNine Coloring View -![KemoNine Coloring View](Notes/attachments/Vault%20Screenshot%203.png) +![KemoNine Coloring View](attachments/Readme/Vault%20Screenshot%203.png) diff --git a/attachments/.nomedia b/attachments/.nomedia new file mode 100644 index 0000000..cd7bc87 --- /dev/null +++ b/attachments/.nomedia @@ -0,0 +1 @@ +/storage/emulated/0/obsidian/digital-art-composition-book \ No newline at end of file diff --git a/Notes/attachments/Vault Screenshot 1.png b/attachments/Readme/Vault Screenshot 1.png similarity index 100% rename from Notes/attachments/Vault Screenshot 1.png rename to attachments/Readme/Vault Screenshot 1.png diff --git a/Notes/attachments/Vault Screenshot 2.png b/attachments/Readme/Vault Screenshot 2.png similarity index 100% rename from Notes/attachments/Vault Screenshot 2.png rename to attachments/Readme/Vault Screenshot 2.png diff --git a/Notes/attachments/Vault Screenshot 3.png b/attachments/Readme/Vault Screenshot 3.png similarity index 100% rename from Notes/attachments/Vault Screenshot 3.png rename to attachments/Readme/Vault Screenshot 3.png diff --git a/Notes/attachments/downloading.png b/attachments/Readme/downloading.png similarity index 100% rename from Notes/attachments/downloading.png rename to attachments/Readme/downloading.png diff --git a/Notes/attachments/downloading_2.png b/attachments/Readme/downloading_2.png similarity index 100% rename from Notes/attachments/downloading_2.png rename to attachments/Readme/downloading_2.png