@design-edito/tools 0.2.39 → 0.2.40

package/node/cloud-storage/operations/upload-file/index.d.ts

@@ -2,15 +2,60 @@ import { Readable } from 'node:stream';
 import { Bucket as GCSBucket } from '@google-cloud/storage';
 import { Client as FtpClient } from 'basic-ftp';
 import SftpClient from 'ssh2-sftp-client';
-import { Outcome } from '../../../../agnostic/misc/outcome/index.js';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
 import { S3ClientWithBucket } from '../../clients/index.js';
 import { UploadOptions as FtpUploadOptions } from '../../../ftps/file/upload/index.js';
 import { UploadOptions as SftpUploadOptions } from '../../../sftp/file/upload/index.js';
 import { UploadOptions as S3UploadOptions } from '../../../@aws-s3/storage/file/upload/index.js';
 import { UploadOptions as GcsUploadOptions } from '../../../@google-cloud/storage/file/upload/index.js';
+/** Return type for upload file operations. */
 type Returned = Outcome.Either<true, string>;
+/**
+ * Uploads a file stream to a Google Cloud Storage bucket.
+ *
+ * @param {Readable} fileStream           - The file content as a stream.
+ * @param {string}   path                 - The path to upload the file to.
+ * @param {GCSBucket} client              - The Google Cloud Storage bucket instance.
+ * @param {GcsUploadOptions} [options]     - Optional upload configuration.
+ * @returns {Promise<Outcome.Either<true, string>>}
+ * - On success:  `Outcome.makeSuccess(true)`.
+ * - On failure:  `Outcome.makeFailure(errStr)`.
+ */
 export declare function uploadFile(fileStream: Readable, path: string, client: GCSBucket, options?: GcsUploadOptions): Promise<Returned>;
+/**
+ * Uploads a file stream to an S3 bucket.
+ *
+ * @param {Readable} fileStream           - The file content as a stream.
+ * @param {string}   path                 - The path to upload the file to.
+ * @param {S3ClientWithBucket} client     - The S3 client with bucket configuration.
+ * @param {S3UploadOptions} [options]      - Optional upload configuration.
+ * @returns {Promise<Outcome.Either<true, string>>}
+ * - On success:  `Outcome.makeSuccess(true)`.
+ * - On failure:  `Outcome.makeFailure(errStr)`.
+ */
 export declare function uploadFile(fileStream: Readable, path: string, client: S3ClientWithBucket, options?: S3UploadOptions): Promise<Returned>;
+/**
+ * Uploads a file stream to an FTP server.
+ *
+ * @param {Readable} fileStream           - The file content as a stream.
+ * @param {string}   path                 - The path to upload the file to.
+ * @param {FtpClient} client              - The FTP client instance.
+ * @param {FtpUploadOptions} [options]     - Optional upload configuration.
+ * @returns {Promise<Outcome.Either<true, string>>}
+ * - On success:  `Outcome.makeSuccess(true)`.
+ * - On failure:  `Outcome.makeFailure(errStr)`.
+ */
 export declare function uploadFile(fileStream: Readable, path: string, client: FtpClient, options?: FtpUploadOptions): Promise<Returned>;
+/**
+ * Uploads a file stream to an SFTP server.
+ *
+ * @param {Readable} fileStream           - The file content as a stream.
+ * @param {string}   path                 - The path to upload the file to.
+ * @param {SftpClient} client             - The SFTP client instance.
+ * @param {SftpUploadOptions} [options]   - Optional upload configuration.
+ * @returns {Promise<Outcome.Either<true, string>>}
+ * - On success:  `Outcome.makeSuccess(true)`.
+ * - On failure:  `Outcome.makeFailure(errStr)`.
+ */
 export declare function uploadFile(fileStream: Readable, path: string, client: SftpClient, options?: SftpUploadOptions): Promise<Returned>;
 export {};

package/node/cloud-storage/operations/upload-file/index.js

