@mnaoumov/typescript-lib 0.0.0 → 1.0.1

package/dist/lib/esm/blob.mjs

@@ -0,0 +1,77 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import {
+  extractJpegMetadataSegments,
+  injectJpegMetadataSegments
+} from "./jpeg-metadata.mjs";
+import { assertNonNullable } from "./type-guards.mjs";
+async function blobToArrayBuffer(blob) {
+  return await blob.arrayBuffer();
+}
+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, options) {
+  const sourceSegments = options?.shouldPreserveMetadata ? extractJpegMetadataSegments(new Uint8Array(await blob.arrayBuffer())) : [];
+  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");
+      assertNonNullable(context, "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);
+      const withMetadata = injectJpegMetadataSegments(new Uint8Array(arrayBuffer), sourceSegments);
+      resolve(withMetadata.buffer);
+    }
+  });
+}
+function dataUrlToArrayBuffer(dataUrl) {
+  const parts = dataUrl.split(";base64,");
+  const base64 = parts[1];
+  if (!base64) {
+    throw new Error("Invalid data URL");
+  }
+  const raw = atob(base64);
+  const rawLength = raw.length;
+  const uInt8Array = new Uint8Array(rawLength);
+  for (let index = 0; index < rawLength; index++) {
+    uInt8Array[index] = raw.charCodeAt(index);
+  }
+  return uInt8Array.buffer;
+}
+function isImageFile(file) {
+  return file.type.startsWith("image/");
+}
+export {
+  blobToArrayBuffer,
+  blobToDataUrl,
+  blobToJpegArrayBuffer,
+  dataUrlToArrayBuffer,
+  isImageFile
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/blob.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for Blob objects.\n */\n\nimport {\n  extractJpegMetadataSegments,\n  injectJpegMetadataSegments\n} from './jpeg-metadata.ts';\nimport { assertNonNullable } from './type-guards.ts';\n\n/**\n * Options for {@link blobToJpegArrayBuffer}.\n */\nexport interface BlobToJpegArrayBufferOptions {\n  /**\n   * Whether to carry the source image's metadata segments (EXIF, GPS, XMP, ICC profile) into the\n   * re-encoded JPEG. Only has an effect when the source is a JPEG. Defaults to `false`, which is the\n   * behavior a canvas re-encode has always had.\n   */\n  readonly shouldPreserveMetadata?: boolean | undefined;\n}\n\n/**\n * Converts a {@link Blob} object to an {@link ArrayBuffer}.\n *\n * @param blob - The Blob object to convert.\n * @returns A {@link Promise} that resolves to an {@link ArrayBuffer}.\n */\nexport async function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer> {\n  return await blob.arrayBuffer();\n}\n\n/**\n * Converts a {@link Blob} object to a data URL.\n *\n * @param blob - The Blob object to convert.\n * @returns A {@link Promise} that resolves to a data URL.\n */\nexport async function blobToDataUrl(blob: Blob): Promise<string> {\n  return await new Promise((resolve) => {\n    const reader = new FileReader();\n    reader.addEventListener('loadend', handleLoadEnd);\n    reader.readAsDataURL(blob);\n\n    function handleLoadEnd(): void {\n      resolve(reader.result as string);\n    }\n  });\n}\n\n/**\n * Converts a {@link Blob} object to a JPEG ArrayBuffer with the specified quality.\n *\n * The conversion is a canvas re-encode, which keeps only the pixels \u2014 EXIF, GPS, XMP and the ICC\n * profile are dropped by construction. Pass {@link BlobToJpegArrayBufferOptions.shouldPreserveMetadata}\n * to carry those segments across from the source, which works only when the source is itself a JPEG:\n * nothing else stores them in a form that can be copied verbatim.\n *\n * @param blob - The Blob object to convert.\n * @param jpegQuality - The quality of the JPEG image (0 to 1).\n * @param options - Conversion options.\n * @returns A {@link Promise} that resolves to an {@link ArrayBuffer}.\n */\nexport async function blobToJpegArrayBuffer(blob: Blob, jpegQuality: number, options?: BlobToJpegArrayBufferOptions): Promise<ArrayBuffer> {\n  const sourceSegments = options?.shouldPreserveMetadata\n    ? extractJpegMetadataSegments(new Uint8Array(await blob.arrayBuffer()))\n    : [];\n  const dataUrl = await blobToDataUrl(blob);\n  return new Promise((resolve) => {\n    const image = new Image();\n    image.addEventListener('load', handleLoad);\n    image.src = dataUrl;\n\n    function handleLoad(): void {\n      const canvas = document.createElement('canvas');\n      const context = canvas.getContext('2d');\n      assertNonNullable(context, 'Could not get 2D context.');\n      const imageWidth = image.width;\n      const imageHeight = image.height;\n\n      canvas.width = imageWidth;\n      canvas.height = imageHeight;\n\n      context.fillStyle = '#fff';\n      context.fillRect(0, 0, imageWidth, imageHeight);\n      context.save();\n\n      const HALF = 0.5;\n      context.translate(imageWidth * HALF, imageHeight * HALF);\n      context.drawImage(image, 0, 0, imageWidth, imageHeight, -imageWidth * HALF, -imageHeight * HALF, imageWidth, imageHeight);\n      context.restore();\n\n      const jpegDataUrl = canvas.toDataURL('image/jpeg', jpegQuality);\n      const arrayBuffer = dataUrlToArrayBuffer(jpegDataUrl);\n      const withMetadata = injectJpegMetadataSegments(new Uint8Array(arrayBuffer), sourceSegments);\n      resolve(withMetadata.buffer as ArrayBuffer);\n    }\n  });\n}\n\n/**\n * Converts a base64 encoded string to an {@link ArrayBuffer}.\n *\n * @param dataUrl - The data URL to convert.\n * @returns The decoded ArrayBuffer.\n */\nexport function dataUrlToArrayBuffer(dataUrl: string): ArrayBuffer {\n  const parts = dataUrl.split(';base64,');\n  const base64 = parts[1];\n  if (!base64) {\n    throw new Error('Invalid data URL');\n  }\n\n  const raw = atob(base64);\n  const rawLength = raw.length;\n\n  const uInt8Array = new Uint8Array(rawLength);\n\n  for (let index = 0; index < rawLength; index++) {\n    // eslint-disable-next-line unicorn/prefer-code-point -- `raw` is a binary string, one byte per code unit. `codePointAt` would combine a surrogate pair into a value above 255 and consume two positions, which is exactly the wrong reading here.\n    uInt8Array[index] = raw.charCodeAt(index);\n  }\n  return uInt8Array.buffer;\n}\n\n/**\n * Checks if a given file is an image.\n *\n * @param file - The file to check.\n * @returns `true` if the file is an image, `false` otherwise.\n */\nexport function isImageFile(file: File): boolean {\n  return file.type.startsWith('image/');\n}\n"],
  "mappings": ";;;;;AAMA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAoBlC,eAAsB,kBAAkB,MAAkC;AACxE,SAAO,MAAM,KAAK,YAAY;AAChC;AAQA,eAAsB,cAAc,MAA6B;AAC/D,SAAO,MAAM,IAAI,QAAQ,CAAC,YAAY;AACpC,UAAM,SAAS,IAAI,WAAW;AAC9B,WAAO,iBAAiB,WAAW,aAAa;AAChD,WAAO,cAAc,IAAI;AAEzB,aAAS,gBAAsB;AAC7B,cAAQ,OAAO,MAAgB;AAAA,IACjC;AAAA,EACF,CAAC;AACH;AAeA,eAAsB,sBAAsB,MAAY,aAAqB,SAA8D;AACzI,QAAM,iBAAiB,SAAS,yBAC5B,4BAA4B,IAAI,WAAW,MAAM,KAAK,YAAY,CAAC,CAAC,IACpE,CAAC;AACL,QAAM,UAAU,MAAM,cAAc,IAAI;AACxC,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,QAAQ,IAAI,MAAM;AACxB,UAAM,iBAAiB,QAAQ,UAAU;AACzC,UAAM,MAAM;AAEZ,aAAS,aAAmB;AAC1B,YAAM,SAAS,SAAS,cAAc,QAAQ;AAC9C,YAAM,UAAU,OAAO,WAAW,IAAI;AACtC,wBAAkB,SAAS,2BAA2B;AACtD,YAAM,aAAa,MAAM;AACzB,YAAM,cAAc,MAAM;AAE1B,aAAO,QAAQ;AACf,aAAO,SAAS;AAEhB,cAAQ,YAAY;AACpB,cAAQ,SAAS,GAAG,GAAG,YAAY,WAAW;AAC9C,cAAQ,KAAK;AAEb,YAAM,OAAO;AACb,cAAQ,UAAU,aAAa,MAAM,cAAc,IAAI;AACvD,cAAQ,UAAU,OAAO,GAAG,GAAG,YAAY,aAAa,CAAC,aAAa,MAAM,CAAC,cAAc,MAAM,YAAY,WAAW;AACxH,cAAQ,QAAQ;AAEhB,YAAM,cAAc,OAAO,UAAU,cAAc,WAAW;AAC9D,YAAM,cAAc,qBAAqB,WAAW;AACpD,YAAM,eAAe,2BAA2B,IAAI,WAAW,WAAW,GAAG,cAAc;AAC3F,cAAQ,aAAa,MAAqB;AAAA,IAC5C;AAAA,EACF,CAAC;AACH;AAQO,SAAS,qBAAqB,SAA8B;AACjE,QAAM,QAAQ,QAAQ,MAAM,UAAU;AACtC,QAAM,SAAS,MAAM,CAAC;AACtB,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,kBAAkB;AAAA,EACpC;AAEA,QAAM,MAAM,KAAK,MAAM;AACvB,QAAM,YAAY,IAAI;AAEtB,QAAM,aAAa,IAAI,WAAW,SAAS;AAE3C,WAAS,QAAQ,GAAG,QAAQ,WAAW,SAAS;AAE9C,eAAW,KAAK,IAAI,IAAI,WAAW,KAAK;AAAA,EAC1C;AACA,SAAO,WAAW;AACpB;AAQO,SAAS,YAAY,MAAqB;AAC/C,SAAO,KAAK,KAAK,WAAW,QAAQ;AACtC;",
  "names": []
}


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

@@ -0,0 +1,17 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for byte counts.
+ */
+/**
+ * Renders a byte count the way a file manager does, so a running total answers "is this getting huge?" at
+ * a glance.
+ *
+ * Past the largest unit the number keeps growing rather than starting over, because under-reporting a size
+ * by a factor of 1024 is worse than an ungainly number.
+ *
+ * @param bytes - The number of bytes.
+ * @returns The formatted size, e.g. `1.4 MB`.
+ */
+export declare function formatBytes(bytes: number): string;

package/dist/lib/esm/bytes.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
+*/
+
+const BYTES_PER_UNIT = 1024;
+const DECIMALS = 1;
+const UNITS = [
+  "B",
+  "KB",
+  "MB",
+  "GB",
+  "TB"
+];
+function formatBytes(bytes) {
+  let size = bytes;
+  let unit = UNITS[0];
+  let isInBytes = true;
+  for (const largerUnit of UNITS.slice(1)) {
+    if (size < BYTES_PER_UNIT) {
+      break;
+    }
+    size /= BYTES_PER_UNIT;
+    unit = largerUnit;
+    isInBytes = false;
+  }
+  return `${isInBytes ? String(size) : size.toFixed(DECIMALS)} ${unit}`;
+}
+export {
+  formatBytes
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,87 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Provides the interface for controlling debug output through namespace management.
+ *
+ * Debug namespaces follow the pattern 'lorem', `lorem:ipsum`, `lorem:ipsum:dolor`, etc, and can use wildcards (`*`).
+ *
+ * @example
+ * - `lorem:*` matches all submodules of 'lorem'
+ * - `*:ipsum` matches all plugins' `ipsum` submodules
+ * - `*` matches everything
+ *
+ * Special syntax:
+ * - Namespaces prefixed with '-' are explicitly disabled
+ * - Multiple namespaces can be combined with commas: `lorem,-lorem:ipsum,dolor:*`
+ *
+ * @see {@link https://mnaoumov.dev/obsidian-dev-utils/guides/debugging/}
+ */
+/**
+ * Controls debug output by managing debug namespaces.
+ * Exposed globally as `window.DEBUG`.
+ *
+ * @remarks
+ * Debug settings persist across plugin reloads in localStorage.
+ */
+export interface DebugController {
+    /**
+     * Disable specific debug namespaces. Disabled namespaces take precedence
+     * over enabled ones when there's a conflict.
+     *
+     * @example
+     * ```typescript
+     * window.DEBUG.disable('foo-bar'); // hide all debug messages from the `foo-bar` plugin
+     * window.DEBUG.disable('foo-bar:*'); // hide all debug messages from the `foo-bar` plugin submodules
+     * window.DEBUG.disable(['foo-bar', 'baz-qux']); // disable multiple namespaces
+     * window.DEBUG.disable('foo-bar,baz-qux'); // disable multiple namespaces using comma-separated string
+     * window.DEBUG.disable('*'); // disable all debug messages
+     * ```
+     *
+     * @param namespaces - Single namespace string or array of namespace strings to disable
+     */
+    disable: (namespaces: string | string[]) => void;
+    /**
+     * Enable specific debug namespaces. Note that explicitly disabled
+     * namespaces (prefixed with '-') will remain disabled.
+     *
+     * @example
+     * ```typescript
+     * window.DEBUG.enable('foo-bar'); // show all debug messages from the `foo-bar` plugin
+     * window.DEBUG.enable('foo-bar:obsidian-dev-utils:*'); // show all debug messages from the `obsidian-dev-utils` library within the `foo-bar` plugin
+     * window.DEBUG.enable('foo-bar:*'); // show all debug messages from the `foo-bar` plugin and its submodules
+     * window.DEBUG.enable('*:obsidian-dev-utils:*'); // show all debug messages for the `obsidian-dev-utils` library within any plugin
+     * window.DEBUG.enable(['foo-bar', 'baz-qux']); // enable multiple namespaces
+     * window.DEBUG.enable('foo-bar,baz-qux'); // enable multiple namespaces using comma-separated string
+     * window.DEBUG.enable('*'); // show all debug messages
+     * ```
+     *
+     * @param namespaces - Single namespace string or array of namespace strings to enable
+     */
+    enable: (namespaces: string | string[]) => void;
+    /**
+     * Get currently configured debug namespaces.
+     *
+     * @example
+     * ```typescript
+     * window.DEBUG.get(); // returns ['foo-bar', 'baz-qux:*', '-lorem-ipsum']
+     * ```
+     *
+     * @returns Array of enabled and disabled (prefixed with `-`) debug namespaces
+     */
+    get: () => string[];
+    /**
+     * Set debug namespaces, replacing all previous configurations.
+     *
+     * @example
+     * ```typescript
+     * window.DEBUG.set(['foo-bar', 'baz-qux:*', '-lorem-ipsum']); // Enable 'foo-bar' and 'baz-qux:*', explicitly disable 'lorem-ipsum'
+     * window.DEBUG.set('foo-bar,baz-qux:*,-lorem-ipsum'); // Same thing using comma-separated string
+     * window.DEBUG.set('*'); // Enable all debug messages
+     * window.DEBUG.set(''); // Disable all debug messages
+     * ```
+     *
+     * @param namespaces - String or array of namespace patterns
+     */
+    set: (namespaces: string | string[]) => void;
+}

package/dist/lib/esm/debug-controller.mjs

@@ -0,0 +1,6 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

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

@@ -0,0 +1,66 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for debugging.
+ */
+import type { Debugger } from 'debug';
+import type { DebugController } from './debug-controller.mjs';
+/**
+ * Parameters for {@link printWithStackTrace}.
+ */
+export interface PrintWithStackTraceParams {
+    /**
+     * The arguments to print.
+     */
+    readonly $arguments: unknown[];
+    /**
+     * The debugger instance.
+     */
+    readonly debuggerInstance: Debugger;
+    /**
+     * The message to print.
+     */
+    readonly message: string;
+    /**
+     * The stack trace to print.
+     */
+    readonly stackTrace: string;
+}
+/**
+ * Enables the debuggers for the library (under its debug namespace, see `Library.debugNamespace`).
+ */
+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 library (under its debug namespace, see `Library.debugNamespace`).
+ *
+ * @param namespace - The namespace for the debugger instance.
+ * @returns A debugger instance for the library (under its debug namespace, see `Library.debugNamespace`).
+ */
+export declare function getLibDebugger(namespace: string): Debugger;
+/**
+ * Prints a message with a stack trace.
+ *
+ * @param params - The parameters for printing the message.
+ */
+export declare function printWithStackTrace(params: PrintWithStackTraceParams): 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,168 @@
+/*
+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 debug from "debug";
+import {
+  CustomStackTraceError,
+  getStackTrace
+} from "./error.mjs";
+import { Library } from "./library.mjs";
+import { getTypescriptLibState } from "./typescript-lib-state.mjs";
+const NAMESPACE_SEPARATOR = ",";
+const NEGATED_NAMESPACE_PREFIX = "-";
+function enableLibraryDebuggers() {
+  enableNamespaces([Library.debugNamespace, `${Library.debugNamespace}:*`]);
+}
+function getDebugController() {
+  return {
+    disable: disableNamespaces,
+    enable: enableNamespaces,
+    get: getNamespaces,
+    set: setNamespaces
+  };
+}
+function getDebugger(namespace, framesToSkip = 0) {
+  const key = `${namespace}:${String(framesToSkip)}`;
+  const debuggersMap = getTypescriptLibState("debuggers", /* @__PURE__ */ new Map()).value;
+  let debuggerEx = debuggersMap.get(key);
+  if (!debuggerEx) {
+    debuggerEx = getSharedDebugLibInstance()(namespace);
+    debuggerEx.log = (message, ...$arguments) => {
+      logWithCaller({
+        $arguments,
+        framesToSkip,
+        message,
+        namespace
+      });
+    };
+    debuggersMap.set(key, debuggerEx);
+  }
+  return debuggerEx;
+}
+function getLibDebugger(namespace) {
+  return getDebugger(`${Library.debugPrefixNamespace}${Library.debugNamespace}:${namespace}`);
+}
+function printWithStackTrace(params) {
+  const {
+    $arguments,
+    debuggerInstance,
+    message,
+    stackTrace
+  } = params;
+  if (!Library.shouldPrintStackTrace) {
+    debuggerInstance(message, ...$arguments);
+    return;
+  }
+  debuggerInstance(message, ...$arguments, "\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}.${formatGuideReference(` 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;
+    set.delete(namespace);
+    set.add(negatedNamespace);
+  }
+  setNamespaces([...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;
+      set.delete(negatedNamespace);
+    }
+    set.add(namespace);
+  }
+  setNamespaces([...set]);
+}
+function formatGuideReference(suffix) {
+  return Library.debugGuideUrl ? ` See ${Library.debugGuideUrl}${suffix}.` : "";
+}
+function getNamespaces() {
+  return toArray(getSharedDebugLibInstance().load() ?? "");
+}
+function getSharedDebugLibInstance() {
+  return getTypescriptLibState("debug", debug).value;
+}
+function logWithCaller(params) {
+  const {
+    $arguments,
+    framesToSkip,
+    message,
+    namespace
+  } = params;
+  if (!getSharedDebugLibInstance().enabled(namespace)) {
+    return;
+  }
+  if (!Library.shouldPrintStackTrace) {
+    console.debug(message, ...$arguments);
+    return;
+  }
+  const CALLER_FRAME_INDEX = 3;
+  console.debug(message, ...$arguments, "\n\n---\nLogger stack trace:\n", makeStackTraceError(getStackTrace(CALLER_FRAME_INDEX + framesToSkip)));
+}
+function makeStackTraceError(stackTrace) {
+  return new CustomStackTraceError({
+    cause: void 0,
+    message: `Debug mode: intentional placeholder error.${formatGuideReference("")}`,
+    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((namespace) => toArray(namespace));
+}
+export {
+  enableLibraryDebuggers,
+  getDebugController,
+  getDebugger,
+  getLibDebugger,
+  printWithStackTrace,
+  showInitialDebugMessage
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/debug.ts"],"sourcesContent":["/**\n * @file\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 {\n  CustomStackTraceError,\n  getStackTrace\n} from './error.ts';\nimport { Library } from './library.ts';\nimport { getTypescriptLibState } from './typescript-lib-state.ts';\n\nconst NAMESPACE_SEPARATOR = ',';\nconst NEGATED_NAMESPACE_PREFIX = '-';\n\n/**\n * Parameters for {@link printWithStackTrace}.\n */\nexport interface PrintWithStackTraceParams {\n  /**\n   * The arguments to print.\n   */\n  readonly $arguments: unknown[];\n\n  /**\n   * The debugger instance.\n   */\n  readonly debuggerInstance: Debugger;\n\n  /**\n   * The message to print.\n   */\n  readonly message: string;\n\n  /**\n   * The stack trace to print.\n   */\n  readonly stackTrace: string;\n}\n\n/**\n * Parameters for {@link logWithCaller}.\n */\ninterface LogWithCallerParams {\n  /**\n   * The arguments to print.\n   */\n  readonly $arguments: unknown[];\n\n  /**\n   * The number of frames to skip in the stack trace.\n   */\n  readonly framesToSkip: number;\n\n  /**\n   * The message to print.\n   */\n  readonly message: string;\n\n  /**\n   * The namespace for the debugger instance.\n   */\n  readonly namespace: string;\n}\n\n/**\n * Enables the debuggers for the library (under its debug namespace, see `Library.debugNamespace`).\n */\nexport function enableLibraryDebuggers(): void {\n  enableNamespaces([Library.debugNamespace, `${Library.debugNamespace}:*`]);\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 = getTypescriptLibState('debuggers', new Map<string, Debugger>()).value;\n  let debuggerEx = debuggersMap.get(key);\n  if (!debuggerEx) {\n    debuggerEx = getSharedDebugLibInstance()(namespace);\n    debuggerEx.log = (message: string, ...$arguments: unknown[]): void => {\n      logWithCaller({\n        $arguments,\n        framesToSkip,\n        message,\n        namespace\n      });\n    };\n\n    debuggersMap.set(key, debuggerEx);\n  }\n\n  return debuggerEx;\n}\n\n/**\n * Returns a debugger instance for the library (under its debug namespace, see `Library.debugNamespace`).\n *\n * @param namespace - The namespace for the debugger instance.\n * @returns A debugger instance for the library (under its debug namespace, see `Library.debugNamespace`).\n */\nexport function getLibDebugger(namespace: string): Debugger {\n  return getDebugger(`${Library.debugPrefixNamespace}${Library.debugNamespace}:${namespace}`);\n}\n\n/**\n * Prints a message with a stack trace.\n *\n * @param params - The parameters for printing the message.\n */\nexport function printWithStackTrace(params: PrintWithStackTraceParams): void {\n  const {\n    $arguments,\n    debuggerInstance,\n    message,\n    stackTrace\n  } = params;\n  if (!Library.shouldPrintStackTrace) {\n    debuggerInstance(message, ...$arguments);\n    return;\n  }\n\n  debuggerInstance(message, ...$arguments, '\\n\\n---\\nContext stack trace:\\n', makeStackTraceError(stackTrace));\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}.${formatGuideReference(` 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    set.delete(namespace);\n    set.add(negatedNamespace);\n  }\n  setNamespaces([...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      set.delete(negatedNamespace);\n    }\n    set.add(namespace);\n  }\n  setNamespaces([...set]);\n}\n\nfunction formatGuideReference(suffix: string): string {\n  return Library.debugGuideUrl ? ` See ${Library.debugGuideUrl}${suffix}.` : '';\n}\n\nfunction getNamespaces(): string[] {\n  return toArray(getSharedDebugLibInstance().load() ?? '');\n}\n\nfunction getSharedDebugLibInstance(): typeof debug {\n  return getTypescriptLibState('debug', debug).value;\n}\n\nfunction logWithCaller(params: LogWithCallerParams): void {\n  const {\n    $arguments,\n    framesToSkip,\n    message,\n    namespace\n  } = params;\n  if (!getSharedDebugLibInstance().enabled(namespace)) {\n    return;\n  }\n\n  if (!Library.shouldPrintStackTrace) {\n    // eslint-disable-next-line no-console -- Valid usage.\n    console.debug(message, ...$arguments);\n    return;\n  }\n\n  /**\n   * The caller is 3 frames above this one, because the call stack is as follows:\n   *\n   * 0: logWithCaller\n   * 1: debugInstance.log\n   * 2: debug\n   * 3: functionName (the caller)\n   *\n   * `getStackTrace` drops its own frame and, on an engine that writes one, the `Error` header line.\n   */\n  const CALLER_FRAME_INDEX = 3;\n\n  // eslint-disable-next-line no-console -- Valid usage.\n  console.debug(message, ...$arguments, '\\n\\n---\\nLogger stack trace:\\n', makeStackTraceError(getStackTrace(CALLER_FRAME_INDEX + framesToSkip)));\n}\n\nfunction makeStackTraceError(stackTrace: string): CustomStackTraceError {\n  return new CustomStackTraceError({\n    cause: undefined,\n    message: `Debug mode: intentional placeholder error.${formatGuideReference('')}`,\n    stackTrace\n  });\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((namespace) => toArray(namespace));\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/desktop-zip-extractor.d.mts

@@ -0,0 +1,96 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference types="node" />
+/**
+ * @file
+ *
+ * Extracts a ZIP archive to disk using only Node's `zlib` — with no third-party unzip dependency.
+ *
+ * It exists for one measured reason. The dependency it replaced on this path, `adm-zip`, bundled
+ * roughly 34 KB of minified JavaScript into EVERY Obsidian plugin built with this library: a plugin
+ * ships a single CJS `main.js`, esbuild has no code splitting to put a dependency behind, and a
+ * `await import()` only defers evaluation — the module body is inlined either way. `node:zlib` is
+ * already an esbuild external, so the same work now costs a plugin bundle nothing at all. Archives are
+ * WRITTEN with `fflate` at release time (`script-utils/demo-vault.ts`), which is Node-side tooling and
+ * never reaches a plugin bundle — a third-party writer there is also what keeps this reader checked
+ * against an implementation that is not its own.
+ *
+ * Deliberately narrow: it reads exactly what that writer produces — stored and deflated entries in an
+ * unencrypted archive below the 4 GB / 65535-entry ZIP64 threshold — and raises a named error for
+ * anything else rather than guessing at it. Sizes and offsets are taken from the central directory,
+ * which is authoritative even for archives written with data descriptors.
+ *
+ * The `node:` imports below are safe to merely EVALUATE on mobile — `require` hands back `undefined`
+ * there and nothing reads it at load time — so this module can sit in the generated barrels without
+ * breaking the library's load on Android. Only the calls are desktop-only.
+ */
+import type { Buffer } from 'node:buffer';
+/**
+ * Parameters for {@link extractZipArchive}.
+ */
+export interface ExtractZipArchiveParams {
+    /**
+     * The raw ZIP archive bytes.
+     */
+    readonly archive: Buffer;
+    /**
+     * The file-system implementation the extracted entries are written with.
+     *
+     * Injected rather than imported so the caller chooses which `fs` writes the files. The demo-vault
+     * opener hands over Electron's `original-fs` (see {@link ZipExtractionFileSystem}).
+     */
+    readonly fileSystem: ZipExtractionFileSystem;
+    /**
+     * The directory to extract into. Created if it does not exist.
+     */
+    readonly targetDirectory: string;
+}
+/**
+ * The slice of `node:fs` extraction needs.
+ *
+ * Only the two WRITING calls are required, and that is deliberate: Electron's asar layer intercepts
+ * `fs` READS (and `existsSync`) on any path containing `.asar`, which a demo vault may legitimately
+ * ship as a plain file. Never probing the target with a read keeps that interception out of the
+ * picture entirely, and a caller that hands over Electron's `original-fs` is safe even from the
+ * write side.
+ */
+export interface ZipExtractionFileSystem {
+    /**
+     * Creates a directory, including any missing parents.
+     *
+     * @param path - The directory to create.
+     * @param options - The {@link ZipExtractionMkdirOptions}.
+     * @returns The first directory created, if any.
+     */
+    mkdirSync: (path: string, options: ZipExtractionMkdirOptions) => string | undefined;
+    /**
+     * Writes a file, overwriting it if it exists.
+     *
+     * @param path - The file to write.
+     * @param data - The bytes to write.
+     */
+    writeFileSync: (path: string, data: Buffer) => void;
+}
+/**
+ * The options {@link ZipExtractionFileSystem.mkdirSync} is always called with.
+ *
+ * Extraction never probes for an existing directory, so every call has to create the missing parents
+ * itself and tolerate a directory that is already there.
+ */
+export interface ZipExtractionMkdirOptions {
+    /**
+     * Always `true`.
+     */
+    readonly recursive: true;
+}
+/**
+ * Extracts every entry of a ZIP archive into a directory.
+ *
+ * Directory entries become directories; a file entry's parents are created whether or not the archive
+ * declared them. An entry whose name would escape {@link ExtractZipArchiveParams.targetDirectory} is
+ * refused rather than written (the "zip slip" traversal), as is an encrypted, ZIP64, or
+ * unknown-compression archive.
+ *
+ * @param params - The {@link ExtractZipArchiveParams}.
+ * @throws An {@link Error} naming the reason when the archive cannot be read as written.
+ */
+export declare function extractZipArchive(params: ExtractZipArchiveParams): void;