@mnaoumov/obsidian-lib 10.4.1 → 10.5.1

package/dist/lib/esm/index.mjs

@@ -12,6 +12,7 @@ import * as attachment_unit_folder from "./attachment-unit-folder.mjs";
 import * as backlink_index from "./backlink-index.mjs";
 import * as backlink from "./backlink.mjs";
 import * as bases_view_registrar from "./bases-view-registrar.mjs";
+import * as bug_report from "./bug-report.mjs";
 import * as bulk_operation_progress from "./bulk-operation-progress.mjs";
 import * as bulk_operation from "./bulk-operation.mjs";
 import * as callout from "./callout.mjs";
@@ -36,6 +37,7 @@ import * as demo_vault_helper from "./demo-vault-helper.mjs";
 import * as demo_vault_naming from "./demo-vault-naming.mjs";
 import * as desktop_bulk_operation_git from "./desktop-bulk-operation-git.mjs";
 import * as desktop_demo_vault_opener from "./desktop-demo-vault-opener.mjs";
+import * as desktop_operating_system from "./desktop-operating-system.mjs";
 import * as desktop_trusted_input from "./desktop-trusted-input.mjs";
 import * as editor_extension_registrar from "./editor-extension-registrar.mjs";
 import * as editor_suggest_registrar from "./editor-suggest-registrar.mjs";
@@ -68,7 +70,9 @@ import * as markdown_post_processor_registrar from "./markdown-post-processor-re
 import * as markdown_view from "./markdown-view.mjs";
 import * as markdown from "./markdown.mjs";
 import * as menu_event_registrar from "./menu-event-registrar.mjs";
+import * as menu from "./menu.mjs";
 import * as metadata_cache from "./metadata-cache.mjs";
+import * as mobile_app_info from "./mobile-app-info.mjs";
 import * as mobile_trusted_input from "./mobile-trusted-input.mjs";
 import * as modals from "./modals/index.mjs";
 import * as note_priority from "./note-priority.mjs";
@@ -94,6 +98,7 @@ import * as ribbon_icon_registrar from "./ribbon-icon-registrar.mjs";
 import * as setting_components from "./setting-components/index.mjs";
 import * as setting_ex from "./setting-ex.mjs";
 import * as setting_group_ex from "./setting-group-ex.mjs";
+import * as settings_modal from "./settings-modal.mjs";
 import * as status_bar_item_registrar from "./status-bar-item-registrar.mjs";
 import * as templater from "./templater.mjs";
 import * as transformers from "./transformers/index.mjs";
