@mnaoumov/obsidian-lib 6.0.4 → 6.2.0

package/dist/lib/esm/validation.d.mts

@@ -25,29 +25,85 @@ export declare function isValidationMessageHolder(value: unknown): value is Vali
  */
 export declare const OBSIDIAN_UNSAFE_FILENAME_CHARS: RegExp;
 /**
- * Windows-specific unsafe file name path characters.
+ * The characters Obsidian refuses in a file name on Windows.
+ *
+ * Read from Obsidian 1.15.0's `app.js`, whose name check throws on this set from `app.vault.create`, a
+ * rename and Sync alike.
  */
 export declare const WINDOWS_UNSAFE_PATH_CHARS: RegExp;
 /**
- * Unix-specific unsafe file name path characters.
+ * The characters Obsidian refuses in a file name on macOS, Linux and iOS, plus the NUL no file system stores.
+ *
+ * This is Obsidian's refusal set, not the file system's: macOS and Linux store `\` and `:`, but Obsidian
+ * refuses both, so a name holding either cannot be created through the vault there. Read from Obsidian
+ * 1.15.0's `app.js`.
  */
 export declare const UNIX_UNSAFE_PATH_CHARS: RegExp;
+/**
+ * The characters Obsidian refuses in a file name on Android, plus the NUL no file system stores.
+ *
+ * Obsidian adds `* ? < > "` to the {@link UNIX_UNSAFE_PATH_CHARS} set there, because Android's shared
+ * storage refuses them. Read from Obsidian 1.15.0's `app.js`.
+ */
+export declare const ANDROID_UNSAFE_PATH_CHARS: RegExp;
+/**
+ * Validates a single file or folder name against every naming rule this module owns.
+ *
+ * The rules, checked in this order, and the first one broken names the message:
+ *
+ * 1. The name is not empty.
+ * 2. It holds no control character (U+0000 to U+001F).
+ * 3. It holds none of the characters {@link getOsAndObsidianUnsafePathCharsRegExp} matches.
+ * 4. It does not end with a dot or a space ({@link hasWindowsTrailingChars}).
+ * 5. It is not an MS-DOS device name ({@link isWindowsReservedName}), with or without an extension.
+ *
+ * Only rule 3 depends on the platform. Rules 2, 4 and 5 apply on every platform, because a vault is synced,
+ * and a name created on macOS or Linux that Windows refuses breaks the vault there. The character set follows
+ * the platform because it is Obsidian's own refusal set, which differs per platform: a name such as `a?b` is
+ * accepted on macOS, where Obsidian creates it.
+ *
+ * @param name - The name to validate. A single path segment, with or without its extension.
+ * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.
+ * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to
+ * `Platform.isAndroidApp`.
+ * @returns A message describing the first broken rule, or an empty string if the name is valid.
+ */
+export declare function getFileNameValidationMessage(name: string, isWindows?: boolean, isAndroid?: boolean): string;
 /**
  * Returns a regexp matching all unsafe characters in file names/paths.
  *
- * Includes both OS-specific restrictions and Obsidian-specific ones.
+ * Includes both the platform's refused characters ({@link getOsUnsafePathCharsRegExp}) and the ones that break
+ * links ({@link OBSIDIAN_UNSAFE_FILENAME_CHARS}).
  *
- * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.
+ * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.
+ * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to
+ * `Platform.isAndroidApp`.
  * @returns A regexp matching all unsafe characters in file names/paths.
  */
