@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/esm/path-compatibility.d.mts

@@ -0,0 +1,263 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Which naming constraints each platform imposes, which of them a given path violates, and how to repair a
+ * name so it satisfies every enabled platform at once.
+ *
+ * Pure by design — no `App`, no vault, no I/O — so the whole correctness surface (byte counting, extension
+ * preservation, truncation order, profile composition) is unit-testable without an Obsidian instance. The
+ * vault pass that consumes it lives in each plugin that reports or repairs path problems.
+ *
+ * A vault is synced, so the platform that matters is not necessarily the one running: enabling several
+ * platforms composes their constraints by intersection, and a name has to satisfy all of them.
+ */
+/**
+ * A platform a vault may be synced to, and whose naming rules can therefore be enforced.
+ */
+export declare enum PathCompatibilityPlatform {
+    Android = "Android",
+    Ios = "Ios",
+    Linux = "Linux",
+    MacOs = "MacOs",
+    Windows = "Windows"
+}
+/**
+ * What a single path or name is wrong about, on one platform.
+ */
+export declare enum PathCompatibilityViolationType {
+    ForbiddenCharacter = "ForbiddenCharacter",
+    NameTooLong = "NameTooLong",
+    /**
+     * The name holds a character Obsidian links do not work with (`#`, `^`, `[`, `]`, `|`). Obsidian's rule, not
+     * a platform's: the filesystem stores such a name fine, so naming a platform for it would be false.
+     */
+    ObsidianForbiddenCharacter = "ObsidianForbiddenCharacter",
+    PathTooLong = "PathTooLong",
+    ReservedName = "ReservedName",
+    TrailingCharacter = "TrailingCharacter",
+    /**
+     * The name is stored on disk in a form other than Unicode NFC, e.g. `й` as `и` followed by a combining
+     * breve. Not a platform's rule but a sync hazard: tools outside Obsidian see the two forms as two names.
+     */
+    UnicodeNotNormalized = "UnicodeNotNormalized"
+}
+/**
+ * Parameters for {@link findPathCompatibilityViolations}.
+ */
+export interface FindPathCompatibilityViolationsParams {
+    /**
+     * Whether the path names a folder, which has its own path budget.
+     */
+    readonly isFolder: boolean;
+    /**
+     * The length of the longest vault root path the vault is expected to live under, in characters.
+     *
+     * The vault root of a platform the check is not running on is unknowable, so it is stated rather than
+     * guessed — see the `maxVaultRootPathLength` setting.
+     */
+    readonly maxVaultRootPathLength: number;
+    /**
+     * The vault-relative path to check.
+     */
+    readonly path: string;
+    /**
+     * The platforms whose rules to enforce.
+     */
+    readonly platforms: readonly PathCompatibilityPlatform[];
+}
+/**
+ * A length a path or name was measured at, and the limit it exceeds.
+ */
+export interface PathCompatibilityMeasurement {
+    /**
+     * Whether both numbers count UTF-8 bytes rather than UTF-16 units.
+     */
+    readonly isInBytes: boolean;
+    /**
+     * The measured length.
+     */
+    readonly length: number;
+    /**
+     * The largest length the platform accepts.
+     */
+    readonly limit: number;
+    /**
+     * The vault root length counted into {@link PathCompatibilityMeasurement.length}, before the separator
+     * after it. `null` for a name, which carries no root.
+     */
+    readonly vaultRootLength: null | number;
+}
+/**
+ * The naming rules of one platform.
+ */
+export interface PathCompatibilityProfile {
+    /**
+     * Whether this platform applies Windows' naming rules: its forbidden characters, its reserved device
+     * names, and its rejection of trailing dots and spaces.
+     *
+     * One flag for three rules because they are one filesystem's rules, and no platform adopts a subset.
+     */
+    readonly hasWindowsNamingRules: boolean;
+    /**
+     * The longest absolute path a file may have, in this profile's unit.
+     */
+    readonly maxFilePathLength: number;
+    /**
+     * The longest absolute path a folder may have, in this profile's unit.
+     *
+     * Below {@link PathCompatibilityProfile.maxFilePathLength} on Windows, where the shorter budget leaves
+     * room for an `8.3` name inside the folder.
+     */
+    readonly maxFolderPathLength: number;
+    /**
+     * The longest single name — one path segment — in this profile's unit.
+     */
+    readonly maxNameLength: number;
+    /**
+     * The platform this profile describes.
+     */
+    readonly platform: PathCompatibilityPlatform;
+    /**
+     * Whether lengths count UTF-8 bytes (ext4, APFS) rather than UTF-16 units (NTFS).
+     *
+     * This is the whole reason the 255 limit is not a character count: a name of 128 CJK characters is 384
+     * bytes and is rejected by ext4 while being nowhere near any limit Windows has.
+     */
+    readonly shouldMeasureInBytes: boolean;
+}
+/**
+ * One thing wrong with one path, and the platform that objects to it.
+ */
+export interface PathCompatibilityViolation {
+    /**
+     * The offending characters, each once, in the order they first appear in the name.
+     *
+     * Set for {@link PathCompatibilityViolationType.ForbiddenCharacter} and
+     * {@link PathCompatibilityViolationType.ObsidianForbiddenCharacter}, so the report can name them.
+     */
+    readonly characters?: readonly string[];
+    /**
+     * What was measured and the limit it was measured against.
+     *
+     * Set for {@link PathCompatibilityViolationType.NameTooLong} and
+     * {@link PathCompatibilityViolationType.PathTooLong}, so a reader of the report can verify the verdict.
+     */
+    readonly measurement?: PathCompatibilityMeasurement;
+    /**
+     * The platform whose rules the path breaks. Another enabled platform may accept the very same path.
+     *
+     * `null` for a violation no single platform owns, which is
+     * {@link PathCompatibilityViolationType.ObsidianForbiddenCharacter} and
+     * {@link PathCompatibilityViolationType.UnicodeNotNormalized}.
+     */
+    readonly platform: null | PathCompatibilityPlatform;
+    /**
+     * What is wrong.
+     */
+    readonly type: PathCompatibilityViolationType;
+}
+/**
+ * Parameters for {@link repairName}.
+ */
+export interface RepairNameParams {
+    /**
+     * The name without its extension. For a folder, the whole name.
+     */
+    readonly basename: string;
+    /**
+     * The name's extension, without the leading dot. Empty for a folder or an extension-less file.
+     */
+    readonly extension: string;
+    /**
+     * What each forbidden character is replaced with. Empty deletes it. Must pass
+     * {@link getForbiddenCharacterReplacementValidationMessage}, or the repair would put back what it removed.
+     */
+    readonly forbiddenCharacterReplacement: string;
+    /**
+     * Whether the name belongs to a folder.
+     */
+    readonly isFolder: boolean;
+    /**
+     * The length of the longest vault root path the vault is expected to live under, in characters.
+     */
+    readonly maxVaultRootPathLength: number;
+    /**
+     * The vault-relative path of the parent folder. Empty at the vault root.
+     */
+    readonly parentPath: string;
+    /**
+     * The platforms whose rules the repaired name must satisfy.
+     */
+    readonly platforms: readonly PathCompatibilityPlatform[];
+}
+/**
+ * Every platform, in the order the settings tab and the consistency report list them: the ones whose limits
+ * actually bind in practice first.
+ */
+export declare const PATH_COMPATIBILITY_PLATFORMS: readonly PathCompatibilityPlatform[];
+/**
+ * How each platform is named in the settings tab and the consistency report.
+ *
+ * Not translated: these are product names, and `macOS` is spelled `macOS` in every language.
+ */
+export declare const PATH_COMPATIBILITY_PLATFORM_LABELS: Record<PathCompatibilityPlatform, string>;
+/**
+ * Finds everything wrong with a path, across every enabled platform.
+ *
+ * Read-only: this is what the consistency report renders, and it never proposes a repair.
+ *
+ * @param params - The path and the platforms to check it against.
+ * @returns The violations, empty when the path is valid everywhere.
+ */
+export declare function findPathCompatibilityViolations(params: FindPathCompatibilityViolationsParams): PathCompatibilityViolation[];
+/**
+ * The platform the plugin is running on, or `null` on a platform with no profile.
+ *
+ * Used only to seed the settings defaults, so that a fresh install reports on the vault in front of it
+ * without the user configuring anything first.
+ *
+ * @returns The current platform, or `null`.
+ */
+export declare function getCurrentPathCompatibilityPlatform(): null | PathCompatibilityPlatform;
+/**
+ * Validates the text a forbidden character is replaced with.
+ *
+ * Every platform's set is checked, not only the enabled ones: the toggles can change after the replacement
+ * is chosen, and a replacement one platform refuses would make the repair of that platform produce a name
+ * that is still invalid there.
+ *
+ * @param replacement - The replacement text. Empty is valid and deletes the character.
+ * @returns A message naming the first refused character, or an empty string when the replacement is valid.
+ */
+export declare function getForbiddenCharacterReplacementValidationMessage(replacement: string): string;
+/**
+ * Whether a name is in Unicode NFC, the form Obsidian gives every name it creates.
+ *
+ * @param name - The name as it is stored on disk.
+ * @returns Whether it is NFC.
+ */
+export declare function isUnicodeNormalized(name: string): boolean;
+/**
+ * Measures a string the way a filesystem does.
+ *
+ * @param $string - The string to measure.
+ * @param shouldMeasureInBytes - Whether to count UTF-8 bytes rather than UTF-16 units.
+ * @returns The length.
+ */
+export declare function measure($string: string, shouldMeasureInBytes: boolean): number;
+/**
+ * Repairs a name so that it satisfies every enabled platform.
+ *
+ * The order is deliberate: characters are replaced and a reserved name de-reserved BEFORE anything is
+ * truncated, because both can change the length, and trailing dots and spaces are trimmed AFTER every cut,
+ * because a cut can expose new ones.
+ *
+ * Truncation only ever shortens the basename — an extension is what tells Obsidian and the OS what the file
+ * is, so a truncated one turns a working `.png` into a broken `.pn`.
+ *
+ * @param params - The name and the platforms it must satisfy.
+ * @returns The repaired name, unchanged when it was already valid, or `null` when no name survives the
+ * repair — which is what the report calls out rather than failing silently.
+ */
+export declare function repairName(params: RepairNameParams): null | string;