@@ -114,6 +119,7 @@ export {
   backlink,
   backlink_index as "backlink-index",
   bases_view_registrar as "bases-view-registrar",
+  bug_report as "bug-report",
   bulk_operation as "bulk-operation",
   bulk_operation_progress as "bulk-operation-progress",
   callout,
@@ -138,6 +144,7 @@ export {
   demo_vault_naming as "demo-vault-naming",
   desktop_bulk_operation_git as "desktop-bulk-operation-git",
   desktop_demo_vault_opener as "desktop-demo-vault-opener",
+  desktop_operating_system as "desktop-operating-system",
   desktop_trusted_input as "desktop-trusted-input",
   editor,
   editor_extension_registrar as "editor-extension-registrar",
@@ -169,8 +176,10 @@ export {
   markdown_code_block_processor_registrar as "markdown-code-block-processor-registrar",
   markdown_post_processor_registrar as "markdown-post-processor-registrar",
   markdown_view as "markdown-view",
+  menu,
   menu_event_registrar as "menu-event-registrar",
   metadata_cache as "metadata-cache",
+  mobile_app_info as "mobile-app-info",
   mobile_trusted_input as "mobile-trusted-input",
   modals,
   note_priority as "note-priority",
@@ -196,6 +205,7 @@ export {
   setting_components as "setting-components",
   setting_ex as "setting-ex",
   setting_group_ex as "setting-group-ex",
+  settings_modal as "settings-modal",
   status_bar_item_registrar as "status-bar-item-registrar",
   templater,
   transformers,
@@ -207,4 +217,4 @@ export {
   view_registrar as "view-registrar",
   workspace
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as '__merged' from './__merged.ts';\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'attachment-unit-folder' from './attachment-unit-folder.ts';\nexport * as 'backlink-index' from './backlink-index.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'bulk-operation-progress' from './bulk-operation-progress.ts';\nexport * as 'bulk-operation' from './bulk-operation.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'canvas' from './canvas.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'code-block-reg-exp' from './code-block-reg-exp.ts';\nexport * as 'codemirror' from './codemirror/index.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'data-stores' from './data-stores/index.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'debug' from './debug.ts';\nexport * as 'demo-vault-helper-settings' from './demo-vault-helper-settings.ts';\nexport * as 'demo-vault-helper' from './demo-vault-helper.ts';\nexport * as 'demo-vault-naming' from './demo-vault-naming.ts';\nexport * as 'desktop-bulk-operation-git' from './desktop-bulk-operation-git.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'events' from './events.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-explorer' from './file-explorer.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'folder-note' from './folder-note.ts';\nexport * as 'frontmatter-formatting' from './frontmatter-formatting.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'generated-during-build' from './generated-during-build.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'library-styles' from './library-styles.ts';\nexport * as 'library' from './library.ts';\nexport * as 'link-name' from './link-name.ts';\nexport * as 'link-update-progress' from './link-update-progress.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'mobile-trusted-input' from './mobile-trusted-input.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'note-priority' from './note-priority.ts';\nexport * as 'notebook-navigator' from './notebook-navigator.ts';\nexport * as 'obsidian-lib-state' from './obsidian-lib-state.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'obsidian-word-characters' from './obsidian-word-characters.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'popovers' from './popovers/index.ts';\nexport * as 'position' from './position.ts';\nexport * as 'property-entry' from './property-entry.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'templater' from './templater.ts';\nexport * as 'transformers' from './transformers/index.ts';\nexport * as 'trusted-input' from './trusted-input.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;AAEA,YAAY,cAAgB;AAC5B,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAYC,4BAA8B;AAC1C,YAAYC,oBAAsB;AAClC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,6BAA+B;AAC3C,YAAYC,oBAAsB;AAClC,YAAY,aAAe;AAC3B,YAAY,YAAc;AAC1B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,wBAA0B;AACtC,YAAY,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAY,WAAa;AACzB,YAAYC,gCAAkC;AAC9C,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAYC,gCAAkC;AAC9C,YAAYC,+BAAiC;AAC7C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,iBAAmB;AAC/B,YAAYC,4BAA8B;AAC1C,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,4BAA8B;AAC1C,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAYC,oBAAsB;AAClC,YAAY,aAAe;AAC3B,YAAYC,eAAiB;AAC7B,YAAYC,0BAA4B;AACxC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,oBAAsB;AAClC,YAAYC,0BAA4B;AACxC,YAAY,YAAc;AAC1B,YAAYC,mBAAqB;AACjC,YAAYC,wBAA0B;AACtC,YAAYC,wBAA0B;AACtC,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,8BAAgC;AAC5C,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,cAAgB;AAC5B,YAAY,cAAgB;AAC5B,YAAYC,oBAAsB;AAClC,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,+BAAiC;AAC7C,YAAY,eAAiB;AAC7B,YAAY,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "attachment-unit-folder", "backlink-index", "bases-view-registrar", "bulk-operation-progress", "bulk-operation", "case-insensitive-file-index", "code-block-markdown-information", "code-block-reg-exp", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "data-stores", "dataview-link", "demo-vault-helper-settings", "demo-vault-helper", "demo-vault-naming", "desktop-bulk-operation-git", "desktop-demo-vault-opener", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-explorer", "file-manager", "file-system", "folder-note", "frontmatter-formatting", "frontmatter-link-cache-with-offsets", "generated-during-build", "hover-link-source-registrar", "html-element", "is-in-obsidian", "library-styles", "link-name", "link-update-progress", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "mobile-trusted-input", "note-priority", "notebook-navigator", "obsidian-lib-state", "obsidian-protocol-handler-registrar", "obsidian-settings", "obsidian-word-characters", "parse-link", "path-settings", "plugin-cli-handler-registrar", "property-entry", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "status-bar-item-registrar", "trusted-input", "vault-delete", "vault-transaction", "view-registrar"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as '__merged' from './__merged.ts';\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'attachment-unit-folder' from './attachment-unit-folder.ts';\nexport * as 'backlink-index' from './backlink-index.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'bug-report' from './bug-report.ts';\nexport * as 'bulk-operation-progress' from './bulk-operation-progress.ts';\nexport * as 'bulk-operation' from './bulk-operation.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'canvas' from './canvas.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'code-block-reg-exp' from './code-block-reg-exp.ts';\nexport * as 'codemirror' from './codemirror/index.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'data-stores' from './data-stores/index.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'debug' from './debug.ts';\nexport * as 'demo-vault-helper-settings' from './demo-vault-helper-settings.ts';\nexport * as 'demo-vault-helper' from './demo-vault-helper.ts';\nexport * as 'demo-vault-naming' from './demo-vault-naming.ts';\nexport * as 'desktop-bulk-operation-git' from './desktop-bulk-operation-git.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-operating-system' from './desktop-operating-system.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'events' from './events.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-explorer' from './file-explorer.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'folder-note' from './folder-note.ts';\nexport * as 'frontmatter-formatting' from './frontmatter-formatting.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'generated-during-build' from './generated-during-build.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'library-styles' from './library-styles.ts';\nexport * as 'library' from './library.ts';\nexport * as 'link-name' from './link-name.ts';\nexport * as 'link-update-progress' from './link-update-progress.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'menu' from './menu.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'mobile-app-info' from './mobile-app-info.ts';\nexport * as 'mobile-trusted-input' from './mobile-trusted-input.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'note-priority' from './note-priority.ts';\nexport * as 'notebook-navigator' from './notebook-navigator.ts';\nexport * as 'obsidian-lib-state' from './obsidian-lib-state.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'obsidian-word-characters' from './obsidian-word-characters.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'popovers' from './popovers/index.ts';\nexport * as 'position' from './position.ts';\nexport * as 'property-entry' from './property-entry.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'settings-modal' from './settings-modal.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'templater' from './templater.ts';\nexport * as 'transformers' from './transformers/index.ts';\nexport * as 'trusted-input' from './trusted-input.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;AAEA,YAAY,cAAgB;AAC5B,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAYC,4BAA8B;AAC1C,YAAYC,oBAAsB;AAClC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,gBAAkB;AAC9B,YAAYC,6BAA+B;AAC3C,YAAYC,oBAAsB;AAClC,YAAY,aAAe;AAC3B,YAAY,YAAc;AAC1B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,wBAA0B;AACtC,YAAY,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAY,WAAa;AACzB,YAAYC,gCAAkC;AAC9C,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAYC,gCAAkC;AAC9C,YAAYC,+BAAiC;AAC7C,YAAYC,8BAAgC;AAC5C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,iBAAmB;AAC/B,YAAYC,4BAA8B;AAC1C,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,4BAA8B;AAC1C,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAYC,oBAAsB;AAClC,YAAY,aAAe;AAC3B,YAAYC,eAAiB;AAC7B,YAAYC,0BAA4B;AACxC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAYC,qBAAuB;AACnC,YAAYC,0BAA4B;AACxC,YAAY,YAAc;AAC1B,YAAYC,mBAAqB;AACjC,YAAYC,wBAA0B;AACtC,YAAYC,wBAA0B;AACtC,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,8BAAgC;AAC5C,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,cAAgB;AAC5B,YAAY,cAAgB;AAC5B,YAAYC,oBAAsB;AAClC,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,oBAAsB;AAClC,YAAYC,+BAAiC;AAC7C,YAAY,eAAiB;AAC7B,YAAY,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "attachment-unit-folder", "backlink-index", "bases-view-registrar", "bug-report", "bulk-operation-progress", "bulk-operation", "case-insensitive-file-index", "code-block-markdown-information", "code-block-reg-exp", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "data-stores", "dataview-link", "demo-vault-helper-settings", "demo-vault-helper", "demo-vault-naming", "desktop-bulk-operation-git", "desktop-demo-vault-opener", "desktop-operating-system", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-explorer", "file-manager", "file-system", "folder-note", "frontmatter-formatting", "frontmatter-link-cache-with-offsets", "generated-during-build", "hover-link-source-registrar", "html-element", "is-in-obsidian", "library-styles", "link-name", "link-update-progress", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "mobile-app-info", "mobile-trusted-input", "note-priority", "notebook-navigator", "obsidian-lib-state", "obsidian-protocol-handler-registrar", "obsidian-settings", "obsidian-word-characters", "parse-link", "path-settings", "plugin-cli-handler-registrar", "property-entry", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "settings-modal", "status-bar-item-registrar", "trusted-input", "vault-delete", "vault-transaction", "view-registrar"]
}


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

@@ -0,0 +1,65 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Helpers for Obsidian menus.
+ */
+import type { Menu, MenuItem } from 'obsidian';
+/**
+ * Parameters for {@link addSingleChoiceMenuItems}.
+ *
+ * @typeParam T - The type of the values to choose from.
+ */
+export interface AddSingleChoiceMenuItemsParams<T> {
+    /**
+     * The value checked when the menu opens.
+     */
+    readonly currentValue: T;
+    /**
+     * The menu to add the items to.
+     */
+    readonly menu: Menu;
+    /**
+     * Called with the chosen value when the user clicks an item.
+     */
+    readonly onChange: (value: T) => void;
+    /**
+     * The choices, in menu order.
+     */
+    readonly options: readonly SingleChoiceMenuOption<T>[];
+    /**
+     * The menu section to put the items in.
+     */
+    readonly section?: string;
+}
+/**
+ * One choice of a single-choice menu group.
+ *
+ * @typeParam T - The type of the value.
+ */
+export interface SingleChoiceMenuOption<T> {
+    /**
+     * The item's icon.
+     */
+    readonly icon?: string;
+    /**
+     * The item's title.
+     */
+    readonly title: string;
+    /**
+     * The value the item stands for.
+     */
+    readonly value: T;
+}
+/**
+ * Adds a group of menu items of which exactly one is checked, like radio buttons.
+ *
+ * A click checks the clicked item and unchecks the rest of the group before calling `onChange`, so a menu
+ * that is shown again shows the new choice. Obsidian still closes the menu after a click (read from its
+ * `1.15.0` `MenuItem.handleEvent`). Values are compared with `===`.
+ *
+ * @typeParam T - The type of the values to choose from.
+ * @param params - The parameters.
+ * @returns The items added, in option order.
+ */
+export declare function addSingleChoiceMenuItems<T>(params: AddSingleChoiceMenuItemsParams<T>): MenuItem[];

package/dist/lib/esm/menu.mjs

@@ -0,0 +1,30 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+function addSingleChoiceMenuItems(params) {
+  const items = [];
+  for (const option of params.options) {
+    params.menu.addItem((item) => {
+      items.push(item);
+      item.setTitle(option.title).setChecked(option.value === params.currentValue).onClick(() => {
+        for (const groupItem of items) {
+          groupItem.setChecked(groupItem === item);
+        }
+        params.onChange(option.value);
+      });
+      if (option.icon !== void 0) {
+        item.setIcon(option.icon);
+      }
+      if (params.section !== void 0) {
+        item.setSection(params.section);
+      }
+    });
+  }
+  return items;
+}
+export {
+  addSingleChoiceMenuItems
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/mobile-app-info.d.mts

@@ -0,0 +1,32 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Reads the Obsidian mobile app's build and the device's operating system, for a bug report.
+ *
+ * Mobile only: it calls the Capacitor bridge's `nativePromise`, which Obsidian's own code uses but which
+ * no public typing declares, so the shapes are declared here, narrowed to the members read, and checked
+ * at run time. On any other runtime {@link getMobileAppInfo} resolves to `null`. Reach it through
+ * {@link ./bug-report.ts | bug-report}.
+ */
+/**
+ * What the mobile app and its device report about themselves.
+ */
+export interface MobileAppInfo {
+    /**
+     * The installed app's version and build, such as `1.15.0 (291)`, or `null` when the app did not say.
+     */
+    readonly installerVersion: null | string;
+    /**
+     * The device's operating system, version and model, such as `android 15 (Google Pixel 8)`, or `null`
+     * when the device did not say.
+     */
+    readonly operatingSystem: null | string;
+}
+/**
+ * Gets what the mobile app and its device report about themselves.
+ *
+ * @returns The app's version and the device's operating system, or `null` where there is no Capacitor
+ *   bridge. Each field is `null` when its call fails or answers in an unexpected shape.
+ */
+export declare function getMobileAppInfo(): Promise<MobileAppInfo | null>;

package/dist/lib/esm/mobile-app-info.mjs

@@ -0,0 +1,84 @@
+/*
+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 {
+  functionTypeGuard,
+  isString,
+  objectTypeGuard,
+  optionalTypeGuard
+} from "@mnaoumov/typescript-lib/type-guards";
+const isAppInfo = objectTypeGuard({
+  build: optionalTypeGuard(isString),
+  version: isString
+});
+const isCapacitorBridge = objectTypeGuard({
+  nativePromise: functionTypeGuard()
+});
+const isDeviceInfo = objectTypeGuard({
+  manufacturer: optionalTypeGuard(isString),
+  model: optionalTypeGuard(isString),
+  osVersion: isString,
+  platform: isString
+});
+async function getMobileAppInfo() {
+  const capacitor = window.Capacitor;
+  if (!isCapacitorBridge(capacitor)) {
+    return null;
+  }
+  const [appInfo, deviceInfo] = await Promise.all([
+    callGetInfo(capacitor, "App"),
+    callGetInfo(capacitor, "Device")
+  ]);
+  return {
+    installerVersion: isAppInfo(appInfo) ? formatAppInfo(appInfo) : null,
+    operatingSystem: isDeviceInfo(deviceInfo) ? formatDeviceInfo(deviceInfo) : null
+  };
+}
+async function callGetInfo(capacitor, pluginName) {
+  try {
+    return await capacitor.nativePromise(pluginName, "getInfo");
+  } catch {
+    return null;
+  }
+}
+function formatAppInfo(appInfo) {
+  return appInfo.build ? `${appInfo.version} (${appInfo.build})` : appInfo.version;
+}
+function formatDeviceInfo(deviceInfo) {
+  const operatingSystem = `${deviceInfo.platform} ${deviceInfo.osVersion}`;
+  const model = [deviceInfo.manufacturer, deviceInfo.model].filter(Boolean).join(" ");
+  return model ? `${operatingSystem} (${model})` : operatingSystem;
+}
+export {
+  getMobileAppInfo
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/modals/modal.d.mts

@@ -60,5 +60,9 @@ export declare abstract class ModalBase<Value> extends Modal {
  * @typeParam Value - The type of the value resolved by the modal.
  * @param modalCreator - A function that creates a modal.
  * @returns A {@link Promise} that resolves when the modal is closed.
+ *
+ * @remarks
+ * While the modal is open, a bulk operation that awaits it keeps its lease lock fresh, through
+ * `holdBulkOperationWhile`.
  */
 export declare function showModal<Value>(modalCreator: (resolve: PromiseResolve<Value>) => Modal): Promise<Value>;

package/dist/lib/esm/modals/modal.mjs

@@ -31,6 +31,7 @@ ensureBrowserProcess();
 })();
 
 import { Modal } from "obsidian";
+import { holdBulkOperationWhile } from "../bulk-operation-progress.mjs";
 import { addPluginCssClasses } from "../plugin/plugin-context.mjs";
 class ModalBase extends Modal {
   /**
@@ -57,13 +58,15 @@ class ModalBase extends Modal {
   }
 }
 async function showModal(modalCreator) {
-  return await new Promise((resolve) => {
-    const modal = modalCreator(resolve);
-    modal.open();
-  });
+  return await holdBulkOperationWhile(
+    new Promise((resolve) => {
+      const modal = modalCreator(resolve);
+      modal.open();
+    })
+  );
 }
 export {
   ModalBase,
   showModal
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian-settings.mjs

@@ -30,7 +30,10 @@ function ensureBrowserProcess() {
 ensureBrowserProcess();
 })();
 
-import { assertNever } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  assertNever,
+  ensureNonNullable
+} from "@mnaoumov/typescript-lib/type-guards";
 var SpellcheckMode = /* @__PURE__ */ ((SpellcheckMode2) => {
   SpellcheckMode2["AlwaysOn"] = "AlwaysOn";
   SpellcheckMode2["FollowObsidianSetting"] = "FollowObsidianSetting";
@@ -38,7 +41,7 @@ var SpellcheckMode = /* @__PURE__ */ ((SpellcheckMode2) => {
   return SpellcheckMode2;
 })(SpellcheckMode || {});
 function getNewLinkFormat(app) {
-  return app.vault.getConfig("newLinkFormat");
+  return ensureNonNullable(app.vault.getConfig("newLinkFormat"));
 }
 function isSpellcheckEnabled(app) {
   return Boolean(app.vault.getConfig("spellcheck"));
@@ -69,4 +72,4 @@ export {
   isSpellcheckEnabledForMode,
   shouldUseWikilinks
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -350,6 +350,8 @@ export declare abstract class PluginBase extends PluginBase_base implements Plug
  *
  * @param plugin - The plugin to reload.
  * @returns A {@link Promise} that resolves when the plugin is reloaded.
+ * @throws {@link PluginEnableRefusedError} If Obsidian refused to enable the plugin again, which leaves it
+ * disabled.
  */
 export declare function reloadPlugin(plugin: Plugin): Promise<void>;
 /**