-export declare function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolean): RegExp;
+export declare function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolean, isAndroid?: boolean): RegExp;
+/**
+ * Returns a regexp matching the characters Obsidian refuses in a file name on the given platform.
+ *
+ * That is {@link WINDOWS_UNSAFE_PATH_CHARS} on Windows, {@link ANDROID_UNSAFE_PATH_CHARS} on Android and
+ * {@link UNIX_UNSAFE_PATH_CHARS} everywhere else. It is Obsidian's set rather than the file system's, so a
+ * name it accepts can be created through the vault.
+ *
+ * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.
+ * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to
+ * `Platform.isAndroidApp`.
+ * @returns A regexp matching the characters Obsidian refuses in a file name on the given platform.
+ */
+export declare function getOsUnsafePathCharsRegExp(isWindows?: boolean, isAndroid?: boolean): RegExp;
 /**
- * Returns a regexp matching characters that are not safe to use in file names/paths at the OS level.
+ * Validates every segment of a vault path with {@link getFileNameValidationMessage}.
  *
- * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.
- * @returns A regexp matching characters that are not safe to use in file names/paths at the OS level.
+ * @param path - The vault-relative path to validate, with `/` as the separator.
+ * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.
+ * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to
+ * `Platform.isAndroidApp`.
+ * @returns The message for the first invalid segment, or an empty string if every segment is valid.
  */
