obsidian-dev-utils 17.10.0 → 17.10.2-beta.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # CHANGELOG
 
+## 17.10.2-beta.1
+
+- Don't replace import.meta.url in esm
+- Refactor require usage
+- Refactor changeExtension
+- Regenerate exports
+- Don't generate cjs/mjs exports for @types folder
+- Move from @types.ts
+- Generate mjs exports
+- Refactor to transformer
+- Warn unknown properties
+
+## 17.10.1
+
+- Simplify styles
+
 ## 17.10.0
 
 - Switch to moment.Duration

package/README.md

@@ -142,6 +142,8 @@ npx obsidian-dev-utils version <versionUpdateType>
 
 Runs build checks before updating the version and releases if all checks pass. The `<versionUpdateType>` can be `major`, `minor`, `patch`, `beta`, or a specific version like `x.y.z[-suffix]`.
 
+If you use `beta` as `<versionUpdateType>` for your Obsidian plugin, the plugin will be deployed compatible to install with [BRAT](https://obsidian.md/plugins?id=obsidian42-brat).
+
 #### Simplified Usage
 
 To simplify the usage of these commands, you can add them to your `package.json`:
@@ -189,7 +191,7 @@ await obsidianDevUtils.obsidian.Modal.Prompt.prompt({
   title: 'Enter your name'
 });
 
-// if you have `moduleResolution` set to `node` in your `tsconfig.json`, you should use the import in the following way:
+// if you have `moduleResolution` set to `node` or `node10` in your `tsconfig.json`, you should use the import in the following way:
 import { prompt } from 'obsidian-dev-utils/dist/lib/obsidian/Modal/Prompt';
 ```
 
@@ -202,7 +204,7 @@ Default styles are defined in [styles.css](https://github.com/mnaoumov/obsidian-
 You can override those styles in your plugin's `styles.css` file via adding your plugin's id to the selector, e.g. for plugin `foo-bar`:
 
 ```css
-.foo-bar.obsidian-dev-utils.plugin-settings-tab .value-component-invalid {
+.foo-bar.obsidian-dev-utils :invalid {
   box-shadow: 0 0 0 2px var(--text-error);
 }
 ```

package/dist/lib/Async.mjs

@@ -0,0 +1,154 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+import { getLibDebugger } from "./Debug.mjs";
+import {
+  emitAsyncErrorEvent,
+  getStackTrace,
+  printError
+} from "./Error.mjs";
+async function addErrorHandler(asyncFn) {
+  try {
+    await asyncFn();
+  } catch (asyncError) {
+    emitAsyncErrorEvent(asyncError);
+  }
+}
+async function asyncFilter(arr, predicate) {
+  const predicateResults = await asyncMap(arr, predicate);
+  return arr.filter((_, index) => predicateResults[index] ?? false);
+}
+async function asyncFlatMap(arr, callback) {
+  return (await asyncMap(arr, callback)).flat();
+}
+async function asyncMap(arr, callback) {
+  return await Promise.all(arr.map(callback));
+}
+function convertAsyncToSync(asyncFunc) {
+  return (...args) => {
+    invokeAsyncSafely(() => asyncFunc(...args));
+  };
+}
+function convertSyncToAsync(syncFn) {
+  return (...args) => Promise.resolve().then(() => syncFn(...args));
+}
+function invokeAsyncSafely(asyncFn) {
+  void addErrorHandler(asyncFn);
+}
+function marksAsTerminateRetry(error) {
+  return Object.assign(error, { __terminateRetry: true });
+}
+async function retryWithTimeout(fn, retryOptions, stackTrace) {
+  const retryWithTimeoutDebugger = getLibDebugger("Async:retryWithTimeout");
+  stackTrace ??= getStackTrace(1);
+  const DEFAULT_RETRY_OPTIONS = {
+    // eslint-disable-next-line no-magic-numbers
+    retryDelayInMilliseconds: 100,
+    shouldRetryOnError: false,
+    // eslint-disable-next-line no-magic-numbers
+    timeoutInMilliseconds: 5e3
+  };
+  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
+  await runWithTimeout(fullOptions.timeoutInMilliseconds, async () => {
+    let attempt = 0;
+    for (; ; ) {
+      fullOptions.abortSignal?.throwIfAborted();
+      attempt++;
+      let isSuccess;
+      try {
+        isSuccess = await fn();
+      } catch (error) {
+        if (!fullOptions.shouldRetryOnError || error.__terminateRetry) {
+          throw error;
+        }
+        printError(error);
+        isSuccess = false;
+      }
+      if (isSuccess) {
+        if (attempt > 1) {
+          retryWithTimeoutDebugger(`Retry completed successfully after ${attempt.toString()} attempts`);
+          retryWithTimeoutDebugger.printStackTrace(stackTrace);
+        }
+        return;
+      }
+      retryWithTimeoutDebugger(
+        `Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${fullOptions.retryDelayInMilliseconds.toString()} milliseconds`,
+        {
+          fn
+        }
+      );
+      retryWithTimeoutDebugger.printStackTrace(stackTrace);
+      await sleep(fullOptions.retryDelayInMilliseconds);
+    }
+  });
+}
+async function runWithTimeout(timeoutInMilliseconds, fn) {
+  let isTimedOut = true;
+  let result = null;
+  const startTime = performance.now();
+  await Promise.race([run(), innerTimeout()]);
+  if (isTimedOut) {
+    throw new Error("Timed out");
+  }
+  return result;
+  async function run() {
+    result = await fn();
+    isTimedOut = false;
+    const duration = performance.now() - startTime;
+    getLibDebugger("Async:runWithTimeout")(`Execution time: ${duration.toString()} milliseconds`, { fn });
+  }
+  async function innerTimeout() {
+    if (!isTimedOut) {
+      return;
+    }
+    await sleep(timeoutInMilliseconds);
+    if (!isTimedOut) {
+      return;
+    }
+    const duration = performance.now() - startTime;
+    console.warn(`Timed out in ${duration.toString()} milliseconds`, { fn });
+    const _debugger = getLibDebugger("Async:runWithTimeout:timeout");
+    if (_debugger.enabled) {
+      _debugger(
+        `The execution is not terminated because debugger ${_debugger.namespace} is enabled. See https://github.com/mnaoumov/obsidian-dev-utils/?tab=readme-ov-file#debugging for more information`
+      );
+      await innerTimeout();
+    }
+  }
+}
+async function sleep(milliseconds) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+async function timeout(timeoutInMilliseconds) {
+  await sleep(timeoutInMilliseconds);
+  throw new Error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`);
+}
+async function toArray(iter) {
+  const arr = [];
+  for await (const item of iter) {
+    arr.push(item);
+  }
+  return arr;
+}
+export {
+  addErrorHandler,
+  asyncFilter,
+  asyncFlatMap,
+  asyncMap,
+  convertAsyncToSync,
+  convertSyncToAsync,
+  invokeAsyncSafely,
+  marksAsTerminateRetry,
+  retryWithTimeout,
+  runWithTimeout,
+  sleep,
+  timeout,
+  toArray
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Async.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Async\n * Contains utility functions for asynchronous operations.\n */\n\nimport { getLibDebugger } from './Debug.ts';\nimport {\n  emitAsyncErrorEvent,\n  getStackTrace,\n  printError\n} from './Error.ts';\n\n/**\n * A type representing a value that can either be a direct value or a Promise resolving to that value.\n * @typeParam T - The type of the value.\n */\nexport type MaybePromise<T> = Promise<T> | T;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * The abort signal to cancel the retry operation.\n   */\n  abortSignal?: AbortSignal;\n\n  /**\n   * The delay in milliseconds between retry attempts.\n   */\n  retryDelayInMilliseconds?: number;\n\n  /**\n   * Whether to retry the function on error.\n   */\n  shouldRetryOnError?: boolean;\n\n  /**\n   * The maximum time in milliseconds to wait before giving up on retrying.\n   */\n  timeoutInMilliseconds?: number;\n}\n\n/**\n * A marker interface to indicate that an error should terminate retry logic.\n */\nexport interface TerminateRetry {\n  /**\n   * A marker property to indicate that an error should terminate retry logic.\n   */\n  __terminateRetry: true;\n}\n\n/**\n * Adds an error handler to a Promise that catches any errors and emits an async error event.\n *\n * @param asyncFn - The asynchronous function to add an error handler to.\n * @returns A Promise that resolves when the asynchronous function completes or emits async error event.\n */\nexport async function addErrorHandler(asyncFn: () => Promise<unknown>): Promise<void> {\n  try {\n    await asyncFn();\n  } catch (asyncError) {\n    emitAsyncErrorEvent(asyncError);\n  }\n}\n\n/**\n * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param arr - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A Promise that resolves with an array of elements that satisfy the predicate function.\n */\nexport async function asyncFilter<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => MaybePromise<boolean>): Promise<T[]> {\n  const predicateResults = await asyncMap(arr, predicate);\n  return arr.filter((_, index) => predicateResults[index] ?? false);\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over and flatten.\n * @param callback - The callback function to apply to each element.\n * @returns A Promise that resolves with a flattened array of the results of the callback function.\n */\nexport async function asyncFlatMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U[]>): Promise<U[]> {\n  return (await asyncMap(arr, callback)).flat();\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over.\n * @param callback - The callback function to apply to each element.\n * @returns A Promise that resolves with an array of the results of the callback function.\n */\nexport async function asyncMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U>): Promise<U[]> {\n  return await Promise.all(arr.map(callback));\n}\n\n/**\n * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @param asyncFunc - The asynchronous function to convert.\n * @returns A function that wraps the asynchronous function in a synchronous interface.\n */\nexport function convertAsyncToSync<Args extends unknown[]>(asyncFunc: (...args: Args) => Promise<unknown>): (...args: Args) => void {\n  return (...args: Args): void => {\n    invokeAsyncSafely(() => asyncFunc(...args));\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a Promise.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @typeParam Result - The type of the function's return value.\n * @param syncFn - The synchronous function to convert.\n * @returns A function that wraps the synchronous function in an asynchronous interface.\n */\nexport function convertSyncToAsync<Args extends unknown[], Result>(syncFn: (...args: Args) => Result): (...args: Args) => Promise<Result> {\n  return (...args: Args): Promise<Result> => Promise.resolve().then(() => syncFn(...args));\n}\n\n/**\n * Invokes a Promise and safely handles any errors by catching them and emitting an async error event.\n *\n * @param asyncFn - The asynchronous function to invoke safely.\n */\nexport function invokeAsyncSafely(asyncFn: () => Promise<unknown>): void {\n  // eslint-disable-next-line no-void\n  void addErrorHandler(asyncFn);\n}\n\n/**\n * Marks an error to terminate retry logic.\n *\n * @param error - The error to mark to terminate retry logic.\n * @returns An error that should terminate retry logic.\n */\nexport function marksAsTerminateRetry<TError extends Error>(error: TError): TerminateRetry & TError {\n  return Object.assign(error, { __terminateRetry: true }) as TerminateRetry & TError;\n}\n\n/**\n * Retries the provided function until it returns true or the timeout is reached.\n *\n * @param fn - The function to retry.\n * @param retryOptions - Optional parameters to configure the retry behavior.\n * @param stackTrace - Optional stack trace.\n * @returns A Promise that resolves when the function returns true or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(fn: () => MaybePromise<boolean>, retryOptions?: RetryOptions, stackTrace?: string): Promise<void> {\n  const retryWithTimeoutDebugger = getLibDebugger('Async:retryWithTimeout');\n  stackTrace ??= getStackTrace(1);\n  const DEFAULT_RETRY_OPTIONS = {\n    // eslint-disable-next-line no-magic-numbers\n    retryDelayInMilliseconds: 100,\n    shouldRetryOnError: false,\n    // eslint-disable-next-line no-magic-numbers\n    timeoutInMilliseconds: 5000\n  };\n  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  await runWithTimeout(fullOptions.timeoutInMilliseconds, async () => {\n    let attempt = 0;\n    for (;;) {\n      fullOptions.abortSignal?.throwIfAborted();\n      attempt++;\n      let isSuccess: boolean;\n      try {\n        isSuccess = await fn();\n      } catch (error) {\n        if (!fullOptions.shouldRetryOnError || (error as Partial<TerminateRetry>).__terminateRetry) {\n          throw error;\n        }\n        printError(error);\n        isSuccess = false;\n      }\n      if (isSuccess) {\n        if (attempt > 1) {\n          retryWithTimeoutDebugger(`Retry completed successfully after ${attempt.toString()} attempts`);\n          retryWithTimeoutDebugger.printStackTrace(stackTrace);\n        }\n        return;\n      }\n\n      retryWithTimeoutDebugger(\n        `Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${fullOptions.retryDelayInMilliseconds.toString()} milliseconds`,\n        {\n          fn\n        }\n      );\n      retryWithTimeoutDebugger.printStackTrace(stackTrace);\n      await sleep(fullOptions.retryDelayInMilliseconds);\n    }\n  });\n}\n\n/**\n * Executes a function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.\n *\n * If `DEBUG=obsidian-dev-utils:Async:runWithTimeout` is set, the execution is not terminated after the timeout and the function is allowed to run indefinitely.\n *\n * @typeParam R - The type of the result from the asynchronous function.\n * @param timeoutInMilliseconds - The maximum time to wait in milliseconds.\n * @param fn - The function to execute.\n * @returns A Promise that resolves with the result of the asynchronous function or rejects if it times out.\n */\nexport async function runWithTimeout<R>(timeoutInMilliseconds: number, fn: () => MaybePromise<R>): Promise<R> {\n  let isTimedOut = true;\n  let result: R = null as R;\n  const startTime = performance.now();\n  await Promise.race([run(), innerTimeout()]);\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (isTimedOut) {\n    throw new Error('Timed out');\n  }\n  return result;\n\n  async function run(): Promise<void> {\n    result = await fn();\n    isTimedOut = false;\n    const duration = performance.now() - startTime;\n    getLibDebugger('Async:runWithTimeout')(`Execution time: ${duration.toString()} milliseconds`, { fn });\n  }\n\n  async function innerTimeout(): Promise<void> {\n    if (!isTimedOut) {\n      return;\n    }\n    await sleep(timeoutInMilliseconds);\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    if (!isTimedOut) {\n      return;\n    }\n    const duration = performance.now() - startTime;\n    console.warn(`Timed out in ${duration.toString()} milliseconds`, { fn });\n    const _debugger = getLibDebugger('Async:runWithTimeout:timeout');\n    if (_debugger.enabled) {\n      _debugger(\n        `The execution is not terminated because debugger ${_debugger.namespace} is enabled. See https://github.com/mnaoumov/obsidian-dev-utils/?tab=readme-ov-file#debugging for more information`\n      );\n      await innerTimeout();\n    }\n  }\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param milliseconds - The time to wait in milliseconds.\n * @returns A Promise that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number): Promise<void> {\n  await new Promise((resolve) => {\n    setTimeout(resolve, milliseconds);\n  });\n}\n\n/**\n * Returns a Promise that rejects after the specified timeout period.\n *\n * @param timeoutInMilliseconds - The timeout period in milliseconds.\n * @returns A Promise that always rejects with a timeout error.\n */\nexport async function timeout(timeoutInMilliseconds: number): Promise<never> {\n  await sleep(timeoutInMilliseconds);\n  throw new Error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`);\n}\n\n/**\n * Converts an AsyncIterableIterator to an array by consuming all its elements.\n *\n * @typeParam T - The type of elements produced by the AsyncIterableIterator.\n * @param iter - The AsyncIterableIterator to convert.\n * @returns A Promise that resolves with an array of all the elements in the AsyncIterableIterator.\n */\nexport async function toArray<T>(iter: AsyncIterableIterator<T>): Promise<T[]> {\n  const arr: T[] = [];\n  for await (const item of iter) {\n    arr.push(item);\n  }\n  return arr;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/Blob.mjs

@@ -0,0 +1,81 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+async function blobToArrayBuffer(blob) {
+  return await new Promise((resolve) => {
+    const reader = new FileReader();
+    reader.addEventListener("loadend", handleLoadEnd);
+    reader.readAsArrayBuffer(blob);
+    function handleLoadEnd() {
+      resolve(reader.result);
+    }
+  });
+}
+async function blobToDataUrl(blob) {
+  return await new Promise((resolve) => {
+    const reader = new FileReader();
+    reader.addEventListener("loadend", handleLoadEnd);
+    reader.readAsDataURL(blob);
+    function handleLoadEnd() {
+      resolve(reader.result);
+    }
+  });
+}
+async function blobToJpegArrayBuffer(blob, jpegQuality) {
+  const dataUrl = await blobToDataUrl(blob);
+  return new Promise((resolve) => {
+    const image = new Image();
+    image.addEventListener("load", handleLoad);
+    image.src = dataUrl;
+    function handleLoad() {
+      const canvas = document.createElement("canvas");
+      const context = canvas.getContext("2d");
+      if (!context) {
+        throw new Error("Could not get 2D context.");
+      }
+      const imageWidth = image.width;
+      const imageHeight = image.height;
+      canvas.width = imageWidth;
+      canvas.height = imageHeight;
+      context.fillStyle = "#fff";
+      context.fillRect(0, 0, imageWidth, imageHeight);
+      context.save();
+      const HALF = 0.5;
+      context.translate(imageWidth * HALF, imageHeight * HALF);
+      context.drawImage(image, 0, 0, imageWidth, imageHeight, -imageWidth * HALF, -imageHeight * HALF, imageWidth, imageHeight);
+      context.restore();
+      const jpegDataUrl = canvas.toDataURL("image/jpeg", jpegQuality);
+      const arrayBuffer = dataUrlToArrayBuffer(jpegDataUrl);
+      resolve(arrayBuffer);
+    }
+  });
+}
+function dataUrlToArrayBuffer(dataUrl) {
+  const parts = dataUrl.split(";base64,");
+  const base64 = parts[1];
+  if (!base64) {
+    throw new Error("Invalid data URL");
+  }
+  const raw = window.atob(base64);
+  const rawLength = raw.length;
+  const uInt8Array = new Uint8Array(rawLength);
+  for (let i = 0; i < rawLength; i++) {
+    uInt8Array[i] = raw.charCodeAt(i);
+  }
+  return uInt8Array.buffer;
+}
+function isImageFile(file) {
+  return file.type.startsWith("image/");
+}
+export {
+  blobToArrayBuffer,
+  blobToDataUrl,
+  blobToJpegArrayBuffer,
+  dataUrlToArrayBuffer,
+  isImageFile
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/CssClass.mjs

@@ -0,0 +1,32 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+var CssClass = /* @__PURE__ */ ((CssClass2) => {
+  CssClass2["AlertModal"] = "alert-modal";
+  CssClass2["ConfirmModal"] = "confirm-modal";
+  CssClass2["DateComponent"] = "date-component";
+  CssClass2["DateTimeComponent"] = "datetime-component";
+  CssClass2["EmailComponent"] = "email-component";
+  CssClass2["FileComponent"] = "file-component";
+  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["NumberComponent"] = "number-component";
+  CssClass2["PluginSettingsTab"] = "plugin-settings-tab";
+  CssClass2["PromptModal"] = "prompt-modal";
+  CssClass2["SelectItemModal"] = "select-item-modal";
+  CssClass2["TimeComponent"] = "time-component";
+  CssClass2["UrlComponent"] = "url-component";
+  CssClass2["WeekComponent"] = "week-component";
+  return CssClass2;
+})(CssClass || {});
+export {
+  CssClass
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL0Nzc0NsYXNzLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvbiBDc3NDbGFzc1xuICogQ1NTIGNsYXNzZXMgdXNlZCBieSB0aGUgYG9ic2lkaWFuLWRldi11dGlsc2AgbGlicmFyeS5cbiAqL1xuXG4vKipcbiAqIENTUyBjbGFzc2VzIHVzZWQgYnkgdGhlIGBvYnNpZGlhbi1kZXYtdXRpbHNgIGxpYnJhcnkuXG4gKi9cbmV4cG9ydCBlbnVtIENzc0NsYXNzIHtcbiAgLyoqXG4gICAqIFRoZSBDU1MgY2xhc3MgZm9yIHRoZSBhbGVydCBtb2RhbC5cbiAgICovXG4gIEFsZXJ0TW9kYWwgPSAnYWxlcnQtbW9kYWwnLFxuXG4gIC8qKlxuICAgKiBUaGUgQ1NTIGNsYXNzIGZvciB0aGUgY29uZmlybSBtb2RhbC5cbiAgICovXG4gIENvbmZpcm1Nb2RhbCA9ICdjb25maXJtLW1vZGFsJyxcblxuICAvKipcbiAgICogVGhlIENTUyBjbGFzcyBmb3IgdGhlIGRhdGUgY29tcG9uZW50LlxuICAgKi9cbiAgRGF0ZUNvbXBvbmVudCA9ICdkYXRlLWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIFRoZSBDU1MgY2xhc3MgZm9yIHRoZSBkYXRlIGFuZCB0aW1lIGNvbXBvbmVudC5cbiAgICovXG4gIERhdGVUaW1lQ29tcG9uZW50ID0gJ2RhdGV0aW1lLWNvbXBvbmVudCcsXG5cbiAgLyoqXG4gICAqIFRoZSBDU1MgY2xhc3MgZm9yIHRoZSBlbWFpbCBjb21wb25lbnQuXG4gICAqL1xuICBFbWFpbENvbXBvbmVudCA9ICdlbWFpbC1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBUaGUgQ1NTIGNsYXNzIGZvciB0aGUgZmlsZSBjb21wb25lbnQuXG4gICAqL1xuICBGaWxlQ29tcG9uZW50ID0gJ2ZpbGUtY29tcG9uZW50JyxcblxuICAvKipcbiAgICogVGhlIENTUyBjbGFzcyBmb3IgdGhlIGxpYnJhcnkgbmFtZS5cbiAgICovXG4gIExpYnJhcnlOYW1lID0gJ29ic2lkaWFuLWRldi11dGlscycsXG5cbiAgLyoqXG4gICAqIFRoZSBDU1MgY2xhc3MgZm9yIHRoZSBtb250aCBjb21wb25lbnQuXG4gICAqL1xuICBNb250aENvbXBvbmVudCA9ICdtb250aC1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBUaGUgQ1NTIGNsYXNzIGZvciB0aGUgbXVsdGlwbGUgZHJvcGRvd24gY29tcG9uZW50LlxuICAgKi9cbiAgTXVsdGlwbGVEcm9wZG93bkNvbXBvbmVudCA9ICdtdWx0aXBsZS1kcm9wZG93bi1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBUaGUgQ1NTIGNsYXNzIGZvciB0aGUgbXVsdGlwbGUgZW1haWwgY29tcG9uZW50LlxuICAgKi9cbiAgTXVsdGlwbGVFbWFpbENvbXBvbmVudCA9ICdtdWx0aXBsZS1lbWFpbC1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBUaGUgQ1NTIGNsYXNzIGZvciB0aGUgbXVsdGlwbGUgZmlsZSBjb21wb25lbnQuXG4gICAqL1xuICBNdWx0aXBsZUZpbGVDb21wb25lbnQgPSAnbXVsdGlwbGUtZmlsZS1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBUaGUgQ1NTIGNsYXNzIGZvciB0aGUgbnVtYmVyIGNvbXBvbmVudC5cbiAgICovXG4gIE51bWJlckNvbXBvbmVudCA9ICdudW1iZXItY29tcG9uZW50JyxcblxuICAvKipcbiAgICogVGhlIENTUyBjbGFzcyBmb3IgdGhlIHBsdWdpbiBzZXR0aW5ncyB0YWIuXG4gICAqL1xuICBQbHVnaW5TZXR0aW5nc1RhYiA9ICdwbHVnaW4tc2V0dGluZ3MtdGFiJyxcblxuICAvKipcbiAgICogVGhlIENTUyBjbGFzcyBmb3IgdGhlIHByb21wdCBtb2RhbC5cbiAgICovXG4gIFByb21wdE1vZGFsID0gJ3Byb21wdC1tb2RhbCcsXG5cbiAgLyoqXG4gICAqIFRoZSBDU1MgY2xhc3MgZm9yIHRoZSBzZWxlY3QgaXRlbSBtb2RhbC5cbiAgICovXG4gIFNlbGVjdEl0ZW1Nb2RhbCA9ICdzZWxlY3QtaXRlbS1tb2RhbCcsXG5cbiAgLyoqXG4gICAqIFRoZSBDU1MgY2xhc3MgZm9yIHRoZSB0aW1lIGNvbXBvbmVudC5cbiAgICovXG4gIFRpbWVDb21wb25lbnQgPSAndGltZS1jb21wb25lbnQnLFxuXG4gIC8qKlxuICAgKiBUaGUgQ1NTIGNsYXNzIGZvciB0aGUgdXJsIGNvbXBvbmVudC5cbiAgICovXG4gIFVybENvbXBvbmVudCA9ICd1cmwtY29tcG9uZW50JyxcblxuICAvKipcbiAgICogVGhlIENTUyBjbGFzcyBmb3IgdGhlIHdlZWsgY29tcG9uZW50LlxuICAgKi9cbiAgV2Vla0NvbXBvbmVudCA9ICd3ZWVrLWNvbXBvbmVudCdcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7QUFRTyxJQUFLLFdBQUwsa0JBQUtBLGNBQUw7QUFJTCxFQUFBQSxVQUFBLGdCQUFhO0FBS2IsRUFBQUEsVUFBQSxrQkFBZTtBQUtmLEVBQUFBLFVBQUEsbUJBQWdCO0FBS2hCLEVBQUFBLFVBQUEsdUJBQW9CO0FBS3BCLEVBQUFBLFVBQUEsb0JBQWlCO0FBS2pCLEVBQUFBLFVBQUEsbUJBQWdCO0FBS2hCLEVBQUFBLFVBQUEsaUJBQWM7QUFLZCxFQUFBQSxVQUFBLG9CQUFpQjtBQUtqQixFQUFBQSxVQUFBLCtCQUE0QjtBQUs1QixFQUFBQSxVQUFBLDRCQUF5QjtBQUt6QixFQUFBQSxVQUFBLDJCQUF3QjtBQUt4QixFQUFBQSxVQUFBLHFCQUFrQjtBQUtsQixFQUFBQSxVQUFBLHVCQUFvQjtBQUtwQixFQUFBQSxVQUFBLGlCQUFjO0FBS2QsRUFBQUEsVUFBQSxxQkFBa0I7QUFLbEIsRUFBQUEsVUFBQSxtQkFBZ0I7QUFLaEIsRUFBQUEsVUFBQSxrQkFBZTtBQUtmLEVBQUFBLFVBQUEsbUJBQWdCO0FBekZOLFNBQUFBO0FBQUEsR0FBQTsiLAogICJuYW1lcyI6IFsiQ3NzQ2xhc3MiXQp9Cg==

package/dist/lib/Debug.mjs

@@ -0,0 +1,137 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+import debug from "debug";
+import { LIBRARY_NAME } from "./Library.mjs";
+import {
+  getApp,
+  getObsidianDevUtilsState
+} from "./obsidian/App.mjs";
+import {
+  getPluginId,
+  NO_PLUGIN_ID_INITIALIZED
+} from "./obsidian/Plugin/PluginId.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 debugInstance = getSharedDebugLibInstance()(namespace);
+  debugInstance.log = (message, ...args) => {
+    logWithCaller(namespace, framesToSkip, message, ...args);
+  };
+  debugInstance.printStackTrace = (stackTrace, title) => {
+    printStackTrace(namespace, stackTrace, title);
+  };
+  return debugInstance;
+}
+function getLibDebugger(namespace) {
+  const pluginId = getPluginId();
+  const prefix = pluginId === NO_PLUGIN_ID_INITIALIZED ? "" : `${pluginId}:`;
+  return getDebugger(`${prefix}${LIBRARY_NAME}:${namespace}`);
+}
+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/?tab=readme-ov-file#debugging 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;
+  }
+  const app = getApp();
+  return getObsidianDevUtilsState(app, "debug", debug).value;
+}
+function isInObsidian() {
+  return typeof window !== "undefined";
+}
+function logWithCaller(namespace, framesToSkip, message, ...args) {
+  if (!getSharedDebugLibInstance().enabled(namespace)) {
+    return;
+  }
+  const CALLER_LINE_INDEX = 4;
+  const stackLines = new Error().stack?.split("\n") ?? [];
+  const callerLine = stackLines[CALLER_LINE_INDEX + framesToSkip] ?? "";
+  console.debug(message, ...args);
+  if (isInObsidian()) {
+    printStackTrace(namespace, callerLine, "Debug message caller");
+  }
+}
+function printStackTrace(namespace, stackTrace, title) {
+  const _debugger = getSharedDebugLibInstance()(namespace);
+  if (!_debugger.enabled) {
+    return;
+  }
+  if (!stackTrace) {
+    stackTrace = "(unavailable)";
+  }
+  if (!title) {
+    title = "Caller stack trace";
+  }
+  _debugger(title);
+  const prefix = isInObsidian() ? "StackTraceFakeError\n" : "";
+  console.debug(`${prefix}${stackTrace}`);
+}
+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,
+  showInitialDebugMessage
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Debug.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Debug\n * Contains utility functions for debugging.\n */\n\nimport type { Debugger } from 'debug';\n\nimport debug from 'debug';\n\nimport type { DebugController } from './DebugController.ts';\n\nimport { LIBRARY_NAME } from './Library.ts';\nimport {\n  getApp,\n  getObsidianDevUtilsState\n} from './obsidian/App.ts';\nimport {\n  getPluginId,\n  NO_PLUGIN_ID_INITIALIZED\n} from './obsidian/Plugin/PluginId.ts';\n\ninterface DebuggerEx extends Debugger {\n  printStackTrace(stackTrace: string, title?: string): void;\n}\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): DebuggerEx {\n  const debugInstance = getSharedDebugLibInstance()(namespace) as DebuggerEx;\n  debugInstance.log = (message: string, ...args: unknown[]): void => {\n    logWithCaller(namespace, framesToSkip, message, ...args);\n  };\n  debugInstance.printStackTrace = (stackTrace, title): void => {\n    printStackTrace(namespace, stackTrace, title);\n  };\n  return debugInstance;\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): DebuggerEx {\n  const pluginId = getPluginId();\n  const prefix = pluginId === NO_PLUGIN_ID_INITIALIZED ? '' : `${pluginId}:`;\n  return getDebugger(`${prefix}${LIBRARY_NAME}:${namespace}`);\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/?tab=readme-ov-file#debugging 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  if (typeof window === 'undefined') {\n    return debug;\n  }\n  const app = getApp();\n  return getObsidianDevUtilsState(app, 'debug', debug).value;\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  /**\n   * The 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  const callerLine = stackLines[CALLER_LINE_INDEX + framesToSkip] ?? '';\n  // eslint-disable-next-line no-console\n  console.debug(message, ...args);\n  if (isInObsidian()) {\n    printStackTrace(namespace, callerLine, 'Debug message caller');\n  }\n}\n\nfunction printStackTrace(namespace: string, stackTrace: string, title?: string): void {\n  const _debugger = getSharedDebugLibInstance()(namespace);\n\n  if (!_debugger.enabled) {\n    return;\n  }\n\n  if (!stackTrace) {\n    stackTrace = '(unavailable)';\n  }\n  if (!title) {\n    title = 'Caller stack trace';\n  }\n\n  _debugger(title);\n  const prefix = isInObsidian() ? 'StackTraceFakeError\\n' : '';\n  // eslint-disable-next-line no-console\n  console.debug(`${prefix}${stackTrace}`);\n}\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/DebugController.mjs

@@ -0,0 +1,8 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/Enum.mjs

@@ -0,0 +1,26 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function init(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;if(!require.__isPatched){const originalRequire=require;require=Object.assign(id=>requirePatched(id,originalRequire),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>({browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"}),"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id,originalRequire){const module=originalRequire(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})()
+
+function getEnumKey(enumType, value) {
+  const key = Object.keys(enumType).find((k) => enumType[k] === value);
+  if (key === void 0) {
+    throw new Error(`Invalid enum value: ${value}`);
+  }
+  return key;
+}
+function getEnumValue(enumType, key) {
+  const value = enumType[key];
+  if (value === void 0) {
+    throw new Error(`Invalid enum key: ${key}`);
+  }
+  return value;
+}
+export {
+  getEnumKey,
+  getEnumValue
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL0VudW0udHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uIEVudW1cbiAqIENvbnRhaW5zIHV0aWxpdHkgZnVuY3Rpb25zIGZvciBlbnVtcy5cbiAqL1xuXG4vKipcbiAqIEdldCB0aGUga2V5IG9mIGFuIGVudW0gdmFsdWUuXG4gKlxuICogQHBhcmFtIGVudW1UeXBlIC0gVGhlIGVudW0gdHlwZS5cbiAqIEBwYXJhbSB2YWx1ZSAtIFRoZSB2YWx1ZSB0byBnZXQgdGhlIGtleSBvZi5cbiAqIEByZXR1cm5zIFRoZSBrZXkgb2YgdGhlIGVudW0gdmFsdWUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRFbnVtS2V5PFQgZXh0ZW5kcyBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+PihlbnVtVHlwZTogVCwgdmFsdWU6IFRba2V5b2YgVF0pOiBrZXlvZiBUIHtcbiAgY29uc3Qga2V5ID0gT2JqZWN0LmtleXMoZW51bVR5cGUpLmZpbmQoKGspID0+IGVudW1UeXBlW2tdID09PSB2YWx1ZSk7XG4gIGlmIChrZXkgPT09IHVuZGVmaW5lZCkge1xuICAgIHRocm93IG5ldyBFcnJvcihgSW52YWxpZCBlbnVtIHZhbHVlOiAke3ZhbHVlfWApO1xuICB9XG4gIHJldHVybiBrZXkgYXMga2V5b2YgVDtcbn1cblxuLyoqXG4gKiBHZXQgdGhlIHZhbHVlIG9mIGFuIGVudW0ga2V5LlxuICpcbiAqIEBwYXJhbSBlbnVtVHlwZSAtIFRoZSBlbnVtIHR5cGUuXG4gKiBAcGFyYW0ga2V5IC0gVGhlIGtleSB0byBnZXQgdGhlIHZhbHVlIG9mLlxuICogQHJldHVybnMgVGhlIHZhbHVlIG9mIHRoZSBlbnVtIGtleS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldEVudW1WYWx1ZTxUIGV4dGVuZHMgUmVjb3JkPHN0cmluZywgc3RyaW5nPj4oZW51bVR5cGU6IFQsIGtleTogc3RyaW5nKTogVFtrZXlvZiBUXSB7XG4gIGNvbnN0IHZhbHVlID0gZW51bVR5cGVba2V5XTtcbiAgaWYgKHZhbHVlID09PSB1bmRlZmluZWQpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYEludmFsaWQgZW51bSBrZXk6ICR7a2V5fWApO1xuICB9XG4gIHJldHVybiB2YWx1ZSBhcyBUW2tleW9mIFRdO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7OztBQVlPLFNBQVMsV0FBNkMsVUFBYSxPQUE0QjtBQUNwRyxRQUFNLE1BQU0sT0FBTyxLQUFLLFFBQVEsRUFBRSxLQUFLLENBQUMsTUFBTSxTQUFTLENBQUMsTUFBTSxLQUFLO0FBQ25FLE1BQUksUUFBUSxRQUFXO0FBQ3JCLFVBQU0sSUFBSSxNQUFNLHVCQUF1QixLQUFLLEVBQUU7QUFBQSxFQUNoRDtBQUNBLFNBQU87QUFDVDtBQVNPLFNBQVMsYUFBK0MsVUFBYSxLQUF5QjtBQUNuRyxRQUFNLFFBQVEsU0FBUyxHQUFHO0FBQzFCLE1BQUksVUFBVSxRQUFXO0FBQ3ZCLFVBQU0sSUFBSSxNQUFNLHFCQUFxQixHQUFHLEVBQUU7QUFBQSxFQUM1QztBQUNBLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K