@mnaoumov/typescript-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/desktop-zip-extractor.cjs

@@ -0,0 +1,157 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var desktop_zip_extractor_exports = {};
+__export(desktop_zip_extractor_exports, {
+  extractZipArchive: () => extractZipArchive
+});
+module.exports = __toCommonJS(desktop_zip_extractor_exports);
+var import_node_zlib = require('node:zlib');
+var import_path = require('./path.cjs');
+const END_OF_CENTRAL_DIRECTORY_SIGNATURE = 101010256;
+const CENTRAL_DIRECTORY_HEADER_SIGNATURE = 33639248;
+const LOCAL_FILE_HEADER_SIGNATURE = 67324752;
+const END_OF_CENTRAL_DIRECTORY_SIZE = 22;
+const MAX_ARCHIVE_COMMENT_LENGTH = 65535;
+const SATURATED_UINT_16 = 65535;
+const SATURATED_UINT_32 = 4294967295;
+const ARCHIVE_ENTRY_COUNT_OFFSET = 10;
+const CENTRAL_DIRECTORY_START_OFFSET = 16;
+const CENTRAL_DIRECTORY_FLAGS_OFFSET = 8;
+const CENTRAL_DIRECTORY_COMPRESSION_METHOD_OFFSET = 10;
+const CENTRAL_DIRECTORY_COMPRESSED_SIZE_OFFSET = 20;
+const CENTRAL_DIRECTORY_NAME_LENGTH_OFFSET = 28;
+const CENTRAL_DIRECTORY_EXTRA_LENGTH_OFFSET = 30;
+const CENTRAL_DIRECTORY_COMMENT_LENGTH_OFFSET = 32;
+const CENTRAL_DIRECTORY_LOCAL_HEADER_OFFSET_OFFSET = 42;
+const CENTRAL_DIRECTORY_HEADER_SIZE = 46;
+const LOCAL_HEADER_NAME_LENGTH_OFFSET = 26;
+const LOCAL_HEADER_EXTRA_LENGTH_OFFSET = 28;
+const LOCAL_HEADER_SIZE = 30;
+const COMPRESSION_METHOD_STORED = 0;
+const COMPRESSION_METHOD_DEFLATED = 8;
+const ENCRYPTED_FLAG_DIVISOR = 2;
+const ENTRY_NAME_SEPARATOR = "/";
+const WINDOWS_DRIVE_PREFIX_REG_EXP = /^[A-Za-z]:/;
+function extractZipArchive(params) {
+  const {
+    archive,
+    fileSystem,
+    targetDirectory
+  } = params;
+  fileSystem.mkdirSync(targetDirectory, { recursive: true });
+  for (const entry of readCentralDirectory(archive)) {
+    assertSafeEntryName(entry.name);
+    if (entry.name.endsWith(ENTRY_NAME_SEPARATOR)) {
+      fileSystem.mkdirSync((0, import_path.join)(targetDirectory, entry.name.slice(0, -1)), { recursive: true });
+      continue;
+    }
+    const entryPath = (0, import_path.join)(targetDirectory, entry.name);
+    fileSystem.mkdirSync((0, import_path.dirname)(entryPath), { recursive: true });
+    fileSystem.writeFileSync(entryPath, readEntryData(archive, entry));
+  }
+}
+function assertSafeEntryName(entryName) {
+  if (entryName.startsWith(ENTRY_NAME_SEPARATOR)) {
+    throw new Error(`Refusing to extract the absolute archive entry '${entryName}'.`);
+  }
+  if (WINDOWS_DRIVE_PREFIX_REG_EXP.test(entryName)) {
+    throw new Error(`Refusing to extract the drive-qualified archive entry '${entryName}'.`);
+  }
+  if (entryName.includes("\\")) {
+    throw new Error(`Refusing to extract the archive entry '${entryName}', which uses a backslash separator.`);
+  }
+  if (entryName.split(ENTRY_NAME_SEPARATOR).includes("..")) {
+    throw new Error(`Refusing to extract the archive entry '${entryName}', which points outside the target directory.`);
+  }
+}
+function findEndOfCentralDirectoryOffset(archive) {
+  const lastPossibleOffset = archive.length - END_OF_CENTRAL_DIRECTORY_SIZE;
+  const firstPossibleOffset = Math.max(0, lastPossibleOffset - MAX_ARCHIVE_COMMENT_LENGTH);
+  for (let offset = lastPossibleOffset; offset >= firstPossibleOffset; offset--) {
+    if (archive.readUInt32LE(offset) === END_OF_CENTRAL_DIRECTORY_SIGNATURE) {
+      return offset;
+    }
+  }
+  throw new Error("The archive is not a ZIP file: its end-of-central-directory record is missing.");
+}
+function readCentralDirectory(archive) {
+  const endOfCentralDirectoryOffset = findEndOfCentralDirectoryOffset(archive);
+  const entryCount = archive.readUInt16LE(endOfCentralDirectoryOffset + ARCHIVE_ENTRY_COUNT_OFFSET);
+  let entryOffset = archive.readUInt32LE(endOfCentralDirectoryOffset + CENTRAL_DIRECTORY_START_OFFSET);
+  if (entryCount === SATURATED_UINT_16 || entryOffset === SATURATED_UINT_32) {
+    throw new Error("ZIP64 archives are not supported.");
+  }
+  const entries = [];
+  for (let entryIndex = 0; entryIndex < entryCount; entryIndex++) {
+    if (archive.readUInt32LE(entryOffset) !== CENTRAL_DIRECTORY_HEADER_SIGNATURE) {
+      throw new Error(`The archive's central directory is corrupt at entry ${String(entryIndex)}.`);
+    }
+    const flags = archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_FLAGS_OFFSET);
+    if (flags % ENCRYPTED_FLAG_DIVISOR === 1) {
+      throw new Error("Encrypted ZIP archives are not supported.");
+    }
+    const compressedSize = archive.readUInt32LE(entryOffset + CENTRAL_DIRECTORY_COMPRESSED_SIZE_OFFSET);
+    const localHeaderOffset = archive.readUInt32LE(entryOffset + CENTRAL_DIRECTORY_LOCAL_HEADER_OFFSET_OFFSET);
+    if (compressedSize === SATURATED_UINT_32 || localHeaderOffset === SATURATED_UINT_32) {
+      throw new Error("ZIP64 archives are not supported.");
+    }
+    const nameLength = archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_NAME_LENGTH_OFFSET);
+    const nameOffset = entryOffset + CENTRAL_DIRECTORY_HEADER_SIZE;
+    entries.push({
+      compressedSize,
+      compressionMethod: archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_COMPRESSION_METHOD_OFFSET),
+      localHeaderOffset,
+      name: archive.toString("utf-8", nameOffset, nameOffset + nameLength)
+    });
+    entryOffset = nameOffset + nameLength + archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_EXTRA_LENGTH_OFFSET) + archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_COMMENT_LENGTH_OFFSET);
+  }
+  return entries;
+}
+function readEntryData(archive, entry) {
+  if (archive.readUInt32LE(entry.localHeaderOffset) !== LOCAL_FILE_HEADER_SIGNATURE) {
+    throw new Error(`The archive entry '${entry.name}' has a corrupt local header.`);
+  }
+  const dataOffset = entry.localHeaderOffset + LOCAL_HEADER_SIZE + archive.readUInt16LE(entry.localHeaderOffset + LOCAL_HEADER_NAME_LENGTH_OFFSET) + archive.readUInt16LE(entry.localHeaderOffset + LOCAL_HEADER_EXTRA_LENGTH_OFFSET);
+  const dataEnd = dataOffset + entry.compressedSize;
+  if (dataEnd > archive.length) {
+    throw new Error(`The archive is truncated: entry '${entry.name}' runs past its end.`);
+  }
+  const compressedData = archive.subarray(dataOffset, dataEnd);
+  switch (entry.compressionMethod) {
+    case COMPRESSION_METHOD_DEFLATED: {
+      return (0, import_node_zlib.inflateRawSync)(compressedData);
+    }
+    case COMPRESSION_METHOD_STORED: {
+      return compressedData;
+    }
+    default: {
+      throw new Error(`The archive entry '${entry.name}' uses unsupported compression method ${String(entry.compressionMethod)}.`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractZipArchive
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/desktop-zip-extractor.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Extracts a ZIP archive to disk using only Node's `zlib` \u2014 with no third-party unzip dependency.\n *\n * It exists for one measured reason. The dependency it replaced on this path, `adm-zip`, bundled\n * roughly 34 KB of minified JavaScript into EVERY Obsidian plugin built with this library: a plugin\n * ships a single CJS `main.js`, esbuild has no code splitting to put a dependency behind, and a\n * `await import()` only defers evaluation \u2014 the module body is inlined either way. `node:zlib` is\n * already an esbuild external, so the same work now costs a plugin bundle nothing at all. Archives are\n * WRITTEN with `fflate` at release time (`script-utils/demo-vault.ts`), which is Node-side tooling and\n * never reaches a plugin bundle \u2014 a third-party writer there is also what keeps this reader checked\n * against an implementation that is not its own.\n *\n * Deliberately narrow: it reads exactly what that writer produces \u2014 stored and deflated entries in an\n * unencrypted archive below the 4 GB / 65535-entry ZIP64 threshold \u2014 and raises a named error for\n * anything else rather than guessing at it. Sizes and offsets are taken from the central directory,\n * which is authoritative even for archives written with data descriptors.\n *\n * The `node:` imports below are safe to merely EVALUATE on mobile \u2014 `require` hands back `undefined`\n * there and nothing reads it at load time \u2014 so this module can sit in the generated barrels without\n * breaking the library's load on Android. Only the calls are desktop-only.\n */\n\nimport type { Buffer } from 'node:buffer';\n\nimport { inflateRawSync } from 'node:zlib';\n\nimport {\n  dirname,\n  join\n} from './path.ts';\n\n/**\n * Parameters for {@link extractZipArchive}.\n */\nexport interface ExtractZipArchiveParams {\n  /**\n   * The raw ZIP archive bytes.\n   */\n  readonly archive: Buffer;\n\n  /**\n   * The file-system implementation the extracted entries are written with.\n   *\n   * Injected rather than imported so the caller chooses which `fs` writes the files. The demo-vault\n   * opener hands over Electron's `original-fs` (see {@link ZipExtractionFileSystem}).\n   */\n  readonly fileSystem: ZipExtractionFileSystem;\n\n  /**\n   * The directory to extract into. Created if it does not exist.\n   */\n  readonly targetDirectory: string;\n}\n\n/**\n * The slice of `node:fs` extraction needs.\n *\n * Only the two WRITING calls are required, and that is deliberate: Electron's asar layer intercepts\n * `fs` READS (and `existsSync`) on any path containing `.asar`, which a demo vault may legitimately\n * ship as a plain file. Never probing the target with a read keeps that interception out of the\n * picture entirely, and a caller that hands over Electron's `original-fs` is safe even from the\n * write side.\n */\nexport interface ZipExtractionFileSystem {\n  /**\n   * Creates a directory, including any missing parents.\n   *\n   * @param path - The directory to create.\n   * @param options - The {@link ZipExtractionMkdirOptions}.\n   * @returns The first directory created, if any.\n   */\n  mkdirSync: (path: string, options: ZipExtractionMkdirOptions) => string | undefined;\n\n  /**\n   * Writes a file, overwriting it if it exists.\n   *\n   * @param path - The file to write.\n   * @param data - The bytes to write.\n   */\n  writeFileSync: (path: string, data: Buffer) => void;\n}\n\n/**\n * The options {@link ZipExtractionFileSystem.mkdirSync} is always called with.\n *\n * Extraction never probes for an existing directory, so every call has to create the missing parents\n * itself and tolerate a directory that is already there.\n */\nexport interface ZipExtractionMkdirOptions {\n  /**\n   * Always `true`.\n   */\n  readonly recursive: true;\n}\n\ninterface ZipEntry {\n  readonly compressedSize: number;\n  readonly compressionMethod: number;\n  readonly localHeaderOffset: number;\n  readonly name: string;\n}\n\nconst END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06_05_4B_50;\nconst CENTRAL_DIRECTORY_HEADER_SIGNATURE = 0x02_01_4B_50;\nconst LOCAL_FILE_HEADER_SIGNATURE = 0x04_03_4B_50;\n\nconst END_OF_CENTRAL_DIRECTORY_SIZE = 22;\nconst MAX_ARCHIVE_COMMENT_LENGTH = 65_535;\n\n// A count or offset saturated to all-ones means the real value lives in a ZIP64 record this reader\n// does not implement, so the field must never be read at face value.\nconst SATURATED_UINT_16 = 65_535;\nconst SATURATED_UINT_32 = 4_294_967_295;\n\n// Field offsets within the end-of-central-directory record.\nconst ARCHIVE_ENTRY_COUNT_OFFSET = 10;\nconst CENTRAL_DIRECTORY_START_OFFSET = 16;\n\n// Field offsets within a central-directory header.\nconst CENTRAL_DIRECTORY_FLAGS_OFFSET = 8;\nconst CENTRAL_DIRECTORY_COMPRESSION_METHOD_OFFSET = 10;\nconst CENTRAL_DIRECTORY_COMPRESSED_SIZE_OFFSET = 20;\nconst CENTRAL_DIRECTORY_NAME_LENGTH_OFFSET = 28;\nconst CENTRAL_DIRECTORY_EXTRA_LENGTH_OFFSET = 30;\nconst CENTRAL_DIRECTORY_COMMENT_LENGTH_OFFSET = 32;\nconst CENTRAL_DIRECTORY_LOCAL_HEADER_OFFSET_OFFSET = 42;\nconst CENTRAL_DIRECTORY_HEADER_SIZE = 46;\n\n// Field offsets within a local file header.\nconst LOCAL_HEADER_NAME_LENGTH_OFFSET = 26;\nconst LOCAL_HEADER_EXTRA_LENGTH_OFFSET = 28;\nconst LOCAL_HEADER_SIZE = 30;\n\nconst COMPRESSION_METHOD_STORED = 0;\nconst COMPRESSION_METHOD_DEFLATED = 8;\n\n// Bit 0 of the general-purpose flags marks an encrypted entry, and it is the lowest bit \u2014 so the\n// remainder tests it without reaching for a bitwise operator.\nconst ENCRYPTED_FLAG_DIVISOR = 2;\n\nconst ENTRY_NAME_SEPARATOR = '/';\nconst WINDOWS_DRIVE_PREFIX_REG_EXP = /^[A-Za-z]:/;\n\n/**\n * Extracts every entry of a ZIP archive into a directory.\n *\n * Directory entries become directories; a file entry's parents are created whether or not the archive\n * declared them. An entry whose name would escape {@link ExtractZipArchiveParams.targetDirectory} is\n * refused rather than written (the \"zip slip\" traversal), as is an encrypted, ZIP64, or\n * unknown-compression archive.\n *\n * @param params - The {@link ExtractZipArchiveParams}.\n * @throws An {@link Error} naming the reason when the archive cannot be read as written.\n */\nexport function extractZipArchive(params: ExtractZipArchiveParams): void {\n  const {\n    archive,\n    fileSystem,\n    targetDirectory\n  } = params;\n\n  fileSystem.mkdirSync(targetDirectory, { recursive: true });\n\n  for (const entry of readCentralDirectory(archive)) {\n    assertSafeEntryName(entry.name);\n\n    if (entry.name.endsWith(ENTRY_NAME_SEPARATOR)) {\n      // Named without its trailing separator, so the created path reads the same as every other one.\n      fileSystem.mkdirSync(join(targetDirectory, entry.name.slice(0, -1)), { recursive: true });\n      continue;\n    }\n\n    const entryPath = join(targetDirectory, entry.name);\n    fileSystem.mkdirSync(dirname(entryPath), { recursive: true });\n    fileSystem.writeFileSync(entryPath, readEntryData(archive, entry));\n  }\n}\n\n/**\n * Refuses an entry name that would place the extracted file outside the target directory.\n *\n * An archive is untrusted input even when we published it ourselves, and every one of these shapes\n * escapes the target: an absolute POSIX path, a Windows drive-qualified path, a backslash (which the\n * ZIP specification forbids as a separator, so its only use here is to smuggle one past a\n * forward-slash check), and a `..` segment.\n *\n * @param entryName - The entry name as recorded in the archive.\n */\nfunction assertSafeEntryName(entryName: string): void {\n  if (entryName.startsWith(ENTRY_NAME_SEPARATOR)) {\n    throw new Error(`Refusing to extract the absolute archive entry '${entryName}'.`);\n  }\n\n  if (WINDOWS_DRIVE_PREFIX_REG_EXP.test(entryName)) {\n    throw new Error(`Refusing to extract the drive-qualified archive entry '${entryName}'.`);\n  }\n\n  if (entryName.includes('\\\\')) {\n    throw new Error(`Refusing to extract the archive entry '${entryName}', which uses a backslash separator.`);\n  }\n\n  if (entryName.split(ENTRY_NAME_SEPARATOR).includes('..')) {\n    throw new Error(`Refusing to extract the archive entry '${entryName}', which points outside the target directory.`);\n  }\n}\n\n/**\n * Locates the end-of-central-directory record and returns its offset.\n *\n * The record sits at the very end of the archive unless a trailing comment follows it, so it is found\n * by scanning backwards over the comment's maximum length rather than assumed to be at a fixed place.\n *\n * @param archive - The raw ZIP archive bytes.\n * @returns The record's offset.\n */\nfunction findEndOfCentralDirectoryOffset(archive: Buffer): number {\n  const lastPossibleOffset = archive.length - END_OF_CENTRAL_DIRECTORY_SIZE;\n  const firstPossibleOffset = Math.max(0, lastPossibleOffset - MAX_ARCHIVE_COMMENT_LENGTH);\n\n  for (let offset = lastPossibleOffset; offset >= firstPossibleOffset; offset--) {\n    if (archive.readUInt32LE(offset) === END_OF_CENTRAL_DIRECTORY_SIGNATURE) {\n      return offset;\n    }\n  }\n\n  throw new Error('The archive is not a ZIP file: its end-of-central-directory record is missing.');\n}\n\n/**\n * Reads the central directory, which is the archive's authoritative index of its entries.\n *\n * @param archive - The raw ZIP archive bytes.\n * @returns One {@link ZipEntry} per entry, in the order the archive lists them.\n */\nfunction readCentralDirectory(archive: Buffer): ZipEntry[] {\n  const endOfCentralDirectoryOffset = findEndOfCentralDirectoryOffset(archive);\n  const entryCount = archive.readUInt16LE(endOfCentralDirectoryOffset + ARCHIVE_ENTRY_COUNT_OFFSET);\n  let entryOffset = archive.readUInt32LE(endOfCentralDirectoryOffset + CENTRAL_DIRECTORY_START_OFFSET);\n\n  if (entryCount === SATURATED_UINT_16 || entryOffset === SATURATED_UINT_32) {\n    throw new Error('ZIP64 archives are not supported.');\n  }\n\n  const entries: ZipEntry[] = [];\n  for (let entryIndex = 0; entryIndex < entryCount; entryIndex++) {\n    if (archive.readUInt32LE(entryOffset) !== CENTRAL_DIRECTORY_HEADER_SIGNATURE) {\n      throw new Error(`The archive's central directory is corrupt at entry ${String(entryIndex)}.`);\n    }\n\n    const flags = archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_FLAGS_OFFSET);\n    if (flags % ENCRYPTED_FLAG_DIVISOR === 1) {\n      throw new Error('Encrypted ZIP archives are not supported.');\n    }\n\n    const compressedSize = archive.readUInt32LE(entryOffset + CENTRAL_DIRECTORY_COMPRESSED_SIZE_OFFSET);\n    const localHeaderOffset = archive.readUInt32LE(entryOffset + CENTRAL_DIRECTORY_LOCAL_HEADER_OFFSET_OFFSET);\n    if (compressedSize === SATURATED_UINT_32 || localHeaderOffset === SATURATED_UINT_32) {\n      throw new Error('ZIP64 archives are not supported.');\n    }\n\n    const nameLength = archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_NAME_LENGTH_OFFSET);\n    const nameOffset = entryOffset + CENTRAL_DIRECTORY_HEADER_SIZE;\n    entries.push({\n      compressedSize,\n      compressionMethod: archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_COMPRESSION_METHOD_OFFSET),\n      localHeaderOffset,\n      name: archive.toString('utf-8', nameOffset, nameOffset + nameLength)\n    });\n\n    entryOffset = nameOffset\n      + nameLength\n      + archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_EXTRA_LENGTH_OFFSET)\n      + archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_COMMENT_LENGTH_OFFSET);\n  }\n\n  return entries;\n}\n\n/**\n * Reads and decompresses one entry's bytes.\n *\n * The data's start is computed from the LOCAL header rather than the central one: the two carry\n * independent name and extra-field lengths, and only the local pair describes where the bytes\n * actually begin.\n *\n * @param archive - The raw ZIP archive bytes.\n * @param entry - The entry, as read from the central directory.\n * @returns The entry's uncompressed content.\n */\nfunction readEntryData(archive: Buffer, entry: ZipEntry): Buffer {\n  if (archive.readUInt32LE(entry.localHeaderOffset) !== LOCAL_FILE_HEADER_SIGNATURE) {\n    throw new Error(`The archive entry '${entry.name}' has a corrupt local header.`);\n  }\n\n  const dataOffset = entry.localHeaderOffset\n    + LOCAL_HEADER_SIZE\n    + archive.readUInt16LE(entry.localHeaderOffset + LOCAL_HEADER_NAME_LENGTH_OFFSET)\n    + archive.readUInt16LE(entry.localHeaderOffset + LOCAL_HEADER_EXTRA_LENGTH_OFFSET);\n  const dataEnd = dataOffset + entry.compressedSize;\n  if (dataEnd > archive.length) {\n    throw new Error(`The archive is truncated: entry '${entry.name}' runs past its end.`);\n  }\n\n  const compressedData = archive.subarray(dataOffset, dataEnd);\n  switch (entry.compressionMethod) {\n    case COMPRESSION_METHOD_DEFLATED: {\n      return inflateRawSync(compressedData);\n    }\n    case COMPRESSION_METHOD_STORED: {\n      return compressedData;\n    }\n    default: {\n      throw new Error(`The archive entry '${entry.name}' uses unsupported compression method ${String(entry.compressionMethod)}.`);\n    }\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BA,uBAA+B;AAE/B,kBAGO;AAyEP,MAAM,qCAAqC;AAC3C,MAAM,qCAAqC;AAC3C,MAAM,8BAA8B;AAEpC,MAAM,gCAAgC;AACtC,MAAM,6BAA6B;AAInC,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB;AAG1B,MAAM,6BAA6B;AACnC,MAAM,iCAAiC;AAGvC,MAAM,iCAAiC;AACvC,MAAM,8CAA8C;AACpD,MAAM,2CAA2C;AACjD,MAAM,uCAAuC;AAC7C,MAAM,wCAAwC;AAC9C,MAAM,0CAA0C;AAChD,MAAM,+CAA+C;AACrD,MAAM,gCAAgC;AAGtC,MAAM,kCAAkC;AACxC,MAAM,mCAAmC;AACzC,MAAM,oBAAoB;AAE1B,MAAM,4BAA4B;AAClC,MAAM,8BAA8B;AAIpC,MAAM,yBAAyB;AAE/B,MAAM,uBAAuB;AAC7B,MAAM,+BAA+B;AAa9B,SAAS,kBAAkB,QAAuC;AACvE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,aAAW,UAAU,iBAAiB,EAAE,WAAW,KAAK,CAAC;AAEzD,aAAW,SAAS,qBAAqB,OAAO,GAAG;AACjD,wBAAoB,MAAM,IAAI;AAE9B,QAAI,MAAM,KAAK,SAAS,oBAAoB,GAAG;AAE7C,iBAAW,cAAU,kBAAK,iBAAiB,MAAM,KAAK,MAAM,GAAG,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,CAAC;AACxF;AAAA,IACF;AAEA,UAAM,gBAAY,kBAAK,iBAAiB,MAAM,IAAI;AAClD,eAAW,cAAU,qBAAQ,SAAS,GAAG,EAAE,WAAW,KAAK,CAAC;AAC5D,eAAW,cAAc,WAAW,cAAc,SAAS,KAAK,CAAC;AAAA,EACnE;AACF;AAYA,SAAS,oBAAoB,WAAyB;AACpD,MAAI,UAAU,WAAW,oBAAoB,GAAG;AAC9C,UAAM,IAAI,MAAM,mDAAmD,SAAS,IAAI;AAAA,EAClF;AAEA,MAAI,6BAA6B,KAAK,SAAS,GAAG;AAChD,UAAM,IAAI,MAAM,0DAA0D,SAAS,IAAI;AAAA,EACzF;AAEA,MAAI,UAAU,SAAS,IAAI,GAAG;AAC5B,UAAM,IAAI,MAAM,0CAA0C,SAAS,sCAAsC;AAAA,EAC3G;AAEA,MAAI,UAAU,MAAM,oBAAoB,EAAE,SAAS,IAAI,GAAG;AACxD,UAAM,IAAI,MAAM,0CAA0C,SAAS,+CAA+C;AAAA,EACpH;AACF;AAWA,SAAS,gCAAgC,SAAyB;AAChE,QAAM,qBAAqB,QAAQ,SAAS;AAC5C,QAAM,sBAAsB,KAAK,IAAI,GAAG,qBAAqB,0BAA0B;AAEvF,WAAS,SAAS,oBAAoB,UAAU,qBAAqB,UAAU;AAC7E,QAAI,QAAQ,aAAa,MAAM,MAAM,oCAAoC;AACvE,aAAO;AAAA,IACT;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,gFAAgF;AAClG;AAQA,SAAS,qBAAqB,SAA6B;AACzD,QAAM,8BAA8B,gCAAgC,OAAO;AAC3E,QAAM,aAAa,QAAQ,aAAa,8BAA8B,0BAA0B;AAChG,MAAI,cAAc,QAAQ,aAAa,8BAA8B,8BAA8B;AAEnG,MAAI,eAAe,qBAAqB,gBAAgB,mBAAmB;AACzE,UAAM,IAAI,MAAM,mCAAmC;AAAA,EACrD;AAEA,QAAM,UAAsB,CAAC;AAC7B,WAAS,aAAa,GAAG,aAAa,YAAY,cAAc;AAC9D,QAAI,QAAQ,aAAa,WAAW,MAAM,oCAAoC;AAC5E,YAAM,IAAI,MAAM,uDAAuD,OAAO,UAAU,CAAC,GAAG;AAAA,IAC9F;AAEA,UAAM,QAAQ,QAAQ,aAAa,cAAc,8BAA8B;AAC/E,QAAI,QAAQ,2BAA2B,GAAG;AACxC,YAAM,IAAI,MAAM,2CAA2C;AAAA,IAC7D;AAEA,UAAM,iBAAiB,QAAQ,aAAa,cAAc,wCAAwC;AAClG,UAAM,oBAAoB,QAAQ,aAAa,cAAc,4CAA4C;AACzG,QAAI,mBAAmB,qBAAqB,sBAAsB,mBAAmB;AACnF,YAAM,IAAI,MAAM,mCAAmC;AAAA,IACrD;AAEA,UAAM,aAAa,QAAQ,aAAa,cAAc,oCAAoC;AAC1F,UAAM,aAAa,cAAc;AACjC,YAAQ,KAAK;AAAA,MACX;AAAA,MACA,mBAAmB,QAAQ,aAAa,cAAc,2CAA2C;AAAA,MACjG;AAAA,MACA,MAAM,QAAQ,SAAS,SAAS,YAAY,aAAa,UAAU;AAAA,IACrE,CAAC;AAED,kBAAc,aACV,aACA,QAAQ,aAAa,cAAc,qCAAqC,IACxE,QAAQ,aAAa,cAAc,uCAAuC;AAAA,EAChF;AAEA,SAAO;AACT;AAaA,SAAS,cAAc,SAAiB,OAAyB;AAC/D,MAAI,QAAQ,aAAa,MAAM,iBAAiB,MAAM,6BAA6B;AACjF,UAAM,IAAI,MAAM,sBAAsB,MAAM,IAAI,+BAA+B;AAAA,EACjF;AAEA,QAAM,aAAa,MAAM,oBACrB,oBACA,QAAQ,aAAa,MAAM,oBAAoB,+BAA+B,IAC9E,QAAQ,aAAa,MAAM,oBAAoB,gCAAgC;AACnF,QAAM,UAAU,aAAa,MAAM;AACnC,MAAI,UAAU,QAAQ,QAAQ;AAC5B,UAAM,IAAI,MAAM,oCAAoC,MAAM,IAAI,sBAAsB;AAAA,EACtF;AAEA,QAAM,iBAAiB,QAAQ,SAAS,YAAY,OAAO;AAC3D,UAAQ,MAAM,mBAAmB;AAAA,IAC/B,KAAK,6BAA6B;AAChC,iBAAO,iCAAe,cAAc;AAAA,IACtC;AAAA,IACA,KAAK,2BAA2B;AAC9B,aAAO;AAAA,IACT;AAAA,IACA,SAAS;AACP,YAAM,IAAI,MAAM,sBAAsB,MAAM,IAAI,yCAAyC,OAAO,MAAM,iBAAiB,CAAC,GAAG;AAAA,IAC7H;AAAA,EACF;AACF;",
  "names": []
}


package/dist/lib/cjs/desktop-zip-extractor.d.cts

@@ -0,0 +1,96 @@
+/// <reference path="./library-references.d.cts" />
+/// <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' with { 'resolution-mode': 'import' };
+/**
+ * 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;