@mnaoumov/obsidian-lib 10.10.0 → 10.12.0

package/dist/lib/cjs/components/all-windows-status-bar-item-component.cjs

@@ -0,0 +1,245 @@
+/*
+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();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var all_windows_status_bar_item_component_exports = {};
+__export(all_windows_status_bar_item_component_exports, {
+  AllWindowsStatusBarItemComponent: () => AllWindowsStatusBarItemComponent,
+  WINDOW_STATUS_BAR_CSS_CLASS: () => WINDOW_STATUS_BAR_CSS_CLASS,
+  getPluginStatusBarItemCssClass: () => getPluginStatusBarItemCssClass,
+  registerAllWindowsStatusBarItem: () => registerAllWindowsStatusBarItem
+});
+module.exports = __toCommonJS(all_windows_status_bar_item_component_exports);
+var import_obsidian = require('obsidian');
+var import_all_windows_event_component = require('./all-windows-event-component.cjs');
+var import_component_ex = require('./component-ex.cjs');
+const WINDOW_STATUS_BAR_CSS_CLASS = "obsidian-lib-window-status-bar";
+const APP_CONTAINER_CSS_CLASS = "app-container";
+const STATUS_BAR_CSS_CLASS = "status-bar";
+const STATUS_BAR_ITEM_CSS_CLASS = "status-bar-item";
+class AllWindowsStatusBarItemComponent extends import_component_ex.ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The CSS classes added to each item.
+   */
+  itemClasses;
+  /**
+   * Renders the item of one window.
+   */
+  renderItem;
+  /**
+   * Whether a status bar is created in a window that has none.
+   */
+  shouldCreateMissingStatusBar;
+  itemElsByWindow = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new instance of the `AllWindowsStatusBarItemComponent` class.
+   *
+   * @param params - The {@link AllWindowsStatusBarItemComponentConstructorParams}.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.renderItem = params.render;
+    this.shouldCreateMissingStatusBar = params.shouldCreateMissingStatusBar ?? true;
+    this.itemClasses = [
+      STATUS_BAR_ITEM_CSS_CLASS,
+      ...params.pluginId === void 0 ? [] : [getPluginStatusBarItemCssClass(params.pluginId)],
+      ...params.cls ?? []
+    ];
+  }
+  /**
+   * Gets the item of a window.
+   *
+   * @param win - The window.
+   * @returns The item, or `null` when the window has none.
+   */
+  getItemEl(win) {
+    return this.itemElsByWindow.get(win) ?? null;
+  }
+  /**
+   * Gets the items of every window that has one.
+   *
+   * @returns The items.
+   */
+  getItemEls() {
+    return [...this.itemElsByWindow.values()];
+  }
+  /**
+   * Creates the item in every window, now and as popouts open. A no-op on mobile.
+   */
+  onload() {
+    super.onload();
+    if (import_obsidian.Platform.isMobile) {
+      return;
+    }
+    const allWindowsEventComponent = this.addChild(new import_all_windows_event_component.AllWindowsEventComponent(this.app));
+    allWindowsEventComponent.registerAllWindowsHandler((win) => this.attach(win));
+  }
+  /**
+   * Renders the item of every window again.
+   */
+  refresh() {
+    for (const [win, el] of this.itemElsByWindow) {
+      this.renderItem({ el, win });
+    }
+  }
+  attach(win) {
+    const statusBarEl = this.findOrCreateStatusBar(win.document);
+    if (!statusBarEl) {
+      return null;
+    }
+    const el = statusBarEl.createDiv({ cls: [...this.itemClasses] });
+    this.itemElsByWindow.set(win, el);
+    this.renderItem({ el, win });
+    return () => {
+      this.itemElsByWindow.delete(win);
+      el.remove();
+      if (statusBarEl.classList.contains(WINDOW_STATUS_BAR_CSS_CLASS) && !statusBarEl.querySelector(`:scope > .${STATUS_BAR_ITEM_CSS_CLASS}`)) {
+        statusBarEl.remove();
+      }
+    };
+  }
+  findOrCreateStatusBar(doc) {
+    const appContainerEl = doc.body.querySelector(`:scope > .${APP_CONTAINER_CSS_CLASS}`);
+    if (!appContainerEl) {
+      return null;
+    }
+    const statusBarEl = appContainerEl.querySelector(`:scope > .${STATUS_BAR_CSS_CLASS}`);
+    if (statusBarEl) {
+      return statusBarEl;
+    }
+    if (!this.shouldCreateMissingStatusBar) {
+      return null;
+    }
+    return appContainerEl.createDiv({ cls: [STATUS_BAR_CSS_CLASS, WINDOW_STATUS_BAR_CSS_CLASS] });
+  }
+}
+function getPluginStatusBarItemCssClass(pluginId) {
+  return `plugin-${pluginId.toLowerCase().replace(/[^_a-zA-Z0-9-]/, "-")}`;
+}
+function registerAllWindowsStatusBarItem(params) {
+  const { component, ...constructorParams } = params;
+  return component.addChild(new AllWindowsStatusBarItemComponent(constructorParams));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AllWindowsStatusBarItemComponent,
+  WINDOW_STATUS_BAR_CSS_CLASS,
+  getPluginStatusBarItemCssClass,
+  registerAllWindowsStatusBarItem
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/all-windows-status-bar-item-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, and\n * removes only its own items when a window closes or the component unloads.\n *\n * Read from Obsidian `1.15.1`: the main window builds `body > .app-container > .status-bar`, and\n * `Plugin.addStatusBarItem` is a `.status-bar-item` created in it. A popout builds `body > .app-container` with the\n * workspace only, and **no status bar**. `app.css` styles `.status-bar` without scoping it to a window, so a\n * `.status-bar` created inside a popout's `.app-container` looks and sits exactly like the main one. By default\n * this component creates that bar in a popout that lacks one, and marks it with\n * {@link WINDOW_STATUS_BAR_CSS_CLASS}. The marker is a wire constant shared by every copy of this library: any copy\n * reuses a marked bar, and whichever copy removes the last item from it removes the bar too.\n *\n * Mobile has no popouts, and `app.css` hides `.status-bar` under `.is-mobile`, so on mobile the component creates\n * nothing and never calls the render callback.\n */\n\nimport type {\n  App,\n  Component\n} from 'obsidian';\n\nimport { Platform } from 'obsidian';\n\nimport { AllWindowsEventComponent } from './all-windows-event-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * The class that marks a status bar this library created in a window that had none.\n * Other copies of the library match it, so its value must never change.\n */\nexport const WINDOW_STATUS_BAR_CSS_CLASS = 'obsidian-lib-window-status-bar';\n\nconst APP_CONTAINER_CSS_CLASS = 'app-container';\nconst STATUS_BAR_CSS_CLASS = 'status-bar';\nconst STATUS_BAR_ITEM_CSS_CLASS = 'status-bar-item';\n\n/**\n * Parameters for the {@link AllWindowsStatusBarItemComponent} constructor.\n */\nexport interface AllWindowsStatusBarItemComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Extra CSS classes for each item.\n   */\n  readonly cls?: readonly string[];\n\n  /**\n   * The plugin id. When given, each item gets the `plugin-<id>` class that `Plugin.addStatusBarItem` adds, so\n   * themes and CSS snippets that target the plugin's status-bar items match these too.\n   */\n  readonly pluginId?: string;\n\n  /**\n   * Renders the item of one window. Called when the item is created and again by\n   * {@link AllWindowsStatusBarItemComponent.refresh}, so it must be safe to call repeatedly on the same element.\n   *\n   * @param params - The item and its window.\n   */\n  readonly render: (params: AllWindowsStatusBarItemRenderParams) => void;\n\n  /**\n   * Whether to create a status bar in a window that has none, as every popout in Obsidian `1.15.1` does.\n   * When `false`, such a window gets no item. Defaults to `true`.\n   */\n  readonly shouldCreateMissingStatusBar?: boolean;\n}\n\n/**\n * Parameters passed to {@link AllWindowsStatusBarItemComponentConstructorParams.render}.\n */\nexport interface AllWindowsStatusBarItemRenderParams {\n  /**\n   * The status-bar item owned by this component in {@link win}.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The window the item is in. Use its document for anything the render creates outside the item.\n   */\n  readonly win: Window;\n}\n\n/**\n * Parameters for {@link registerAllWindowsStatusBarItem}.\n */\nexport interface RegisterAllWindowsStatusBarItemParams extends AllWindowsStatusBarItemComponentConstructorParams {\n  /**\n   * The component that owns the items: they are removed when it unloads.\n   */\n  readonly component: Component;\n}\n\n/**\n * Shows one status-bar item in the main window and in every desktop popout while loaded.\n */\nexport class AllWindowsStatusBarItemComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The CSS classes added to each item.\n   */\n  protected readonly itemClasses: readonly string[];\n\n  /**\n   * Renders the item of one window.\n   */\n  protected readonly renderItem: (params: AllWindowsStatusBarItemRenderParams) => void;\n\n  /**\n   * Whether a status bar is created in a window that has none.\n   */\n  protected readonly shouldCreateMissingStatusBar: boolean;\n\n  private readonly itemElsByWindow = new Map<Window, HTMLElement>();\n\n  /**\n   * Creates a new instance of the `AllWindowsStatusBarItemComponent` class.\n   *\n   * @param params - The {@link AllWindowsStatusBarItemComponentConstructorParams}.\n   */\n  public constructor(params: AllWindowsStatusBarItemComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.renderItem = params.render;\n    this.shouldCreateMissingStatusBar = params.shouldCreateMissingStatusBar ?? true;\n    this.itemClasses = [\n      STATUS_BAR_ITEM_CSS_CLASS,\n      ...params.pluginId === undefined ? [] : [getPluginStatusBarItemCssClass(params.pluginId)],\n      ...params.cls ?? []\n    ];\n  }\n\n  /**\n   * Gets the item of a window.\n   *\n   * @param win - The window.\n   * @returns The item, or `null` when the window has none.\n   */\n  public getItemEl(win: Window): HTMLElement | null {\n    return this.itemElsByWindow.get(win) ?? null;\n  }\n\n  /**\n   * Gets the items of every window that has one.\n   *\n   * @returns The items.\n   */\n  public getItemEls(): HTMLElement[] {\n    return [...this.itemElsByWindow.values()];\n  }\n\n  /**\n   * Creates the item in every window, now and as popouts open. A no-op on mobile.\n   */\n  public override onload(): void {\n    super.onload();\n\n    if (Platform.isMobile) {\n      return;\n    }\n\n    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));\n    allWindowsEventComponent.registerAllWindowsHandler((win) => this.attach(win));\n  }\n\n  /**\n   * Renders the item of every window again.\n   */\n  public refresh(): void {\n    for (const [win, el] of this.itemElsByWindow) {\n      this.renderItem({ el, win });\n    }\n  }\n\n  private attach(win: Window): (() => void) | null {\n    const statusBarEl = this.findOrCreateStatusBar(win.document);\n    if (!statusBarEl) {\n      return null;\n    }\n\n    const el = statusBarEl.createDiv({ cls: [...this.itemClasses] });\n    this.itemElsByWindow.set(win, el);\n    this.renderItem({ el, win });\n\n    return () => {\n      this.itemElsByWindow.delete(win);\n      el.remove();\n      if (statusBarEl.classList.contains(WINDOW_STATUS_BAR_CSS_CLASS) && !statusBarEl.querySelector(`:scope > .${STATUS_BAR_ITEM_CSS_CLASS}`)) {\n        statusBarEl.remove();\n      }\n    };\n  }\n\n  private findOrCreateStatusBar(doc: Document): HTMLElement | null {\n    const appContainerEl = doc.body.querySelector<HTMLElement>(`:scope > .${APP_CONTAINER_CSS_CLASS}`);\n    if (!appContainerEl) {\n      return null;\n    }\n\n    const statusBarEl = appContainerEl.querySelector<HTMLElement>(`:scope > .${STATUS_BAR_CSS_CLASS}`);\n    if (statusBarEl) {\n      return statusBarEl;\n    }\n\n    if (!this.shouldCreateMissingStatusBar) {\n      return null;\n    }\n\n    return appContainerEl.createDiv({ cls: [STATUS_BAR_CSS_CLASS, WINDOW_STATUS_BAR_CSS_CLASS] });\n  }\n}\n\n/**\n * Gets the class `Plugin.addStatusBarItem` adds to a plugin's status-bar items.\n * It copies Obsidian `1.15.1` exactly, including that only the first disallowed character is replaced.\n *\n * @param pluginId - The plugin id.\n * @returns The CSS class.\n */\nexport function getPluginStatusBarItemCssClass(pluginId: string): string {\n  return `plugin-${pluginId.toLowerCase().replace(/[^_a-zA-Z0-9-]/, '-')}`;\n}\n\n/**\n * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, until\n * the owning component unloads.\n *\n * @param params - The {@link RegisterAllWindowsStatusBarItemParams}. The owner must be loaded.\n * @returns The {@link AllWindowsStatusBarItemComponent}. Call its {@link AllWindowsStatusBarItemComponent.refresh} to\n *   render every item again, or remove it from the owner to stop early.\n */\nexport function registerAllWindowsStatusBarItem(params: RegisterAllWindowsStatusBarItemParams): AllWindowsStatusBarItemComponent {\n  const { component, ...constructorParams } = params;\n  return component.addChild(new AllWindowsStatusBarItemComponent(constructorParams));\n}\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/components/all-windows-status-bar-item-component.d.cts