@@ -1,14 +1,35 @@
 import {
-  uploadFile
-} from "../../../../chunks/chunk-XBA26Z7E.js";
-import "../../../../chunks/chunk-FB3GNE2B.js";
-import "../../../../chunks/chunk-FD5WR2A5.js";
-import "../../../../chunks/chunk-QDVDHFMZ.js";
-import "../../../../chunks/chunk-CVDCTI7F.js";
-import "../../../../chunks/chunk-V3GX7SIJ.js";
-import "../../../../chunks/chunk-JMU5PDBD.js";
+  upload as upload4
+} from "../../../../chunks/chunk-UZ4SWSOZ.js";
+import {
+  upload as upload2
+} from "../../../../chunks/chunk-Y6FD4ASO.js";
+import {
+  upload as upload3
+} from "../../../../chunks/chunk-FM3HGCFL.js";
+import {
+  upload
+} from "../../../../chunks/chunk-AOEOW5XW.js";
+import {
+  isFtpClient,
+  isGcsBucket,
+  isS3ClientWithBucket,
+  isSftpClient
+} from "../../../../chunks/chunk-ISJONMNA.js";
+import {
+  makeFailure
+} from "../../../../chunks/chunk-QEKI6WGQ.js";
 import "../../../../chunks/chunk-FENXVJYO.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
+
+// src/node/cloud-storage/operations/upload-file/index.ts
+async function uploadFile(fileStream, path, client, options) {
+  if (isGcsBucket(client)) return upload4(client, path, fileStream, options);
+  if (isS3ClientWithBucket(client)) return upload3(client.client, client.bucketName, path, fileStream, options);
+  if (isFtpClient(client)) return upload(client, path, fileStream, options);
+  if (isSftpClient(client)) return upload2(client, path, fileStream, options);
+  return makeFailure("Invalid client type");
+}
 export {
   uploadFile
 };

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

@@ -1,5 +1,5 @@
 import { Buffer } from 'node:buffer';
