@design-edito/tools 0.4.5 → 0.4.6

package/node/encryption/@aes-256-gcm/buffer/index.js

@@ -1,74 +1,33 @@
-// src/node/encryption/@aes-256-gcm/buffer/index.ts
-import { Buffer as Buffer3 } from "node:buffer";
-
-// src/agnostic/misc/outcome/index.ts
-function makeSuccess(payload) {
-  return { success: true, payload };
+import { Buffer } from 'node:buffer';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
+import { encryptUint8Array, decryptUint8Array } from '../uint8-array/index.js';
+/**
+ * Encrypts a `Buffer` by converting it to a `Uint8Array`, performing encryption, and then returning the result as a `Buffer`.
+ *
+ * @param {Buffer} inputBuffer - The input data to encrypt.
+ * @param {string} encryptionKey - The encryption key to use.
+ *
+ * @returns {Outcome.Either<Buffer, string>} The result of the encryption. Success returns the encrypted data as a `Buffer` (with IV prepended), or failure returns an error message.
+ */
+export function encrypt(inputBuffer, encryptionKey) {
+    const fileArray = new Uint8Array(inputBuffer);
+    const encryptionOutcome = encryptUint8Array(fileArray, encryptionKey);
+    if (!encryptionOutcome.success)
+        return encryptionOutcome;
+    return Outcome.makeSuccess(Buffer.from(encryptionOutcome.payload));
 }
-function makeFailure(error) {
-  return { success: false, error };
+/**
+ * Decrypts an encrypted `Buffer` by converting it to a `Uint8Array`, performing decryption, and then returning the result as a `Buffer`.
+ *
+ * @param {Buffer} encryptedBuffer - The encrypted data to decrypt.
+ * @param {string} encryptionKey - The encryption key to use.
+ *
+ * @returns {Outcome.Either<Buffer, string>} The result of the decryption. Success returns the decrypted data as a `Buffer`, or failure returns an error message.
+ */
+export function decrypt(encryptedBuffer, encryptionKey) {
+    const encryptedArray = new Uint8Array(encryptedBuffer);
+    const decryptionOutcome = decryptUint8Array(encryptedArray, encryptionKey);
+    if (!decryptionOutcome.success)
+        return decryptionOutcome;
+    return Outcome.makeSuccess(Buffer.from(decryptionOutcome.payload));
 }
-
-// src/node/encryption/@aes-256-gcm/uint8-array/index.ts
-import { Buffer as Buffer2 } from "node:buffer";
-import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
-
-// src/agnostic/errors/unknown-to-string/index.ts
-function unknownToString(unk, encoding) {
-  if (unk instanceof Error) return unk.message;
-  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
-  if (typeof unk === "string") return unk;
-  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
-  return `${unk}`;
-}
-
-// src/node/encryption/@aes-256-gcm/uint8-array/index.ts
-function encryptUint8Array(fileArray, encryptionKey) {
-  const ivLength = 12;
-  const keyBuffer = Buffer2.from(encryptionKey, "utf-8");
-  if (keyBuffer.length !== 32) return makeFailure("Encryption key must be 32 bytes for AES-256-GCM.");
-  try {
-    const iv = randomBytes(ivLength);
-    const cipher = createCipheriv("aes-256-gcm", keyBuffer, iv);
-    let encrypted = cipher.update(fileArray);
-    encrypted = Buffer2.concat([encrypted, cipher.final()]);
-    return makeSuccess(new Uint8Array(Buffer2.concat([iv, encrypted])));
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return makeFailure(errStr);
-  }
-}
-function decryptUint8Array(encryptedFile, encryptionKey) {
-  const ivLength = 12;
-  const iv = encryptedFile.subarray(0, ivLength);
-  const keyBuffer = Buffer2.from(encryptionKey, "utf-8");
-  if (keyBuffer.length !== 32) return makeFailure("Encryption key must be 32 bytes for AES-256-GCM.");
-  try {
-    const encryptedData = encryptedFile.subarray(ivLength);
-    const decipher = createDecipheriv("aes-256-gcm", keyBuffer, iv);
-    let decrypted = decipher.update(encryptedData);
-    decrypted = Buffer2.concat([decrypted, decipher.final()]);
-    return makeSuccess(new Uint8Array(decrypted));
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return makeFailure(errStr);
-  }
-}
-
-// src/node/encryption/@aes-256-gcm/buffer/index.ts
-function encrypt(inputBuffer, encryptionKey) {
-  const fileArray = new Uint8Array(inputBuffer);
-  const encryptionOutcome = encryptUint8Array(fileArray, encryptionKey);
-  if (!encryptionOutcome.success) return encryptionOutcome;
-  return makeSuccess(Buffer3.from(encryptionOutcome.payload));
-}
-function decrypt(encryptedBuffer, encryptionKey) {
-  const encryptedArray = new Uint8Array(encryptedBuffer);
-  const decryptionOutcome = decryptUint8Array(encryptedArray, encryptionKey);
-  if (!decryptionOutcome.success) return decryptionOutcome;
-  return makeSuccess(Buffer3.from(decryptionOutcome.payload));
-}
-export {
-  decrypt,
-  encrypt
-};

package/node/encryption/@aes-256-gcm/uint8-array/index.js

@@ -1,57 +1,57 @@
-// src/node/encryption/@aes-256-gcm/uint8-array/index.ts
-import { Buffer as Buffer2 } from "node:buffer";
-import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
-
-// src/agnostic/errors/unknown-to-string/index.ts
-function unknownToString(unk, encoding) {
-  if (unk instanceof Error) return unk.message;
-  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
-  if (typeof unk === "string") return unk;
-  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
-  return `${unk}`;
+import { Buffer } from 'node:buffer';
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
+import { unknownToString } from '../../../../agnostic/errors/unknown-to-string/index.js';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
+/**
+ * Encrypts a `Uint8Array` using AES-256-GCM encryption and the specified encryption key.
+ *
+ * @param {Uint8Array} fileArray - The input data to encrypt.
+ * @param {string} encryptionKey - The encryption key to use.
+ * @param {number} [options.ivLength=16] - The length of the initialization vector (IV). Defaults to 16 bytes.
+ *
+ * @returns {Outcome.Either<Uint8Array, string>} The result of the encryption. Success returns the encrypted data as a `Uint8Array` (with IV prepended), or failure returns an error message.
+ */
+export function encryptUint8Array(fileArray, encryptionKey) {
+    const ivLength = 12;
+    const keyBuffer = Buffer.from(encryptionKey, 'utf-8');
+    if (keyBuffer.length !== 32)
+        return Outcome.makeFailure('Encryption key must be 32 bytes for AES-256-GCM.');
+    try {
+        const iv = randomBytes(ivLength);
+        const cipher = createCipheriv('aes-256-gcm', keyBuffer, iv);
+        let encrypted = cipher.update(fileArray);
+        encrypted = Buffer.concat([encrypted, cipher.final()]);
+        return Outcome.makeSuccess(new Uint8Array(Buffer.concat([iv, encrypted])));
+    }
+    catch (err) {
+        const errStr = unknownToString(err);
+        return Outcome.makeFailure(errStr);
+    }
 }
-
-// src/agnostic/misc/outcome/index.ts
-function makeSuccess(payload) {
-  return { success: true, payload };
+/**
+ * Decrypts an encrypted `Uint8Array` using AES-256-GCM encryption and the specified encryption key.
+ *
+ * @param {Uint8Array} encryptedFile - The encrypted data to decrypt.
+ * @param {string} encryptionKey - The encryption key to use.
+ * @param {number} [options.ivLength=16] - The length of the initialization vector (IV). Defaults to 16 bytes.
+ *
+ * @returns {Outcome.Either<Uint8Array, string>} The result of the decryption. Success returns the decrypted data as a `Uint8Array`, or failure returns an error message.
+ */
+export function decryptUint8Array(encryptedFile, encryptionKey) {
+    const ivLength = 12;
+    const iv = encryptedFile.subarray(0, ivLength);
+    const keyBuffer = Buffer.from(encryptionKey, 'utf-8');
+    if (keyBuffer.length !== 32)
+        return Outcome.makeFailure('Encryption key must be 32 bytes for AES-256-GCM.');
+    try {
+        const encryptedData = encryptedFile.subarray(ivLength);
+        const decipher = createDecipheriv('aes-256-gcm', keyBuffer, iv);
+        let decrypted = decipher.update(encryptedData);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        return Outcome.makeSuccess(new Uint8Array(decrypted));
+    }
+    catch (err) {
+        const errStr = unknownToString(err);
+        return Outcome.makeFailure(errStr);
+    }
 }
-function makeFailure(error) {
-  return { success: false, error };
-}
-
-// src/node/encryption/@aes-256-gcm/uint8-array/index.ts
-function encryptUint8Array(fileArray, encryptionKey) {
-  const ivLength = 12;
-  const keyBuffer = Buffer2.from(encryptionKey, "utf-8");
-  if (keyBuffer.length !== 32) return makeFailure("Encryption key must be 32 bytes for AES-256-GCM.");
-  try {
-    const iv = randomBytes(ivLength);
-    const cipher = createCipheriv("aes-256-gcm", keyBuffer, iv);
-    let encrypted = cipher.update(fileArray);
-    encrypted = Buffer2.concat([encrypted, cipher.final()]);
-    return makeSuccess(new Uint8Array(Buffer2.concat([iv, encrypted])));
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return makeFailure(errStr);
-  }
-}
-function decryptUint8Array(encryptedFile, encryptionKey) {
-  const ivLength = 12;
-  const iv = encryptedFile.subarray(0, ivLength);
-  const keyBuffer = Buffer2.from(encryptionKey, "utf-8");
-  if (keyBuffer.length !== 32) return makeFailure("Encryption key must be 32 bytes for AES-256-GCM.");
-  try {
-    const encryptedData = encryptedFile.subarray(ivLength);
-    const decipher = createDecipheriv("aes-256-gcm", keyBuffer, iv);
-    let decrypted = decipher.update(encryptedData);
-    decrypted = Buffer2.concat([decrypted, decipher.final()]);
-    return makeSuccess(new Uint8Array(decrypted));
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return makeFailure(errStr);
-  }
-}
-export {
-  decryptUint8Array,
-  encryptUint8Array
-};

package/node/encryption/key/index.js

@@ -1,13 +1,20 @@
-// src/node/encryption/key/index.ts
-import { pbkdf2Sync, randomBytes } from "node:crypto";
-function generate(passphrase, outputByteLength, options) {
-  const { saltLength = 16, iterations = 1e5 } = options ?? {};
-  const salt = randomBytes(saltLength);
-  const key = pbkdf2Sync(passphrase, salt, iterations, outputByteLength, "sha256");
-  const saltString = salt.toString("hex");
-  const keyString = key.toString("hex");
-  return `${saltString}:${keyString}`;
+import { pbkdf2Sync, randomBytes } from 'node:crypto';
+/**
+ * Generates an encryption key from a passphrase using PBKDF2.
+ *
+ * @param {string} passphrase - The passphrase to derive the key from.
+ * @param {number} outputByteLength - The length of the output encryption key in bytes.
+ * @param {GenerateOptions} [options] - Optional options.
+ * @param {number} [options.saltLength=16] - The length of the salt in bytes. Defaults to 16 bytes.
+ * @param {number} [options.iterations=100000] - The number of PBKDF2 iterations. Defaults to 100,000 iterations.
+ *
+ * @returns {string} The derived encryption key and salt, concatenated as a string in the format `salt:encryptionKey`.
+ */
+export function generate(passphrase, outputByteLength, options) {
+    const { saltLength = 16, iterations = 100000 } = options ?? {};
+    const salt = randomBytes(saltLength);
+    const key = pbkdf2Sync(passphrase, salt, iterations, outputByteLength, 'sha256');
+    const saltString = salt.toString('hex');
+    const keyString = key.toString('hex');
+    return `${saltString}:${keyString}`;
 }
-export {
-  generate
-};

package/node/files/index.d.ts

@@ -1,3 +1,3 @@
 export * as isInDirectory from './is-in-directory/index.js'
-export * as subpaths from './subpaths/index.js'
 export * as readWrite from './read-write/index.js'
+export * as subpaths from './subpaths/index.js'

package/node/files/index.js

@@ -1,3 +1,3 @@
 export * as isInDirectory from './is-in-directory/index.js'
-export * as subpaths from './subpaths/index.js'
 export * as readWrite from './read-write/index.js'
+export * as subpaths from './subpaths/index.js'

package/node/files/is-in-directory/index.js

@@ -1,9 +1,12 @@
-// src/node/files/is-in-directory/index.ts
-import path from "node:path";
-function isInDirectory(childPath, parentPath) {
-  const rel = path.relative(parentPath, childPath);
-  return rel !== "" && !rel.startsWith("..");
+import path from 'node:path';
+/**
+ * Checks whether a child path is contained within a parent directory.
+ *
+ * @param childPath  - The path to check if it's within the parent.
+ * @param parentPath - The parent directory path.
+ * @returns `true` if `childPath` is within `parentPath`, `false` otherwise.
+ */
+export function isInDirectory(childPath, parentPath) {
+    const rel = path.relative(parentPath, childPath);
+    return rel !== '' && !rel.startsWith('..');
 }
-export {
-  isInDirectory
-};

package/node/files/read-write/index.js

@@ -1,16 +1,12 @@
-// src/node/files/read-write/index.ts
-import { promises as fs } from "node:fs";
-async function readWrite(path, editor, opts = {}) {
-  const readData = await fs.readFile(path, opts.readOptions);
-  const edited = typeof editor === "function" ? editor(readData) : Object.entries(editor).reduce(
-    (acc, [from, to]) => acc.replaceAll(from, to),
-    readData.toString()
-  );
-  const actualWriteOptions = opts.writeOptions ?? opts.readOptions;
-  const targetOutput = opts.output ?? path;
-  if (opts.dryRun !== true) await fs.writeFile(targetOutput, edited, actualWriteOptions);
-  return edited;
+import { promises as fs } from 'node:fs';
+export async function readWrite(path, editor, opts = {}) {
+    const readData = await fs.readFile(path, opts.readOptions);
+    const edited = typeof editor === 'function'
+        ? editor(readData)
+        : Object.entries(editor).reduce((acc, [from, to]) => acc.replaceAll(from, to), readData.toString());
+    const actualWriteOptions = opts.writeOptions ?? opts.readOptions;
+    const targetOutput = opts.output ?? path;
+    if (opts.dryRun !== true)
+        await fs.writeFile(targetOutput, edited, actualWriteOptions);
+    return edited;
 }
-export {
-  readWrite
-};

package/node/files/subpaths/index.js

@@ -1,130 +1,165 @@
-// src/node/files/subpaths/index.ts
-import { promises as fs } from "node:fs";
-import path from "node:path";
-
-// src/agnostic/strings/matches/index.ts
-function matches(input, matcher) {
-  if (typeof matcher === "string") return input === matcher;
-  if (typeof matcher === "function") return matcher(input);
-  return input.match(matcher) !== null;
-}
-function matchesSome(input, matchers) {
-  if (!Array.isArray(matchers)) return matches(input, matchers);
-  return matchers.some((matcher) => matches(input, matcher));
-}
-
-// src/node/files/subpaths/index.ts
-var defaultListContext = {
-  depth: 0,
-  lstats: null,
-  rootPath: null
+/* eslint-disable @typescript-eslint/no-throw-literal */
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { matchesSome as stringMatchesSome } from '../../../agnostic/strings/matches/index.js';
+export const defaultListContext = {
+    depth: 0,
+    lstats: null,
+    rootPath: null
 };
-var fillListContext = (input) => {
-  return {
-    ...defaultListContext,
-    ...input
-  };
+/**
+ * Fills missing properties in a list context with default values.
+ *
+ * @param {ListContext} input - The partial list context to fill.
+ * @returns {Required<ListContext>} A complete list context with all properties set.
+ */
+export const fillListContext = (input) => {
+    return {
+        ...defaultListContext,
+        ...input
+    };
 };
-var defaultListOptions = {
-  directories: true,
-  files: true,
-  symlinks: true,
-  hidden: true,
-  followSimlinks: false,
-  dedupeSimlinksContents: false,
-  maxDepth: Infinity,
-  returnRelative: false,
-  exclude: null,
-  include: null,
-  filter: () => true
+export const defaultListOptions = {
+    directories: true,
+    files: true,
+    symlinks: true,
+    hidden: true,
+    followSimlinks: false,
+    dedupeSimlinksContents: false,
+    maxDepth: Infinity,
+    returnRelative: false,
+    exclude: null,
+    include: null,
+    filter: () => true
 };
-var fillOptions = (input) => {
-  return {
-    ...defaultListOptions,
-    ...input
-  };
+/**
+ * Fills missing properties in list options with default values.
+ *
+ * @param {ListOptions} input - The partial list options to fill.
+ * @returns {Required<ListOptions>} A complete list options object with all properties set.
+ */
+export const fillOptions = (input) => {
+    return {
+        ...defaultListOptions,
+        ...input
+    };
 };
-async function list(...args) {
-  const [inputPath, _options] = args;
-  const options = fillOptions(_options ?? {});
-  const subpaths = await listAbsoluteSubpaths(...args);
-  return options.returnRelative ? subpaths.map((subpath) => path.relative(inputPath, subpath)) : subpaths;
+/**
+ * Lists all subpaths under a given directory path.
+ *
+ * The function recursively traverses the directory tree and returns all matching
+ * files, directories, and symlinks based on the provided options.
+ *
+ * @param inputPath - The root directory path to list subpaths from.
+ * @param [options] - Optional configuration for filtering and behavior. See `ListOptions` for details.
+ * @returns Array of subpaths (absolute or relative based on `returnRelative` option).
+ */
+export async function list(...args) {
+    const [inputPath, _options] = args;
+    const options = fillOptions(_options ?? {});
+    const subpaths = await listAbsoluteSubpaths(...args);
+    return options.returnRelative
+        ? subpaths.map(subpath => path.relative(inputPath, subpath))
+        : subpaths;
 }
-async function listAbsoluteSubpaths(inputPath, _options = {}, __private_context = {}) {
-  const options = fillOptions(_options);
-  const _private_context = fillListContext(__private_context);
-  if (_private_context.rootPath === null) {
-    _private_context.rootPath = inputPath;
-  }
-  const subpaths = [];
-  if (_private_context.depth > options.maxDepth) return subpaths;
-  try {
-    const pathStat = _private_context.lstats ?? await fs.lstat(inputPath);
-    if (!pathStat.isDirectory()) return subpaths;
-  } catch (err) {
-    return subpaths;
-  }
-  const childrenRelPaths = await fs.readdir(inputPath);
-  await Promise.all(childrenRelPaths.map(async (childRelPath) => {
-    const childAbsPath = path.join(inputPath, childRelPath);
-    const childRelFromRootPath = path.relative(_private_context.rootPath ?? inputPath, childAbsPath);
-    const childLstats = await fs.lstat(childAbsPath);
+/**
+ * Internal function that lists absolute subpaths recursively.
+ *
+ * @param {string} inputPath              - The directory path to list.
+ * @param {ListOptions} [_options]        - Optional configuration.
+ * @param {ListContext} [__private_context] - Internal recursion context.
+ * @returns {Promise<string[]>} Array of absolute subpaths.
+ */
+async function listAbsoluteSubpaths(inputPath, _options = {}, 
+// eslint-disable-next-line @typescript-eslint/naming-convention
+__private_context = {}) {
+    const options = fillOptions(_options);
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const _private_context = fillListContext(__private_context);
+    if (_private_context.rootPath === null) {
+        _private_context.rootPath = inputPath;
+    }
+    const subpaths = [];
+    if (_private_context.depth > options.maxDepth)
+        return subpaths;
     try {
-      const isDirectory = childLstats.isDirectory();
-      const isSymlink = childLstats.isSymbolicLink();
-      const isFile = !isDirectory && !isSymlink;
-      const isHidden = path.basename(childAbsPath).startsWith(".");
-      const type = isDirectory ? "directory" : isSymlink ? "symlink" : "file";
-      if (isDirectory && !options.directories) throw true;
-      if (isSymlink && !options.symlinks) throw false;
-      if (isFile && !options.files) throw false;
-      if (isHidden && !options.hidden) throw false;
-      const realPath = isSymlink ? await fs.realpath(childAbsPath) : childAbsPath;
-      const childPathForFilters = options.returnRelative ? childRelFromRootPath : childAbsPath;
-      const isInExclude = matchesSome(childPathForFilters, options.exclude ?? []);
-      const isInInclude = matchesSome(childPathForFilters, options.include ?? []);
-      if (isInExclude && !isInInclude) throw false;
-      const isInFilter = await options.filter(childPathForFilters, { type, hidden: isHidden, realPath });
-      if (!isInFilter) throw true;
-      if (isSymlink) {
-        if (!options.followSimlinks) subpaths.push(childAbsPath);
-        else {
-          const childSubpaths = await listAbsoluteSubpaths(realPath, options, {
-            ..._private_context,
-            depth: _private_context.depth + 1
-          });
-          subpaths.push(realPath, ...childSubpaths);
+        const pathStat = _private_context.lstats ?? await fs.lstat(inputPath);
+        if (!pathStat.isDirectory())
+            return subpaths;
+    }
+    catch (err) {
+        return subpaths;
+    }
+    const childrenRelPaths = await fs.readdir(inputPath);
+    await Promise.all(childrenRelPaths.map(async (childRelPath) => {
+        const childAbsPath = path.join(inputPath, childRelPath);
+        const childRelFromRootPath = path.relative(_private_context.rootPath ?? inputPath, childAbsPath);
+        const childLstats = await fs.lstat(childAbsPath);
+        try {
+            const isDirectory = childLstats.isDirectory();
+            const isSymlink = childLstats.isSymbolicLink();
+            const isFile = !isDirectory && !isSymlink;
+            const isHidden = path.basename(childAbsPath).startsWith('.');
+            const type = isDirectory ? 'directory' : (isSymlink ? 'symlink' : 'file');
+            if (isDirectory && !options.directories)
+                throw true;
+            if (isSymlink && !options.symlinks)
+                throw false;
+            if (isFile && !options.files)
+                throw false;
+            if (isHidden && !options.hidden)
+                throw false;
+            const realPath = isSymlink
+                ? await fs.realpath(childAbsPath)
+                : childAbsPath;
+            const childPathForFilters = options.returnRelative ? childRelFromRootPath : childAbsPath;
+            const isInExclude = stringMatchesSome(childPathForFilters, options.exclude ?? []);
+            const isInInclude = stringMatchesSome(childPathForFilters, options.include ?? []);
+            if (isInExclude && !isInInclude)
+                throw false;
+            const isInFilter = await options.filter(childPathForFilters, { type, hidden: isHidden, realPath });
+            if (!isInFilter)
+                throw true;
+            if (isSymlink) {
+                if (!options.followSimlinks)
+                    subpaths.push(childAbsPath);
+                else {
+                    const childSubpaths = await listAbsoluteSubpaths(realPath, options, {
+                        ..._private_context,
+                        depth: _private_context.depth + 1
+                    });
+                    subpaths.push(realPath, ...childSubpaths);
+                }
+            }
+            else {
+                if (isDirectory) {
+                    const childSubpaths = await listAbsoluteSubpaths(childAbsPath, options, {
+                        ..._private_context,
+                        depth: _private_context.depth + 1,
+                        lstats: childLstats
+                    });
+                    subpaths.push(childAbsPath, ...childSubpaths);
+                }
+                else {
+                    subpaths.push(childAbsPath);
+                }
+            }
         }
-      } else {
-        if (isDirectory) {
-          const childSubpaths = await listAbsoluteSubpaths(childAbsPath, options, {
-            ..._private_context,
-            depth: _private_context.depth + 1,
-            lstats: childLstats
-          });
-          subpaths.push(childAbsPath, ...childSubpaths);
-        } else {
-          subpaths.push(childAbsPath);
+        catch (err) {
+            if (typeof err !== 'boolean')
+                throw new Error('This try/catch block should only throw booleans');
+            const shouldDiveDeeper = err;
+            if (!shouldDiveDeeper)
+                return [];
+            const childSubpaths = await listAbsoluteSubpaths(childAbsPath, options, {
+                ..._private_context,
+                depth: _private_context.depth + 1,
+                lstats: childLstats
+            });
+            subpaths.push(...childSubpaths);
         }
-      }
-    } catch (err) {
-      if (typeof err !== "boolean") throw new Error("This try/catch block should only throw booleans");
-      const shouldDiveDeeper = err;
-      if (!shouldDiveDeeper) return [];
-      const childSubpaths = await listAbsoluteSubpaths(childAbsPath, options, {
-        ..._private_context,
-        depth: _private_context.depth + 1,
-        lstats: childLstats
-      });
-      subpaths.push(...childSubpaths);
-    }
-  }));
-  return options.dedupeSimlinksContents ? Array.from(new Set(subpaths)) : subpaths;
+    }));
+    return options.dedupeSimlinksContents
+        ? Array.from(new Set(subpaths))
+        : subpaths;
 }
-export {
-  defaultListContext,
-  defaultListOptions,
-  fillListContext,
-  fillOptions,
-  list
-};