@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.1.0

package/dist/demo-vault-helper/main.js

@@ -0,0 +1,1264 @@
+"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() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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/path-browserify/index.js
+var require_path_browserify = __commonJS({
+  "node_modules/path-browserify/index.js"(exports2, module2) {
+    "use strict";
+    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 posix2 = {
+      // 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 = process.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 posix2.normalize(joined);
+      },
+      relative: function relative(from, to) {
+        assertPath(from);
+        assertPath(to);
+        if (from === to) return "";
+        from = posix2.resolve(from);
+        to = posix2.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 dirname2(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 basename2(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 extname2(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 format2(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 parse2(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
+    };
+    posix2.posix = posix2;
+    module2.exports = posix2;
+  }
+});
+
+// demo-vault-helper/main.ts
+var main_exports = {};
+__export(main_exports, {
+  default: () => DemoVaultHelperPlugin
+});
+module.exports = __toCommonJS(main_exports);
+var import_obsidian3 = require("obsidian");
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/path.mjs
+var import_path_browserify = __toESM(require_path_browserify(), 1);
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/aggregate-error.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/function.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+function noop() {
+}
+var noopAsyncSingletonPromise = Promise.resolve();
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/type-guards.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/disposable.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/value-wrapper.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+var ValueWrapper = class _ValueWrapper {
+  /**
+   * Gets the wrapped value.
+   *
+   * @returns The wrapped value.
+   * @throws An {@link Error} if the value has not been set.
+   */
+  get value() {
+    if (!this.hasValue) {
+      throw new Error("Value is not set");
+    }
+    return this._value;
+  }
+  /**
+   * Sets the wrapped value.
+   *
+   * @param value - The value to wrap.
+   */
+  set value(value) {
+    this._value = value;
+    this.hasValue = true;
+  }
+  _value = null;
+  hasValue = false;
+  /**
+   * Creates a new value wrapper. Use {@link ValueWrapper.of} or {@link ValueWrapper.unset} instead.
+   */
+  constructor() {
+    noop();
+  }
+  /**
+   * Make wrapper from the value.
+   *
+   * @typeParam T - Type of the value to wrap.
+   * @param value - The value to wrap.
+   * @returns The wrapper.
+   */
+  static of(value) {
+    const wrapper = new _ValueWrapper();
+    wrapper.value = value;
+    return wrapper;
+  }
+  /**
+   * Make the wrapper with unset value.
+   *
+   * @typeParam T - Type of the value to wrap.
+   * @returns The wrapper.
+   */
+  static unset() {
+    return new _ValueWrapper();
+  }
+};
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/typescript-lib-state.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/abort-controller.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/reg-exp.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/value-provider.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/string.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+var EMPTY = "";
+var ESCAPE_MAP = {
+  "\n": String.raw`\n`,
+  "\r": String.raw`\r`,
+  "	": String.raw`\t`,
+  "\b": String.raw`\b`,
+  "\f": String.raw`\f`,
+  "'": String.raw`\'`,
+  '"': String.raw`\"`,
+  "\\": "\\\\"
+};
+var UNESCAPE_MAP = {};
+for (const [key, value] of Object.entries(ESCAPE_MAP)) {
+  UNESCAPE_MAP[value] = key;
+}
+
+// node_modules/@mnaoumov/typescript-lib/dist/lib/esm/path.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+var posix = import_path_browserify.default.posix;
+var delimiter = posix.delimiter;
+var separator = import_path_browserify.default.posix.sep;
+var basename = posix.basename;
+var dirname = posix.dirname;
+var extname = posix.extname;
+var format = posix.format;
+var join = posix.join;
+var normalizePath = posix.normalize;
+var parse = posix.parse;
+
+// node_modules/@mnaoumov/obsidian-lib/dist/lib/esm/demo-vault-helper.mjs
+var import_obsidian2 = require("obsidian");
+
+// node_modules/@mnaoumov/obsidian-lib/dist/lib/esm/community-plugins.mjs
+var import_obsidian = require("obsidian");
+
+// node_modules/@mnaoumov/obsidian-lib/dist/lib/esm/obsidian-dev-utils-state.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+function getObsidianDevUtilsState(key, defaultValue) {
+  return getObsidianDevUtilsBag()[key] ??= ValueWrapper.of(defaultValue);
+}
+function getObsidianDevUtilsBag() {
+  const wrapper = globalThis;
+  wrapper.__obsidianDevUtils ??= {};
+  return wrapper.__obsidianDevUtils;
+}
+
+// node_modules/@mnaoumov/obsidian-lib/dist/lib/esm/community-plugins.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+var COMMUNITY_PLUGINS_STATE_KEY = "communityPluginEntriesPromise";
+var COMMUNITY_PLUGINS_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
+var DATA_JSON_INDENT = 2;
+var ConfigureCommunityPluginResult = /* @__PURE__ */ ((ConfigureCommunityPluginResult2) => {
+  ConfigureCommunityPluginResult2["AppliedLive"] = "appliedLive";
+  ConfigureCommunityPluginResult2["Skipped"] = "skipped";
+  ConfigureCommunityPluginResult2["Success"] = "success";
+  return ConfigureCommunityPluginResult2;
+})(ConfigureCommunityPluginResult || {});
+async function configureCommunityPlugin(params) {
+  const { app, settings } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  const settingsComponent = getSettingsComponent(app.plugins.plugins[pluginId]);
+  if (checkHasEditAndSave(settingsComponent)) {
+    await settingsComponent.editAndSave((pluginSettings) => {
+      Object.assign(pluginSettings, settings);
+    });
+    return "appliedLive";
+  }
+  const dataPath = `${app.vault.configDir}/plugins/${pluginId}/data.json`;
+  let data = {};
+  if (await app.vault.adapter.exists(dataPath)) {
+    const parsed = JSON.parse(await app.vault.adapter.read(dataPath));
+    if (parsed !== null && typeof parsed === "object") {
+      data = parsed;
+    }
+  }
+  const serializedBefore = JSON.stringify(data);
+  Object.assign(data, settings);
+  if (JSON.stringify(data) === serializedBefore) {
+    return "skipped";
+  }
+  const serialized = String(JSON.stringify(data, null, DATA_JSON_INDENT));
+  await app.vault.adapter.write(dataPath, `${serialized}
+`);
+  return "success";
+}
+async function disableCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (!app.plugins.enabledPlugins.has(pluginId)) {
+    return;
+  }
+  await app.plugins.disablePluginAndSave(pluginId);
+}
+async function enableCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (app.plugins.enabledPlugins.has(pluginId)) {
+    return;
+  }
+  await app.plugins.enablePluginAndSave(pluginId);
+}
+async function getCommunityPluginRepo(pluginId) {
+  const entries = await getCommunityPluginEntries();
+  const entry = entries.find((candidate) => candidate.id === pluginId);
+  return entry?.repo ?? null;
+}
+async function getLatestReleaseVersion(repo) {
+  const response = await (0, import_obsidian.requestUrl)(`https://api.github.com/repos/${repo}/releases/latest`);
+  const release = response.json;
+  return release.tag_name;
+}
+async function installCommunityPlugin(params) {
+  const { app } = params;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (Object.hasOwn(app.plugins.manifests, pluginId)) {
+    return;
+  }
+  const repo = await getCommunityPluginRepo(pluginId);
+  if (!repo) {
+    throw new Error(`Plugin '${pluginId}' was not found in the Obsidian community plugins registry.`);
+  }
+  const version = await getLatestReleaseVersion(repo);
+  const manifest = await getPluginManifest(repo, version);
+  await app.plugins.installPlugin(repo, version, manifest);
+}
+async function installConfigureEnableCommunityPlugin(params) {
+  const { app, settings } = params;
+  await installCommunityPlugin(params);
+  const didSettingsChange = settings ? await configureCommunityPlugin({ ...params, settings }) === "success" : false;
+  const pluginId = await resolveCommunityPluginId(params);
+  if (!app.plugins.enabledPlugins.has(pluginId)) {
+    await enableCommunityPlugin(params);
+  } else if (didSettingsChange) {
+    await disableCommunityPlugin(params);
+    await enableCommunityPlugin(params);
+  }
+}
+function checkHasEditAndSave(settingsComponent) {
+  return typeof settingsComponent === "object" && settingsComponent !== null && "editAndSave" in settingsComponent && typeof settingsComponent.editAndSave === "function";
+}
+async function fetchCommunityPluginEntries() {
+  const response = await (0, import_obsidian.requestUrl)(COMMUNITY_PLUGINS_URL);
+  return response.json;
+}
+async function getCommunityPluginEntries() {
+  const cache = getObsidianDevUtilsState(COMMUNITY_PLUGINS_STATE_KEY, null);
+  cache.value ??= fetchCommunityPluginEntries();
+  try {
+    return await cache.value;
+  } catch (error) {
+    cache.value = null;
+    throw error;
+  }
+}
+async function getPluginManifest(repo, version) {
+  const response = await (0, import_obsidian.requestUrl)(`https://github.com/${repo}/releases/download/${version}/manifest.json`);
+  return response.json;
+}
+function getSettingsComponent(plugin) {
+  return typeof plugin !== "object" || plugin === null || !("pluginSettingsComponent" in plugin) ? null : plugin.pluginSettingsComponent;
+}
+async function resolveCommunityPluginId(reference) {
+  if ("pluginId" in reference) {
+    return reference.pluginId;
+  }
+  const entries = await getCommunityPluginEntries();
+  const entry = entries.find((candidate) => candidate.name === reference.pluginName);
+  if (!entry) {
+    throw new Error(`Plugin named '${reference.pluginName}' was not found in the Obsidian community plugins registry.`);
+  }
+  return entry.id;
+}
+
+// node_modules/@mnaoumov/obsidian-lib/dist/lib/esm/demo-vault-helper.mjs
+(function() {
+  function ensureDisposeSymbols(symbolConstructor = Symbol) {
+    symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+    symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+  }
+  function ensureBrowserProcess() {
+    const browserProcess = {
+      browser: true,
+      cwd() {
+        return "/";
+      },
+      env: {},
+      platform: "android"
+    };
+    const existingProcess = globalThis.process;
+    if (!existingProcess) {
+      globalThis.process = browserProcess;
+      return;
+    }
+    if (existingProcess.versions?.node) {
+      return;
+    }
+    const existingProcessRecord = existingProcess;
+    for (const [key, value] of Object.entries(browserProcess)) {
+      existingProcessRecord[key] ??= value;
+    }
+    existingProcessRecord["browser"] = true;
+  }
+  (function initEsm() {
+    ensureDisposeSymbols();
+    ensureBrowserProcess();
+  })();
+})();
+var CODE_SCRIPT_TOOLKIT_PLUGIN_ID = "fix-require-modules";
+var CODE_SCRIPT_TOOLKIT_MODULES_ROOT = "_assets/CodeScriptToolkit";
+var CODE_SCRIPT_TOOLKIT_SETTINGS = {
+  defaultCodeButtonConfig: "---\nsourceVisibility: collapsed\n---",
+  invocableScriptsFolder: "Invocables",
+  modulesRoot: CODE_SCRIPT_TOOLKIT_MODULES_ROOT,
+  shouldHandleProtocolUrls: true,
+  startupScriptPath: "startup.ts"
+};
+var FOLDER_NOTES_PLUGIN_ID = "folder-notes";
+var FOLDER_NOTES_SETTINGS = {
+  folderNoteName: "README",
+  hideFolderNote: true,
+  storageLocation: "insideFolder"
+};
+var DEMO_VAULT_HELPER_PLUGIN_ID = "demo-vault-helper";
+var PLUGINS_FOLDER_NAME = "plugins";
+var DATA_JSON_FILE_NAME = "data.json";
+var INVALID_DEMO_VAULT_ERROR_MESSAGE = "Invalid demo vault";
+var OPEN_DEMO_VAULT_COMMAND_NAME = "Open demo vault";
+var SANDBOX_NOTICE_DURATION_IN_MILLISECONDS = 0;
+async function bootstrapDemoVault(params) {
+  const { app } = params;
+  const demoedPluginId = await getDemoedPluginId(app);
+  await installCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });
+  const result = await configureCommunityPlugin({
+    app,
+    pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID,
+    settings: CODE_SCRIPT_TOOLKIT_SETTINGS
+  });
+  await ensureInvocableScriptsFolder(app);
+  if (!app.plugins.enabledPlugins.has(CODE_SCRIPT_TOOLKIT_PLUGIN_ID)) {
+    await enableCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });
+  } else if (result === ConfigureCommunityPluginResult.Success) {
+    await disableCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });
+    await enableCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });
+  }
+  await installConfigureEnableCommunityPlugin({
+    app,
+    pluginId: FOLDER_NOTES_PLUGIN_ID,
+    settings: FOLDER_NOTES_SETTINGS
+  });
+  showSandboxNotice(app, demoedPluginId);
+}
+function buildSandboxNoticeFragment(pluginName) {
+  return createFragment((fragment) => {
+    fragment.appendText("This is a demo vault for ");
+    fragment.createEl("b", { text: pluginName });
+    fragment.appendText(".");
+    fragment.createEl("br");
+    fragment.appendText("It is a temporary sandbox, cleaned up automatically about a day after you last use it.");
+    fragment.createEl("br");
+    fragment.appendText("Executing ");
+    fragment.createEl("b", { text: `${pluginName}: ${OPEN_DEMO_VAULT_COMMAND_NAME}` });
+    fragment.appendText(" command again creates a new copy with the latest plugin version, so your notes will not appear in it.");
+  });
+}
+async function ensureInvocableScriptsFolder(app) {
+  const invocableScriptsFolderPath = join(CODE_SCRIPT_TOOLKIT_MODULES_ROOT, CODE_SCRIPT_TOOLKIT_SETTINGS.invocableScriptsFolder);
+  if (!await app.vault.adapter.exists(invocableScriptsFolderPath)) {
+    await app.vault.adapter.mkdir(invocableScriptsFolderPath);
+  }
+}
+async function getDemoedPluginId(app) {
+  const settingsPath = join(app.vault.configDir, PLUGINS_FOLDER_NAME, DEMO_VAULT_HELPER_PLUGIN_ID, DATA_JSON_FILE_NAME);
+  if (!await app.vault.adapter.exists(settingsPath)) {
+    throw new Error(INVALID_DEMO_VAULT_ERROR_MESSAGE);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await app.vault.adapter.read(settingsPath));
+  } catch (error) {
+    throw new Error(INVALID_DEMO_VAULT_ERROR_MESSAGE, { cause: error });
+  }
+  const demoedPluginId = parsed?.demoedPluginId;
+  if (typeof demoedPluginId !== "string" || demoedPluginId === EMPTY) {
+    throw new Error(INVALID_DEMO_VAULT_ERROR_MESSAGE);
+  }
+  return demoedPluginId;
+}
+function showSandboxNotice(app, demoedPluginId) {
+  const pluginName = app.plugins.manifests[demoedPluginId]?.name ?? demoedPluginId;
+  const fragment = buildSandboxNoticeFragment(pluginName);
+  app.setting.close();
+  new import_obsidian2.Notice(fragment, SANDBOX_NOTICE_DURATION_IN_MILLISECONDS);
+}
+
+// demo-vault-helper/main.ts
+var DemoVaultHelperPlugin = class extends import_obsidian3.Plugin {
+  onload() {
+    this.app.workspace.onLayoutReady(() => {
+      void this.bootstrap();
+    });
+  }
+  async bootstrap() {
+    try {
+      await bootstrapDemoVault({ app: this.app });
+    } catch (error) {
+      new import_obsidian3.Notice(`Demo Vault Helper failed to bootstrap: ${String(error)}`);
+      console.error(error);
+    }
+  }
+};