-import { Outcome } from '../../../../agnostic/misc/outcome/index.js';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
 /**
  * Encrypts a `Buffer` by converting it to a `Uint8Array`, performing encryption, and then returning the result as a `Buffer`.
  *

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

@@ -1,11 +1,27 @@
 import {
-  decrypt,
-  encrypt
-} from "../../../../chunks/chunk-JTJA7DGW.js";
-import "../../../../chunks/chunk-REZC75LB.js";
-import "../../../../chunks/chunk-JMU5PDBD.js";
+  decryptUint8Array,
+  encryptUint8Array
+} from "../../../../chunks/chunk-FH74QWR6.js";
+import {
+  makeSuccess
+} from "../../../../chunks/chunk-QEKI6WGQ.js";
 import "../../../../chunks/chunk-FENXVJYO.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
+
+// src/node/encryption/@aes-256-gcm/buffer/index.ts
+import { Buffer } from "node:buffer";
+function encrypt(inputBuffer, encryptionKey) {
+  const fileArray = new Uint8Array(inputBuffer);
+  const encryptionOutcome = encryptUint8Array(fileArray, encryptionKey);
+  if (!encryptionOutcome.success) return encryptionOutcome;
+  return makeSuccess(Buffer.from(encryptionOutcome.payload));
+}
+function decrypt(encryptedBuffer, encryptionKey) {
+  const encryptedArray = new Uint8Array(encryptedBuffer);
+  const decryptionOutcome = decryptUint8Array(encryptedArray, encryptionKey);
+  if (!decryptionOutcome.success) return decryptionOutcome;
+  return makeSuccess(Buffer.from(decryptionOutcome.payload));
+}
 export {
   decrypt,
   encrypt

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

@@ -1,4 +1,4 @@
-import { Outcome } from '../../../../agnostic/misc/outcome/index.js';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
 /**
  * Encrypts a `Uint8Array` using AES-256-GCM encryption and the specified encryption key.
  *

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

@@ -1,10 +1,10 @@
 import {
   decryptUint8Array,
   encryptUint8Array
-} from "../../../../chunks/chunk-REZC75LB.js";
-import "../../../../chunks/chunk-JMU5PDBD.js";
+} from "../../../../chunks/chunk-FH74QWR6.js";
+import "../../../../chunks/chunk-QEKI6WGQ.js";
 import "../../../../chunks/chunk-FENXVJYO.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   decryptUint8Array,
   encryptUint8Array

package/node/encryption/key/index.js

@@ -1,7 +1,15 @@
-import {
-  generate
-} from "../../../chunks/chunk-HKTNK262.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// 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}`;
+}
 export {
   generate
 };

package/node/files/is-in-directory/index.d.ts

@@ -1 +1,8 @@
+/**
+ * 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 declare function isInDirectory(childPath: string, parentPath: string): boolean;

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

@@ -1,7 +1,11 @@
-import {
-  isInDirectory
-} from "../../../chunks/chunk-NRITRUZW.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// 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("..");
+}
 export {
   isInDirectory
 };

package/node/files/read-write/index.d.ts

@@ -2,8 +2,52 @@ import { promises as fs } from 'node:fs';
 type Path = Parameters<typeof fs.writeFile>[0];
 type ReadFileData = Awaited<ReturnType<typeof fs.readFile>>;
 type WriteFileData = Parameters<typeof fs.writeFile>[1];
-type ReadOptions = Parameters<typeof fs.readFile>[1];
-type WriteOptions = Parameters<typeof fs.writeFile>[2];
-export type ReadWriteEditorFunc = (curr: ReadFileData) => WriteFileData;
-export declare function readWrite(path: Path, editor: ReadWriteEditorFunc, ...options: [ReadOptions?, WriteOptions?]): Promise<string | import("stream") | NodeJS.ArrayBufferView<ArrayBufferLike> | Iterable<string | NodeJS.ArrayBufferView<ArrayBufferLike>> | AsyncIterable<string | NodeJS.ArrayBufferView<ArrayBufferLike>>>;
+export type Options = {
+    /** Additional parameters forwarded to the underlying `fs.readFile`. */
+    readOptions?: Parameters<typeof fs.readFile>[1];
+    /** Additional parameters forwarded to the underlying `fs.writeFile`. */
+    writeOptions?: Parameters<typeof fs.writeFile>[2];
+    /** Output path for the edited file. If not provided, the file is written back to the original `path`. */
+    output?: Path;
+    /** If `true`, the file is not written to disk, only the edited content is returned. @default false */
+    dryRun?: boolean;
+};
+/** Function that takes the current file content and returns the edited content. */
+export type EditorFunc<T extends WriteFileData = WriteFileData> = (curr: ReadFileData) => T;
+/** Object mapping strings to replace (keys) with their replacements (values). */
+export type Replacements = Record<string, string>;
+/**
+ * Reads a file, applies edits, and optionally writes it back.
+ *
+ * The function supports two editing modes:
+ * - **Replacements mode**: Pass an object with string replacements.
+ * - **Function mode**: Pass a function that transforms the file content.
+ *
+ * @param {Path} path                    - The path to the file to read and edit.
+ * @param {Replacements} editor          - Object mapping strings to replace with their replacements.
+ * @param {Options} [opts]               - Optional configuration.
+ * @param {Parameters<typeof fs.readFile>[1]} [opts.readOptions]  - Extra `readFile` params.
+ * @param {Parameters<typeof fs.writeFile>[2]} [opts.writeOptions] - Extra `writeFile` params.
+ * @param {Path} [opts.output]           - Output path (defaults to `path`).
+ * @param {boolean} [opts.dryRun=false]  - If `true`, skip writing to disk.
+ * @returns {Promise<string>} The edited file content as a string.
+ */
+export declare function readWrite(path: Path, editor: Replacements, opts?: Options): Promise<string>;
+/**
+ * Reads a file, applies edits, and optionally writes it back.
+ *
+ * The function supports two editing modes:
+ * - **Replacements mode**: Pass an object with string replacements.
+ * - **Function mode**: Pass a function that transforms the file content.
+ *
+ * @param {Path} path                    - The path to the file to read and edit.
+ * @param {EditorFunc<T>} editor         - Function that transforms the file content.
+ * @param {Options} [opts]               - Optional configuration.
+ * @param {Parameters<typeof fs.readFile>[1]} [opts.readOptions]  - Extra `readFile` params.
+ * @param {Parameters<typeof fs.writeFile>[2]} [opts.writeOptions] - Extra `writeFile` params.
+ * @param {Path} [opts.output]           - Output path (defaults to `path`).
+ * @param {boolean} [opts.dryRun=false]  - If `true`, skip writing to disk.
+ * @returns {Promise<T>} The edited file content of type `T`.
+ */
+export declare function readWrite<T extends WriteFileData>(path: Path, editor: EditorFunc<T>, opts?: Options): Promise<T>;
 export {};

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

@@ -1,7 +1,18 @@
-import {
-  readWrite
-} from "../../../chunks/chunk-7DBNMU6N.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// 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 === void 0 ? path : opts.output;
+  if (opts.dryRun !== true) await fs.writeFile(targetOutput, edited, actualWriteOptions);
+  return edited;
+}
 export {
   readWrite
 };