@@ -0,0 +1,146 @@
+/// <reference path="../library-references.d.cts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, and
+ * removes only its own items when a window closes or the component unloads.
+ *
+ * Read from Obsidian `1.15.1`: the main window builds `body > .app-container > .status-bar`, and
+ * `Plugin.addStatusBarItem` is a `.status-bar-item` created in it. A popout builds `body > .app-container` with the
+ * workspace only, and **no status bar**. `app.css` styles `.status-bar` without scoping it to a window, so a
+ * `.status-bar` created inside a popout's `.app-container` looks and sits exactly like the main one. By default
+ * this component creates that bar in a popout that lacks one, and marks it with
+ * {@link WINDOW_STATUS_BAR_CSS_CLASS}. The marker is a wire constant shared by every copy of this library: any copy
+ * reuses a marked bar, and whichever copy removes the last item from it removes the bar too.
+ *
+ * Mobile has no popouts, and `app.css` hides `.status-bar` under `.is-mobile`, so on mobile the component creates
+ * nothing and never calls the render callback.
+ */
+import type { App, Component } from 'obsidian' with { 'resolution-mode': 'import' };
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * The class that marks a status bar this library created in a window that had none.
+ * Other copies of the library match it, so its value must never change.
+ */
+export declare const WINDOW_STATUS_BAR_CSS_CLASS = "obsidian-lib-window-status-bar";
+/**
+ * Parameters for the {@link AllWindowsStatusBarItemComponent} constructor.
+ */
+export interface AllWindowsStatusBarItemComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * Extra CSS classes for each item.
+     */
+    readonly cls?: readonly string[];
+    /**
+     * The plugin id. When given, each item gets the `plugin-<id>` class that `Plugin.addStatusBarItem` adds, so
+     * themes and CSS snippets that target the plugin's status-bar items match these too.
+     */
+    readonly pluginId?: string;
+    /**
+     * Renders the item of one window. Called when the item is created and again by
+     * {@link AllWindowsStatusBarItemComponent.refresh}, so it must be safe to call repeatedly on the same element.
+     *
+     * @param params - The item and its window.
+     */
+    readonly render: (params: AllWindowsStatusBarItemRenderParams) => void;
+    /**
+     * Whether to create a status bar in a window that has none, as every popout in Obsidian `1.15.1` does.
+     * When `false`, such a window gets no item. Defaults to `true`.
+     */
+    readonly shouldCreateMissingStatusBar?: boolean;
+}
+/**
+ * Parameters passed to {@link AllWindowsStatusBarItemComponentConstructorParams.render}.
+ */
+export interface AllWindowsStatusBarItemRenderParams {
+    /**
+     * The status-bar item owned by this component in {@link win}.
+     */
+    readonly el: HTMLElement;
+    /**
+     * The window the item is in. Use its document for anything the render creates outside the item.
+     */
+    readonly win: Window;
+}
+/**
+ * Parameters for {@link registerAllWindowsStatusBarItem}.
+ */
+export interface RegisterAllWindowsStatusBarItemParams extends AllWindowsStatusBarItemComponentConstructorParams {
+    /**
+     * The component that owns the items: they are removed when it unloads.
+     */
+    readonly component: Component;
+}
+/**
+ * Shows one status-bar item in the main window and in every desktop popout while loaded.
+ */
+export declare class AllWindowsStatusBarItemComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The CSS classes added to each item.
+     */
+    protected readonly itemClasses: readonly string[];
+    /**
+     * Renders the item of one window.
+     */
+    protected readonly renderItem: (params: AllWindowsStatusBarItemRenderParams) => void;
+    /**
+     * Whether a status bar is created in a window that has none.
+     */
+    protected readonly shouldCreateMissingStatusBar: boolean;
+    private readonly itemElsByWindow;
+    /**
+     * Creates a new instance of the `AllWindowsStatusBarItemComponent` class.
+     *
+     * @param params - The {@link AllWindowsStatusBarItemComponentConstructorParams}.
+     */
+    constructor(params: AllWindowsStatusBarItemComponentConstructorParams);
+    /**
+     * Gets the item of a window.
+     *
+     * @param win - The window.
+     * @returns The item, or `null` when the window has none.
+     */
+    getItemEl(win: Window): HTMLElement | null;
+    /**
+     * Gets the items of every window that has one.
+     *
+     * @returns The items.
+     */
+    getItemEls(): HTMLElement[];
+    /**
+     * Creates the item in every window, now and as popouts open. A no-op on mobile.
+     */
+    onload(): void;
+    /**
+     * Renders the item of every window again.
+     */
+    refresh(): void;
+    private attach;
+    private findOrCreateStatusBar;
+}
+/**
+ * Gets the class `Plugin.addStatusBarItem` adds to a plugin's status-bar items.
+ * It copies Obsidian `1.15.1` exactly, including that only the first disallowed character is replaced.
+ *
+ * @param pluginId - The plugin id.
+ * @returns The CSS class.
+ */
+export declare function getPluginStatusBarItemCssClass(pluginId: string): string;
+/**
+ * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, until
+ * the owning component unloads.
+ *
+ * @param params - The {@link RegisterAllWindowsStatusBarItemParams}. The owner must be loaded.
+ * @returns The {@link AllWindowsStatusBarItemComponent}. Call its {@link AllWindowsStatusBarItemComponent.refresh} to
+ *   render every item again, or remove it from the owner to stop early.
+ */
+export declare function registerAllWindowsStatusBarItem(params: RegisterAllWindowsStatusBarItemParams): AllWindowsStatusBarItemComponent;

