obsidian-dev-utils 80.1.0 → 81.0.0

package/dist/lib/esm/script-utils/npm-publish.mjs

@@ -28,7 +28,7 @@ import {
   resolvePathFromRoot
 } from "./root.mjs";
 async function publish(isBeta) {
-  const envPath = resolvePathFromRoot(".env");
+  const envPath = resolvePathFromRoot({ path: ".env" });
   if (envPath && existsSync(envPath)) {
     loadEnvFile(envPath);
   }
@@ -40,4 +40,4 @@ async function publish(isBeta) {
 export {
   publish
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9ucG0tcHVibGlzaC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIENvbnRhaW5zIHV0aWxpdHkgZnVuY3Rpb25zIGZvciBOUE0gcHVibGlzaC5cbiAqL1xuXG5pbXBvcnQgeyBleGlzdHNTeW5jIH0gZnJvbSAnbm9kZTpmcyc7XG5pbXBvcnQgcHJvY2VzcywgeyBsb2FkRW52RmlsZSB9IGZyb20gJ25vZGU6cHJvY2Vzcyc7XG5cbmltcG9ydCB7XG4gIGV4ZWNGcm9tUm9vdCxcbiAgcmVzb2x2ZVBhdGhGcm9tUm9vdFxufSBmcm9tICcuL3Jvb3QudHMnO1xuXG5pbnRlcmZhY2UgTnBtRW52IHtcbiAgTlBNX1RPS0VOOiBzdHJpbmc7XG59XG5cbi8qKlxuICogUHVibGlzaCB0byBOUE0uXG4gKlxuICogQHBhcmFtIGlzQmV0YSAtIFdoZXRoZXIgdG8gcHVibGlzaCB0byB0aGUgYmV0YSBOUE0gcmVnaXN0cnkuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBwdWJsaXNoKGlzQmV0YT86IGJvb2xlYW4pOiBQcm9taXNlPHZvaWQ+IHtcbiAgY29uc3QgZW52UGF0aCA9IHJlc29sdmVQYXRoRnJvbVJvb3QoJy5lbnYnKTtcbiAgaWYgKGVudlBhdGggJiYgZXhpc3RzU3luYyhlbnZQYXRoKSkge1xuICAgIGxvYWRFbnZGaWxlKGVudlBhdGgpO1xuICB9XG4gIGNvbnN0IG5wbUVudiA9IHByb2Nlc3MuZW52IGFzIFBhcnRpYWw8TnBtRW52PjtcbiAgYXdhaXQgZXhlY0Zyb21Sb290KFsnbnBtJywgJ2NvbmZpZycsICdzZXQnLCBgLy9yZWdpc3RyeS5ucG1qcy5vcmcvOl9hdXRoVG9rZW49JHtucG1FbnYuTlBNX1RPS0VOID8/ICcnfWBdKTtcblxuICBjb25zdCB0YWcgPSBpc0JldGEgPyAnYmV0YScgOiAnbGF0ZXN0JztcbiAgYXdhaXQgZXhlY0Zyb21Sb290KFsnbnBtJywgJ3B1Ymxpc2gnLCAnLS10YWcnLCB0YWddKTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBTUEsU0FBUyxrQkFBa0I7QUFDM0IsT0FBTyxXQUFXLG1CQUFtQjtBQUVyQztBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsT0FDSztBQVdQLGVBQXNCLFFBQVEsUUFBaUM7QUFDN0QsUUFBTSxVQUFVLG9CQUFvQixNQUFNO0FBQzFDLE1BQUksV0FBVyxXQUFXLE9BQU8sR0FBRztBQUNsQyxnQkFBWSxPQUFPO0FBQUEsRUFDckI7QUFDQSxRQUFNLFNBQVMsUUFBUTtBQUN2QixRQUFNLGFBQWEsQ0FBQyxPQUFPLFVBQVUsT0FBTyxvQ0FBb0MsT0FBTyxhQUFhLEVBQUUsRUFBRSxDQUFDO0FBRXpHLFFBQU0sTUFBTSxTQUFTLFNBQVM7QUFDOUIsUUFBTSxhQUFhLENBQUMsT0FBTyxXQUFXLFNBQVMsR0FBRyxDQUFDO0FBQ3JEOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9ucG0tcHVibGlzaC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIENvbnRhaW5zIHV0aWxpdHkgZnVuY3Rpb25zIGZvciBOUE0gcHVibGlzaC5cbiAqL1xuXG5pbXBvcnQgeyBleGlzdHNTeW5jIH0gZnJvbSAnbm9kZTpmcyc7XG5pbXBvcnQgcHJvY2VzcywgeyBsb2FkRW52RmlsZSB9IGZyb20gJ25vZGU6cHJvY2Vzcyc7XG5cbmltcG9ydCB7XG4gIGV4ZWNGcm9tUm9vdCxcbiAgcmVzb2x2ZVBhdGhGcm9tUm9vdFxufSBmcm9tICcuL3Jvb3QudHMnO1xuXG5pbnRlcmZhY2UgTnBtRW52IHtcbiAgTlBNX1RPS0VOOiBzdHJpbmc7XG59XG5cbi8qKlxuICogUHVibGlzaCB0byBOUE0uXG4gKlxuICogQHBhcmFtIGlzQmV0YSAtIFdoZXRoZXIgdG8gcHVibGlzaCB0byB0aGUgYmV0YSBOUE0gcmVnaXN0cnkuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBwdWJsaXNoKGlzQmV0YT86IGJvb2xlYW4pOiBQcm9taXNlPHZvaWQ+IHtcbiAgY29uc3QgZW52UGF0aCA9IHJlc29sdmVQYXRoRnJvbVJvb3QoeyBwYXRoOiAnLmVudicgfSk7XG4gIGlmIChlbnZQYXRoICYmIGV4aXN0c1N5bmMoZW52UGF0aCkpIHtcbiAgICBsb2FkRW52RmlsZShlbnZQYXRoKTtcbiAgfVxuICBjb25zdCBucG1FbnYgPSBwcm9jZXNzLmVudiBhcyBQYXJ0aWFsPE5wbUVudj47XG4gIGF3YWl0IGV4ZWNGcm9tUm9vdChbJ25wbScsICdjb25maWcnLCAnc2V0JywgYC8vcmVnaXN0cnkubnBtanMub3JnLzpfYXV0aFRva2VuPSR7bnBtRW52Lk5QTV9UT0tFTiA/PyAnJ31gXSk7XG5cbiAgY29uc3QgdGFnID0gaXNCZXRhID8gJ2JldGEnIDogJ2xhdGVzdCc7XG4gIGF3YWl0IGV4ZWNGcm9tUm9vdChbJ25wbScsICdwdWJsaXNoJywgJy0tdGFnJywgdGFnXSk7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQU1BLFNBQVMsa0JBQWtCO0FBQzNCLE9BQU8sV0FBVyxtQkFBbUI7QUFFckM7QUFBQSxFQUNFO0FBQUEsRUFDQTtBQUFBLE9BQ0s7QUFXUCxlQUFzQixRQUFRLFFBQWlDO0FBQzdELFFBQU0sVUFBVSxvQkFBb0IsRUFBRSxNQUFNLE9BQU8sQ0FBQztBQUNwRCxNQUFJLFdBQVcsV0FBVyxPQUFPLEdBQUc7QUFDbEMsZ0JBQVksT0FBTztBQUFBLEVBQ3JCO0FBQ0EsUUFBTSxTQUFTLFFBQVE7QUFDdkIsUUFBTSxhQUFhLENBQUMsT0FBTyxVQUFVLE9BQU8sb0NBQW9DLE9BQU8sYUFBYSxFQUFFLEVBQUUsQ0FBQztBQUV6RyxRQUFNLE1BQU0sU0FBUyxTQUFTO0FBQzlCLFFBQU0sYUFBYSxDQUFDLE9BQU8sV0FBVyxTQUFTLEdBQUcsQ0FBQztBQUNyRDsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/script-utils/npm.mjs

@@ -38,44 +38,53 @@ async function editNpmShrinkWrapJson(editFn, options = {}) {
     cwd,
     shouldSkipIfMissing
   } = options;
-  await editJson(getNpmShrinkWrapJsonPath(cwd), editFn, normalizeOptionalProperties({ shouldSkipIfMissing }));
+  await editJson(normalizeOptionalProperties({ editFn, path: getNpmShrinkWrapJsonPath(cwd), shouldSkipIfMissing }));
 }
 async function editPackageJson(editFn, options = {}) {
   const {
     cwd,
     shouldSkipIfMissing
   } = options;
-  await editJson(getPackageJsonPath(cwd), editFn, normalizeOptionalProperties({ shouldSkipIfMissing }));
+  await editJson(normalizeOptionalProperties({ editFn, path: getPackageJsonPath(cwd), shouldSkipIfMissing }));
 }
 function editPackageJsonSync(editFn, options = {}) {
   const {
     cwd,
     shouldSkipIfMissing
   } = options;
-  editJsonSync(getPackageJsonPath(cwd), editFn, normalizeOptionalProperties({ shouldSkipIfMissing }));
+  editJsonSync(normalizeOptionalProperties({ editFn, path: getPackageJsonPath(cwd), shouldSkipIfMissing }));
 }
 async function editPackageLockJson(editFn, options = {}) {
   const {
     cwd,
     shouldSkipIfMissing
   } = options;
-  await editJson(getPackageLockJsonPath(cwd), editFn, normalizeOptionalProperties({ shouldSkipIfMissing }));
+  await editJson(normalizeOptionalProperties({ editFn, path: getPackageLockJsonPath(cwd), shouldSkipIfMissing }));
 }
 function editPackageLockJsonSync(editFn, options = {}) {
   const {
     cwd,
     shouldSkipIfMissing
   } = options;
-  editJsonSync(getPackageLockJsonPath(cwd), editFn, normalizeOptionalProperties({ shouldSkipIfMissing }));
+  editJsonSync(normalizeOptionalProperties({ editFn, path: getPackageLockJsonPath(cwd), shouldSkipIfMissing }));
 }
 function getNpmShrinkWrapJsonPath(cwd) {
-  return ensureNonNullable(resolvePathFromRoot(ObsidianPluginRepoPaths.NpmShrinkwrapJson, cwd), "Could not determine the npm-shrinkwrap.json path");
+  return ensureNonNullable(
+    resolvePathFromRoot(normalizeOptionalProperties({ cwd, path: ObsidianPluginRepoPaths.NpmShrinkwrapJson })),
+    "Could not determine the npm-shrinkwrap.json path"
+  );
 }
 function getPackageJsonPath(cwd) {
-  return ensureNonNullable(resolvePathFromRoot(ObsidianPluginRepoPaths.PackageJson, cwd), "Could not determine the package.json path");
+  return ensureNonNullable(
+    resolvePathFromRoot(normalizeOptionalProperties({ cwd, path: ObsidianPluginRepoPaths.PackageJson })),
+    "Could not determine the package.json path"
+  );
 }
 function getPackageLockJsonPath(cwd) {
-  return ensureNonNullable(resolvePathFromRoot(ObsidianPluginRepoPaths.PackageLockJson, cwd), "Could not determine the package-lock.json path");
+  return ensureNonNullable(
+    resolvePathFromRoot(normalizeOptionalProperties({ cwd, path: ObsidianPluginRepoPaths.PackageLockJson })),
+    "Could not determine the package-lock.json path"
+  );
 }
 async function readPackageJson(cwd) {
   return await readJson(getPackageJsonPath(cwd));
@@ -119,4 +128,4 @@ export {
   writePackageLockJson,
   writePackageLockJsonSync
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/npm.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for NPM package.json.\n */\n\nimport type {\n  PackageJson,\n  Promisable\n} from 'type-fest';\n\nimport type { EditJsonOptions } from './json.ts';\n\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport { ObsidianPluginRepoPaths } from '../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\nimport {\n  editJson,\n  editJsonSync,\n  readJson,\n  readJsonSync,\n  writeJson,\n  writeJsonSync\n} from './json.ts';\nimport { resolvePathFromRoot } from './root.ts';\n\n/**\n * Options for {@link editNpmShrinkWrapJson}.\n */\nexport type EditNpmShrinkWrapJsonOptions = EditPackageJsonOptions;\n\n/**\n * Options for {@link editPackageJson}.\n */\nexport interface EditPackageJsonOptions {\n  /**\n   * A current working folder where `package.json` is located.\n   */\n  readonly cwd?: string;\n\n  /**\n   * If `true`, skips editing if the file does not exist.\n   */\n  readonly shouldSkipIfMissing?: boolean;\n}\n\n/**\n * Options for {@link editPackageJsonSync}.\n */\nexport type EditPackageJsonSyncOptions = EditPackageJsonOptions;\n\n/**\n * Options for {@link editPackageLockJson}.\n */\nexport type EditPackageLockJsonOptions = EditPackageJsonOptions;\n\n/**\n * Options for {@link editPackageLockJsonSync}.\n */\nexport type EditPackageLockJsonSyncOptions = EditPackageJsonOptions;\n\n/**\n * A type of the `package.json` file.\n */\nexport type { PackageJson };\n\n/**\n * A type of the `package-lock.json` file.\n */\nexport interface PackageLockJson extends Partial<PackageJson> {\n  /**\n   * Packages in the `package-lock.json` file.\n   */\n  packages?: Record<string, PackageJson>;\n}\n\n/**\n * Reads, edits, and writes back the `package-lock.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n * @returns A {@link Promise} that resolves when the file has been edited and written.\n */\nexport async function editNpmShrinkWrapJson(\n  editFn: (packageLockJson: PackageLockJson) => Promisable<void>,\n  options: EditNpmShrinkWrapJsonOptions = {}\n): Promise<void> {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  await editJson<PackageJson>(getNpmShrinkWrapJsonPath(cwd), editFn, normalizeOptionalProperties<EditJsonOptions>({ shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n * @returns A {@link Promise} that resolves when the file has been edited and written.\n */\nexport async function editPackageJson(\n  editFn: (packageJson: PackageJson) => Promisable<void>,\n  options: EditPackageJsonOptions = {}\n): Promise<void> {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  await editJson<PackageJson>(getPackageJsonPath(cwd), editFn, normalizeOptionalProperties<EditJsonOptions>({ shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n */\nexport function editPackageJsonSync(\n  editFn: (packageJson: PackageJson) => void,\n  options: EditPackageJsonSyncOptions = {}\n): void {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  editJsonSync<PackageJson>(getPackageJsonPath(cwd), editFn, normalizeOptionalProperties<EditJsonOptions>({ shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package-lock.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n * @returns A {@link Promise} that resolves when the file has been edited and written.\n */\nexport async function editPackageLockJson(\n  editFn: (packageLockJson: PackageLockJson) => Promisable<void>,\n  options: EditPackageLockJsonOptions = {}\n): Promise<void> {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  await editJson<PackageJson>(getPackageLockJsonPath(cwd), editFn, normalizeOptionalProperties<EditJsonOptions>({ shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package-lock.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageLockJson` object.\n * @param options - Additional options for editing.\n */\nexport function editPackageLockJsonSync(\n  editFn: (packageLockJson: PackageLockJson) => void,\n  options: EditPackageLockJsonSyncOptions = {}\n): void {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  editJsonSync<PackageLockJson>(getPackageLockJsonPath(cwd), editFn, normalizeOptionalProperties<EditJsonOptions>({ shouldSkipIfMissing }));\n}\n\n/**\n * Resolves the path to the `npm-shrinkwrap.json` file in the specified folder or in the root if no folder is specified.\n *\n * @param cwd - The current working folder where `npm-shrinkwrap.json` is located.\n * @returns The resolved path to the `npm-shrinkwrap.json` file.\n */\nexport function getNpmShrinkWrapJsonPath(cwd?: string): string {\n  return ensureNonNullable(resolvePathFromRoot(ObsidianPluginRepoPaths.NpmShrinkwrapJson, cwd), 'Could not determine the npm-shrinkwrap.json path');\n}\n\n/**\n * Resolves the path to the `package.json` file in the specified folder or in the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package.json` is located.\n * @returns The resolved path to the `package.json` file.\n */\nexport function getPackageJsonPath(cwd?: string): string {\n  return ensureNonNullable(resolvePathFromRoot(ObsidianPluginRepoPaths.PackageJson, cwd), 'Could not determine the package.json path');\n}\n\n/**\n * Resolves the path to the `package-lock.json` file in the specified folder or in the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns The resolved path to the `package-lock.json` file.\n */\nexport function getPackageLockJsonPath(cwd?: string): string {\n  return ensureNonNullable(resolvePathFromRoot(ObsidianPluginRepoPaths.PackageLockJson, cwd), 'Could not determine the package-lock.json path');\n}\n\n/**\n * Reads the `package.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package.json` is located.\n * @returns A {@link Promise} that resolves with the parsed `PackageJson` object.\n */\nexport async function readPackageJson(cwd?: string): Promise<PackageJson> {\n  return await readJson<PackageJson>(getPackageJsonPath(cwd));\n}\n\n/**\n * Reads the `package.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package.json` is located.\n * @returns The parsed `PackageJson` object.\n */\nexport function readPackageJsonSync(cwd?: string): PackageJson {\n  return readJsonSync<PackageJson>(getPackageJsonPath(cwd));\n}\n\n/**\n * Reads the `package-lock.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns A {@link Promise} that resolves with the parsed `PackageJson` object.\n */\nexport async function readPackageLockJson(cwd?: string): Promise<PackageLockJson> {\n  return await readJson<PackageLockJson>(getPackageLockJsonPath(cwd));\n}\n\n/**\n * Reads the `package-lock.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns The parsed `PackageLockJson` object.\n */\nexport function readPackageLockJsonSync(cwd?: string): PackageLockJson {\n  return readJsonSync<PackageLockJson>(getPackageLockJsonPath(cwd));\n}\n\n/**\n * Writes the provided `PackageJson` object to the `package.json` file in the specified folder or in the root.\n *\n * @param packageJson - The `PackageJson` object to write.\n * @param cwd - The current working folder where `package.json` is located.\n * @returns A {@link Promise} that resolves when the file has been written.\n */\nexport async function writePackageJson(packageJson: PackageJson, cwd?: string): Promise<void> {\n  await writeJson(getPackageJsonPath(cwd), packageJson);\n}\n\n/**\n * Writes the provided `PackageJson` object to the `package.json` file in the specified folder or in the root.\n *\n * @param packageJson - The `PackageJson` object to write.\n * @param cwd - The current working folder where `package.json` is located.\n */\nexport function writePackageJsonSync(packageJson: PackageJson, cwd?: string): void {\n  writeJsonSync(getPackageJsonPath(cwd), packageJson);\n}\n\n/**\n * Writes the provided `PackageJson` object to the `package-lock.json` file in the specified folder or in the root.\n *\n * @param packageLockJson - The `PackageLockJson` object to write.\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns A {@link Promise} that resolves when the file has been written.\n */\nexport async function writePackageLockJson(packageLockJson: PackageLockJson, cwd?: string): Promise<void> {\n  await writeJson(getPackageLockJsonPath(cwd), packageLockJson);\n}\n\n/**\n * Writes the provided `PackageLockJson` object to the `package-lock.json` file in the specified folder or in the root.\n *\n * @param packageLockJson - The `PackageLockJson` object to write.\n * @param cwd - The current working folder where `package-lock.json` is located.\n */\nexport function writePackageLockJsonSync(packageLockJson: PackageLockJson, cwd?: string): void {\n  writeJsonSync(getPackageLockJsonPath(cwd), packageLockJson);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAaA,SAAS,mCAAmC;AAC5C,SAAS,+BAA+B;AACxC,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,2BAA2B;AA2DpC,eAAsB,sBACpB,QACA,UAAwC,CAAC,GAC1B;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,SAAsB,yBAAyB,GAAG,GAAG,QAAQ,4BAA6C,EAAE,oBAAoB,CAAC,CAAC;AAC1I;AASA,eAAsB,gBACpB,QACA,UAAkC,CAAC,GACpB;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,SAAsB,mBAAmB,GAAG,GAAG,QAAQ,4BAA6C,EAAE,oBAAoB,CAAC,CAAC;AACpI;AAQO,SAAS,oBACd,QACA,UAAsC,CAAC,GACjC;AACN,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,eAA0B,mBAAmB,GAAG,GAAG,QAAQ,4BAA6C,EAAE,oBAAoB,CAAC,CAAC;AAClI;AASA,eAAsB,oBACpB,QACA,UAAsC,CAAC,GACxB;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,SAAsB,uBAAuB,GAAG,GAAG,QAAQ,4BAA6C,EAAE,oBAAoB,CAAC,CAAC;AACxI;AAQO,SAAS,wBACd,QACA,UAA0C,CAAC,GACrC;AACN,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,eAA8B,uBAAuB,GAAG,GAAG,QAAQ,4BAA6C,EAAE,oBAAoB,CAAC,CAAC;AAC1I;AAQO,SAAS,yBAAyB,KAAsB;AAC7D,SAAO,kBAAkB,oBAAoB,wBAAwB,mBAAmB,GAAG,GAAG,kDAAkD;AAClJ;AAQO,SAAS,mBAAmB,KAAsB;AACvD,SAAO,kBAAkB,oBAAoB,wBAAwB,aAAa,GAAG,GAAG,2CAA2C;AACrI;AAQO,SAAS,uBAAuB,KAAsB;AAC3D,SAAO,kBAAkB,oBAAoB,wBAAwB,iBAAiB,GAAG,GAAG,gDAAgD;AAC9I;AAQA,eAAsB,gBAAgB,KAAoC;AACxE,SAAO,MAAM,SAAsB,mBAAmB,GAAG,CAAC;AAC5D;AAQO,SAAS,oBAAoB,KAA2B;AAC7D,SAAO,aAA0B,mBAAmB,GAAG,CAAC;AAC1D;AAQA,eAAsB,oBAAoB,KAAwC;AAChF,SAAO,MAAM,SAA0B,uBAAuB,GAAG,CAAC;AACpE;AAQO,SAAS,wBAAwB,KAA+B;AACrE,SAAO,aAA8B,uBAAuB,GAAG,CAAC;AAClE;AASA,eAAsB,iBAAiB,aAA0B,KAA6B;AAC5F,QAAM,UAAU,mBAAmB,GAAG,GAAG,WAAW;AACtD;AAQO,SAAS,qBAAqB,aAA0B,KAAoB;AACjF,gBAAc,mBAAmB,GAAG,GAAG,WAAW;AACpD;AASA,eAAsB,qBAAqB,iBAAkC,KAA6B;AACxG,QAAM,UAAU,uBAAuB,GAAG,GAAG,eAAe;AAC9D;AAQO,SAAS,yBAAyB,iBAAkC,KAAoB;AAC7F,gBAAc,uBAAuB,GAAG,GAAG,eAAe;AAC5D;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/npm.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for NPM package.json.\n */\n\nimport type {\n  PackageJson,\n  Promisable\n} from 'type-fest';\n\nimport type {\n  EditJsonParams,\n  EditJsonSyncParams\n} from './json.ts';\nimport type { ResolvePathFromRootParams } from './root.ts';\n\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport { ObsidianPluginRepoPaths } from '../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\nimport {\n  editJson,\n  editJsonSync,\n  readJson,\n  readJsonSync,\n  writeJson,\n  writeJsonSync\n} from './json.ts';\nimport { resolvePathFromRoot } from './root.ts';\n\n/**\n * Options for {@link editNpmShrinkWrapJson}.\n */\nexport type EditNpmShrinkWrapJsonOptions = EditPackageJsonOptions;\n\n/**\n * Options for {@link editPackageJson}.\n */\nexport interface EditPackageJsonOptions {\n  /**\n   * A current working folder where `package.json` is located.\n   */\n  readonly cwd?: string;\n\n  /**\n   * If `true`, skips editing if the file does not exist.\n   */\n  readonly shouldSkipIfMissing?: boolean;\n}\n\n/**\n * Options for {@link editPackageJsonSync}.\n */\nexport type EditPackageJsonSyncOptions = EditPackageJsonOptions;\n\n/**\n * Options for {@link editPackageLockJson}.\n */\nexport type EditPackageLockJsonOptions = EditPackageJsonOptions;\n\n/**\n * Options for {@link editPackageLockJsonSync}.\n */\nexport type EditPackageLockJsonSyncOptions = EditPackageJsonOptions;\n\n/**\n * A type of the `package.json` file.\n */\nexport type { PackageJson };\n\n/**\n * A type of the `package-lock.json` file.\n */\nexport interface PackageLockJson extends Partial<PackageJson> {\n  /**\n   * Packages in the `package-lock.json` file.\n   */\n  packages?: Record<string, PackageJson>;\n}\n\n/**\n * Reads, edits, and writes back the `package-lock.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n * @returns A {@link Promise} that resolves when the file has been edited and written.\n */\nexport async function editNpmShrinkWrapJson(\n  editFn: (packageLockJson: PackageLockJson) => Promisable<void>,\n  options: EditNpmShrinkWrapJsonOptions = {}\n): Promise<void> {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  await editJson<PackageJson>(normalizeOptionalProperties<EditJsonParams<PackageJson>>({ editFn, path: getNpmShrinkWrapJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n * @returns A {@link Promise} that resolves when the file has been edited and written.\n */\nexport async function editPackageJson(\n  editFn: (packageJson: PackageJson) => Promisable<void>,\n  options: EditPackageJsonOptions = {}\n): Promise<void> {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  await editJson<PackageJson>(normalizeOptionalProperties<EditJsonParams<PackageJson>>({ editFn, path: getPackageJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n */\nexport function editPackageJsonSync(\n  editFn: (packageJson: PackageJson) => void,\n  options: EditPackageJsonSyncOptions = {}\n): void {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  editJsonSync<PackageJson>(normalizeOptionalProperties<EditJsonSyncParams<PackageJson>>({ editFn, path: getPackageJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package-lock.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageJson` object.\n * @param options - Additional options for editing.\n * @returns A {@link Promise} that resolves when the file has been edited and written.\n */\nexport async function editPackageLockJson(\n  editFn: (packageLockJson: PackageLockJson) => Promisable<void>,\n  options: EditPackageLockJsonOptions = {}\n): Promise<void> {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  await editJson<PackageJson>(normalizeOptionalProperties<EditJsonParams<PackageJson>>({ editFn, path: getPackageLockJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Reads, edits, and writes back the `package-lock.json` file using the provided edit function.\n *\n * @param editFn - The function to edit the parsed `PackageLockJson` object.\n * @param options - Additional options for editing.\n */\nexport function editPackageLockJsonSync(\n  editFn: (packageLockJson: PackageLockJson) => void,\n  options: EditPackageLockJsonSyncOptions = {}\n): void {\n  const {\n    cwd,\n    shouldSkipIfMissing\n  } = options;\n  editJsonSync<PackageLockJson>(normalizeOptionalProperties<EditJsonSyncParams<PackageLockJson>>({ editFn, path: getPackageLockJsonPath(cwd), shouldSkipIfMissing }));\n}\n\n/**\n * Resolves the path to the `npm-shrinkwrap.json` file in the specified folder or in the root if no folder is specified.\n *\n * @param cwd - The current working folder where `npm-shrinkwrap.json` is located.\n * @returns The resolved path to the `npm-shrinkwrap.json` file.\n */\nexport function getNpmShrinkWrapJsonPath(cwd?: string): string {\n  return ensureNonNullable(\n    resolvePathFromRoot(normalizeOptionalProperties<ResolvePathFromRootParams>({ cwd, path: ObsidianPluginRepoPaths.NpmShrinkwrapJson })),\n    'Could not determine the npm-shrinkwrap.json path'\n  );\n}\n\n/**\n * Resolves the path to the `package.json` file in the specified folder or in the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package.json` is located.\n * @returns The resolved path to the `package.json` file.\n */\nexport function getPackageJsonPath(cwd?: string): string {\n  return ensureNonNullable(\n    resolvePathFromRoot(normalizeOptionalProperties<ResolvePathFromRootParams>({ cwd, path: ObsidianPluginRepoPaths.PackageJson })),\n    'Could not determine the package.json path'\n  );\n}\n\n/**\n * Resolves the path to the `package-lock.json` file in the specified folder or in the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns The resolved path to the `package-lock.json` file.\n */\nexport function getPackageLockJsonPath(cwd?: string): string {\n  return ensureNonNullable(\n    resolvePathFromRoot(normalizeOptionalProperties<ResolvePathFromRootParams>({ cwd, path: ObsidianPluginRepoPaths.PackageLockJson })),\n    'Could not determine the package-lock.json path'\n  );\n}\n\n/**\n * Reads the `package.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package.json` is located.\n * @returns A {@link Promise} that resolves with the parsed `PackageJson` object.\n */\nexport async function readPackageJson(cwd?: string): Promise<PackageJson> {\n  return await readJson<PackageJson>(getPackageJsonPath(cwd));\n}\n\n/**\n * Reads the `package.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package.json` is located.\n * @returns The parsed `PackageJson` object.\n */\nexport function readPackageJsonSync(cwd?: string): PackageJson {\n  return readJsonSync<PackageJson>(getPackageJsonPath(cwd));\n}\n\n/**\n * Reads the `package-lock.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns A {@link Promise} that resolves with the parsed `PackageJson` object.\n */\nexport async function readPackageLockJson(cwd?: string): Promise<PackageLockJson> {\n  return await readJson<PackageLockJson>(getPackageLockJsonPath(cwd));\n}\n\n/**\n * Reads the `package-lock.json` file from the specified folder or from the root if no folder is specified.\n *\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns The parsed `PackageLockJson` object.\n */\nexport function readPackageLockJsonSync(cwd?: string): PackageLockJson {\n  return readJsonSync<PackageLockJson>(getPackageLockJsonPath(cwd));\n}\n\n/**\n * Writes the provided `PackageJson` object to the `package.json` file in the specified folder or in the root.\n *\n * @param packageJson - The `PackageJson` object to write.\n * @param cwd - The current working folder where `package.json` is located.\n * @returns A {@link Promise} that resolves when the file has been written.\n */\nexport async function writePackageJson(packageJson: PackageJson, cwd?: string): Promise<void> {\n  await writeJson(getPackageJsonPath(cwd), packageJson);\n}\n\n/**\n * Writes the provided `PackageJson` object to the `package.json` file in the specified folder or in the root.\n *\n * @param packageJson - The `PackageJson` object to write.\n * @param cwd - The current working folder where `package.json` is located.\n */\nexport function writePackageJsonSync(packageJson: PackageJson, cwd?: string): void {\n  writeJsonSync(getPackageJsonPath(cwd), packageJson);\n}\n\n/**\n * Writes the provided `PackageJson` object to the `package-lock.json` file in the specified folder or in the root.\n *\n * @param packageLockJson - The `PackageLockJson` object to write.\n * @param cwd - The current working folder where `package-lock.json` is located.\n * @returns A {@link Promise} that resolves when the file has been written.\n */\nexport async function writePackageLockJson(packageLockJson: PackageLockJson, cwd?: string): Promise<void> {\n  await writeJson(getPackageLockJsonPath(cwd), packageLockJson);\n}\n\n/**\n * Writes the provided `PackageLockJson` object to the `package-lock.json` file in the specified folder or in the root.\n *\n * @param packageLockJson - The `PackageLockJson` object to write.\n * @param cwd - The current working folder where `package-lock.json` is located.\n */\nexport function writePackageLockJsonSync(packageLockJson: PackageLockJson, cwd?: string): void {\n  writeJsonSync(getPackageLockJsonPath(cwd), packageLockJson);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAiBA,SAAS,mCAAmC;AAC5C,SAAS,+BAA+B;AACxC,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,2BAA2B;AA2DpC,eAAsB,sBACpB,QACA,UAAwC,CAAC,GAC1B;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,SAAsB,4BAAyD,EAAE,QAAQ,MAAM,yBAAyB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AAC5J;AASA,eAAsB,gBACpB,QACA,UAAkC,CAAC,GACpB;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,SAAsB,4BAAyD,EAAE,QAAQ,MAAM,mBAAmB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AACtJ;AAQO,SAAS,oBACd,QACA,UAAsC,CAAC,GACjC;AACN,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,eAA0B,4BAA6D,EAAE,QAAQ,MAAM,mBAAmB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AACxJ;AASA,eAAsB,oBACpB,QACA,UAAsC,CAAC,GACxB;AACf,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,SAAsB,4BAAyD,EAAE,QAAQ,MAAM,uBAAuB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AAC1J;AAQO,SAAS,wBACd,QACA,UAA0C,CAAC,GACrC;AACN,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,eAA8B,4BAAiE,EAAE,QAAQ,MAAM,uBAAuB,GAAG,GAAG,oBAAoB,CAAC,CAAC;AACpK;AAQO,SAAS,yBAAyB,KAAsB;AAC7D,SAAO;AAAA,IACL,oBAAoB,4BAAuD,EAAE,KAAK,MAAM,wBAAwB,kBAAkB,CAAC,CAAC;AAAA,IACpI;AAAA,EACF;AACF;AAQO,SAAS,mBAAmB,KAAsB;AACvD,SAAO;AAAA,IACL,oBAAoB,4BAAuD,EAAE,KAAK,MAAM,wBAAwB,YAAY,CAAC,CAAC;AAAA,IAC9H;AAAA,EACF;AACF;AAQO,SAAS,uBAAuB,KAAsB;AAC3D,SAAO;AAAA,IACL,oBAAoB,4BAAuD,EAAE,KAAK,MAAM,wBAAwB,gBAAgB,CAAC,CAAC;AAAA,IAClI;AAAA,EACF;AACF;AAQA,eAAsB,gBAAgB,KAAoC;AACxE,SAAO,MAAM,SAAsB,mBAAmB,GAAG,CAAC;AAC5D;AAQO,SAAS,oBAAoB,KAA2B;AAC7D,SAAO,aAA0B,mBAAmB,GAAG,CAAC;AAC1D;AAQA,eAAsB,oBAAoB,KAAwC;AAChF,SAAO,MAAM,SAA0B,uBAAuB,GAAG,CAAC;AACpE;AAQO,SAAS,wBAAwB,KAA+B;AACrE,SAAO,aAA8B,uBAAuB,GAAG,CAAC;AAClE;AASA,eAAsB,iBAAiB,aAA0B,KAA6B;AAC5F,QAAM,UAAU,mBAAmB,GAAG,GAAG,WAAW;AACtD;AAQO,SAAS,qBAAqB,aAA0B,KAAoB;AACjF,gBAAc,mBAAmB,GAAG,GAAG,WAAW;AACpD;AASA,eAAsB,qBAAqB,iBAAkC,KAA6B;AACxG,QAAM,UAAU,uBAAuB,GAAG,GAAG,eAAe;AAC9D;AAQO,SAAS,yBAAyB,iBAAkC,KAAoB;AAC7F,gBAAc,uBAAuB,GAAG,GAAG,eAAe;AAC5D;",
  "names": []
}


package/dist/lib/esm/script-utils/root.d.mts

@@ -10,6 +10,45 @@ import type { CommandPart, ExecDetailedOptions, ExecOptions, ExecResult, ExecSim
  * Options for {@link execFromRoot}.
  */
 export type ExecFromRootOptions = ExecOptions;
+/**
+ * Parameters for {@link resolvePathFromRoot}.
+ */
+export interface ResolvePathFromRootParams {
+    /**
+     * The current working folder to resolve from.
+     */
+    readonly cwd?: string;
+    /**
+     * The path to resolve.
+     */
+    readonly path: string;
+}
+/**
+ * Parameters for {@link resolvePathFromRootSafe}.
+ */
+export interface ResolvePathFromRootSafeParams {
+    /**
+     * The current working folder to resolve from.
+     */
+    readonly cwd?: string;
+    /**
+     * The path to resolve.
+     */
+    readonly path: string;
+}
+/**
+ * Parameters for {@link toRelativeFromRoot}.
+ */
+export interface ToRelativeFromRootParams {
+    /**
+     * The current working folder to resolve from.
+     */
+    readonly cwd?: string;
+    /**
+     * The absolute path to convert.
+     */
+    readonly path: string;
+}
 /**
  * Executes a command from the root folder of the project.
  *
@@ -46,24 +85,21 @@ export declare function getRootFolder(cwd?: string): null | string;
 /**
  * Resolves a path relative to the root folder of the project.
  *
- * @param path - The path to resolve.
- * @param cwd - The current working folder to resolve from.
+ * @param params - The parameters for the function.
  * @returns The resolved absolute path.
  */
-export declare function resolvePathFromRoot(path: string, cwd?: string): null | string;
+export declare function resolvePathFromRoot(params: ResolvePathFromRootParams): null | string;
 /**
  * Resolves a path relative to the root folder, returning the resolved path or the original path if it does not exist.
  *
- * @param path - The path to resolve.
- * @param cwd - The current working folder to resolve from.
+ * @param params - The parameters for the function.
  * @returns The resolved path or the original path if it does not exist.
  */
-export declare function resolvePathFromRootSafe(path: string, cwd?: string): string;
+export declare function resolvePathFromRootSafe(params: ResolvePathFromRootSafeParams): string;
 /**
  * Converts an absolute path to a relative path from the root folder of the project.
  *
- * @param path - The absolute path to convert.
- * @param cwd - The current working folder to resolve from.
+ * @param params - The parameters for the function.
  * @returns The relative path from the root folder.
  */
-export declare function toRelativeFromRoot(path: string, cwd?: string): null | string;
+export declare function toRelativeFromRoot(params: ToRelativeFromRootParams): null | string;

package/dist/lib/esm/script-utils/root.mjs

@@ -22,6 +22,7 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 import { existsSync } from "node:fs";
+import { normalizeOptionalProperties } from "../object-utils.mjs";
 import {
   dirname,
   join,
@@ -54,17 +55,31 @@ function getRootFolder(cwd) {
   }
   return null;
 }
-function resolvePathFromRoot(path, cwd) {
+function resolvePathFromRoot(params) {
+  const {
+    cwd,
+    path
+  } = params;
   const rootFolder = getRootFolder(cwd);
   if (!rootFolder) {
     return null;
   }
   return resolve(rootFolder, path);
 }
-function resolvePathFromRootSafe(path, cwd) {
-  return resolvePathFromRoot(path, cwd) ?? path;
+function resolvePathFromRootSafe(params) {
+  const {
+    cwd,
+    path
+  } = params;
+  return resolvePathFromRoot(normalizeOptionalProperties({ cwd, path })) ?? path;
 }
-function toRelativeFromRoot(path, cwd) {
+function toRelativeFromRoot(params) {
+  const {
+    cwd
+  } = params;
+  let {
+    path
+  } = params;
   const rootFolder = getRootFolder(cwd);
   if (!rootFolder) {
     return null;
@@ -79,4 +94,4 @@ export {
   resolvePathFromRootSafe,
   toRelativeFromRoot
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/root.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for executing commands from the root folder of a project,\n * resolving paths relative to the root.\n */\n\nimport { existsSync } from 'node:fs';\n\nimport type {\n  CommandPart,\n  ExecDetailedOptions,\n  ExecOptions,\n  ExecResult,\n  ExecSimpleOptions\n} from './exec.ts';\n\nimport {\n  dirname,\n  join,\n  relative,\n  resolve,\n  toPosixPath\n} from '../path.ts';\nimport { exec } from './exec.ts';\nimport { ObsidianDevUtilsRepoPaths } from './obsidian-dev-utils-repo-paths.ts';\n\n/**\n * Options for {@link execFromRoot}.\n */\nexport type ExecFromRootOptions = ExecOptions;\n\n/**\n * Executes a command from the root folder of the project.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport async function execFromRoot(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\n/**\n * Executes a command from the root folder of the project.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function execFromRoot(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\n/**\n * Executes a command from the root folder of the project.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command or an ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function execFromRoot(command: CommandPart[] | string, options: ExecFromRootOptions = {}): Promise<ExecResult | string> {\n  let root = getRootFolder(options.cwd);\n\n  if (!root) {\n    if (options.shouldFailIfCalledFromOutsideRoot ?? true) {\n      throw new Error('Could not find root folder');\n    }\n\n    root = options.cwd ?? process.cwd();\n  }\n\n  if (options.shouldIncludeDetails) {\n    return exec(command, { ...options, cwd: root, shouldIncludeDetails: true });\n  }\n\n  return exec(command, { ...options, cwd: root, shouldIncludeDetails: false });\n}\n\n/**\n * Retrieves the root folder of the project.\n *\n * @param cwd - The current working folder to resolve from.\n * @returns The path to the root folder.\n * @throws If the root folder cannot be found.\n */\nexport function getRootFolder(cwd?: string): null | string {\n  let currentFolder = toPosixPath(cwd ?? process.cwd());\n  while (currentFolder !== ObsidianDevUtilsRepoPaths.CurrentFolder as string && currentFolder !== ObsidianDevUtilsRepoPaths.RootFolder as string) {\n    if (existsSync(join(currentFolder, ObsidianDevUtilsRepoPaths.PackageJson))) {\n      return toPosixPath(currentFolder);\n    }\n    currentFolder = dirname(currentFolder);\n  }\n\n  return null;\n}\n\n/**\n * Resolves a path relative to the root folder of the project.\n *\n * @param path - The path to resolve.\n * @param cwd - The current working folder to resolve from.\n * @returns The resolved absolute path.\n */\nexport function resolvePathFromRoot(path: string, cwd?: string): null | string {\n  const rootFolder = getRootFolder(cwd);\n  if (!rootFolder) {\n    return null;\n  }\n\n  return resolve(rootFolder, path);\n}\n\n/**\n * Resolves a path relative to the root folder, returning the resolved path or the original path if it does not exist.\n *\n * @param path - The path to resolve.\n * @param cwd - The current working folder to resolve from.\n * @returns The resolved path or the original path if it does not exist.\n */\nexport function resolvePathFromRootSafe(path: string, cwd?: string): string {\n  return resolvePathFromRoot(path, cwd) ?? path;\n}\n\n/**\n * Converts an absolute path to a relative path from the root folder of the project.\n *\n * @param path - The absolute path to convert.\n * @param cwd - The current working folder to resolve from.\n * @returns The relative path from the root folder.\n */\nexport function toRelativeFromRoot(path: string, cwd?: string): null | string {\n  const rootFolder = getRootFolder(cwd);\n  if (!rootFolder) {\n    return null;\n  }\n\n  path = toPosixPath(path);\n  return relative(rootFolder, path);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAOA,SAAS,kBAAkB;AAU3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AACrB,SAAS,iCAAiC;AA4CnC,SAAS,aAAa,SAAiC,UAA+B,CAAC,GAAiC;AAC7H,MAAI,OAAO,cAAc,QAAQ,GAAG;AAEpC,MAAI,CAAC,MAAM;AACT,QAAI,QAAQ,qCAAqC,MAAM;AACrD,YAAM,IAAI,MAAM,4BAA4B;AAAA,IAC9C;AAEA,WAAO,QAAQ,OAAO,QAAQ,IAAI;AAAA,EACpC;AAEA,MAAI,QAAQ,sBAAsB;AAChC,WAAO,KAAK,SAAS,EAAE,GAAG,SAAS,KAAK,MAAM,sBAAsB,KAAK,CAAC;AAAA,EAC5E;AAEA,SAAO,KAAK,SAAS,EAAE,GAAG,SAAS,KAAK,MAAM,sBAAsB,MAAM,CAAC;AAC7E;AASO,SAAS,cAAc,KAA6B;AACzD,MAAI,gBAAgB,YAAY,OAAO,QAAQ,IAAI,CAAC;AACpD,SAAO,kBAAkB,0BAA0B,iBAA2B,kBAAkB,0BAA0B,YAAsB;AAC9I,QAAI,WAAW,KAAK,eAAe,0BAA0B,WAAW,CAAC,GAAG;AAC1E,aAAO,YAAY,aAAa;AAAA,IAClC;AACA,oBAAgB,QAAQ,aAAa;AAAA,EACvC;AAEA,SAAO;AACT;AASO,SAAS,oBAAoB,MAAc,KAA6B;AAC7E,QAAM,aAAa,cAAc,GAAG;AACpC,MAAI,CAAC,YAAY;AACf,WAAO;AAAA,EACT;AAEA,SAAO,QAAQ,YAAY,IAAI;AACjC;AASO,SAAS,wBAAwB,MAAc,KAAsB;AAC1E,SAAO,oBAAoB,MAAM,GAAG,KAAK;AAC3C;AASO,SAAS,mBAAmB,MAAc,KAA6B;AAC5E,QAAM,aAAa,cAAc,GAAG;AACpC,MAAI,CAAC,YAAY;AACf,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,IAAI;AACvB,SAAO,SAAS,YAAY,IAAI;AAClC;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/root.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for executing commands from the root folder of a project,\n * resolving paths relative to the root.\n */\n\nimport { existsSync } from 'node:fs';\n\nimport type {\n  CommandPart,\n  ExecDetailedOptions,\n  ExecOptions,\n  ExecResult,\n  ExecSimpleOptions\n} from './exec.ts';\n\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport {\n  dirname,\n  join,\n  relative,\n  resolve,\n  toPosixPath\n} from '../path.ts';\nimport { exec } from './exec.ts';\nimport { ObsidianDevUtilsRepoPaths } from './obsidian-dev-utils-repo-paths.ts';\n\n/**\n * Options for {@link execFromRoot}.\n */\nexport type ExecFromRootOptions = ExecOptions;\n\n/**\n * Parameters for {@link resolvePathFromRoot}.\n */\nexport interface ResolvePathFromRootParams {\n  /**\n   * The current working folder to resolve from.\n   */\n  readonly cwd?: string;\n\n  /**\n   * The path to resolve.\n   */\n  readonly path: string;\n}\n/**\n * Parameters for {@link resolvePathFromRootSafe}.\n */\nexport interface ResolvePathFromRootSafeParams {\n  /**\n   * The current working folder to resolve from.\n   */\n  readonly cwd?: string;\n\n  /**\n   * The path to resolve.\n   */\n  readonly path: string;\n}\n/**\n * Parameters for {@link toRelativeFromRoot}.\n */\nexport interface ToRelativeFromRootParams {\n  /**\n   * The current working folder to resolve from.\n   */\n  readonly cwd?: string;\n\n  /**\n   * The absolute path to convert.\n   */\n  readonly path: string;\n}\n\n/**\n * Executes a command from the root folder of the project.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport async function execFromRoot(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\n/**\n * Executes a command from the root folder of the project.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function execFromRoot(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\n/**\n * Executes a command from the root folder of the project.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command or an ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function execFromRoot(command: CommandPart[] | string, options: ExecFromRootOptions = {}): Promise<ExecResult | string> {\n  let root = getRootFolder(options.cwd);\n\n  if (!root) {\n    if (options.shouldFailIfCalledFromOutsideRoot ?? true) {\n      throw new Error('Could not find root folder');\n    }\n\n    root = options.cwd ?? process.cwd();\n  }\n\n  if (options.shouldIncludeDetails) {\n    return exec(command, { ...options, cwd: root, shouldIncludeDetails: true });\n  }\n\n  return exec(command, { ...options, cwd: root, shouldIncludeDetails: false });\n}\n\n/**\n * Retrieves the root folder of the project.\n *\n * @param cwd - The current working folder to resolve from.\n * @returns The path to the root folder.\n * @throws If the root folder cannot be found.\n */\nexport function getRootFolder(cwd?: string): null | string {\n  let currentFolder = toPosixPath(cwd ?? process.cwd());\n  while (currentFolder !== ObsidianDevUtilsRepoPaths.CurrentFolder as string && currentFolder !== ObsidianDevUtilsRepoPaths.RootFolder as string) {\n    if (existsSync(join(currentFolder, ObsidianDevUtilsRepoPaths.PackageJson))) {\n      return toPosixPath(currentFolder);\n    }\n    currentFolder = dirname(currentFolder);\n  }\n\n  return null;\n}\n\n/**\n * Resolves a path relative to the root folder of the project.\n *\n * @param params - The parameters for the function.\n * @returns The resolved absolute path.\n */\nexport function resolvePathFromRoot(params: ResolvePathFromRootParams): null | string {\n  const {\n    cwd,\n    path\n  } = params;\n  const rootFolder = getRootFolder(cwd);\n  if (!rootFolder) {\n    return null;\n  }\n\n  return resolve(rootFolder, path);\n}\n\n/**\n * Resolves a path relative to the root folder, returning the resolved path or the original path if it does not exist.\n *\n * @param params - The parameters for the function.\n * @returns The resolved path or the original path if it does not exist.\n */\nexport function resolvePathFromRootSafe(params: ResolvePathFromRootSafeParams): string {\n  const {\n    cwd,\n    path\n  } = params;\n  return resolvePathFromRoot(normalizeOptionalProperties<ResolvePathFromRootParams>({ cwd, path })) ?? path;\n}\n\n/**\n * Converts an absolute path to a relative path from the root folder of the project.\n *\n * @param params - The parameters for the function.\n * @returns The relative path from the root folder.\n */\nexport function toRelativeFromRoot(params: ToRelativeFromRootParams): null | string {\n  const {\n    cwd\n  } = params;\n  let {\n    path\n  } = params;\n  const rootFolder = getRootFolder(cwd);\n  if (!rootFolder) {\n    return null;\n  }\n\n  path = toPosixPath(path);\n  return relative(rootFolder, path);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAOA,SAAS,kBAAkB;AAU3B,SAAS,mCAAmC;AAC5C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AACrB,SAAS,iCAAiC;AAuFnC,SAAS,aAAa,SAAiC,UAA+B,CAAC,GAAiC;AAC7H,MAAI,OAAO,cAAc,QAAQ,GAAG;AAEpC,MAAI,CAAC,MAAM;AACT,QAAI,QAAQ,qCAAqC,MAAM;AACrD,YAAM,IAAI,MAAM,4BAA4B;AAAA,IAC9C;AAEA,WAAO,QAAQ,OAAO,QAAQ,IAAI;AAAA,EACpC;AAEA,MAAI,QAAQ,sBAAsB;AAChC,WAAO,KAAK,SAAS,EAAE,GAAG,SAAS,KAAK,MAAM,sBAAsB,KAAK,CAAC;AAAA,EAC5E;AAEA,SAAO,KAAK,SAAS,EAAE,GAAG,SAAS,KAAK,MAAM,sBAAsB,MAAM,CAAC;AAC7E;AASO,SAAS,cAAc,KAA6B;AACzD,MAAI,gBAAgB,YAAY,OAAO,QAAQ,IAAI,CAAC;AACpD,SAAO,kBAAkB,0BAA0B,iBAA2B,kBAAkB,0BAA0B,YAAsB;AAC9I,QAAI,WAAW,KAAK,eAAe,0BAA0B,WAAW,CAAC,GAAG;AAC1E,aAAO,YAAY,aAAa;AAAA,IAClC;AACA,oBAAgB,QAAQ,aAAa;AAAA,EACvC;AAEA,SAAO;AACT;AAQO,SAAS,oBAAoB,QAAkD;AACpF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,aAAa,cAAc,GAAG;AACpC,MAAI,CAAC,YAAY;AACf,WAAO;AAAA,EACT;AAEA,SAAO,QAAQ,YAAY,IAAI;AACjC;AAQO,SAAS,wBAAwB,QAA+C;AACrF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,SAAO,oBAAoB,4BAAuD,EAAE,KAAK,KAAK,CAAC,CAAC,KAAK;AACvG;AAQO,SAAS,mBAAmB,QAAiD;AAClF,QAAM;AAAA,IACJ;AAAA,EACF,IAAI;AACJ,MAAI;AAAA,IACF;AAAA,EACF,IAAI;AACJ,QAAM,aAAa,cAAc,GAAG;AACpC,MAAI,CAAC,YAAY;AACf,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,IAAI;AACvB,SAAO,SAAS,YAAY,IAAI;AAClC;",
  "names": []
}


package/dist/lib/esm/script-utils/validate-declarations.mjs

@@ -56,7 +56,7 @@ function validateDeclarations() {
       options,
       rootNames: fileNames,
       shouldKeepDiagnostic: (diagnostic) => !isThirdPartyModuleImportDiagnostic(diagnostic),
-      shouldKeepFile: (fileName) => shouldKeepProjectFile(fileName, rootCanonical)
+      shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })
     });
     isValid &&= isConfigValid;
   }
@@ -97,10 +97,11 @@ function isThirdPartyModuleImportDiagnostic(diagnostic) {
   const specifier = findEnclosingModuleSpecifier(file, diagnostic.start);
   return specifier !== null && !specifier.startsWith(RELATIVE_SPECIFIER_PREFIX);
 }
-function shouldKeepProjectFile(fileName, rootCanonical) {
+function shouldKeepProjectFile(params) {
+  const { fileName, rootCanonical } = params;
   return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);
 }
 export {
   validateDeclarations
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/validate-declarations.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Type-checks the generated declaration files (`.d.cts` / `.d.mts`) to prove they are self-contained\n * \u2014 every `lib` and internal cross-reference they rely on resolves on its own, independent of the\n * consumer's `tsconfig`.\n *\n * The library does not own the types of the third-party packages its declarations import (e.g.\n * `type-fest`, `obsidian`, `markdownlint`). Cross-module-format interop diagnostics caused by those\n * imports \u2014 for example a CommonJS `.d.cts` importing an ESM-only package without a\n * `resolution-mode` attribute (`TS1541` / `TS1542` / `TS1479`) \u2014 describe the third-party package's\n * shape, not a flaw in our declarations, and are the consumer's concern. They are therefore ignored.\n * Only diagnostics about the library's own declarations are reported.\n */\n\nimport type {\n  Diagnostic,\n  Node,\n  SourceFile\n} from 'typescript';\n\nimport {\n  forEachChild,\n  isExportDeclaration,\n  isImportDeclaration,\n  isImportTypeNode,\n  isLiteralTypeNode,\n  isStringLiteral\n} from 'typescript';\n\nimport { join } from '../path.ts';\nimport {\n  checkProjectTypes,\n  parseTsConfig,\n  toCanonical\n} from './check-project-types.ts';\nimport { ObsidianDevUtilsRepoPaths } from './obsidian-dev-utils-repo-paths.ts';\nimport { getRootFolder } from './root.ts';\n\nconst NODE_MODULES_SEGMENT = '/node_modules/';\nconst RELATIVE_SPECIFIER_PREFIX = '.';\n\nconst VALIDATE_DECLARATIONS_TS_CONFIG_FILE_NAMES = [\n  ObsidianDevUtilsRepoPaths.TsConfigValidateDeclarationsJson,\n  ObsidianDevUtilsRepoPaths.TsConfigValidateDeclarationsCjsJson\n];\n\n/**\n * Parameters for {@link shouldKeepProjectFile}.\n */\ninterface ShouldKeepProjectFileParams {\n  /**\n   * Absolute path of the file under consideration.\n   */\n  readonly fileName: string;\n\n  /**\n   * Absolute (canonical) path of the project root.\n   */\n  readonly rootCanonical: string;\n}\n\n/**\n * Validates the generated declaration files against the `tsconfig.validate-declarations*.json`\n * configs, reporting only diagnostics that concern the library's own declarations and ignoring those\n * caused by importing third-party packages.\n *\n * @returns `true` when the library's own declarations have no type errors, `false` otherwise.\n * @throws If the root folder cannot be found.\n */\nexport function validateDeclarations(): boolean {\n  const root = getRootFolder();\n\n  if (!root) {\n    throw new Error('Could not find root folder');\n  }\n\n  const rootCanonical = toCanonical(root);\n\n  let isValid = true;\n\n  for (const tsConfigFileName of VALIDATE_DECLARATIONS_TS_CONFIG_FILE_NAMES) {\n    const { fileNames, options } = parseTsConfig(join(root, tsConfigFileName));\n    const isConfigValid = checkProjectTypes({\n      options,\n      rootNames: fileNames,\n      shouldKeepDiagnostic: (diagnostic) => !isThirdPartyModuleImportDiagnostic(diagnostic),\n      shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })\n    });\n    isValid &&= isConfigValid;\n  }\n\n  return isValid;\n}\n\nfunction findEnclosingModuleSpecifier(sourceFile: SourceFile, position: number): null | string {\n  let specifier: null | string = null;\n  visit(sourceFile);\n  return specifier;\n\n  function visit(node: Node): void {\n    if (position < node.getStart(sourceFile) || position >= node.getEnd()) {\n      return;\n    }\n\n    const nodeSpecifier = getModuleSpecifier(node);\n    if (nodeSpecifier !== null) {\n      specifier = nodeSpecifier;\n    }\n\n    forEachChild(node, visit);\n  }\n}\n\nfunction getModuleSpecifier(node: Node): null | string {\n  if (isImportDeclaration(node) || isExportDeclaration(node)) {\n    return getStringLiteralText(node.moduleSpecifier);\n  }\n\n  if (isImportTypeNode(node)) {\n    return isLiteralTypeNode(node.argument) ? getStringLiteralText(node.argument.literal) : null;\n  }\n\n  return null;\n}\n\nfunction getStringLiteralText(node: Node | undefined): null | string {\n  return node && isStringLiteral(node) ? node.text : null;\n}\n\nfunction isThirdPartyModuleImportDiagnostic(diagnostic: Diagnostic): boolean {\n  const file = diagnostic.file;\n  if (!file || diagnostic.start === undefined) {\n    return false;\n  }\n\n  const specifier = findEnclosingModuleSpecifier(file, diagnostic.start);\n  return specifier !== null && !specifier.startsWith(RELATIVE_SPECIFIER_PREFIX);\n}\n\n/**\n * Determines whether a file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @param params - The parameters for the check.\n * @returns `true` when the file belongs to the project.\n */\nfunction shouldKeepProjectFile(params: ShouldKeepProjectFileParams): boolean {\n  const { fileName, rootCanonical } = params;\n  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAqBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,YAAY;AACrB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,iCAAiC;AAC1C,SAAS,qBAAqB;AAE9B,MAAM,uBAAuB;AAC7B,MAAM,4BAA4B;AAElC,MAAM,6CAA6C;AAAA,EACjD,0BAA0B;AAAA,EAC1B,0BAA0B;AAC5B;AAyBO,SAAS,uBAAgC;AAC9C,QAAM,OAAO,cAAc;AAE3B,MAAI,CAAC,MAAM;AACT,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAC9C;AAEA,QAAM,gBAAgB,YAAY,IAAI;AAEtC,MAAI,UAAU;AAEd,aAAW,oBAAoB,4CAA4C;AACzE,UAAM,EAAE,WAAW,QAAQ,IAAI,cAAc,KAAK,MAAM,gBAAgB,CAAC;AACzE,UAAM,gBAAgB,kBAAkB;AAAA,MACtC;AAAA,MACA,WAAW;AAAA,MACX,sBAAsB,CAAC,eAAe,CAAC,mCAAmC,UAAU;AAAA,MACpF,gBAAgB,CAAC,aAAa,sBAAsB,EAAE,UAAU,cAAc,CAAC;AAAA,IACjF,CAAC;AACD,gBAAY;AAAA,EACd;AAEA,SAAO;AACT;AAEA,SAAS,6BAA6B,YAAwB,UAAiC;AAC7F,MAAI,YAA2B;AAC/B,QAAM,UAAU;AAChB,SAAO;AAEP,WAAS,MAAM,MAAkB;AAC/B,QAAI,WAAW,KAAK,SAAS,UAAU,KAAK,YAAY,KAAK,OAAO,GAAG;AACrE;AAAA,IACF;AAEA,UAAM,gBAAgB,mBAAmB,IAAI;AAC7C,QAAI,kBAAkB,MAAM;AAC1B,kBAAY;AAAA,IACd;AAEA,iBAAa,MAAM,KAAK;AAAA,EAC1B;AACF;AAEA,SAAS,mBAAmB,MAA2B;AACrD,MAAI,oBAAoB,IAAI,KAAK,oBAAoB,IAAI,GAAG;AAC1D,WAAO,qBAAqB,KAAK,eAAe;AAAA,EAClD;AAEA,MAAI,iBAAiB,IAAI,GAAG;AAC1B,WAAO,kBAAkB,KAAK,QAAQ,IAAI,qBAAqB,KAAK,SAAS,OAAO,IAAI;AAAA,EAC1F;AAEA,SAAO;AACT;AAEA,SAAS,qBAAqB,MAAuC;AACnE,SAAO,QAAQ,gBAAgB,IAAI,IAAI,KAAK,OAAO;AACrD;AAEA,SAAS,mCAAmC,YAAiC;AAC3E,QAAM,OAAO,WAAW;AACxB,MAAI,CAAC,QAAQ,WAAW,UAAU,QAAW;AAC3C,WAAO;AAAA,EACT;AAEA,QAAM,YAAY,6BAA6B,MAAM,WAAW,KAAK;AACrE,SAAO,cAAc,QAAQ,CAAC,UAAU,WAAW,yBAAyB;AAC9E;AAQA,SAAS,sBAAsB,QAA8C;AAC3E,QAAM,EAAE,UAAU,cAAc,IAAI;AACpC,SAAO,SAAS,WAAW,GAAG,aAAa,GAAG,KAAK,CAAC,SAAS,SAAS,oBAAoB;AAC5F;",
  "names": []
}