package/node/files/subpaths/index.d.ts

@@ -1,34 +1,63 @@
 import { Stats } from 'node:fs';
-export declare namespace Subpaths {
-    export type ChildType = 'file' | 'directory' | 'symlink';
-    export type ChildDetails = {
-        type: ChildType;
-        hidden: boolean;
-        realPath: string;
-    };
-    export type ListContext = {
-        depth?: number;
-        lstats?: Stats | null;
-        rootPath?: string | null;
-    };
-    export const defaultListContext: Required<ListContext>;
-    export const fillListContext: (input: ListContext) => Required<ListContext>;
-    export type ListOptions = {
-        directories?: boolean;
-        files?: boolean;
-        symlinks?: boolean;
-        hidden?: boolean;
-        followSimlinks?: boolean;
-        dedupeSimlinksContents?: boolean;
-        maxDepth?: number;
-        returnRelative?: boolean;
-        exclude?: RegExp | string | (RegExp | string)[] | null;
-        include?: RegExp | string | (RegExp | string)[] | null;
-        filter?: ((path: string, details: ChildDetails) => boolean | Promise<boolean>);
-    };
-    export const defaultListOptions: Required<ListOptions>;
-    export const fillOptions: (input: ListOptions) => Required<ListOptions>;
-    export function list(...args: Parameters<typeof listAbsoluteSubpaths>): Promise<string[]>;
-    function listAbsoluteSubpaths(inputPath: string, _options?: ListOptions, __private_context?: ListContext): Promise<string[]>;
-    export {};
-}
+/** Type of child entry in a directory. */
+export type ChildType = 'file' | 'directory' | 'symlink';
+export type ChildDetails = {
+    /** The type of the child entry. */ type: ChildType;
+    /** Whether the child entry is hidden (starts with '.'). */ hidden: boolean;
+    /** The real path of the child entry (resolved if it's a symlink). */ realPath: string;
+};
+export type ListContext = {
+    /** Current recursion depth. */ depth?: number;
+    /** Cached lstat result for the current path. */ lstats?: Stats | null;
+    /** Root path from which the listing started. */ rootPath?: string | null;
+};
+export declare const defaultListContext: Required<ListContext>;
+/**
+ * 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 declare const fillListContext: (input: ListContext) => Required<ListContext>;
+export type ListOptions = {
+    /** Whether to include directories in the results. @default true */ directories?: boolean;
+    /** Whether to include files in the results. @default true */ files?: boolean;
+    /** Whether to include symlinks in the results. @default true */ symlinks?: boolean;
+    /** Whether to include hidden files/directories (starting with '.'). @default true */ hidden?: boolean;
+    /** Whether to follow symlinks and include their contents. @default false */ followSimlinks?: boolean;
+    /** Whether to deduplicate paths when following symlinks. @default false */ dedupeSimlinksContents?: boolean;
+    /** Maximum recursion depth. @default Infinity */ maxDepth?: number;
+    /** Whether to return relative paths instead of absolute paths. @default false */ returnRelative?: boolean;
+    /** Patterns to exclude from the results. */ exclude?: RegExp | string | (RegExp | string)[] | null;
+    /** Patterns to include in the results (takes precedence over exclude). */ include?: RegExp | string | (RegExp | string)[] | null;
+    /** Custom filter function to further refine results. */ filter?: ((path: string, details: ChildDetails) => boolean | Promise<boolean>);
+};
+export declare const defaultListOptions: Required<ListOptions>;
+/**
+ * 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 declare const fillOptions: (input: ListOptions) => Required<ListOptions>;
+/**
+ * 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 declare function list(...args: Parameters<typeof listAbsoluteSubpaths>): Promise<string[]>;
+/**
+ * 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.
+ */
+declare function listAbsoluteSubpaths(inputPath: string, _options?: ListOptions, __private_context?: ListContext): Promise<string[]>;
+export {};

package/node/files/subpaths/index.js

@@ -1,8 +1,122 @@
 import {
-  Subpaths
-} from "../../../chunks/chunk-F3WCF6DL.js";
-import "../../../chunks/chunk-R3AWQXMY.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+  matchesSome
+} from "../../../chunks/chunk-R3AWQXMY.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/node/files/subpaths/index.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+var defaultListContext = {
+  depth: 0,
+  lstats: null,
+  rootPath: null
+};
+var 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
+};
+var 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;
+}
+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);
+    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 === false) throw true;
+      if (isSymlink && options.symlinks === false) throw false;
+      if (isFile && options.files === false) throw false;
+      if (isHidden && options.hidden === false) 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 === false) 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);
+        }
+      }
+    } 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;
+}
 export {
-  Subpaths
+  defaultListContext,
+  defaultListOptions,
+  fillListContext,
+  fillOptions,
+  list
 };

