obsidian-dev-utils 49.0.3 → 51.0.1

package/dist/lib/esm/css-class.mjs

@@ -0,0 +1,63 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+var CssClass = /* @__PURE__ */ ((CssClass2) => {
+  CssClass2["AlertModal"] = "alert-modal";
+  CssClass2["CancelButton"] = "cancel-button";
+  CssClass2["CheckboxComponent"] = "checkbox-component";
+  CssClass2["CodeHighlighterComponent"] = "code-highlighter-component";
+  CssClass2["ConfirmModal"] = "confirm-modal";
+  CssClass2["DateComponent"] = "date-component";
+  CssClass2["DateTimeComponent"] = "datetime-component";
+  CssClass2["EmailComponent"] = "email-component";
+  CssClass2["FileComponent"] = "file-component";
+  CssClass2["IsPlaceholder"] = "is-placeholder";
+  CssClass2["LibraryName"] = "obsidian-dev-utils";
+  CssClass2["MonthComponent"] = "month-component";
+  CssClass2["MultipleDropdownComponent"] = "multiple-dropdown-component";
+  CssClass2["MultipleEmailComponent"] = "multiple-email-component";
+  CssClass2["MultipleFileComponent"] = "multiple-file-component";
+  CssClass2["MultipleTextComponent"] = "multiple-text-component";
+  CssClass2["NumberComponent"] = "number-component";
+  CssClass2["OkButton"] = "ok-button";
+  CssClass2["OverlayValidator"] = "overlay-validator";
+  CssClass2["PasswordComponent"] = "password-component";
+  CssClass2["PluginSettingsTab"] = "plugin-settings-tab";
+  CssClass2["PromptModal"] = "prompt-modal";
+  CssClass2["SelectItemModal"] = "select-item-modal";
+  CssClass2["SettingComponentWrapper"] = "setting-component-wrapper";
+  CssClass2["TelephoneComponent"] = "telephone-component";
+  CssClass2["TextBox"] = "text-box";
+  CssClass2["TimeComponent"] = "time-component";
+  CssClass2["Tooltip"] = "tooltip";
+  CssClass2["TooltipArrow"] = "tooltip-arrow";
+  CssClass2["TooltipValidator"] = "tooltip-validator";
+  CssClass2["TriStateCheckboxComponent"] = "tri-state-checkbox-component";
+  CssClass2["TypedDropdownComponent"] = "typed-dropdown-component";
+  CssClass2["TypedMultipleDropdownComponent"] = "typed-multiple-dropdown-component";
+  CssClass2["UrlComponent"] = "url-component";
+  CssClass2["WeekComponent"] = "week-component";
+  return CssClass2;
+})(CssClass || {});
+export {
+  CssClass
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2Nzcy1jbGFzcy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqXG4gKiBDU1MgY2xhc3NlcyB1c2VkIGJ5IHRoZSBgb2JzaWRpYW4tZGV2LXV0aWxzYCBsaWJyYXJ5LlxuICovXG5cbi8qKlxuICogQ1NTIGNsYXNzZXMgdXNlZCBieSB0aGUgYG9ic2lkaWFuLWRldi11dGlsc2AgbGlicmFyeS5cbiAqL1xuZXhwb3J0IGVudW0gQ3NzQ2xhc3Mge1xuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSBhbGVydCBtb2RhbC5cbiAgICovXG4gIEFsZXJ0TW9kYWwgPSAnYWxlcnQtbW9kYWwnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIGNhbmNlbCBidXR0b24uXG4gICAqL1xuICBDYW5jZWxCdXR0b24gPSAnY2FuY2VsLWJ1dHRvbicsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgY2hlY2tib3ggY29tcG9uZW50LlxuICAgKi9cbiAgQ2hlY2tib3hDb21wb25lbnQgPSAnY2hlY2tib3gtY29tcG9uZW50JyxcblxuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSBjb2RlIGhpZ2hsaWdodGVyIGNvbXBvbmVudC5cbiAgICovXG4gIENvZGVIaWdobGlnaHRlckNvbXBvbmVudCA9ICdjb2RlLWhpZ2hsaWdodGVyLWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgY29uZmlybSBtb2RhbC5cbiAgICovXG4gIENvbmZpcm1Nb2RhbCA9ICdjb25maXJtLW1vZGFsJyxcblxuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSBkYXRlIGNvbXBvbmVudC5cbiAgICovXG4gIERhdGVDb21wb25lbnQgPSAnZGF0ZS1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIGRhdGUgYW5kIHRpbWUgY29tcG9uZW50LlxuICAgKi9cbiAgRGF0ZVRpbWVDb21wb25lbnQgPSAnZGF0ZXRpbWUtY29tcG9uZW50JyxcblxuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSBlbWFpbCBjb21wb25lbnQuXG4gICAqL1xuICBFbWFpbENvbXBvbmVudCA9ICdlbWFpbC1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIGZpbGUgY29tcG9uZW50LlxuICAgKi9cbiAgRmlsZUNvbXBvbmVudCA9ICdmaWxlLWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgcGxhY2Vob2xkZXIuXG4gICAqL1xuICBJc1BsYWNlaG9sZGVyID0gJ2lzLXBsYWNlaG9sZGVyJyxcblxuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSBsaWJyYXJ5IG5hbWUuXG4gICAqL1xuICBMaWJyYXJ5TmFtZSA9ICdvYnNpZGlhbi1kZXYtdXRpbHMnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIG1vbnRoIGNvbXBvbmVudC5cbiAgICovXG4gIE1vbnRoQ29tcG9uZW50ID0gJ21vbnRoLWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgbXVsdGlwbGUgZHJvcGRvd24gY29tcG9uZW50LlxuICAgKi9cbiAgTXVsdGlwbGVEcm9wZG93bkNvbXBvbmVudCA9ICdtdWx0aXBsZS1kcm9wZG93bi1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIG11bHRpcGxlIGVtYWlsIGNvbXBvbmVudC5cbiAgICovXG4gIE11bHRpcGxlRW1haWxDb21wb25lbnQgPSAnbXVsdGlwbGUtZW1haWwtY29tcG9uZW50JyxcblxuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSBtdWx0aXBsZSBmaWxlIGNvbXBvbmVudC5cbiAgICovXG4gIE11bHRpcGxlRmlsZUNvbXBvbmVudCA9ICdtdWx0aXBsZS1maWxlLWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgbXVsdGlwbGUgdGV4dCBjb21wb25lbnQuXG4gICAqL1xuICBNdWx0aXBsZVRleHRDb21wb25lbnQgPSAnbXVsdGlwbGUtdGV4dC1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIG51bWJlciBjb21wb25lbnQuXG4gICAqL1xuICBOdW1iZXJDb21wb25lbnQgPSAnbnVtYmVyLWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgb2sgYnV0dG9uLlxuICAgKi9cbiAgT2tCdXR0b24gPSAnb2stYnV0dG9uJyxcblxuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSBvdmVybGF5IHZhbGlkYXRvci5cbiAgICovXG4gIE92ZXJsYXlWYWxpZGF0b3IgPSAnb3ZlcmxheS12YWxpZGF0b3InLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIHBhc3N3b3JkIGNvbXBvbmVudC5cbiAgICovXG4gIFBhc3N3b3JkQ29tcG9uZW50ID0gJ3Bhc3N3b3JkLWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgcGx1Z2luIHNldHRpbmdzIHRhYi5cbiAgICovXG4gIFBsdWdpblNldHRpbmdzVGFiID0gJ3BsdWdpbi1zZXR0aW5ncy10YWInLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIHByb21wdCBtb2RhbC5cbiAgICovXG4gIFByb21wdE1vZGFsID0gJ3Byb21wdC1tb2RhbCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgc2VsZWN0IGl0ZW0gbW9kYWwuXG4gICAqL1xuICBTZWxlY3RJdGVtTW9kYWwgPSAnc2VsZWN0LWl0ZW0tbW9kYWwnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIHNldHRpbmcgY29tcG9uZW50IHdyYXBwZXIuXG4gICAqL1xuICBTZXR0aW5nQ29tcG9uZW50V3JhcHBlciA9ICdzZXR0aW5nLWNvbXBvbmVudC13cmFwcGVyJyxcblxuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSB0ZWxlcGhvbmUgY29tcG9uZW50LlxuICAgKi9cbiAgVGVsZXBob25lQ29tcG9uZW50ID0gJ3RlbGVwaG9uZS1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIHRleHQgYm94LlxuICAgKi9cbiAgVGV4dEJveCA9ICd0ZXh0LWJveCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgdGltZSBjb21wb25lbnQuXG4gICAqL1xuICBUaW1lQ29tcG9uZW50ID0gJ3RpbWUtY29tcG9uZW50JyxcblxuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSB0b29sdGlwLlxuICAgKi9cbiAgVG9vbHRpcCA9ICd0b29sdGlwJyxcblxuICAvKipcbiAgICogQSBDU1MgY2xhc3MgZm9yIHRoZSB0b29sdGlwIGFycm93LlxuICAgKi9cbiAgVG9vbHRpcEFycm93ID0gJ3Rvb2x0aXAtYXJyb3cnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIHRvb2x0aXAgdmFsaWRhdG9yLlxuICAgKi9cbiAgVG9vbHRpcFZhbGlkYXRvciA9ICd0b29sdGlwLXZhbGlkYXRvcicsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgdHJpLXN0YXRlIGNoZWNrYm94IGNvbXBvbmVudC5cbiAgICovXG4gIFRyaVN0YXRlQ2hlY2tib3hDb21wb25lbnQgPSAndHJpLXN0YXRlLWNoZWNrYm94LWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgdHlwZWQgZHJvcGRvd24gY29tcG9uZW50LlxuICAgKi9cbiAgVHlwZWREcm9wZG93bkNvbXBvbmVudCA9ICd0eXBlZC1kcm9wZG93bi1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIHR5cGVkIG11bHRpcGxlIGRyb3Bkb3duIGNvbXBvbmVudC5cbiAgICovXG4gIFR5cGVkTXVsdGlwbGVEcm9wZG93bkNvbXBvbmVudCA9ICd0eXBlZC1tdWx0aXBsZS1kcm9wZG93bi1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBBIENTUyBjbGFzcyBmb3IgdGhlIHVybCBjb21wb25lbnQuXG4gICAqL1xuICBVcmxDb21wb25lbnQgPSAndXJsLWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIEEgQ1NTIGNsYXNzIGZvciB0aGUgd2VlayBjb21wb25lbnQuXG4gICAqL1xuICBXZWVrQ29tcG9uZW50ID0gJ3dlZWstY29tcG9uZW50J1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBU08sSUFBSyxXQUFMLGtCQUFLQSxjQUFMO0FBSUwsRUFBQUEsVUFBQSxnQkFBYTtBQUtiLEVBQUFBLFVBQUEsa0JBQWU7QUFLZixFQUFBQSxVQUFBLHVCQUFvQjtBQUtwQixFQUFBQSxVQUFBLDhCQUEyQjtBQUszQixFQUFBQSxVQUFBLGtCQUFlO0FBS2YsRUFBQUEsVUFBQSxtQkFBZ0I7QUFLaEIsRUFBQUEsVUFBQSx1QkFBb0I7QUFLcEIsRUFBQUEsVUFBQSxvQkFBaUI7QUFLakIsRUFBQUEsVUFBQSxtQkFBZ0I7QUFLaEIsRUFBQUEsVUFBQSxtQkFBZ0I7QUFLaEIsRUFBQUEsVUFBQSxpQkFBYztBQUtkLEVBQUFBLFVBQUEsb0JBQWlCO0FBS2pCLEVBQUFBLFVBQUEsK0JBQTRCO0FBSzVCLEVBQUFBLFVBQUEsNEJBQXlCO0FBS3pCLEVBQUFBLFVBQUEsMkJBQXdCO0FBS3hCLEVBQUFBLFVBQUEsMkJBQXdCO0FBS3hCLEVBQUFBLFVBQUEscUJBQWtCO0FBS2xCLEVBQUFBLFVBQUEsY0FBVztBQUtYLEVBQUFBLFVBQUEsc0JBQW1CO0FBS25CLEVBQUFBLFVBQUEsdUJBQW9CO0FBS3BCLEVBQUFBLFVBQUEsdUJBQW9CO0FBS3BCLEVBQUFBLFVBQUEsaUJBQWM7QUFLZCxFQUFBQSxVQUFBLHFCQUFrQjtBQUtsQixFQUFBQSxVQUFBLDZCQUEwQjtBQUsxQixFQUFBQSxVQUFBLHdCQUFxQjtBQUtyQixFQUFBQSxVQUFBLGFBQVU7QUFLVixFQUFBQSxVQUFBLG1CQUFnQjtBQUtoQixFQUFBQSxVQUFBLGFBQVU7QUFLVixFQUFBQSxVQUFBLGtCQUFlO0FBS2YsRUFBQUEsVUFBQSxzQkFBbUI7QUFLbkIsRUFBQUEsVUFBQSwrQkFBNEI7QUFLNUIsRUFBQUEsVUFBQSw0QkFBeUI7QUFLekIsRUFBQUEsVUFBQSxvQ0FBaUM7QUFLakMsRUFBQUEsVUFBQSxrQkFBZTtBQUtmLEVBQUFBLFVBQUEsbUJBQWdCO0FBOUtOLFNBQUFBO0FBQUEsR0FBQTsiLAogICJuYW1lcyI6IFsiQ3NzQ2xhc3MiXQp9Cg==

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

@@ -0,0 +1,47 @@
+/**
+ * @packageDocumentation
+ *
+ * Contains utility functions for debugging.
+ */
+import type { Debugger } from 'debug';
+import type { DebugController } from './debug-controller.mjs';
+/**
+ * Enables the debuggers for the `obsidian-dev-utils` library.
+ */
+export declare function enableLibraryDebuggers(): void;
+/**
+ * Returns a debug controller.
+ *
+ * @returns A debug controller.
+ */
+export declare function getDebugController(): DebugController;
+/**
+ * Returns a debugger instance with a log function that includes the caller's file name and line number.
+ *
+ * @param namespace - The namespace for the debugger instance.
+ * @param framesToSkip - The number of frames to skip in the stack trace.
+ * @returns A debugger instance with a log function that includes the caller's file name and line number.
+ */
+export declare function getDebugger(namespace: string, framesToSkip?: number): Debugger;
+/**
+ * Returns a debugger instance for the `obsidian-dev-utils` library.
+ *
+ * @param namespace - The namespace for the debugger instance.
+ * @returns A debugger instance for the `obsidian-dev-utils` library.
+ */
+export declare function getLibDebugger(namespace: string): Debugger;
+/**
+ * Prints a message with a stack trace.
+ *
+ * @param debuggerInstance - The debugger instance.
+ * @param stackTrace - The stack trace to print.
+ * @param message - The message to print.
+ * @param args - The arguments to print.
+ */
+export declare function printWithStackTrace(debuggerInstance: Debugger, stackTrace: string, message: string, ...args: unknown[]): void;
+/**
+ * Shows an initial debug message.
+ *
+ * @param pluginId - The plugin ID.
+ */
+export declare function showInitialDebugMessage(pluginId: string): void;

package/dist/lib/esm/debug.mjs

@@ -0,0 +1,152 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import debug from "debug";
+import { CustomStackTraceError } from "./error.mjs";
+import { LIBRARY_NAME } from "./library.mjs";
+import { getObsidianDevUtilsState } from "./obsidian/app.mjs";
+import {
+  getPluginId,
+  NO_PLUGIN_ID_INITIALIZED
+} from "./obsidian/plugin/plugin-id.mjs";
+const NAMESPACE_SEPARATOR = ",";
+const NEGATED_NAMESPACE_PREFIX = "-";
+function enableLibraryDebuggers() {
+  enableNamespaces([LIBRARY_NAME, `${LIBRARY_NAME}:*`]);
+}
+function getDebugController() {
+  return {
+    disable: disableNamespaces,
+    enable: enableNamespaces,
+    get: getNamespaces,
+    set: setNamespaces
+  };
+}
+function getDebugger(namespace, framesToSkip = 0) {
+  const key = `${namespace}:${String(framesToSkip)}`;
+  const debuggersMap = getObsidianDevUtilsState(null, "debuggers", /* @__PURE__ */ new Map()).value;
+  let debuggerEx = debuggersMap.get(key);
+  if (!debuggerEx) {
+    debuggerEx = getSharedDebugLibInstance()(namespace);
+    debuggerEx.log = (message, ...args) => {
+      logWithCaller(namespace, framesToSkip, message, ...args);
+    };
+    debuggersMap.set(key, debuggerEx);
+  }
+  return debuggerEx;
+}
+function getLibDebugger(namespace) {
+  const pluginId = getPluginId();
+  const prefix = pluginId === NO_PLUGIN_ID_INITIALIZED ? "" : `${pluginId}:`;
+  return getDebugger(`${prefix}${LIBRARY_NAME}:${namespace}`);
+}
+function printWithStackTrace(debuggerInstance, stackTrace, message, ...args) {
+  if (!isInObsidian()) {
+    debuggerInstance(message, ...args);
+    return;
+  }
+  debuggerInstance(message, ...args, "\n\n---\nContext stack trace:\n", makeStackTraceError(stackTrace));
+}
+function showInitialDebugMessage(pluginId) {
+  const isEnabled = getSharedDebugLibInstance().enabled(pluginId);
+  const state = isEnabled ? "enabled" : "disabled";
+  const changeAction = isEnabled ? "disable" : "enable";
+  const namespaces = getNamespaces();
+  setNamespaces(pluginId);
+  getDebugger(pluginId)(
+    `Debug messages for plugin ${pluginId} are ${state}. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md how to ${changeAction} them.`
+  );
+  setNamespaces(namespaces);
+}
+function disableNamespaces(namespaces) {
+  const set = new Set(getNamespaces());
+  for (const namespace of toArray(namespaces)) {
+    if (namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {
+      continue;
+    }
+    const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;
+    if (set.has(namespace)) {
+      set.delete(namespace);
+    }
+    set.add(negatedNamespace);
+  }
+  setNamespaces(Array.from(set));
+}
+function enableNamespaces(namespaces) {
+  const set = new Set(getNamespaces());
+  for (const namespace of toArray(namespaces)) {
+    if (!namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {
+      const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;
+      if (set.has(negatedNamespace)) {
+        set.delete(negatedNamespace);
+      }
+    }
+    set.add(namespace);
+  }
+  setNamespaces(Array.from(set));
+}
+function getNamespaces() {
+  return toArray(getSharedDebugLibInstance().load() ?? "");
+}
+function getSharedDebugLibInstance() {
+  if (typeof window === "undefined") {
+    return debug;
+  }
+  return getObsidianDevUtilsState(null, "debug", debug).value;
+}
+function isInObsidian() {
+  return typeof window !== "undefined";
+}
+function logWithCaller(namespace, framesToSkip, message, ...args) {
+  if (!getSharedDebugLibInstance().enabled(namespace)) {
+    return;
+  }
+  if (!isInObsidian()) {
+    console.debug(message, ...args);
+    return;
+  }
+  const CALLER_LINE_INDEX = 4;
+  const stackLines = new Error().stack?.split("\n") ?? [];
+  stackLines.splice(0, CALLER_LINE_INDEX + framesToSkip);
+  console.debug(message, ...args, "\n\n---\nLogger stack trace:\n", makeStackTraceError(stackLines.join("\n")));
+}
+function makeStackTraceError(stackTrace) {
+  return new CustomStackTraceError(
+    "Debug mode: intentional placeholder error. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md.",
+    stackTrace,
+    void 0
+  );
+}
+function setNamespaces(namespaces) {
+  getSharedDebugLibInstance().enable(toArray(namespaces).join(NAMESPACE_SEPARATOR));
+}
+function toArray(namespaces) {
+  return typeof namespaces === "string" ? namespaces.split(NAMESPACE_SEPARATOR).filter(Boolean) : namespaces.flatMap(toArray);
+}
+export {
+  enableLibraryDebuggers,
+  getDebugController,
+  getDebugger,
+  getLibDebugger,
+  printWithStackTrace,
+  showInitialDebugMessage
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/debug.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for debugging.\n */\n\nimport type { Debugger } from 'debug';\n\nimport debug from 'debug';\n\nimport type { DebugController } from './debug-controller.ts';\n\nimport { CustomStackTraceError } from './error.ts';\nimport { LIBRARY_NAME } from './library.ts';\nimport { getObsidianDevUtilsState } from './obsidian/app.ts';\nimport {\n  getPluginId,\n  NO_PLUGIN_ID_INITIALIZED\n} from './obsidian/plugin/plugin-id.ts';\n\nconst NAMESPACE_SEPARATOR = ',';\nconst NEGATED_NAMESPACE_PREFIX = '-';\n\n/**\n * Enables the debuggers for the `obsidian-dev-utils` library.\n */\nexport function enableLibraryDebuggers(): void {\n  enableNamespaces([LIBRARY_NAME, `${LIBRARY_NAME}:*`]);\n}\n\n/**\n * Returns a debug controller.\n *\n * @returns A debug controller.\n */\nexport function getDebugController(): DebugController {\n  return {\n    disable: disableNamespaces,\n    enable: enableNamespaces,\n    get: getNamespaces,\n    set: setNamespaces\n  };\n}\n\n/**\n * Returns a debugger instance with a log function that includes the caller's file name and line number.\n *\n * @param namespace - The namespace for the debugger instance.\n * @param framesToSkip - The number of frames to skip in the stack trace.\n * @returns A debugger instance with a log function that includes the caller's file name and line number.\n */\nexport function getDebugger(namespace: string, framesToSkip = 0): Debugger {\n  const key = `${namespace}:${String(framesToSkip)}`;\n  const debuggersMap = getObsidianDevUtilsState(null, 'debuggers', new Map<string, Debugger>()).value;\n  let debuggerEx = debuggersMap.get(key);\n  if (!debuggerEx) {\n    debuggerEx = getSharedDebugLibInstance()(namespace);\n    debuggerEx.log = (message: string, ...args: unknown[]): void => {\n      logWithCaller(namespace, framesToSkip, message, ...args);\n    };\n\n    debuggersMap.set(key, debuggerEx);\n  }\n\n  return debuggerEx;\n}\n\n/**\n * Returns a debugger instance for the `obsidian-dev-utils` library.\n *\n * @param namespace - The namespace for the debugger instance.\n * @returns A debugger instance for the `obsidian-dev-utils` library.\n */\nexport function getLibDebugger(namespace: string): Debugger {\n  const pluginId = getPluginId();\n  const prefix = pluginId === NO_PLUGIN_ID_INITIALIZED ? '' : `${pluginId}:`;\n  return getDebugger(`${prefix}${LIBRARY_NAME}:${namespace}`);\n}\n\n/**\n * Prints a message with a stack trace.\n *\n * @param debuggerInstance - The debugger instance.\n * @param stackTrace - The stack trace to print.\n * @param message - The message to print.\n * @param args - The arguments to print.\n */\nexport function printWithStackTrace(debuggerInstance: Debugger, stackTrace: string, message: string, ...args: unknown[]): void {\n  /* v8 ignore start -- Only the true branch is taken in Node tests (window is undefined). */\n  if (!isInObsidian()) {\n    /* v8 ignore stop */\n    debuggerInstance(message, ...args);\n    return;\n  }\n\n  /* v8 ignore start -- Only reachable in Obsidian (window defined). */\n  debuggerInstance(message, ...args, '\\n\\n---\\nContext stack trace:\\n', makeStackTraceError(stackTrace));\n  /* v8 ignore stop */\n}\n\n/**\n * Shows an initial debug message.\n *\n * @param pluginId - The plugin ID.\n */\nexport function showInitialDebugMessage(pluginId: string): void {\n  const isEnabled = getSharedDebugLibInstance().enabled(pluginId);\n  const state = isEnabled ? 'enabled' : 'disabled';\n  const changeAction = isEnabled ? 'disable' : 'enable';\n  const namespaces = getNamespaces();\n  setNamespaces(pluginId);\n  getDebugger(pluginId)(\n    `Debug messages for plugin ${pluginId} are ${state}. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md how to ${changeAction} them.`\n  );\n  setNamespaces(namespaces);\n}\n\nfunction disableNamespaces(namespaces: string | string[]): void {\n  const set = new Set(getNamespaces());\n  for (const namespace of toArray(namespaces)) {\n    if (namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {\n      continue;\n    }\n    const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;\n    if (set.has(namespace)) {\n      set.delete(namespace);\n    }\n    set.add(negatedNamespace);\n  }\n  setNamespaces(Array.from(set));\n}\n\nfunction enableNamespaces(namespaces: string | string[]): void {\n  const set = new Set(getNamespaces());\n  for (const namespace of toArray(namespaces)) {\n    if (!namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {\n      const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;\n      if (set.has(negatedNamespace)) {\n        set.delete(negatedNamespace);\n      }\n    }\n    set.add(namespace);\n  }\n  setNamespaces(Array.from(set));\n}\n\nfunction getNamespaces(): string[] {\n  return toArray(getSharedDebugLibInstance().load() ?? '');\n}\n\nfunction getSharedDebugLibInstance(): typeof debug {\n  /* v8 ignore start -- In Node tests, window is always undefined. */\n  if (typeof window === 'undefined') {\n    /* v8 ignore stop */\n    return debug;\n  }\n  /* v8 ignore start -- Only reachable in Obsidian (window defined). */\n  return getObsidianDevUtilsState(null, 'debug', debug).value;\n  /* v8 ignore stop */\n}\n\nfunction isInObsidian(): boolean {\n  return typeof window !== 'undefined';\n}\n\nfunction logWithCaller(namespace: string, framesToSkip: number, message: string, ...args: unknown[]): void {\n  if (!getSharedDebugLibInstance().enabled(namespace)) {\n    return;\n  }\n\n  /* v8 ignore start -- Only the true branch is taken in Node tests (window is undefined). */\n  if (!isInObsidian()) {\n    /* v8 ignore stop */\n    console.debug(message, ...args);\n    return;\n  }\n\n  /* v8 ignore start -- Only reachable in Obsidian (window defined). */\n  /**\n   * A caller line index is 4 because the call stack is as follows:\n   *\n   * 0: Error\n   * 1:     at logWithCaller (?:?:?)\n   * 2:     at debugInstance.log (?:?:?)\n   * 3:     at debug (?:?:?)\n   * 4:     at functionName (path/to/caller.js:?:?)\n   */\n  const CALLER_LINE_INDEX = 4;\n\n  const stackLines = new Error().stack?.split('\\n') ?? [];\n  stackLines.splice(0, CALLER_LINE_INDEX + framesToSkip);\n\n  console.debug(message, ...args, '\\n\\n---\\nLogger stack trace:\\n', makeStackTraceError(stackLines.join('\\n')));\n  /* v8 ignore stop */\n}\n\n/* v8 ignore start -- Only used in Obsidian context. */\nfunction makeStackTraceError(stackTrace: string): CustomStackTraceError {\n  return new CustomStackTraceError(\n    'Debug mode: intentional placeholder error. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md.',\n    stackTrace,\n    undefined\n  );\n}\n/* v8 ignore stop */\n\n/**\n * Sets the namespaces to enable.\n *\n * @param namespaces - The namespaces to enable.\n */\nfunction setNamespaces(namespaces: string | string[]): void {\n  getSharedDebugLibInstance().enable(toArray(namespaces).join(NAMESPACE_SEPARATOR));\n}\n\nfunction toArray(namespaces: string | string[]): string[] {\n  return typeof namespaces === 'string' ? namespaces.split(NAMESPACE_SEPARATOR).filter(Boolean) : namespaces.flatMap(toArray);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/enum.mjs

@@ -0,0 +1,33 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { ensureNonNullable } from "./type-guards.mjs";
+function getEnumKey(enumType, value) {
+  return ensureNonNullable(Object.keys(enumType).find((k) => enumType[k] === value), `Invalid enum value: ${value}`);
+}
+function getEnumValue(enumType, key) {
+  return ensureNonNullable(enumType[key], `Invalid enum key: ${key}`);
+}
+export {
+  getEnumKey,
+  getEnumValue
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VudW0udHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uXG4gKlxuICogQ29udGFpbnMgdXRpbGl0eSBmdW5jdGlvbnMgZm9yIGVudW1zLlxuICovXG5cbmltcG9ydCB7IGVuc3VyZU5vbk51bGxhYmxlIH0gZnJvbSAnLi90eXBlLWd1YXJkcy50cyc7XG5cbi8qKlxuICogR2V0IHRoZSBrZXkgb2YgYW4gZW51bSB2YWx1ZS5cbiAqXG4gKiBAcGFyYW0gZW51bVR5cGUgLSBUaGUgZW51bSB0eXBlLlxuICogQHBhcmFtIHZhbHVlIC0gVGhlIHZhbHVlIHRvIGdldCB0aGUga2V5IG9mLlxuICogQHJldHVybnMgVGhlIGtleSBvZiB0aGUgZW51bSB2YWx1ZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldEVudW1LZXk8VCBleHRlbmRzIFJlY29yZDxzdHJpbmcsIHN0cmluZz4+KGVudW1UeXBlOiBULCB2YWx1ZTogVFtrZXlvZiBUXSk6IGtleW9mIFQge1xuICByZXR1cm4gZW5zdXJlTm9uTnVsbGFibGUoT2JqZWN0LmtleXMoZW51bVR5cGUpLmZpbmQoKGspID0+IGVudW1UeXBlW2tdID09PSB2YWx1ZSksIGBJbnZhbGlkIGVudW0gdmFsdWU6ICR7dmFsdWV9YCkgYXMga2V5b2YgVDtcbn1cblxuLyoqXG4gKiBHZXQgdGhlIHZhbHVlIG9mIGFuIGVudW0ga2V5LlxuICpcbiAqIEBwYXJhbSBlbnVtVHlwZSAtIFRoZSBlbnVtIHR5cGUuXG4gKiBAcGFyYW0ga2V5IC0gVGhlIGtleSB0byBnZXQgdGhlIHZhbHVlIG9mLlxuICogQHJldHVybnMgVGhlIHZhbHVlIG9mIHRoZSBlbnVtIGtleS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldEVudW1WYWx1ZTxUIGV4dGVuZHMgUmVjb3JkPHN0cmluZywgc3RyaW5nPj4oZW51bVR5cGU6IFQsIGtleTogc3RyaW5nKTogVFtrZXlvZiBUXSB7XG4gIHJldHVybiBlbnN1cmVOb25OdWxsYWJsZShlbnVtVHlwZVtrZXldLCBgSW52YWxpZCBlbnVtIGtleTogJHtrZXl9YCkgYXMgVFtrZXlvZiBUXTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQU1BLFNBQVMseUJBQXlCO0FBUzNCLFNBQVMsV0FBNkMsVUFBYSxPQUE0QjtBQUNwRyxTQUFPLGtCQUFrQixPQUFPLEtBQUssUUFBUSxFQUFFLEtBQUssQ0FBQyxNQUFNLFNBQVMsQ0FBQyxNQUFNLEtBQUssR0FBRyx1QkFBdUIsS0FBSyxFQUFFO0FBQ25IO0FBU08sU0FBUyxhQUErQyxVQUFhLEtBQXlCO0FBQ25HLFNBQU8sa0JBQWtCLFNBQVMsR0FBRyxHQUFHLHFCQUFxQixHQUFHLEVBQUU7QUFDcEU7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/error.mjs

@@ -0,0 +1,131 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import { AsyncEvents } from "./async-events.mjs";
+import { ensureNonNullable } from "./type-guards.mjs";
+const ASYNC_ERROR_EVENT = "asyncError";
+const asyncErrorEventEmitter = new AsyncEvents();
+asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);
+const ASYNC_WRAPPER_ERROR_MESSAGE = "An unhandled error occurred executing async operation";
+const STACK_TRACE_PREFIX = "    at";
+class CustomStackTraceError extends Error {
+  /**
+   * Creates a new CustomStackTraceError.
+   *
+   * @param message - The message of the error.
+   * @param stackTrace - The stack trace of the error.
+   * @param cause - The cause of the error.
+   */
+  constructor(message, stackTrace, cause) {
+    super(message, { cause });
+    this.name = "CustomStackTraceError";
+    Error.captureStackTrace?.(this, CustomStackTraceError);
+    let rootCause = cause;
+    const parentCauses = /* @__PURE__ */ new Set();
+    while (rootCause instanceof CustomStackTraceError) {
+      if (parentCauses.has(rootCause)) {
+        throw new Error("Circular cause detected");
+      }
+      parentCauses.add(rootCause);
+      rootCause = rootCause.cause;
+    }
+    const originalStackLines = ensureNonNullable(this.stack).split("\n");
+    const stackLines = stackTrace.split("\n");
+    const ERROR_HEADER_REG_EXP = /^\w*Error(?:: |$)/;
+    if (ERROR_HEADER_REG_EXP.test(ensureNonNullable(stackLines[0]))) {
+      stackLines.splice(0, 1);
+    }
+    originalStackLines.splice(1, originalStackLines.length - 1, ...stackLines);
+    this.stack = originalStackLines.join("\n");
+  }
+}
+class SilentError extends Error {
+  /**
+   * Creates a new SilentError.
+   *
+   * @param message - The message of the error.
+   */
+  constructor(message) {
+    super(message);
+    this.name = "SilentError";
+    Error.captureStackTrace?.(this, SilentError);
+  }
+}
+function emitAsyncErrorEvent(asyncError) {
+  asyncErrorEventEmitter.trigger(ASYNC_ERROR_EVENT, asyncError);
+}
+function errorToString(error) {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  let message = error.stack ?? `${error.name}: ${error.message}`;
+  if (error.cause !== void 0) {
+    const causeStrLines = errorToString(error.cause).split("\n");
+    message += `
+${generateStackTraceLine("Caused by:")}`;
+    for (const line of causeStrLines) {
+      if (!line.trim()) {
+        continue;
+      }
+      message += line.startsWith(STACK_TRACE_PREFIX) ? `
+${line}` : `
+${generateStackTraceLine(line)}`;
+    }
+  }
+  return message;
+}
+function getStackTrace(framesToSkip = 0) {
+  const ADDITIONAL_FRAMES_TO_SKIP = 2;
+  const stack = ensureNonNullable(new Error().stack);
+  const lines = stack.split("\n");
+  return lines.slice(framesToSkip + ADDITIONAL_FRAMES_TO_SKIP).join("\n");
+}
+function printError(error, console) {
+  console ??= globalThis.console;
+  console.error(errorToString(error));
+}
+function registerAsyncErrorEventHandler(handler) {
+  const eventRef = asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);
+  return () => {
+    asyncErrorEventEmitter.offref(eventRef);
+  };
+}
+function throwExpression(error) {
+  throw error;
+}
+function generateStackTraceLine(title) {
+  return `${STACK_TRACE_PREFIX} --- ${title} --- (0)`;
+}
+function handleAsyncError(asyncError) {
+  printError(asyncError);
+}
+export {
+  ASYNC_WRAPPER_ERROR_MESSAGE,
+  CustomStackTraceError,
+  SilentError,
+  emitAsyncErrorEvent,
+  errorToString,
+  getStackTrace,
+  printError,
+  registerAsyncErrorEventHandler,
+  throwExpression
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/error.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for error handling.\n */\n\nimport { AsyncEvents } from './async-events.ts';\nimport { ensureNonNullable } from './type-guards.ts';\n\nconst ASYNC_ERROR_EVENT = 'asyncError';\n\nconst asyncErrorEventEmitter = new AsyncEvents();\nasyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);\n\n/**\n * A message of the AsyncWrapperError.\n */\nexport const ASYNC_WRAPPER_ERROR_MESSAGE = 'An unhandled error occurred executing async operation';\n\nconst STACK_TRACE_PREFIX = '    at';\n\n/**\n * An error that wraps an error with a custom stack trace.\n */\nexport class CustomStackTraceError extends Error {\n  /**\n   * Creates a new CustomStackTraceError.\n   *\n   * @param message - The message of the error.\n   * @param stackTrace - The stack trace of the error.\n   * @param cause - The cause of the error.\n   */\n  public constructor(message: string, stackTrace: string, cause: unknown) {\n    super(message, { cause });\n    this.name = 'CustomStackTraceError';\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `?.` is used to support iOS before 17.2.\n    Error.captureStackTrace?.(this, CustomStackTraceError);\n\n    let rootCause = cause;\n    const parentCauses = new Set<CustomStackTraceError>();\n    while (rootCause instanceof CustomStackTraceError) {\n      if (parentCauses.has(rootCause)) {\n        throw new Error('Circular cause detected');\n      }\n      parentCauses.add(rootCause);\n      rootCause = rootCause.cause;\n    }\n\n    const originalStackLines = ensureNonNullable(this.stack).split('\\n');\n    const stackLines = stackTrace.split('\\n');\n    const ERROR_HEADER_REG_EXP = /^\\w*Error(?:: |$)/;\n    if (ERROR_HEADER_REG_EXP.test(ensureNonNullable(stackLines[0]))) {\n      stackLines.splice(0, 1);\n    }\n    originalStackLines.splice(1, originalStackLines.length - 1, ...stackLines);\n    this.stack = originalStackLines.join('\\n');\n  }\n}\n\n/**\n * An error that is not printed to the console.\n */\nexport class SilentError extends Error {\n  /**\n   * Creates a new SilentError.\n   *\n   * @param message - The message of the error.\n   */\n  public constructor(message: string) {\n    super(message);\n    this.name = 'SilentError';\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `?.` is used to support iOS before 17.2.\n    Error.captureStackTrace?.(this, SilentError);\n  }\n}\n\n/**\n * Emits an asynchronous error event.\n *\n * @param asyncError - The error to emit as an asynchronous error event.\n */\nexport function emitAsyncErrorEvent(asyncError: unknown): void {\n  asyncErrorEventEmitter.trigger(ASYNC_ERROR_EVENT, asyncError);\n}\n\n/**\n * Converts an error to a string representation, including nested causes with indentation.\n *\n * @param error - The error to convert to a string.\n * @returns The string representation of the error.\n */\nexport function errorToString(error: unknown): string {\n  if (!(error instanceof Error)) {\n    return String(error);\n  }\n\n  let message = error.stack ?? `${error.name}: ${error.message}`;\n  if (error.cause !== undefined) {\n    const causeStrLines = errorToString(error.cause).split('\\n');\n    message += `\\n${generateStackTraceLine('Caused by:')}`;\n    for (const line of causeStrLines) {\n      if (!line.trim()) {\n        continue;\n      }\n      message += line.startsWith(STACK_TRACE_PREFIX)\n        ? `\\n${line}`\n        : `\\n${generateStackTraceLine(line)}`;\n    }\n  }\n  return message;\n}\n\n/**\n * Gets the current stack trace as a string, excluding the current function call.\n *\n * @param framesToSkip - The number of frames to skip in the stack trace.\n * @returns A string representation of the current stack trace, excluding the current function call.\n */\nexport function getStackTrace(framesToSkip = 0): string {\n  // Skipping Error prefix and `getStackTrace` function call\n  const ADDITIONAL_FRAMES_TO_SKIP = 2;\n  const stack = ensureNonNullable(new Error().stack);\n  const lines = stack.split('\\n');\n  return lines.slice(framesToSkip + ADDITIONAL_FRAMES_TO_SKIP).join('\\n');\n}\n\n/**\n * Prints an error to the console, including nested causes and optional ANSI sequence clearing.\n *\n * @param error - The error to print.\n * @param console - The console to print to (default: `globalThis.console`).\n */\nexport function printError(error: unknown, console?: Console): void {\n  console ??= globalThis.console;\n  console.error(errorToString(error));\n}\n\n/**\n * Registers an event handler for asynchronous errors.\n *\n * @param handler - The handler function to be called when an asynchronous error event occurs.\n * @returns A function to unregister the handler.\n */\nexport function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): () => void {\n  const eventRef = asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);\n  return () => {\n    asyncErrorEventEmitter.offref(eventRef);\n  };\n}\n\n/**\n * Throws an error with the specified message.\n *\n * @param error - The error to throw.\n * @throws\n */\nexport function throwExpression(error: unknown): never {\n  throw error;\n}\n\nfunction generateStackTraceLine(title: string): string {\n  return `${STACK_TRACE_PREFIX} --- ${title} --- (0)`;\n}\n\n/**\n * Handles asynchronous errors by printing them.\n *\n * @param asyncError - The asynchronous error to handle.\n */\nfunction handleAsyncError(asyncError: unknown): void {\n  printError(asyncError);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,mBAAmB;AAC5B,SAAS,yBAAyB;AAElC,MAAM,oBAAoB;AAE1B,MAAM,yBAAyB,IAAI,YAAY;AAC/C,uBAAuB,GAAG,mBAAmB,gBAAgB;AAKtD,MAAM,8BAA8B;AAE3C,MAAM,qBAAqB;AAKpB,MAAM,8BAA8B,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQxC,YAAY,SAAiB,YAAoB,OAAgB;AACtE,UAAM,SAAS,EAAE,MAAM,CAAC;AACxB,SAAK,OAAO;AAGZ,UAAM,oBAAoB,MAAM,qBAAqB;AAErD,QAAI,YAAY;AAChB,UAAM,eAAe,oBAAI,IAA2B;AACpD,WAAO,qBAAqB,uBAAuB;AACjD,UAAI,aAAa,IAAI,SAAS,GAAG;AAC/B,cAAM,IAAI,MAAM,yBAAyB;AAAA,MAC3C;AACA,mBAAa,IAAI,SAAS;AAC1B,kBAAY,UAAU;AAAA,IACxB;AAEA,UAAM,qBAAqB,kBAAkB,KAAK,KAAK,EAAE,MAAM,IAAI;AACnE,UAAM,aAAa,WAAW,MAAM,IAAI;AACxC,UAAM,uBAAuB;AAC7B,QAAI,qBAAqB,KAAK,kBAAkB,WAAW,CAAC,CAAC,CAAC,GAAG;AAC/D,iBAAW,OAAO,GAAG,CAAC;AAAA,IACxB;AACA,uBAAmB,OAAO,GAAG,mBAAmB,SAAS,GAAG,GAAG,UAAU;AACzE,SAAK,QAAQ,mBAAmB,KAAK,IAAI;AAAA,EAC3C;AACF;AAKO,MAAM,oBAAoB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM9B,YAAY,SAAiB;AAClC,UAAM,OAAO;AACb,SAAK,OAAO;AAGZ,UAAM,oBAAoB,MAAM,WAAW;AAAA,EAC7C;AACF;AAOO,SAAS,oBAAoB,YAA2B;AAC7D,yBAAuB,QAAQ,mBAAmB,UAAU;AAC9D;AAQO,SAAS,cAAc,OAAwB;AACpD,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,WAAO,OAAO,KAAK;AAAA,EACrB;AAEA,MAAI,UAAU,MAAM,SAAS,GAAG,MAAM,IAAI,KAAK,MAAM,OAAO;AAC5D,MAAI,MAAM,UAAU,QAAW;AAC7B,UAAM,gBAAgB,cAAc,MAAM,KAAK,EAAE,MAAM,IAAI;AAC3D,eAAW;AAAA,EAAK,uBAAuB,YAAY,CAAC;AACpD,eAAW,QAAQ,eAAe;AAChC,UAAI,CAAC,KAAK,KAAK,GAAG;AAChB;AAAA,MACF;AACA,iBAAW,KAAK,WAAW,kBAAkB,IACzC;AAAA,EAAK,IAAI,KACT;AAAA,EAAK,uBAAuB,IAAI,CAAC;AAAA,IACvC;AAAA,EACF;AACA,SAAO;AACT;AAQO,SAAS,cAAc,eAAe,GAAW;AAEtD,QAAM,4BAA4B;AAClC,QAAM,QAAQ,kBAAkB,IAAI,MAAM,EAAE,KAAK;AACjD,QAAM,QAAQ,MAAM,MAAM,IAAI;AAC9B,SAAO,MAAM,MAAM,eAAe,yBAAyB,EAAE,KAAK,IAAI;AACxE;AAQO,SAAS,WAAW,OAAgB,SAAyB;AAClE,cAAY,WAAW;AACvB,UAAQ,MAAM,cAAc,KAAK,CAAC;AACpC;AAQO,SAAS,+BAA+B,SAAoD;AACjG,QAAM,WAAW,uBAAuB,GAAG,mBAAmB,OAAO;AACrE,SAAO,MAAM;AACX,2BAAuB,OAAO,QAAQ;AAAA,EACxC;AACF;AAQO,SAAS,gBAAgB,OAAuB;AACrD,QAAM;AACR;AAEA,SAAS,uBAAuB,OAAuB;AACrD,SAAO,GAAG,kBAAkB,QAAQ,KAAK;AAC3C;AAOA,SAAS,iBAAiB,YAA2B;AACnD,aAAW,UAAU;AACvB;",
  "names": []
}


package/dist/lib/esm/function.mjs

@@ -0,0 +1,42 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+function noop() {
+}
+async function noopAsync() {
+}
+function omitAsyncReturnType(fn) {
+  return async (...args) => {
+    await fn(...args);
+  };
+}
+function omitReturnType(fn) {
+  return (...args) => {
+    fn(...args);
+  };
+}
+export {
+  noop,
+  noopAsync,
+  omitAsyncReturnType,
+  omitReturnType
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/html-element.d.mts

@@ -0,0 +1,122 @@
+/**
+ * @packageDocumentation
+ *
+ * Helpers for working with HTML elements.
+ */
+import type { Promisable } from 'type-fest';
+/**
+ * A HTML element that can be validated.
+ */
+export interface ValidatorElement extends HTMLElement {
+    /**
+     * Checks the validity of the element.
+     *
+     * @returns `true` if the element is valid, `false` otherwise.
+     */
+    checkValidity(): boolean;
+    /**
+     * Reports the validity of the element.
+     */
+    reportValidity(): boolean;
+    /**
+     * Sets a custom error message on the element.
+     *
+     * @param error - The error message to set on the element.
+     */
+    setCustomValidity(error: string): void;
+    /**
+     * An error message of the element.
+     */
+    readonly validationMessage: string;
+}
+/**
+ * Appends a code block to the given DocumentFragment or HTMLElement.
+ *
+ * @param el - The DocumentFragment or HTMLElement to append the code block to.
+ * @param code - The code to be displayed in the code block.
+ */
+export declare function appendCodeBlock(el: DocumentFragment | HTMLElement, code: string): void;
+/**
+ * Creates a div asynchronously.
+ *
+ * @param o - The element information.
+ * @param callback - The callback to call when the div is created.
+ * @returns A {@link Promise} that resolves to the div.
+ */
+export declare function createDivAsync(o?: DomElementInfo | string, callback?: (el: HTMLDivElement) => Promisable<void>): Promise<HTMLDivElement>;
+/**
+ * Creates an element asynchronously.
+ *
+ * @param tag - The tag name of the element to create.
+ * @param o - The element information.
+ * @param callback - The callback to call when the element is created.
+ * @returns A {@link Promise} that resolves to the element.
+ */
+export declare function createElAsync<K extends keyof HTMLElementTagNameMap>(tag: K, o?: DomElementInfo | string, callback?: (el: HTMLElementTagNameMap[K]) => Promisable<void>): Promise<HTMLElementTagNameMap[K]>;
+/**
+ * Creates a DocumentFragment asynchronously.
+ *
+ * @param callback - The callback to call when the DocumentFragment is created.
+ * @returns A {@link Promise} that resolves to the DocumentFragment.
+ */
+export declare function createFragmentAsync(callback?: (el: DocumentFragment) => Promisable<void>): Promise<DocumentFragment>;
+/**
+ * Creates a span asynchronously.
+ *
+ * @param o - The element information.
+ * @param callback - The callback to call when the span is created.
+ * @returns A {@link Promise} that resolves to the span.
+ */
+export declare function createSpanAsync(o?: DomElementInfo | string, callback?: (el: HTMLSpanElement) => Promisable<void>): Promise<HTMLSpanElement>;
+/**
+ * Creates a svg asynchronously.
+ *
+ * @param tag - The tag name of the svg to create.
+ * @param o - The svg information.
+ * @param callback - The callback to call when the svg is created.
+ * @returns A {@link Promise} that resolves to the svg.
+ */
+export declare function createSvgAsync<K extends keyof SVGElementTagNameMap>(tag: K, o?: string | SvgElementInfo, callback?: (el: SVGElementTagNameMap[K]) => Promisable<void>): Promise<SVGElementTagNameMap[K]>;
+/**
+ * Ensures that the given element is loaded.
+ *
+ * @param el - The element to ensure is loaded.
+ * @returns A {@link Promise} that resolves when the element is loaded.
+ */
+export declare function ensureLoaded(el: Element): Promise<void>;
+/**
+ * Gets the z-index of the given element.
+ *
+ * @param el - The element to get the z-index of.
+ * @returns The z-index of the element.
+ */
+export declare function getZIndex(el: Element): number;
+/**
+ * Checks if the element is visible in the offset parent.
+ *
+ * @param el - The element to check.
+ * @returns `true` if the element is visible in the offset parent, `false` otherwise.
+ */
+export declare function isElementVisibleInOffsetParent(el: HTMLElement): boolean;
+/**
+ * Checks if the element is loaded.
+ *
+ * @param el - The element to check.
+ * @returns `true` if the element is loaded, `false` otherwise.
+ */
+export declare function isLoaded(el: Element): boolean;
+/**
+ * Adds an event listener to the ancestor nodes of the given node.
+ *
+ * @param node - The node to add the event listener to.
+ * @param callback - The callback to call when the event is triggered.
+ * @returns A function to remove the event listener.
+ */
+export declare function onAncestorScrollOrResize(node: Node, callback: () => void): () => void;
+/**
+ * Converts a number to a string with 'px' appended.
+ *
+ * @param value - The number to convert.
+ * @returns The number as a string with 'px' appended.
+ */
+export declare function toPx(value: number): string;