-export declare function getOsUnsafePathCharsRegExp(isWindows?: boolean): RegExp;
+export declare function getPathValidationMessage(path: string, isWindows?: boolean, isAndroid?: boolean): string;
 /**
  * Checks whether a name ends with the dots or spaces Windows refuses.
  *

package/dist/lib/esm/validation.mjs

@@ -36,23 +36,49 @@ import {
 } from "@mnaoumov/typescript-lib/path";
 import { oneOf } from "@mnaoumov/typescript-lib/reg-exp";
 import { Platform } from "obsidian";
+import { t } from "./i18n/i18n.mjs";
 function isValidationMessageHolder(value) {
   return value.validationMessage !== void 0;
 }
 const OBSIDIAN_UNSAFE_FILENAME_CHARS = /[#^[\]|]/g;
 const WINDOWS_UNSAFE_PATH_CHARS = /[*\\/<>:|?"]/g;
-const UNIX_UNSAFE_PATH_CHARS = /[\0/]/g;
+const UNIX_UNSAFE_PATH_CHARS = /[\0\\/:]/g;
+const ANDROID_UNSAFE_PATH_CHARS = /[\0*\\/<>:?"]/g;
 const WINDOWS_RESERVED_NAME_REG_EXP = /^(?:AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)$/i;
 const WINDOWS_TRAILING_CHARS_REG_EXP = /[ .]+$/;
-function getOsAndObsidianUnsafePathCharsRegExp(isWindows) {
+const FIRST_NON_CONTROL_CHAR = " ";
+function getFileNameValidationMessage(name, isWindows, isAndroid) {
+  if (name === "") {
+    return t(($) => $.obsidianLib.validation.emptyName);
+  }
+  if (hasControlChars(name)) {
+    return t(($) => $.obsidianLib.validation.controlCharacter, { name });
+  }
+  const unsafeChars = new Set(name.match(getOsAndObsidianUnsafePathCharsRegExp(isWindows, isAndroid)));
+  if (unsafeChars.size > 0) {
+    return t(($) => $.obsidianLib.validation.unsafeCharacters, { characters: [...unsafeChars].join(" "), name });
+  }
+  if (hasWindowsTrailingChars(name)) {
+    return t(($) => $.obsidianLib.validation.trailingCharacters, { name });
+  }
+  return isWindowsReservedName(name) ? t(($) => $.obsidianLib.validation.windowsReservedName, { name }) : "";
+}
+function getOsAndObsidianUnsafePathCharsRegExp(isWindows, isAndroid) {
   return oneOf([
-    getOsUnsafePathCharsRegExp(isWindows),
+    getOsUnsafePathCharsRegExp(isWindows, isAndroid),
     OBSIDIAN_UNSAFE_FILENAME_CHARS
   ]);
 }
-function getOsUnsafePathCharsRegExp(isWindows) {
+function getOsUnsafePathCharsRegExp(isWindows, isAndroid) {
   isWindows ??= Platform.isWin;
-  return isWindows ? WINDOWS_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;
+  if (isWindows) {
+    return WINDOWS_UNSAFE_PATH_CHARS;
+  }
+  isAndroid ??= Platform.isAndroidApp;
+  return isAndroid ? ANDROID_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;
+}
+function getPathValidationMessage(path, isWindows, isAndroid) {
+  return path.split("/").map((segment) => getFileNameValidationMessage(segment, isWindows, isAndroid)).find(Boolean) ?? "";
 }
 function hasWindowsTrailingChars(name) {
   return WINDOWS_TRAILING_CHARS_REG_EXP.test(name);
@@ -64,15 +90,26 @@ function isWindowsReservedName(name) {
 function trimWindowsTrailingChars(name) {
   return name.replace(WINDOWS_TRAILING_CHARS_REG_EXP, "");
 }
+function hasControlChars(name) {
+  for (const char of name) {
+    if (char < FIRST_NON_CONTROL_CHAR) {
+      return true;
+    }
+  }
+  return false;
+}
 export {
+  ANDROID_UNSAFE_PATH_CHARS,
   OBSIDIAN_UNSAFE_FILENAME_CHARS,
   UNIX_UNSAFE_PATH_CHARS,
   WINDOWS_UNSAFE_PATH_CHARS,
+  getFileNameValidationMessage,
   getOsAndObsidianUnsafePathCharsRegExp,
   getOsUnsafePathCharsRegExp,
+  getPathValidationMessage,
   hasWindowsTrailingChars,
   isValidationMessageHolder,
   isWindowsReservedName,
   trimWindowsTrailingChars
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/validation.ts"],"sourcesContent":["/**\n * @file\n *\n * Validation utilities.\n */\n\nimport {\n  basename,\n  extname\n} from '@mnaoumov/typescript-lib/path';\nimport { oneOf } from '@mnaoumov/typescript-lib/reg-exp';\nimport { Platform } from 'obsidian';\n\nimport { t } from './i18n/i18n.ts';\n\n/**\n * Holds a validation message.\n */\nexport interface ValidationMessageHolder {\n  /**\n   * A validation message.\n   */\n  validationMessage: string;\n}\n\n/**\n * Type guard to check if a value is a validation message holder.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a validation message holder, `false` otherwise.\n */\nexport function isValidationMessageHolder(value: unknown): value is ValidationMessageHolder {\n  return (value as Partial<ValidationMessageHolder>).validationMessage !== undefined;\n}\n\n/**\n * Matches characters that are not safe to use in file names within Obsidian.\n */\nexport const OBSIDIAN_UNSAFE_FILENAME_CHARS = /[#^[\\]|]/g;\n\n/**\n * The characters Obsidian refuses in a file name on Windows.\n *\n * Read from Obsidian 1.15.0's `app.js`, whose name check throws on this set from `app.vault.create`, a\n * rename and Sync alike.\n */\nexport const WINDOWS_UNSAFE_PATH_CHARS = /[*\\\\/<>:|?\"]/g;\n\n/**\n * The characters Obsidian refuses in a file name on macOS, Linux and iOS, plus the NUL no file system stores.\n *\n * This is Obsidian's refusal set, not the file system's: macOS and Linux store `\\` and `:`, but Obsidian\n * refuses both, so a name holding either cannot be created through the vault there. Read from Obsidian\n * 1.15.0's `app.js`.\n */\nexport const UNIX_UNSAFE_PATH_CHARS = /[\\0\\\\/:]/g;\n\n/**\n * The characters Obsidian refuses in a file name on Android, plus the NUL no file system stores.\n *\n * Obsidian adds `* ? < > \"` to the {@link UNIX_UNSAFE_PATH_CHARS} set there, because Android's shared\n * storage refuses them. Read from Obsidian 1.15.0's `app.js`.\n */\nexport const ANDROID_UNSAFE_PATH_CHARS = /[\\0*\\\\/<>:?\"]/g;\n\n/**\n * The MS-DOS device names Windows still refuses as a file name, with or without an extension.\n *\n * `CONIN$` / `CONOUT$` and the superscript `COM²` forms are deliberately absent: they are accepted by\n * every Windows version that runs Obsidian, and matching them would rename files that work.\n *\n * Unlike the exported character sets above, this carries no `g` flag, so `test` may be called on it\n * repeatedly — a `g`-flagged regexp advances `lastIndex` and answers differently on consecutive calls.\n */\nconst WINDOWS_RESERVED_NAME_REG_EXP = /^(?:AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)$/i;\n\n/**\n * The trailing dots and spaces Windows strips from a name before it does anything else with it.\n */\nconst WINDOWS_TRAILING_CHARS_REG_EXP = /[ .]+$/;\n\n/**\n * The first character after the C0 control range, U+0000 to U+001F, which Windows refuses in a name.\n */\nconst FIRST_NON_CONTROL_CHAR = ' ';\n\n/**\n * Validates a single file or folder name against every naming rule this module owns.\n *\n * The rules, checked in this order, and the first one broken names the message:\n *\n * 1. The name is not empty.\n * 2. It holds no control character (U+0000 to U+001F).\n * 3. It holds none of the characters {@link getOsAndObsidianUnsafePathCharsRegExp} matches.\n * 4. It does not end with a dot or a space ({@link hasWindowsTrailingChars}).\n * 5. It is not an MS-DOS device name ({@link isWindowsReservedName}), with or without an extension.\n *\n * Only rule 3 depends on the platform. Rules 2, 4 and 5 apply on every platform, because a vault is synced,\n * and a name created on macOS or Linux that Windows refuses breaks the vault there. The character set follows\n * the platform because it is Obsidian's own refusal set, which differs per platform: a name such as `a?b` is\n * accepted on macOS, where Obsidian creates it.\n *\n * @param name - The name to validate. A single path segment, with or without its extension.\n * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.\n * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to\n * `Platform.isAndroidApp`.\n * @returns A message describing the first broken rule, or an empty string if the name is valid.\n */\nexport function getFileNameValidationMessage(name: string, isWindows?: boolean, isAndroid?: boolean): string {\n  if (name === '') {\n    return t(($) => $.obsidianLib.validation.emptyName);\n  }\n\n  if (hasControlChars(name)) {\n    return t(($) => $.obsidianLib.validation.controlCharacter, { name });\n  }\n\n  const unsafeChars = new Set(name.match(getOsAndObsidianUnsafePathCharsRegExp(isWindows, isAndroid)));\n  if (unsafeChars.size > 0) {\n    return t(($) => $.obsidianLib.validation.unsafeCharacters, { characters: [...unsafeChars].join(' '), name });\n  }\n\n  if (hasWindowsTrailingChars(name)) {\n    return t(($) => $.obsidianLib.validation.trailingCharacters, { name });\n  }\n\n  return isWindowsReservedName(name) ? t(($) => $.obsidianLib.validation.windowsReservedName, { name }) : '';\n}\n\n/**\n * Returns a regexp matching all unsafe characters in file names/paths.\n *\n * Includes both the platform's refused characters ({@link getOsUnsafePathCharsRegExp}) and the ones that break\n * links ({@link OBSIDIAN_UNSAFE_FILENAME_CHARS}).\n *\n * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.\n * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to\n * `Platform.isAndroidApp`.\n * @returns A regexp matching all unsafe characters in file names/paths.\n */\nexport function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolean, isAndroid?: boolean): RegExp {\n  return oneOf([\n    getOsUnsafePathCharsRegExp(isWindows, isAndroid),\n    OBSIDIAN_UNSAFE_FILENAME_CHARS\n  ]);\n}\n\n/**\n * Returns a regexp matching the characters Obsidian refuses in a file name on the given platform.\n *\n * That is {@link WINDOWS_UNSAFE_PATH_CHARS} on Windows, {@link ANDROID_UNSAFE_PATH_CHARS} on Android and\n * {@link UNIX_UNSAFE_PATH_CHARS} everywhere else. It is Obsidian's set rather than the file system's, so a\n * name it accepts can be created through the vault.\n *\n * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.\n * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to\n * `Platform.isAndroidApp`.\n * @returns A regexp matching the characters Obsidian refuses in a file name on the given platform.\n */\nexport function getOsUnsafePathCharsRegExp(isWindows?: boolean, isAndroid?: boolean): RegExp {\n  isWindows ??= Platform.isWin;\n  if (isWindows) {\n    return WINDOWS_UNSAFE_PATH_CHARS;\n  }\n\n  isAndroid ??= Platform.isAndroidApp;\n  return isAndroid ? ANDROID_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;\n}\n\n/**\n * Validates every segment of a vault path with {@link getFileNameValidationMessage}.\n *\n * @param path - The vault-relative path to validate, with `/` as the separator.\n * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.\n * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to\n * `Platform.isAndroidApp`.\n * @returns The message for the first invalid segment, or an empty string if every segment is valid.\n */\nexport function getPathValidationMessage(path: string, isWindows?: boolean, isAndroid?: boolean): string {\n  return path.split('/').map((segment) => getFileNameValidationMessage(segment, isWindows, isAndroid)).find(Boolean) ?? '';\n}\n\n/**\n * Checks whether a name ends with the dots or spaces Windows refuses.\n *\n * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are\n * not necessarily those of the machine asking.\n *\n * @param name - The name to check. A single path segment, not a path.\n * @returns `true` if the name ends with a dot or a space, `false` otherwise.\n */\nexport function hasWindowsTrailingChars(name: string): boolean {\n  return WINDOWS_TRAILING_CHARS_REG_EXP.test(name);\n}\n\n/**\n * Checks whether a name is one of the MS-DOS device names Windows refuses.\n *\n * Two steps the caller would otherwise have to know about happen here: trailing dots and spaces are\n * trimmed BEFORE the test, because Windows strips them before deciding and `CON ` is therefore as\n * reserved as `CON`; and the extension is dropped, because `CON.md` is reserved too.\n *\n * `CONIN$` / `CONOUT$` and the superscript `COM²` forms are deliberately NOT reserved: they are accepted\n * by every Windows version that runs Obsidian, and matching them would rename files that work.\n *\n * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are\n * not necessarily those of the machine asking.\n *\n * @param name - The name to check. A single path segment, with or without its extension.\n * @returns `true` if the name is reserved, `false` otherwise.\n */\nexport function isWindowsReservedName(name: string): boolean {\n  const trimmedName = trimWindowsTrailingChars(name);\n  return WINDOWS_RESERVED_NAME_REG_EXP.test(basename(trimmedName, extname(trimmedName)));\n}\n\n/**\n * Removes the trailing dots and spaces Windows refuses from the end of a name.\n *\n * Trim before testing for a reserved name, never after: trimming afterwards turns an accepted `CON ` into\n * a rejected `CON`. {@link isWindowsReservedName} already does this internally.\n *\n * @param name - The name to trim. A single path segment, not a path.\n * @returns The name without its trailing dots and spaces, which may be empty.\n */\nexport function trimWindowsTrailingChars(name: string): string {\n  return name.replace(WINDOWS_TRAILING_CHARS_REG_EXP, '');\n}\n\n/**\n * Checks whether a name holds a control character, U+0000 to U+001F.\n *\n * @param name - The name to check.\n * @returns `true` if the name holds a control character, `false` otherwise.\n */\nfunction hasControlChars(name: string): boolean {\n  for (const char of name) {\n    if (char < FIRST_NON_CONTROL_CHAR) {\n      return true;\n    }\n  }\n\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,aAAa;AACtB,SAAS,gBAAgB;AAEzB,SAAS,SAAS;AAkBX,SAAS,0BAA0B,OAAkD;AAC1F,SAAQ,MAA2C,sBAAsB;AAC3E;AAKO,MAAM,iCAAiC;AAQvC,MAAM,4BAA4B;AASlC,MAAM,yBAAyB;AAQ/B,MAAM,4BAA4B;AAWzC,MAAM,gCAAgC;AAKtC,MAAM,iCAAiC;AAKvC,MAAM,yBAAyB;AAwBxB,SAAS,6BAA6B,MAAc,WAAqB,WAA6B;AAC3G,MAAI,SAAS,IAAI;AACf,WAAO,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,SAAS;AAAA,EACpD;AAEA,MAAI,gBAAgB,IAAI,GAAG;AACzB,WAAO,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,kBAAkB,EAAE,KAAK,CAAC;AAAA,EACrE;AAEA,QAAM,cAAc,IAAI,IAAI,KAAK,MAAM,sCAAsC,WAAW,SAAS,CAAC,CAAC;AACnG,MAAI,YAAY,OAAO,GAAG;AACxB,WAAO,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,kBAAkB,EAAE,YAAY,CAAC,GAAG,WAAW,EAAE,KAAK,GAAG,GAAG,KAAK,CAAC;AAAA,EAC7G;AAEA,MAAI,wBAAwB,IAAI,GAAG;AACjC,WAAO,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,oBAAoB,EAAE,KAAK,CAAC;AAAA,EACvE;AAEA,SAAO,sBAAsB,IAAI,IAAI,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,qBAAqB,EAAE,KAAK,CAAC,IAAI;AAC1G;AAaO,SAAS,sCAAsC,WAAqB,WAA6B;AACtG,SAAO,MAAM;AAAA,IACX,2BAA2B,WAAW,SAAS;AAAA,IAC/C;AAAA,EACF,CAAC;AACH;AAcO,SAAS,2BAA2B,WAAqB,WAA6B;AAC3F,gBAAc,SAAS;AACvB,MAAI,WAAW;AACb,WAAO;AAAA,EACT;AAEA,gBAAc,SAAS;AACvB,SAAO,YAAY,4BAA4B;AACjD;AAWO,SAAS,yBAAyB,MAAc,WAAqB,WAA6B;AACvG,SAAO,KAAK,MAAM,GAAG,EAAE,IAAI,CAAC,YAAY,6BAA6B,SAAS,WAAW,SAAS,CAAC,EAAE,KAAK,OAAO,KAAK;AACxH;AAWO,SAAS,wBAAwB,MAAuB;AAC7D,SAAO,+BAA+B,KAAK,IAAI;AACjD;AAkBO,SAAS,sBAAsB,MAAuB;AAC3D,QAAM,cAAc,yBAAyB,IAAI;AACjD,SAAO,8BAA8B,KAAK,SAAS,aAAa,QAAQ,WAAW,CAAC,CAAC;AACvF;AAWO,SAAS,yBAAyB,MAAsB;AAC7D,SAAO,KAAK,QAAQ,gCAAgC,EAAE;AACxD;AAQA,SAAS,gBAAgB,MAAuB;AAC9C,aAAW,QAAQ,MAAM;AACvB,QAAI,OAAO,wBAAwB;AACjC,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnaoumov/obsidian-lib",
-  "version": "6.0.4",
+  "version": "6.2.0",
   "description": "Runtime library for Obsidian plugin development: plugin base classes, components, settings, modals, vault and metadata helpers.",
   "keywords": [
     "obsidian",
@@ -334,7 +334,7 @@
   "dependencies": {
     "@lezer/common": "1.5.2",
     "@mnaoumov/obsidian-dataview": "^1.0.0",
-    "@mnaoumov/typescript-lib": "^1.6.2",
+    "@mnaoumov/typescript-lib": "^1.7.0",
     "@standard-schema/spec": "^1.1.0",
     "@types/react": "^19.3.0",
     "compare-versions": "^6.1.1",