obsidian-launcher 0.2.0 → 0.2.2

package/dist/{chunk-5W4LJ7AP.cjs → chunk-2DK4DOJU.cjs}

@@ -11,12 +11,12 @@ var _promises3 = require('stream/promises');
 var _get = require('@electron/get');
 var _child_process = require('child_process'); var _child_process2 = _interopRequireDefault(_child_process);
 var _semver = require('semver'); var _semver2 = _interopRequireDefault(_semver);
-var _chromeremoteinterface = require('chrome-remote-interface'); var _chromeremoteinterface2 = _interopRequireDefault(_chromeremoteinterface);
 
 // src/utils.ts
 
 
 var _promisepool = require('@supercharge/promise-pool');
+var _lodash = require('lodash'); var _lodash2 = _interopRequireDefault(_lodash);
 async function fileExists(path5) {
   try {
     await _promises2.default.access(path5);
@@ -71,9 +71,20 @@ async function pool(size, items, func) {
 async function maybe(promise) {
   return promise.then((r) => ({ success: true, result: r, error: void 0 })).catch((e) => ({ success: false, result: void 0, error: e }));
 }
+function mergeKeepUndefined(object, ...sources) {
+  return _lodash2.default.mergeWith(
+    object,
+    ...sources,
+    (objValue, srcValue, key, obj) => {
+      if (_lodash2.default.isPlainObject(obj) && objValue !== srcValue && srcValue === void 0) {
+        obj[key] = srcValue;
+      }
+    }
+  );
+}
 
 // src/apis.ts
-var _lodash = require('lodash'); var _lodash2 = _interopRequireDefault(_lodash);
+
 
 
 var _url = require('url');
@@ -124,7 +135,7 @@ async function fetchGitHubAPIPaginated(url, params = {}) {
   while (next) {
     const response = await fetchGitHubAPI(next);
     results.push(...await response.json());
-    next = _optionalChain([parseLinkHeader, 'call', _4 => _4(_nullishCoalesce(response.headers.get("link"), () => ( ""))), 'access', _5 => _5.next, 'optionalAccess', _6 => _6.url]);
+    next = _optionalChain([parseLinkHeader, 'call', _5 => _5(_nullishCoalesce(response.headers.get("link"), () => ( ""))), 'access', _6 => _6.next, 'optionalAccess', _7 => _7.url]);
   }
   return results;
 }
@@ -234,11 +245,13 @@ var ChromeLocalStorage = class {
 // src/launcherUtils.ts
 
 
+
 var _util = require('util');
 
 var _which = require('which'); var _which2 = _interopRequireDefault(_which);
 
 
+var _chromeremoteinterface = require('chrome-remote-interface'); var _chromeremoteinterface2 = _interopRequireDefault(_chromeremoteinterface);
 var execFile = _util.promisify.call(void 0, _child_process2.default.execFile);
 function normalizeGitHubRepo(repo) {
   return repo.replace(/^(https?:\/\/)?(github.com\/)/, "");
@@ -285,9 +298,7 @@ async function extractObsidianDmg(dmg, dest) {
 function parseObsidianDesktopRelease(fileRelease, isBeta) {
   return {
     version: fileRelease.latestVersion,
-    minInstallerVersion: fileRelease.minimumVersion,
-    maxInstallerVersion: "",
-    // Will be set later
+    minInstallerVersion: fileRelease.minimumVersion != "0.0.0" ? fileRelease.minimumVersion : void 0,
     isBeta,
     downloads: {
       asar: fileRelease.downloadUrl
@@ -311,12 +322,98 @@ function parseObsidianGithubRelease(gitHubRelease) {
     downloads: _lodash2.default.pickBy(downloads, (x) => x !== void 0)
   };
 }
+async function getElectronVersionInfo(version, binaryPath) {
+  console.log(`${version}: Retrieving electron & chrome versions...`);
+  const configDir = await _promises2.default.mkdtemp(_path2.default.join(_os2.default.tmpdir(), `fetch-obsidian-versions-`));
+  const proc = _child_process2.default.spawn(binaryPath, [
+    `--remote-debugging-port=0`,
+    // 0 will make it choose a random available port
+    "--test-type=webdriver",
+    `--user-data-dir=${configDir}`,
+    "--no-sandbox"
+    // Workaround for SUID issue, see https://github.com/electron/electron/issues/42510
+  ]);
+  const procExit = new Promise((resolve) => proc.on("exit", (code) => resolve(_nullishCoalesce(code, () => ( -1)))));
+  let dependencyVersions;
+  try {
+    const portPromise = new Promise((resolve, reject) => {
+      procExit.then(() => reject("Processed ended without opening a port"));
+      proc.stderr.on("data", (data) => {
+        const port2 = _optionalChain([data, 'access', _8 => _8.toString, 'call', _9 => _9(), 'access', _10 => _10.match, 'call', _11 => _11(/ws:\/\/[\w.]+?:(\d+)/), 'optionalAccess', _12 => _12[1]]);
+        if (port2) {
+          resolve(Number(port2));
+        }
+      });
+    });
+    const port = await maybe(withTimeout(portPromise, 10 * 1e3));
+    if (!port.success) {
+      throw new Error("Timed out waiting for Chrome DevTools protocol port");
+    }
+    const client = await _chromeremoteinterface2.default.call(void 0, { port: port.result });
+    const response = await client.Runtime.evaluate({ expression: "JSON.stringify(process.versions)" });
+    dependencyVersions = JSON.parse(response.result.value);
+    await client.close();
+  } finally {
+    proc.kill("SIGTERM");
+    const timeout = await maybe(withTimeout(procExit, 4 * 1e3));
+    if (!timeout.success) {
+      console.log(`${version}: Stuck process ${proc.pid}, using SIGKILL`);
+      proc.kill("SIGKILL");
+    }
+    await procExit;
+    await sleep(1e3);
+    await _promises2.default.rm(configDir, { recursive: true, force: true });
+  }
+  if (!_optionalChain([dependencyVersions, 'optionalAccess', _13 => _13.electron]) || !_optionalChain([dependencyVersions, 'optionalAccess', _14 => _14.chrome])) {
+    throw Error(`Failed to extract electron and chrome versions for ${version}`);
+  }
+  return {
+    electronVersion: dependencyVersions.electron,
+    chromeVersion: dependencyVersions.chrome,
+    nodeVersion: dependencyVersions.node
+  };
+}
 function correctObsidianVersionInfo(versionInfo) {
-  const corrections = {};
+  const corrections = [
+    // These version's downloads are missing or broken.
+    { version: "0.12.16", downloads: { asar: void 0 } },
+    { version: "1.4.7", downloads: { asar: void 0 } },
+    { version: "1.4.8", downloads: { asar: void 0 } },
+    // The minInstallerVersion here is incorrect
+    { version: "1.3.4", minInstallerVersion: "0.14.5" },
+    { version: "1.3.3", minInstallerVersion: "0.14.5" },
+    { version: "1.3.2", minInstallerVersion: "0.14.5" },
+    { version: "1.3.1", minInstallerVersion: "0.14.5" },
+    { version: "1.3.0", minInstallerVersion: "0.14.5" }
+  ];
+  const result = _nullishCoalesce(corrections.find((v) => v.version == versionInfo.version), () => ( {}));
   if (_semver2.default.gte(versionInfo.version, "1.5.3") && _semver2.default.lt(versionInfo.minInstallerVersion, "1.1.9")) {
-    corrections.minInstallerVersion = "1.1.9";
+    result.minInstallerVersion = "1.1.9";
   }
-  return corrections;
+  return result;
+}
+function normalizeObsidianVersionInfo(versionInfo) {
+  versionInfo = {
+    version: versionInfo.version,
+    minInstallerVersion: versionInfo.minInstallerVersion,
+    maxInstallerVersion: versionInfo.maxInstallerVersion,
+    isBeta: versionInfo.isBeta,
+    gitHubRelease: versionInfo.gitHubRelease,
+    downloads: {
+      asar: _optionalChain([versionInfo, 'access', _15 => _15.downloads, 'optionalAccess', _16 => _16.asar]),
+      appImage: _optionalChain([versionInfo, 'access', _17 => _17.downloads, 'optionalAccess', _18 => _18.appImage]),
+      appImageArm: _optionalChain([versionInfo, 'access', _19 => _19.downloads, 'optionalAccess', _20 => _20.appImageArm]),
+      apk: _optionalChain([versionInfo, 'access', _21 => _21.downloads, 'optionalAccess', _22 => _22.apk]),
+      dmg: _optionalChain([versionInfo, 'access', _23 => _23.downloads, 'optionalAccess', _24 => _24.dmg]),
+      exe: _optionalChain([versionInfo, 'access', _25 => _25.downloads, 'optionalAccess', _26 => _26.exe])
+    },
+    electronVersion: versionInfo.electronVersion,
+    chromeVersion: versionInfo.chromeVersion,
+    nodeVersion: versionInfo.nodeVersion
+  };
+  versionInfo.downloads = _lodash2.default.omitBy(versionInfo.downloads, _lodash2.default.isUndefined);
+  versionInfo = _lodash2.default.omitBy(versionInfo, _lodash2.default.isUndefined);
+  return versionInfo;
 }
 
 // src/launcher.ts
@@ -403,8 +500,8 @@ var ObsidianLauncher = class {
     return await this.cachedFetch(this.communityThemesUrl, dest);
   }
   /**
-   * Resolves Obsidian version strings to absolute obsidian versions.
-   * @param appVersion Obsidian version string or "latest", "earliest", or "latest-beta". "earliest" will use the 
+   * Resolves Obsidian app and installer version strings to absolute versions.
+   * @param appVersion Obsidian version string or "latest", "latest-beta" or "earliest". "earliest" will use the 
    *     minAppVersion set in your manifest.json.
    * @param installerVersion Obsidian version string or "latest" or "earliest". "earliest" will use the minimum
    *     installer version compatible with the appVersion.
@@ -412,21 +509,9 @@ var ObsidianLauncher = class {
    */
   async resolveVersions(appVersion, installerVersion = "latest") {
     const versions = await this.getVersions();
-    if (appVersion == "latest-beta") {
-      appVersion = versions.at(-1).version;
-    } else if (appVersion == "latest") {
-      appVersion = versions.filter((v) => !v.isBeta).at(-1).version;
-    } else if (appVersion == "earliest") {
-      appVersion = await _asyncOptionalChain([(await this.getRootManifest()), 'optionalAccess', async _7 => _7.minAppVersion]);
-      if (!appVersion) {
-        throw Error('Unable to resolve Obsidian app version "earliest", no manifest.json or minAppVersion found.');
-      }
-    } else {
-      appVersion = _nullishCoalesce(_semver2.default.valid(appVersion), () => ( appVersion));
-    }
-    const appVersionInfo = versions.find((v) => v.version == appVersion);
-    if (!appVersionInfo) {
-      throw Error(`No Obsidian app version ${appVersion} found`);
+    const appVersionInfo = await this.getVersionInfo(appVersion);
+    if (!appVersionInfo.minInstallerVersion || !appVersionInfo.maxInstallerVersion) {
+      throw Error(`No compatible installers available for app version ${appVersion}`);
     }
     if (installerVersion == "latest") {
       installerVersion = appVersionInfo.maxInstallerVersion;
@@ -439,21 +524,37 @@ var ObsidianLauncher = class {
     if (!installerVersionInfo || !installerVersionInfo.chromeVersion) {
       throw Error(`No Obsidian installer for version ${installerVersion} found`);
     }
-    if (_semver2.default.lt(installerVersionInfo.version, appVersionInfo.minInstallerVersion)) {
+    if (_semver2.default.lt(installerVersionInfo.version, appVersionInfo.minInstallerVersion) || _semver2.default.gt(installerVersionInfo.version, appVersionInfo.maxInstallerVersion)) {
       throw Error(
-        `Installer and app versions incompatible: minInstallerVersion of v${appVersionInfo.version} is ${appVersionInfo.minInstallerVersion}, but v${installerVersionInfo.version} specified`
+        `App and installer versions incompatible: app ${appVersionInfo.version} is compatible with installer >=${appVersionInfo.minInstallerVersion} <=${appVersionInfo.maxInstallerVersion} but ${installerVersionInfo.version} specified`
       );
     }
     return [appVersionInfo.version, installerVersionInfo.version];
   }
-  /** Gets details about an Obsidian version */
+  /**
+   * Gets details about an Obsidian version.
+   * @param version Obsidian version string or "latest", "earliest", or "latest-beta". "earliest" will use the 
+   *     minAppVersion set in your manifest.json.
+   */
   async getVersionInfo(version) {
-    version = (await this.resolveVersions(version))[0];
-    const result = (await this.getVersions()).find((v) => v.version == version);
-    if (!result) {
-      throw Error(`No Obsidian version ${version} found`);
+    const versions = await this.getVersions();
+    if (version == "latest-beta") {
+      version = versions.at(-1).version;
+    } else if (version == "latest") {
+      version = versions.filter((v) => !v.isBeta).at(-1).version;
+    } else if (version == "earliest") {
+      version = await _asyncOptionalChain([(await this.getRootManifest()), 'optionalAccess', async _27 => _27.minAppVersion]);
+      if (!version) {
+        throw Error('Unable to resolve Obsidian app version "earliest", no manifest.json or minAppVersion found.');
+      }
+    } else {
+      version = _nullishCoalesce(_semver2.default.valid(version), () => ( version));
     }
-    return result;
+    const versionInfo = versions.find((v) => v.version == version);
+    if (!versionInfo) {
+      throw Error(`No Obsidian app version ${version} found`);
+    }
+    return versionInfo;
   }
   /**
    * Downloads the Obsidian installer for the given version and platform. Returns the file path.
@@ -899,7 +1000,7 @@ var ObsidianLauncher = class {
    *
    * @param appVersion Obsidian version string.
    * @param installerVersion Obsidian version string.
-   * @param appPath Path to the asar file to install.
+   * @param appPath Path to the asar file to install. Will download if omitted.
    * @param vault Path to the vault to open in Obsidian.
    * @param dest Destination path for the config dir. If omitted it will create it under `/tmp`.
    */
@@ -933,11 +1034,11 @@ var ObsidianLauncher = class {
       };
     }
     await _promises2.default.writeFile(_path2.default.join(configDir, "obsidian.json"), JSON.stringify(obsidianJson));
-    if (params.appPath) {
-      await linkOrCp(params.appPath, _path2.default.join(configDir, _path2.default.basename(params.appPath)));
-    } else if (appVersion != installerVersion) {
-      throw Error("You must specify app path if appVersion != installerVersion");
+    let appPath = params.appPath;
+    if (!appPath) {
+      appPath = await this.downloadApp(appVersion);
     }
+    await linkOrCp(appPath, _path2.default.join(configDir, _path2.default.basename(appPath)));
     const localStorage = new ChromeLocalStorage(configDir);
     await localStorage.setItems("app://obsidian.md", localStorageData);
     await localStorage.close();
@@ -1001,63 +1102,6 @@ var ObsidianLauncher = class {
     });
     return { proc, configDir, vault };
   }
-  /**
-   * Extract electron and chrome versions for an Obsidian version.
-   */
-  async getDependencyVersions(versionInfo) {
-    const binary = await this.downloadInstallerFromVersionInfo(versionInfo);
-    console.log(`${versionInfo.version}: Extracting electron & chrome versions...`);
-    const configDir = await _promises2.default.mkdtemp(_path2.default.join(_os2.default.tmpdir(), `fetch-obsidian-versions-`));
-    const proc = _child_process2.default.spawn(binary, [
-      `--remote-debugging-port=0`,
-      // 0 will make it choose a random available port
-      "--test-type=webdriver",
-      `--user-data-dir=${configDir}`,
-      "--no-sandbox",
-      // Workaround for SUID issue, see https://github.com/electron/electron/issues/42510
-      "--headless"
-    ]);
-    const procExit = new Promise((resolve) => proc.on("exit", (code) => resolve(_nullishCoalesce(code, () => ( -1)))));
-    let dependencyVersions;
-    try {
-      const portPromise = new Promise((resolve, reject) => {
-        procExit.then(() => reject("Processed ended without opening a port"));
-        proc.stderr.on("data", (data) => {
-          const port2 = _optionalChain([data, 'access', _8 => _8.toString, 'call', _9 => _9(), 'access', _10 => _10.match, 'call', _11 => _11(/ws:\/\/[\w.]+?:(\d+)/), 'optionalAccess', _12 => _12[1]]);
-          if (port2) {
-            resolve(Number(port2));
-          }
-        });
-      });
-      const port = await maybe(withTimeout(portPromise, 10 * 1e3));
-      if (!port.success) {
-        throw new Error("Timed out waiting for Chrome DevTools protocol port");
-      }
-      const client = await _chromeremoteinterface2.default.call(void 0, { port: port.result });
-      const response = await client.Runtime.evaluate({ expression: "JSON.stringify(process.versions)" });
-      dependencyVersions = JSON.parse(response.result.value);
-      await client.close();
-    } finally {
-      proc.kill("SIGTERM");
-      const timeout = await maybe(withTimeout(procExit, 4 * 1e3));
-      if (!timeout.success) {
-        console.log(`${versionInfo.version}: Stuck process ${proc.pid}, using SIGKILL`);
-        proc.kill("SIGKILL");
-      }
-      await procExit;
-      await sleep(1e3);
-      await _promises2.default.rm(configDir, { recursive: true, force: true });
-    }
-    if (!_optionalChain([dependencyVersions, 'optionalAccess', _13 => _13.electron]) || !_optionalChain([dependencyVersions, 'optionalAccess', _14 => _14.chrome])) {
-      throw Error(`Failed to extract electron and chrome versions for ${versionInfo.version}`);
-    }
-    return {
-      ...versionInfo,
-      electronVersion: dependencyVersions.electron,
-      chromeVersion: dependencyVersions.chrome,
-      nodeVersion: dependencyVersions.node
-    };
-  }
   /** 
    * Updates the info obsidian-versions.json. The obsidian-versions.json file is used in other launcher commands
    * and in wdio-obsidian-service to get metadata about Obsidian versions in one place such as minInstallerVersion and
@@ -1067,7 +1111,7 @@ var ObsidianLauncher = class {
     const repo = "obsidianmd/obsidian-releases";
     let commitHistory = await fetchGitHubAPIPaginated(`repos/${repo}/commits`, {
       path: "desktop-releases.json",
-      since: _optionalChain([original, 'optionalAccess', _15 => _15.metadata, 'access', _16 => _16.commit_date])
+      since: _optionalChain([original, 'optionalAccess', _28 => _28.metadata, 'access', _29 => _29.commit_date])
     });
     commitHistory.reverse();
     if (original) {
@@ -1080,7 +1124,7 @@ var ObsidianLauncher = class {
     );
     const githubReleases = await fetchGitHubAPIPaginated(`repos/${repo}/releases`);
     const versionMap = _lodash2.default.keyBy(
-      _nullishCoalesce(_optionalChain([original, 'optionalAccess', _17 => _17.versions]), () => ( [])),
+      _nullishCoalesce(_optionalChain([original, 'optionalAccess', _30 => _30.versions]), () => ( [])),
       (v) => v.version
     );
     for (const { beta, ...current } of fileHistory) {
@@ -1104,37 +1148,46 @@ var ObsidianLauncher = class {
     }
     const dependencyVersions = await pool(
       maxInstances,
-      Object.values(versionMap).filter((v) => _optionalChain([v, 'access', _18 => _18.downloads, 'optionalAccess', _19 => _19.appImage]) && !v.chromeVersion),
-      (v) => this.getDependencyVersions(v)
+      Object.values(versionMap).filter((v) => _optionalChain([v, 'access', _31 => _31.downloads, 'optionalAccess', _32 => _32.appImage]) && !v.chromeVersion),
+      async (v) => {
+        const binaryPath = await this.downloadInstallerFromVersionInfo(v);
+        const electronVersionInfo = await getElectronVersionInfo(v.version, binaryPath);
+        return { ...v, ...electronVersionInfo };
+      }
     );
     for (const deps of dependencyVersions) {
       versionMap[deps.version] = _lodash2.default.merge({}, versionMap[deps.version], deps);
     }
-    let maxInstallerVersion = "0.0.0";
+    let minInstallerVersion = void 0;
+    let maxInstallerVersion = void 0;
     for (const version of Object.keys(versionMap).sort(_semver2.default.compare)) {
+      if (!minInstallerVersion && versionMap[version].chromeVersion) {
+        minInstallerVersion = version;
+      }
       if (versionMap[version].downloads.appImage) {
         maxInstallerVersion = version;
       }
-      versionMap[version] = _lodash2.default.merge(
+      versionMap[version] = mergeKeepUndefined(
         {},
         versionMap[version],
-        correctObsidianVersionInfo(versionMap[version]),
-        { maxInstallerVersion }
+        {
+          minInstallerVersion: _nullishCoalesce(versionMap[version].minInstallerVersion, () => ( minInstallerVersion)),
+          maxInstallerVersion
+        },
+        correctObsidianVersionInfo(versionMap[version])
       );
     }
-    const versionInfos = Object.values(versionMap);
-    versionInfos.sort((a, b) => _semver2.default.compare(a.version, b.version));
     const result = {
       metadata: {
-        commit_date: _nullishCoalesce(_optionalChain([commitHistory, 'access', _20 => _20.at, 'call', _21 => _21(-1), 'optionalAccess', _22 => _22.commit, 'access', _23 => _23.committer, 'access', _24 => _24.date]), () => ( _optionalChain([original, 'optionalAccess', _25 => _25.metadata, 'access', _26 => _26.commit_date]))),
-        commit_sha: _nullishCoalesce(_optionalChain([commitHistory, 'access', _27 => _27.at, 'call', _28 => _28(-1), 'optionalAccess', _29 => _29.sha]), () => ( _optionalChain([original, 'optionalAccess', _30 => _30.metadata, 'access', _31 => _31.commit_sha]))),
-        timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _32 => _32.metadata, 'access', _33 => _33.timestamp]), () => ( ""))
+        commit_date: _nullishCoalesce(_optionalChain([commitHistory, 'access', _33 => _33.at, 'call', _34 => _34(-1), 'optionalAccess', _35 => _35.commit, 'access', _36 => _36.committer, 'access', _37 => _37.date]), () => ( _optionalChain([original, 'optionalAccess', _38 => _38.metadata, 'access', _39 => _39.commit_date]))),
+        commit_sha: _nullishCoalesce(_optionalChain([commitHistory, 'access', _40 => _40.at, 'call', _41 => _41(-1), 'optionalAccess', _42 => _42.sha]), () => ( _optionalChain([original, 'optionalAccess', _43 => _43.metadata, 'access', _44 => _44.commit_sha]))),
+        timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _45 => _45.metadata, 'access', _46 => _46.timestamp]), () => ( ""))
         // set down below
       },
-      versions: versionInfos
+      versions: Object.values(versionMap).map(normalizeObsidianVersionInfo).sort((a, b) => _semver2.default.compare(a.version, b.version))
     };
     const dayMs = 24 * 60 * 60 * 1e3;
-    const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _34 => _34.metadata, 'access', _35 => _35.timestamp]), () => ( 0))).getTime();
+    const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _47 => _47.metadata, 'access', _48 => _48.timestamp]), () => ( 0))).getTime();
     if (!_lodash2.default.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
       result.metadata.timestamp = (/* @__PURE__ */ new Date()).toISOString();
     }
@@ -1144,7 +1197,7 @@ var ObsidianLauncher = class {
    * Returns true if the Obsidian version is already in the cache.
    */
   async isInCache(type, version) {
-    version = (await this.resolveVersions(version))[0];
+    version = (await this.getVersionInfo(version)).version;
     let dest;
     if (type == "app") {
       dest = `obsidian-app/obsidian-${version}.asar`;
@@ -1160,12 +1213,13 @@ var ObsidianLauncher = class {
    */
   async isAvailable(version) {
     const versionInfo = await this.getVersionInfo(version);
+    const versionExists = !!(versionInfo.downloads.asar && versionInfo.minInstallerVersion);
     if (versionInfo.isBeta) {
       const hasCreds = !!(process.env["OBSIDIAN_USERNAME"] && process.env["OBSIDIAN_PASSWORD"]);
       const inCache = await this.isInCache("app", versionInfo.version);
-      return hasCreds || inCache;
+      return versionExists && (hasCreds || inCache);
     } else {
-      return !!versionInfo.downloads.asar;
+      return versionExists;
     }
   }
 };
@@ -1173,4 +1227,4 @@ var ObsidianLauncher = class {
 
 
 exports.ObsidianLauncher = ObsidianLauncher;
-//# sourceMappingURL=chunk-5W4LJ7AP.cjs.map
+//# sourceMappingURL=chunk-2DK4DOJU.cjs.map