package/dist/lib/esm/path-compatibility.mjs

@@ -0,0 +1,277 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { Platform } from "obsidian";
+import {
+  getOsUnsafePathCharsRegExp,
+  hasWindowsTrailingChars,
+  isWindowsReservedName,
+  OBSIDIAN_UNSAFE_FILENAME_CHARS,
+  trimWindowsTrailingChars
+} from "./validation.mjs";
+var PathCompatibilityPlatform = /* @__PURE__ */ ((PathCompatibilityPlatform2) => {
+  PathCompatibilityPlatform2["Android"] = "Android";
+  PathCompatibilityPlatform2["Ios"] = "Ios";
+  PathCompatibilityPlatform2["Linux"] = "Linux";
+  PathCompatibilityPlatform2["MacOs"] = "MacOs";
+  PathCompatibilityPlatform2["Windows"] = "Windows";
+  return PathCompatibilityPlatform2;
+})(PathCompatibilityPlatform || {});
+var PathCompatibilityViolationType = /* @__PURE__ */ ((PathCompatibilityViolationType2) => {
+  PathCompatibilityViolationType2["ForbiddenCharacter"] = "ForbiddenCharacter";
+  PathCompatibilityViolationType2["NameTooLong"] = "NameTooLong";
+  PathCompatibilityViolationType2["ObsidianForbiddenCharacter"] = "ObsidianForbiddenCharacter";
+  PathCompatibilityViolationType2["PathTooLong"] = "PathTooLong";
+  PathCompatibilityViolationType2["ReservedName"] = "ReservedName";
+  PathCompatibilityViolationType2["TrailingCharacter"] = "TrailingCharacter";
+  PathCompatibilityViolationType2["UnicodeNotNormalized"] = "UnicodeNotNormalized";
+  return PathCompatibilityViolationType2;
+})(PathCompatibilityViolationType || {});
+const PATH_COMPATIBILITY_PLATFORMS = [
+  "Windows" /* Windows */,
+  "Android" /* Android */,
+  "Linux" /* Linux */,
+  "MacOs" /* MacOs */,
+  "Ios" /* Ios */
+];
+const PATH_COMPATIBILITY_PLATFORM_LABELS = {
+  ["Android" /* Android */]: "Android",
+  ["Ios" /* Ios */]: "iOS",
+  ["Linux" /* Linux */]: "Linux",
+  ["MacOs" /* MacOs */]: "macOS",
+  ["Windows" /* Windows */]: "Windows"
+};
+const WINDOWS_MAX_FILE_PATH_LENGTH = 259;
+const WINDOWS_MAX_FOLDER_PATH_LENGTH = 247;
+const WINDOWS_MAX_NAME_LENGTH = 255;
+const UNIX_MAX_NAME_BYTES = 255;
+const LINUX_MAX_PATH_BYTES = 4096;
+const DARWIN_MAX_PATH_BYTES = 1024;
+const CONTROL_CHARS_REG_EXP = /[\u{0}-\u{1F}]/gu;
+const PATH_COMPATIBILITY_PROFILES = {
+  ["Android" /* Android */]: {
+    hasWindowsNamingRules: false,
+    maxFilePathLength: LINUX_MAX_PATH_BYTES,
+    maxFolderPathLength: LINUX_MAX_PATH_BYTES,
+    maxNameLength: UNIX_MAX_NAME_BYTES,
+    platform: "Android" /* Android */,
+    shouldMeasureInBytes: true
+  },
+  ["Ios" /* Ios */]: {
+    hasWindowsNamingRules: false,
+    maxFilePathLength: DARWIN_MAX_PATH_BYTES,
+    maxFolderPathLength: DARWIN_MAX_PATH_BYTES,
+    maxNameLength: UNIX_MAX_NAME_BYTES,
+    platform: "Ios" /* Ios */,
+    shouldMeasureInBytes: true
+  },
+  ["Linux" /* Linux */]: {
+    hasWindowsNamingRules: false,
+    maxFilePathLength: LINUX_MAX_PATH_BYTES,
+    maxFolderPathLength: LINUX_MAX_PATH_BYTES,
+    maxNameLength: UNIX_MAX_NAME_BYTES,
+    platform: "Linux" /* Linux */,
+    shouldMeasureInBytes: true
+  },
+  ["MacOs" /* MacOs */]: {
+    hasWindowsNamingRules: false,
+    maxFilePathLength: DARWIN_MAX_PATH_BYTES,
+    maxFolderPathLength: DARWIN_MAX_PATH_BYTES,
+    maxNameLength: UNIX_MAX_NAME_BYTES,
+    platform: "MacOs" /* MacOs */,
+    shouldMeasureInBytes: true
+  },
+  ["Windows" /* Windows */]: {
+    hasWindowsNamingRules: true,
+    maxFilePathLength: WINDOWS_MAX_FILE_PATH_LENGTH,
+    maxFolderPathLength: WINDOWS_MAX_FOLDER_PATH_LENGTH,
+    maxNameLength: WINDOWS_MAX_NAME_LENGTH,
+    platform: "Windows" /* Windows */,
+    shouldMeasureInBytes: false
+  }
+};
+function findPathCompatibilityViolations(params) {
+  const violations = [];
+  const name = getName(params.path);
+  const profiles = getProfiles(params.platforms);
+  const obsidianForbiddenCharacters = findCharacters(name, OBSIDIAN_UNSAFE_FILENAME_CHARS);
+  if (profiles.length > 0 && obsidianForbiddenCharacters.length > 0) {
+    violations.push({ characters: obsidianForbiddenCharacters, platform: null, type: "ObsidianForbiddenCharacter" /* ObsidianForbiddenCharacter */ });
+  }
+  for (const profile of profiles) {
+    const maxPathLength = params.isFolder ? profile.maxFolderPathLength : profile.maxFilePathLength;
+    const fullPathLength = params.maxVaultRootPathLength + 1 + measure(params.path, profile.shouldMeasureInBytes);
+    if (fullPathLength > maxPathLength) {
+      violations.push({
+        measurement: {
+          isInBytes: profile.shouldMeasureInBytes,
+          length: fullPathLength,
+          limit: maxPathLength,
+          vaultRootLength: params.maxVaultRootPathLength
+        },
+        platform: profile.platform,
+        type: "PathTooLong" /* PathTooLong */
+      });
+    }
+    const nameLength = measure(name, profile.shouldMeasureInBytes);
+    if (nameLength > profile.maxNameLength) {
+      violations.push({
+        measurement: { isInBytes: profile.shouldMeasureInBytes, length: nameLength, limit: profile.maxNameLength, vaultRootLength: null },
+        platform: profile.platform,
+        type: "NameTooLong" /* NameTooLong */
+      });
+    }
+    const platformForbiddenCharacters = findCharacters(name, getPlatformForbiddenCharactersRegExp(profile));
+    if (platformForbiddenCharacters.length > 0) {
+      violations.push({ characters: platformForbiddenCharacters, platform: profile.platform, type: "ForbiddenCharacter" /* ForbiddenCharacter */ });
+    }
+    if (!profile.hasWindowsNamingRules) {
+      continue;
+    }
+    if (isWindowsReservedName(name)) {
+      violations.push({ platform: profile.platform, type: "ReservedName" /* ReservedName */ });
+    }
+    if (hasWindowsTrailingChars(name)) {
+      violations.push({ platform: profile.platform, type: "TrailingCharacter" /* TrailingCharacter */ });
+    }
+  }
+  return violations;
+}
+function getCurrentPathCompatibilityPlatform() {
+  if (Platform.isWin) {
+    return "Windows" /* Windows */;
+  }
+  if (Platform.isAndroidApp) {
+    return "Android" /* Android */;
+  }
+  if (Platform.isIosApp) {
+    return "Ios" /* Ios */;
+  }
+  if (Platform.isMacOS) {
+    return "MacOs" /* MacOs */;
+  }
+  return Platform.isLinux ? "Linux" /* Linux */ : null;
+}
+function getForbiddenCharacterReplacementValidationMessage(replacement) {
+  const regExps = [
+    getOsUnsafePathCharsRegExp(true, false),
+    getOsUnsafePathCharsRegExp(false, true),
+    getOsUnsafePathCharsRegExp(false, false),
+    OBSIDIAN_UNSAFE_FILENAME_CHARS,
+    CONTROL_CHARS_REG_EXP
+  ];
+  for (const char of replacement) {
+    if (regExps.some((regExp) => char.replace(regExp, "") !== char)) {
+      return `The replacement must not contain "${char}": a file name cannot hold it on every platform.`;
+    }
+  }
+  return "";
+}
+function isUnicodeNormalized(name) {
+  return name === name.normalize("NFC");
+}
+function measure($string, shouldMeasureInBytes) {
+  return shouldMeasureInBytes ? new Blob([$string]).size : $string.length;
+}
+function repairName(params) {
+  const profiles = getProfiles(params.platforms);
+  if (profiles.length === 0) {
+    return buildName(params.basename, params.extension);
+  }
+  let basename = params.basename;
+  let extension = params.extension;
+  for (const profile of profiles) {
+    basename = replaceForbiddenCharacters(basename, profile, params.forbiddenCharacterReplacement);
+    extension = replaceForbiddenCharacters(extension, profile, params.forbiddenCharacterReplacement);
+  }
+  extension = trimTrailingDotsAndSpaces(extension, profiles);
+  basename = trimTrailingDotsAndSpaces(basename, profiles);
+  if (profiles.some((profile) => profile.hasWindowsNamingRules) && isWindowsReservedName(buildName(basename, extension))) {
+    basename += "_";
+  }
+  const codePoints = [...basename];
+  while (codePoints.length > 0) {
+    const candidate = trimTrailingDotsAndSpaces(codePoints.join(""), profiles);
+    if (candidate === "") {
+      return null;
+    }
+    if (doesFitEveryProfile(candidate, extension, profiles, params)) {
+      return buildName(candidate, extension);
+    }
+    codePoints.pop();
+  }
+  return null;
+}
+function buildName(basename, extension) {
+  return extension === "" ? basename : `${basename}.${extension}`;
+}
+function doesFitEveryProfile(basename, extension, profiles, params) {
+  const name = buildName(basename, extension);
+  const path = params.parentPath === "" ? name : `${params.parentPath}/${name}`;
+  return profiles.every((profile) => {
+    const maxPathLength = params.isFolder ? profile.maxFolderPathLength : profile.maxFilePathLength;
+    const fullPathLength = params.maxVaultRootPathLength + 1 + measure(path, profile.shouldMeasureInBytes);
+    return measure(name, profile.shouldMeasureInBytes) <= profile.maxNameLength && fullPathLength <= maxPathLength;
+  });
+}
+function findCharacters(name, regExp) {
+  return [...new Set(name.match(regExp))];
+}
+function getName(path) {
+  const slashIndex = path.lastIndexOf("/");
+  return slashIndex === -1 ? path : path.slice(slashIndex + 1);
+}
+function getPlatformForbiddenCharactersRegExp(profile) {
+  return getOsUnsafePathCharsRegExp(profile.hasWindowsNamingRules, profile.platform === "Android" /* Android */);
+}
+function getProfiles(platforms) {
+  return platforms.map((platform) => PATH_COMPATIBILITY_PROFILES[platform]);
+}
+function replaceForbiddenCharacters($string, profile, replacement) {
+  return $string.replace(getPlatformForbiddenCharactersRegExp(profile), () => replacement).replace(OBSIDIAN_UNSAFE_FILENAME_CHARS, () => replacement);
+}
+function trimTrailingDotsAndSpaces($string, profiles) {
+  return profiles.some((profile) => profile.hasWindowsNamingRules) ? trimWindowsTrailingChars($string) : $string;
+}
+export {
+  PATH_COMPATIBILITY_PLATFORMS,
+  PATH_COMPATIBILITY_PLATFORM_LABELS,
+  PathCompatibilityPlatform,
+  PathCompatibilityViolationType,
+  findPathCompatibilityViolations,
+  getCurrentPathCompatibilityPlatform,
+  getForbiddenCharacterReplacementValidationMessage,
+  isUnicodeNormalized,
+  measure,
+  repairName
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/path-compatibility.ts"],"sourcesContent":["/**\n * @file\n *\n * Which naming constraints each platform imposes, which of them a given path violates, and how to repair a\n * name so it satisfies every enabled platform at once.\n *\n * Pure by design — no `App`, no vault, no I/O — so the whole correctness surface (byte counting, extension\n * preservation, truncation order, profile composition) is unit-testable without an Obsidian instance. The\n * vault pass that consumes it lives in each plugin that reports or repairs path problems.\n *\n * A vault is synced, so the platform that matters is not necessarily the one running: enabling several\n * platforms composes their constraints by intersection, and a name has to satisfy all of them.\n */\n\nimport { Platform } from 'obsidian';\n\nimport {\n  getOsUnsafePathCharsRegExp,\n  hasWindowsTrailingChars,\n  isWindowsReservedName,\n  OBSIDIAN_UNSAFE_FILENAME_CHARS,\n  trimWindowsTrailingChars\n} from './validation.ts';\n\n/**\n * A platform a vault may be synced to, and whose naming rules can therefore be enforced.\n */\nexport enum PathCompatibilityPlatform {\n  Android = 'Android',\n  Ios = 'Ios',\n  Linux = 'Linux',\n  MacOs = 'MacOs',\n  Windows = 'Windows'\n}\n\n/**\n * What a single path or name is wrong about, on one platform.\n */\nexport enum PathCompatibilityViolationType {\n  ForbiddenCharacter = 'ForbiddenCharacter',\n  NameTooLong = 'NameTooLong',\n\n  /**\n   * The name holds a character Obsidian links do not work with (`#`, `^`, `[`, `]`, `|`). Obsidian's rule, not\n   * a platform's: the filesystem stores such a name fine, so naming a platform for it would be false.\n   */\n  ObsidianForbiddenCharacter = 'ObsidianForbiddenCharacter',\n  PathTooLong = 'PathTooLong',\n  ReservedName = 'ReservedName',\n  TrailingCharacter = 'TrailingCharacter',\n\n  /**\n   * The name is stored on disk in a form other than Unicode NFC, e.g. `й` as `и` followed by a combining\n   * breve. Not a platform's rule but a sync hazard: tools outside Obsidian see the two forms as two names.\n   */\n  UnicodeNotNormalized = 'UnicodeNotNormalized'\n}\n\n/**\n * Parameters for {@link findPathCompatibilityViolations}.\n */\nexport interface FindPathCompatibilityViolationsParams {\n  /**\n   * Whether the path names a folder, which has its own path budget.\n   */\n  readonly isFolder: boolean;\n\n  /**\n   * The length of the longest vault root path the vault is expected to live under, in characters.\n   *\n   * The vault root of a platform the check is not running on is unknowable, so it is stated rather than\n   * guessed — see the `maxVaultRootPathLength` setting.\n   */\n  readonly maxVaultRootPathLength: number;\n\n  /**\n   * The vault-relative path to check.\n   */\n  readonly path: string;\n\n  /**\n   * The platforms whose rules to enforce.\n   */\n  readonly platforms: readonly PathCompatibilityPlatform[];\n}\n\n/**\n * A length a path or name was measured at, and the limit it exceeds.\n */\nexport interface PathCompatibilityMeasurement {\n  /**\n   * Whether both numbers count UTF-8 bytes rather than UTF-16 units.\n   */\n  readonly isInBytes: boolean;\n\n  /**\n   * The measured length.\n   */\n  readonly length: number;\n\n  /**\n   * The largest length the platform accepts.\n   */\n  readonly limit: number;\n\n  /**\n   * The vault root length counted into {@link PathCompatibilityMeasurement.length}, before the separator\n   * after it. `null` for a name, which carries no root.\n   */\n  readonly vaultRootLength: null | number;\n}\n\n/**\n * The naming rules of one platform.\n */\nexport interface PathCompatibilityProfile {\n  /**\n   * Whether this platform applies Windows' naming rules: its forbidden characters, its reserved device\n   * names, and its rejection of trailing dots and spaces.\n   *\n   * One flag for three rules because they are one filesystem's rules, and no platform adopts a subset.\n   */\n  readonly hasWindowsNamingRules: boolean;\n\n  /**\n   * The longest absolute path a file may have, in this profile's unit.\n   */\n  readonly maxFilePathLength: number;\n\n  /**\n   * The longest absolute path a folder may have, in this profile's unit.\n   *\n   * Below {@link PathCompatibilityProfile.maxFilePathLength} on Windows, where the shorter budget leaves\n   * room for an `8.3` name inside the folder.\n   */\n  readonly maxFolderPathLength: number;\n\n  /**\n   * The longest single name — one path segment — in this profile's unit.\n   */\n  readonly maxNameLength: number;\n\n  /**\n   * The platform this profile describes.\n   */\n  readonly platform: PathCompatibilityPlatform;\n\n  /**\n   * Whether lengths count UTF-8 bytes (ext4, APFS) rather than UTF-16 units (NTFS).\n   *\n   * This is the whole reason the 255 limit is not a character count: a name of 128 CJK characters is 384\n   * bytes and is rejected by ext4 while being nowhere near any limit Windows has.\n   */\n  readonly shouldMeasureInBytes: boolean;\n}\n\n/**\n * One thing wrong with one path, and the platform that objects to it.\n */\nexport interface PathCompatibilityViolation {\n  /**\n   * The offending characters, each once, in the order they first appear in the name.\n   *\n   * Set for {@link PathCompatibilityViolationType.ForbiddenCharacter} and\n   * {@link PathCompatibilityViolationType.ObsidianForbiddenCharacter}, so the report can name them.\n   */\n  readonly characters?: readonly string[];\n\n  /**\n   * What was measured and the limit it was measured against.\n   *\n   * Set for {@link PathCompatibilityViolationType.NameTooLong} and\n   * {@link PathCompatibilityViolationType.PathTooLong}, so a reader of the report can verify the verdict.\n   */\n  readonly measurement?: PathCompatibilityMeasurement;\n\n  /**\n   * The platform whose rules the path breaks. Another enabled platform may accept the very same path.\n   *\n   * `null` for a violation no single platform owns, which is\n   * {@link PathCompatibilityViolationType.ObsidianForbiddenCharacter} and\n   * {@link PathCompatibilityViolationType.UnicodeNotNormalized}.\n   */\n  readonly platform: null | PathCompatibilityPlatform;\n\n  /**\n   * What is wrong.\n   */\n  readonly type: PathCompatibilityViolationType;\n}\n\n/**\n * Parameters for {@link repairName}.\n */\nexport interface RepairNameParams {\n  /**\n   * The name without its extension. For a folder, the whole name.\n   */\n  readonly basename: string;\n\n  /**\n   * The name's extension, without the leading dot. Empty for a folder or an extension-less file.\n   */\n  readonly extension: string;\n\n  /**\n   * What each forbidden character is replaced with. Empty deletes it. Must pass\n   * {@link getForbiddenCharacterReplacementValidationMessage}, or the repair would put back what it removed.\n   */\n  readonly forbiddenCharacterReplacement: string;\n\n  /**\n   * Whether the name belongs to a folder.\n   */\n  readonly isFolder: boolean;\n\n  /**\n   * The length of the longest vault root path the vault is expected to live under, in characters.\n   */\n  readonly maxVaultRootPathLength: number;\n\n  /**\n   * The vault-relative path of the parent folder. Empty at the vault root.\n   */\n  readonly parentPath: string;\n\n  /**\n   * The platforms whose rules the repaired name must satisfy.\n   */\n  readonly platforms: readonly PathCompatibilityPlatform[];\n}\n\n/**\n * Every platform, in the order the settings tab and the consistency report list them: the ones whose limits\n * actually bind in practice first.\n */\nexport const PATH_COMPATIBILITY_PLATFORMS: readonly PathCompatibilityPlatform[] = [\n  PathCompatibilityPlatform.Windows,\n  PathCompatibilityPlatform.Android,\n  PathCompatibilityPlatform.Linux,\n  PathCompatibilityPlatform.MacOs,\n  PathCompatibilityPlatform.Ios\n];\n\n/**\n * How each platform is named in the settings tab and the consistency report.\n *\n * Not translated: these are product names, and `macOS` is spelled `macOS` in every language.\n */\nexport const PATH_COMPATIBILITY_PLATFORM_LABELS: Record<PathCompatibilityPlatform, string> = {\n  [PathCompatibilityPlatform.Android]: 'Android',\n  [PathCompatibilityPlatform.Ios]: 'iOS',\n  [PathCompatibilityPlatform.Linux]: 'Linux',\n  [PathCompatibilityPlatform.MacOs]: 'macOS',\n  [PathCompatibilityPlatform.Windows]: 'Windows'\n};\n\n/**\n * `MAX_PATH` is 260 including the terminating NUL, so 259 usable characters for a file.\n */\nconst WINDOWS_MAX_FILE_PATH_LENGTH = 259;\n\n/**\n * A folder gets 12 fewer, leaving room for a `\\` and an 8.3 name inside it.\n */\nconst WINDOWS_MAX_FOLDER_PATH_LENGTH = 247;\n\n/**\n * NTFS's per-name cap, in UTF-16 units. Never the binding constraint: a path that fits in\n * {@link WINDOWS_MAX_FILE_PATH_LENGTH} characters contains no longer name.\n */\nconst WINDOWS_MAX_NAME_LENGTH = 255;\n\n/**\n * Ext4 / f2fs / APFS all cap a single name at 255 BYTES. This is the limit a character count gets wrong.\n */\nconst UNIX_MAX_NAME_BYTES = 255;\n\n/**\n * `PATH_MAX` on Linux and Android. So far above anything a vault produces that only the name limit binds.\n */\nconst LINUX_MAX_PATH_BYTES = 4096;\n\n/**\n * `PATH_MAX` on macOS and iOS.\n */\nconst DARWIN_MAX_PATH_BYTES = 1024;\n\n// eslint-disable-next-line no-control-regex -- Control characters are exactly what this matches.\nconst CONTROL_CHARS_REG_EXP = /[\\u{0}-\\u{1F}]/gu;\n\nconst PATH_COMPATIBILITY_PROFILES: Record<PathCompatibilityPlatform, PathCompatibilityProfile> = {\n  [PathCompatibilityPlatform.Android]: {\n    hasWindowsNamingRules: false,\n    maxFilePathLength: LINUX_MAX_PATH_BYTES,\n    maxFolderPathLength: LINUX_MAX_PATH_BYTES,\n    maxNameLength: UNIX_MAX_NAME_BYTES,\n    platform: PathCompatibilityPlatform.Android,\n    shouldMeasureInBytes: true\n  },\n\n  [PathCompatibilityPlatform.Ios]: {\n    hasWindowsNamingRules: false,\n    maxFilePathLength: DARWIN_MAX_PATH_BYTES,\n    maxFolderPathLength: DARWIN_MAX_PATH_BYTES,\n    maxNameLength: UNIX_MAX_NAME_BYTES,\n    platform: PathCompatibilityPlatform.Ios,\n    shouldMeasureInBytes: true\n  },\n\n  [PathCompatibilityPlatform.Linux]: {\n    hasWindowsNamingRules: false,\n    maxFilePathLength: LINUX_MAX_PATH_BYTES,\n    maxFolderPathLength: LINUX_MAX_PATH_BYTES,\n    maxNameLength: UNIX_MAX_NAME_BYTES,\n    platform: PathCompatibilityPlatform.Linux,\n    shouldMeasureInBytes: true\n  },\n\n  [PathCompatibilityPlatform.MacOs]: {\n    hasWindowsNamingRules: false,\n    maxFilePathLength: DARWIN_MAX_PATH_BYTES,\n    maxFolderPathLength: DARWIN_MAX_PATH_BYTES,\n    maxNameLength: UNIX_MAX_NAME_BYTES,\n    platform: PathCompatibilityPlatform.MacOs,\n    shouldMeasureInBytes: true\n  },\n\n  [PathCompatibilityPlatform.Windows]: {\n    hasWindowsNamingRules: true,\n    maxFilePathLength: WINDOWS_MAX_FILE_PATH_LENGTH,\n    maxFolderPathLength: WINDOWS_MAX_FOLDER_PATH_LENGTH,\n    maxNameLength: WINDOWS_MAX_NAME_LENGTH,\n    platform: PathCompatibilityPlatform.Windows,\n    shouldMeasureInBytes: false\n  }\n};\n\n/**\n * Finds everything wrong with a path, across every enabled platform.\n *\n * Read-only: this is what the consistency report renders, and it never proposes a repair.\n *\n * @param params - The path and the platforms to check it against.\n * @returns The violations, empty when the path is valid everywhere.\n */\nexport function findPathCompatibilityViolations(params: FindPathCompatibilityViolationsParams): PathCompatibilityViolation[] {\n  const violations: PathCompatibilityViolation[] = [];\n  const name = getName(params.path);\n  const profiles = getProfiles(params.platforms);\n\n  /*\n   * Once, with no platform: every platform stores such a name, and only Obsidian's links refuse it. Still\n   * gated on a platform being enabled, because that is what switches the whole check on, and the repair only\n   * replaces these characters under a profile.\n   */\n  const obsidianForbiddenCharacters = findCharacters(name, OBSIDIAN_UNSAFE_FILENAME_CHARS);\n\n  if (profiles.length > 0 && obsidianForbiddenCharacters.length > 0) {\n    violations.push({ characters: obsidianForbiddenCharacters, platform: null, type: PathCompatibilityViolationType.ObsidianForbiddenCharacter });\n  }\n\n  for (const profile of profiles) {\n    const maxPathLength = params.isFolder ? profile.maxFolderPathLength : profile.maxFilePathLength;\n    const fullPathLength = params.maxVaultRootPathLength + 1 + measure(params.path, profile.shouldMeasureInBytes);\n\n    if (fullPathLength > maxPathLength) {\n      violations.push({\n        measurement: {\n          isInBytes: profile.shouldMeasureInBytes,\n          length: fullPathLength,\n          limit: maxPathLength,\n          vaultRootLength: params.maxVaultRootPathLength\n        },\n        platform: profile.platform,\n        type: PathCompatibilityViolationType.PathTooLong\n      });\n    }\n\n    const nameLength = measure(name, profile.shouldMeasureInBytes);\n\n    if (nameLength > profile.maxNameLength) {\n      violations.push({\n        measurement: { isInBytes: profile.shouldMeasureInBytes, length: nameLength, limit: profile.maxNameLength, vaultRootLength: null },\n        platform: profile.platform,\n        type: PathCompatibilityViolationType.NameTooLong\n      });\n    }\n\n    const platformForbiddenCharacters = findCharacters(name, getPlatformForbiddenCharactersRegExp(profile));\n\n    if (platformForbiddenCharacters.length > 0) {\n      violations.push({ characters: platformForbiddenCharacters, platform: profile.platform, type: PathCompatibilityViolationType.ForbiddenCharacter });\n    }\n\n    if (!profile.hasWindowsNamingRules) {\n      continue;\n    }\n\n    if (isWindowsReservedName(name)) {\n      violations.push({ platform: profile.platform, type: PathCompatibilityViolationType.ReservedName });\n    }\n\n    if (hasWindowsTrailingChars(name)) {\n      violations.push({ platform: profile.platform, type: PathCompatibilityViolationType.TrailingCharacter });\n    }\n  }\n\n  return violations;\n}\n\n/**\n * The platform the plugin is running on, or `null` on a platform with no profile.\n *\n * Used only to seed the settings defaults, so that a fresh install reports on the vault in front of it\n * without the user configuring anything first.\n *\n * @returns The current platform, or `null`.\n */\nexport function getCurrentPathCompatibilityPlatform(): null | PathCompatibilityPlatform {\n  if (Platform.isWin) {\n    return PathCompatibilityPlatform.Windows;\n  }\n\n  if (Platform.isAndroidApp) {\n    return PathCompatibilityPlatform.Android;\n  }\n\n  if (Platform.isIosApp) {\n    return PathCompatibilityPlatform.Ios;\n  }\n\n  if (Platform.isMacOS) {\n    return PathCompatibilityPlatform.MacOs;\n  }\n\n  return Platform.isLinux ? PathCompatibilityPlatform.Linux : null;\n}\n\n/**\n * Validates the text a forbidden character is replaced with.\n *\n * Every platform's set is checked, not only the enabled ones: the toggles can change after the replacement\n * is chosen, and a replacement one platform refuses would make the repair of that platform produce a name\n * that is still invalid there.\n *\n * @param replacement - The replacement text. Empty is valid and deletes the character.\n * @returns A message naming the first refused character, or an empty string when the replacement is valid.\n */\nexport function getForbiddenCharacterReplacementValidationMessage(replacement: string): string {\n  const regExps = [\n    getOsUnsafePathCharsRegExp(true, false),\n    getOsUnsafePathCharsRegExp(false, true),\n    getOsUnsafePathCharsRegExp(false, false),\n    OBSIDIAN_UNSAFE_FILENAME_CHARS,\n    CONTROL_CHARS_REG_EXP\n  ];\n\n  // A string iterates by code point, so a surrogate pair is named whole, as the user typed it.\n  for (const char of replacement) {\n    // `replace` rather than `test`, for the reason given at `replaceForbiddenCharacters`.\n    if (regExps.some((regExp) => char.replace(regExp, '') !== char)) {\n      return `The replacement must not contain \"${char}\": a file name cannot hold it on every platform.`;\n    }\n  }\n\n  return '';\n}\n\n/**\n * Whether a name is in Unicode NFC, the form Obsidian gives every name it creates.\n *\n * @param name - The name as it is stored on disk.\n * @returns Whether it is NFC.\n */\nexport function isUnicodeNormalized(name: string): boolean {\n  return name === name.normalize('NFC');\n}\n\n/**\n * Measures a string the way a filesystem does.\n *\n * @param $string - The string to measure.\n * @param shouldMeasureInBytes - Whether to count UTF-8 bytes rather than UTF-16 units.\n * @returns The length.\n */\nexport function measure($string: string, shouldMeasureInBytes: boolean): number {\n  return shouldMeasureInBytes ? new Blob([$string]).size : $string.length;\n}\n\n/**\n * Repairs a name so that it satisfies every enabled platform.\n *\n * The order is deliberate: characters are replaced and a reserved name de-reserved BEFORE anything is\n * truncated, because both can change the length, and trailing dots and spaces are trimmed AFTER every cut,\n * because a cut can expose new ones.\n *\n * Truncation only ever shortens the basename — an extension is what tells Obsidian and the OS what the file\n * is, so a truncated one turns a working `.png` into a broken `.pn`.\n *\n * @param params - The name and the platforms it must satisfy.\n * @returns The repaired name, unchanged when it was already valid, or `null` when no name survives the\n * repair — which is what the report calls out rather than failing silently.\n */\nexport function repairName(params: RepairNameParams): null | string {\n  const profiles = getProfiles(params.platforms);\n\n  if (profiles.length === 0) {\n    return buildName(params.basename, params.extension);\n  }\n\n  let basename = params.basename;\n  let extension = params.extension;\n\n  for (const profile of profiles) {\n    basename = replaceForbiddenCharacters(basename, profile, params.forbiddenCharacterReplacement);\n    extension = replaceForbiddenCharacters(extension, profile, params.forbiddenCharacterReplacement);\n  }\n\n  // `note.md ` parses as basename `note` + extension `md `, so trimming only the basename would leave the\n  // trailing space exactly where Windows rejects it — at the end of the name.\n  extension = trimTrailingDotsAndSpaces(extension, profiles);\n\n  /*\n   * Trim BEFORE the de-reserving below, never after. `isWindowsReservedName` trims for its own answer, so\n   * `CON ` is reported reserved either way — but the underscore is appended to whatever is here, and an\n   * untrimmed `CON ` would de-reserve to `CON _` instead of `CON_`.\n   */\n  basename = trimTrailingDotsAndSpaces(basename, profiles);\n\n  /*\n   * The REBUILT name, never the bare basename: `params.basename` has already had its extension split off,\n   * and the library drops one extension of its own, so passing the basename would strip a second segment\n   * and call `CON.x` + `md` reserved — which is not what the report says about `CON.x.md`.\n   */\n  if (profiles.some((profile) => profile.hasWindowsNamingRules) && isWindowsReservedName(buildName(basename, extension))) {\n    // A trailing underscore rather than a prefix: it keeps the name sorting where the user expects it.\n    basename += '_';\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-misused-spread -- Code points are exactly the unit wanted: cutting by UTF-16 unit would split a surrogate pair and leave half an emoji.\n  const codePoints = [...basename];\n\n  while (codePoints.length > 0) {\n    const candidate = trimTrailingDotsAndSpaces(codePoints.join(''), profiles);\n\n    if (candidate === '') {\n      return null;\n    }\n\n    if (doesFitEveryProfile(candidate, extension, profiles, params)) {\n      return buildName(candidate, extension);\n    }\n\n    codePoints.pop();\n  }\n\n  return null;\n}\n\nfunction buildName(basename: string, extension: string): string {\n  return extension === '' ? basename : `${basename}.${extension}`;\n}\n\nfunction doesFitEveryProfile(basename: string, extension: string, profiles: PathCompatibilityProfile[], params: RepairNameParams): boolean {\n  const name = buildName(basename, extension);\n  const path = params.parentPath === '' ? name : `${params.parentPath}/${name}`;\n\n  return profiles.every((profile) => {\n    const maxPathLength = params.isFolder ? profile.maxFolderPathLength : profile.maxFilePathLength;\n    const fullPathLength = params.maxVaultRootPathLength + 1 + measure(path, profile.shouldMeasureInBytes);\n\n    return measure(name, profile.shouldMeasureInBytes) <= profile.maxNameLength && fullPathLength <= maxPathLength;\n  });\n}\n\n/*\n * Each character once, in order of first appearance. `match` on a `g`-flagged regexp returns every match and\n * ignores `lastIndex`, so the shared constants are safe here.\n */\nfunction findCharacters(name: string, regExp: RegExp): string[] {\n  return [...new Set(name.match(regExp))];\n}\n\nfunction getName(path: string): string {\n  const slashIndex = path.lastIndexOf('/');\n  return slashIndex === -1 ? path : path.slice(slashIndex + 1);\n}\n\n/*\n * Both flags explicitly: the library defaults an omitted one to the platform RUNNING the check, which would make\n * the Android profile's verdict depend on where the check runs rather than on the profile. Android's shared\n * storage refuses `* ? < > \"` too: Obsidian Sync itself skips such a remote name on Android.\n */\nfunction getPlatformForbiddenCharactersRegExp(profile: PathCompatibilityProfile): RegExp {\n  return getOsUnsafePathCharsRegExp(profile.hasWindowsNamingRules, profile.platform === PathCompatibilityPlatform.Android);\n}\n\nfunction getProfiles(platforms: readonly PathCompatibilityPlatform[]): PathCompatibilityProfile[] {\n  return platforms.map((platform) => PATH_COMPATIBILITY_PROFILES[platform]);\n}\n\n/*\n * `replace` rather than `test`: the library's regexps carry the `g` flag, and `test` on a `g`-flagged regexp\n * advances `lastIndex`, so consecutive calls on the same constant answer differently.\n */\nfunction replaceForbiddenCharacters($string: string, profile: PathCompatibilityProfile, replacement: string): string {\n  /*\n   * One replacement per forbidden character rather than one per run: it keeps the name's visual structure,\n   * which is what makes the repaired name still recognizable to whoever wrote it. Nothing is lost either way —\n   * the original name is preserved in the note's frontmatter. A replacer FUNCTION, so a `$&` in the\n   * replacement is not expanded as a backreference.\n   */\n  return $string\n    .replace(getPlatformForbiddenCharactersRegExp(profile), () => replacement)\n    .replace(OBSIDIAN_UNSAFE_FILENAME_CHARS, () => replacement);\n}\n\n/*\n * The profile guard is the plugin's, not the library's: the library answers for Windows unconditionally, and\n * this decides whether Windows is one of the platforms the vault has to satisfy.\n */\nfunction trimTrailingDotsAndSpaces($string: string, profiles: PathCompatibilityProfile[]): string {\n  return profiles.some((profile) => profile.hasWindowsNamingRules) ? trimWindowsTrailingChars($string) : $string;\n}\n"],"mappings":"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","names":["PathCompatibilityPlatform","PathCompatibilityViolationType"]}

package/dist/lib/esm/plugin/index.d.mts

@@ -4,7 +4,9 @@ export * as 'plugin-async-cleanup' from './plugin-async-cleanup.mjs';
 export * as 'plugin-context' from './plugin-context.mjs';
 export * as 'plugin-event-source' from './plugin-event-source.mjs';
 export * as 'plugin-install-state' from './plugin-install-state.mjs';
+export * as 'plugin-instance' from './plugin-instance.mjs';
 export * as 'plugin-lifecycle-events' from './plugin-lifecycle-events.mjs';
 export * as 'plugin-settings-tab' from './plugin-settings-tab.mjs';
 export * as 'plugin' from './plugin.mjs';
 export * as 'settings-migration-api' from './settings-migration-api.mjs';
+export * as 'third-party-plugin' from './third-party-plugin.mjs';

package/dist/lib/esm/plugin/index.mjs

@@ -8,10 +8,12 @@ import * as plugin_async_cleanup from "./plugin-async-cleanup.mjs";
 import * as plugin_context from "./plugin-context.mjs";
 import * as plugin_event_source from "./plugin-event-source.mjs";
 import * as plugin_install_state from "./plugin-install-state.mjs";
+import * as plugin_instance from "./plugin-instance.mjs";
 import * as plugin_lifecycle_events from "./plugin-lifecycle-events.mjs";
 import * as plugin_settings_tab from "./plugin-settings-tab.mjs";
 import * as plugin from "./plugin.mjs";
 import * as settings_migration_api from "./settings-migration-api.mjs";
+import * as third_party_plugin from "./third-party-plugin.mjs";
 export {
   plugin,
   plugin_api as "plugin-api",
@@ -19,8 +21,10 @@ export {
   plugin_context as "plugin-context",
   plugin_event_source as "plugin-event-source",
   plugin_install_state as "plugin-install-state",
+  plugin_instance as "plugin-instance",
   plugin_lifecycle_events as "plugin-lifecycle-events",
   plugin_settings_tab as "plugin-settings-tab",
-  settings_migration_api as "settings-migration-api"
+  settings_migration_api as "settings-migration-api",
+  third_party_plugin as "third-party-plugin"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3BsdWdpbi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdwbHVnaW4tYXBpJyBmcm9tICcuL3BsdWdpbi1hcGkudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1hc3luYy1jbGVhbnVwJyBmcm9tICcuL3BsdWdpbi1hc3luYy1jbGVhbnVwLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4taW5zdGFsbC1zdGF0ZScgZnJvbSAnLi9wbHVnaW4taW5zdGFsbC1zdGF0ZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWxpZmVjeWNsZS1ldmVudHMnIGZyb20gJy4vcGx1Z2luLWxpZmVjeWNsZS1ldmVudHMudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1zZXR0aW5ncy10YWInIGZyb20gJy4vcGx1Z2luLXNldHRpbmdzLXRhYi50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luJyBmcm9tICcuL3BsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnc2V0dGluZ3MtbWlncmF0aW9uLWFwaScgZnJvbSAnLi9zZXR0aW5ncy1taWdyYXRpb24tYXBpLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWUEsZ0JBQWtCO0FBQzlCLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyxvQkFBc0I7QUFDbEMsWUFBWUMseUJBQTJCO0FBQ3ZDLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyw2QkFBK0I7QUFDM0MsWUFBWUMseUJBQTJCO0FBQ3ZDLFlBQVksWUFBYztBQUMxQixZQUFZQyw0QkFBOEI7IiwKICAibmFtZXMiOiBbInBsdWdpbi1hcGkiLCAicGx1Z2luLWFzeW5jLWNsZWFudXAiLCAicGx1Z2luLWNvbnRleHQiLCAicGx1Z2luLWV2ZW50LXNvdXJjZSIsICJwbHVnaW4taW5zdGFsbC1zdGF0ZSIsICJwbHVnaW4tbGlmZWN5Y2xlLWV2ZW50cyIsICJwbHVnaW4tc2V0dGluZ3MtdGFiIiwgInNldHRpbmdzLW1pZ3JhdGlvbi1hcGkiXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3BsdWdpbi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdwbHVnaW4tYXBpJyBmcm9tICcuL3BsdWdpbi1hcGkudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1hc3luYy1jbGVhbnVwJyBmcm9tICcuL3BsdWdpbi1hc3luYy1jbGVhbnVwLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4taW5zdGFsbC1zdGF0ZScgZnJvbSAnLi9wbHVnaW4taW5zdGFsbC1zdGF0ZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWluc3RhbmNlJyBmcm9tICcuL3BsdWdpbi1pbnN0YW5jZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWxpZmVjeWNsZS1ldmVudHMnIGZyb20gJy4vcGx1Z2luLWxpZmVjeWNsZS1ldmVudHMudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1zZXR0aW5ncy10YWInIGZyb20gJy4vcGx1Z2luLXNldHRpbmdzLXRhYi50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luJyBmcm9tICcuL3BsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnc2V0dGluZ3MtbWlncmF0aW9uLWFwaScgZnJvbSAnLi9zZXR0aW5ncy1taWdyYXRpb24tYXBpLnRzJztcbmV4cG9ydCAqIGFzICd0aGlyZC1wYXJ0eS1wbHVnaW4nIGZyb20gJy4vdGhpcmQtcGFydHktcGx1Z2luLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWUEsZ0JBQWtCO0FBQzlCLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyxvQkFBc0I7QUFDbEMsWUFBWUMseUJBQTJCO0FBQ3ZDLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyxxQkFBdUI7QUFDbkMsWUFBWUMsNkJBQStCO0FBQzNDLFlBQVlDLHlCQUEyQjtBQUN2QyxZQUFZLFlBQWM7QUFDMUIsWUFBWUMsNEJBQThCO0FBQzFDLFlBQVlDLHdCQUEwQjsiLAogICJuYW1lcyI6IFsicGx1Z2luLWFwaSIsICJwbHVnaW4tYXN5bmMtY2xlYW51cCIsICJwbHVnaW4tY29udGV4dCIsICJwbHVnaW4tZXZlbnQtc291cmNlIiwgInBsdWdpbi1pbnN0YWxsLXN0YXRlIiwgInBsdWdpbi1pbnN0YW5jZSIsICJwbHVnaW4tbGlmZWN5Y2xlLWV2ZW50cyIsICJwbHVnaW4tc2V0dGluZ3MtdGFiIiwgInNldHRpbmdzLW1pZ3JhdGlvbi1hcGkiLCAidGhpcmQtcGFydHktcGx1Z2luIl0KfQo=