package/dist/lib/cjs/components/embed-extensions-component.cjs

@@ -106,6 +106,14 @@ class EmbedExtensionsComponent extends import_component_ex.ComponentEx {
    * Registers the specified file extensions with the given embed type in the Obsidian app.
    * The extensions will be automatically unregistered when the component is unloaded.
    *
+   * The registration is all or nothing: Obsidian throws for an extension that is already registered (by the core or by
+   * another plugin), and in that case every extension this call registered before the conflict is unregistered again
+   * before the error is rethrown. An extension registered by someone else is never unregistered.
+   *
+   * The creator serves every surface that loads an embed: `![[file.ext#subpath]]` in Reading view and Live Preview,
+   * canvas file nodes and the page-preview hover popover. It receives the link's subpath with its leading `#`, or an
+   * empty string. Returning `null` makes Obsidian fall back to its generic file embed.
+   *
    * @param extensions - An array of file extensions to register.
    * @param embedCreator - The embed creator function to associate with the extensions.
    *
@@ -116,9 +124,18 @@ class EmbedExtensionsComponent extends import_component_ex.ComponentEx {
    */
   registerExtensions(extensions, embedCreator) {
     this.ensureLoaded();
-    this.app.embedRegistry.registerExtensions(extensions, embedCreator);
+    const registeredExtensions = [];
+    try {
+      for (const extension of extensions) {
+        this.app.embedRegistry.registerExtension(extension, embedCreator);
+        registeredExtensions.push(extension);
+      }
+    } catch (error) {
+      this.app.embedRegistry.unregisterExtensions(registeredExtensions);
+      throw error;
+    }
     this.register(() => {
-      this.app.embedRegistry.unregisterExtensions(extensions);
+      this.app.embedRegistry.unregisterExtensions(registeredExtensions);
     });
   }
 }
@@ -126,4 +143,4 @@ class EmbedExtensionsComponent extends import_component_ex.ComponentEx {
 0 && (module.exports = {
   EmbedExtensionsComponent
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/components/embed-extensions-component.d.cts

@@ -26,6 +26,14 @@ export declare class EmbedExtensionsComponent extends ComponentEx {
      * Registers the specified file extensions with the given embed type in the Obsidian app.
      * The extensions will be automatically unregistered when the component is unloaded.
      *
+     * The registration is all or nothing: Obsidian throws for an extension that is already registered (by the core or by
+     * another plugin), and in that case every extension this call registered before the conflict is unregistered again
+     * before the error is rethrown. An extension registered by someone else is never unregistered.
+     *
+     * The creator serves every surface that loads an embed: `![[file.ext#subpath]]` in Reading view and Live Preview,
+     * canvas file nodes and the page-preview hover popover. It receives the link's subpath with its leading `#`, or an
+     * empty string. Returning `null` makes Obsidian fall back to its generic file embed.
+     *
      * @param extensions - An array of file extensions to register.
      * @param embedCreator - The embed creator function to associate with the extensions.
      *