package/node/ftps/directory/copy-dir/index.d.ts

@@ -1,5 +1,5 @@
 import { Client } from 'basic-ftp';
-import { Outcome } from '../../../../agnostic/misc/outcome/index.js';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
 export type CopyDirOptions = {
     /**
      * If `false` and a destination file already exists, copying aborts.

package/node/ftps/directory/copy-dir/index.js

@@ -1,9 +1,9 @@
 import {
   copyDir
-} from "../../../../chunks/chunk-N2T672IG.js";
-import "../../../../chunks/chunk-JMU5PDBD.js";
+} from "../../../../chunks/chunk-RGQNRTBI.js";
+import "../../../../chunks/chunk-QEKI6WGQ.js";
 import "../../../../chunks/chunk-FENXVJYO.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   copyDir
 };

package/node/ftps/directory/list/index.d.ts

@@ -1,5 +1,5 @@
 import { Client } from 'basic-ftp';
-import { Outcome } from '../../../../agnostic/misc/outcome/index.js';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
 /**
  * Lists all direct children files under a given directory on an FTP server.
  *

package/node/ftps/directory/list/index.js

@@ -1,9 +1,9 @@
 import {
   list
-} from "../../../../chunks/chunk-3CLGBOHN.js";
-import "../../../../chunks/chunk-JMU5PDBD.js";
+} from "../../../../chunks/chunk-DBNCEHTT.js";
+import "../../../../chunks/chunk-QEKI6WGQ.js";
 import "../../../../chunks/chunk-FENXVJYO.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   list
 };

package/node/ftps/directory/move-dir/index.d.ts

@@ -1,5 +1,5 @@
 import { Client } from 'basic-ftp';
-import { Outcome } from '../../../../agnostic/misc/outcome/index.js';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
 export type MoveDirOptions = {
     /** If false and `targetDir` exists, the operation is aborted. Defaults to false. */
     overwrite?: boolean;

package/node/ftps/directory/move-dir/index.js

@@ -1,9 +1,9 @@
 import {
   moveDir
-} from "../../../../chunks/chunk-BE7OXZRK.js";
-import "../../../../chunks/chunk-JMU5PDBD.js";
+} from "../../../../chunks/chunk-PTN2V757.js";
+import "../../../../chunks/chunk-QEKI6WGQ.js";
 import "../../../../chunks/chunk-FENXVJYO.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   moveDir
 };

package/node/ftps/directory/remove-dir/index.d.ts

@@ -1,5 +1,5 @@
 import { Client } from 'basic-ftp';
-import { Outcome } from '../../../../agnostic/misc/outcome/index.js';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
 export type RemoveDirOptions = {
     /**
      * If **true** (default) the function ignores the case where `directoryPath`

package/node/ftps/directory/remove-dir/index.js

@@ -1,9 +1,9 @@
 import {
   removeDir
-} from "../../../../chunks/chunk-BSUQNHAM.js";
-import "../../../../chunks/chunk-JMU5PDBD.js";
+} from "../../../../chunks/chunk-W5VY535B.js";
+import "../../../../chunks/chunk-QEKI6WGQ.js";
 import "../../../../chunks/chunk-FENXVJYO.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   removeDir
 };

package/node/ftps/file/copy/index.d.ts

@@ -1,5 +1,5 @@
 import { Client } from 'basic-ftp';
-import { Outcome } from '../../../../agnostic/misc/outcome/index.js';
+import * as Outcome from '../../../../agnostic/misc/outcome/index.js';
 export type CopyOptions = {
     /**
      * If `false` and the target already exists, the operation is aborted.

package/node/ftps/file/copy/index.js

@@ -1,9 +1,9 @@
 import {
   copy
-} from "../../../../chunks/chunk-NMYVJJXV.js";
-import "../../../../chunks/chunk-JMU5PDBD.js";
+} from "../../../../chunks/chunk-7B2E2NGH.js";
+import "../../../../chunks/chunk-QEKI6WGQ.js";
 import "../../../../chunks/chunk-FENXVJYO.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   copy
 };