fluent-file 0.1.2 → 0.2.0

package/README.md

@@ -1,68 +1,85 @@
 # Fluent File
 A fluent TypeScript library for working with files and folders
 
-## Folder
-Provides folder fields:
+## FluentFolder
+
+### Fields:
 - `path`: the absolute path to this folder (`/tmp/example/someFolder`)
 - `name`: the last piece of the absolute path (`someFolder`)
-- `parentName`: the 2nd to last piece of the absolute path (`example`)
-- `parentPath`: the absolute path to the parent of this folder (`/tmp/example`)
+- `info`: an object with both `path` and `name`
+
+### Methods:
+- `stats()`
+- `exists()`
+- `ensureExists()`
+- `ensureEmpty()`
+- `remove()`
+- `findFolders()`
+- `findFiles()`
+
+### Transform methods:
+- `file()`: create `FluentFile` by resolving the path from this `FluentFolder`
+- `folder()`: create `FluentFolder` by resolving the path from this `FluentFolder`
 
-Provides folder methods:
-- exists()
-- ensureExists()
-- ensureEmpty()
-- delete()
 
-## AFile
-Provides fields for any kind of file:
+## FluentFile
+
+### Fields:
 - `path`: the absolute path to this file (`/tmp/example/someFolder/someFile.txt`)
-- `name`: the name of the file **without** the extension (`someFile`)
-- `fullName`: the name of the file **with** the extension (`someFile.txt`)
+- `folderPath`: the absolute path to the folder this file is in (`/tmp/example/someFolder`)
+- `info`: an object with `absolutePath`, `folderPath`, `name`, `basename` and `ext`
+
+### Getters/setters (call without arg to get, call with arg to set):
+- `name`: the name of the file **with** the extension (`someFile.txt`)
+- `basename`: the name of the file **without** the extension (`someFile`)
 - `ext`: the file extension **without** the leading dot. (`txt`)
-- `parentName`: the 2nd to last piece of the absolute path to this file  (`someFolder`)
-- `parentPath`: the absolute path to the parent of this file (`/tmp/example/someFolder`)
 
-Provides file methods for any kind of file:
-- `getParentFolder()` returns the [Folder](#folder) instance this file is in
-- `getStats()` calls node:fs/promises.stat()
+### Schema methods:
+- `schema()`: create new `FluentFile` instance with a [Standard Schema](https://standardschema.dev)
+
+### Info methods:
+- `stats()` calls `node:fs/promises.stat()`
 - `exists()`
 - `ensureExists()`
+
+### Move/remove methods:
 - `copyTo()`
 - `moveTo()`
 - `linkTo()`
 - `symlinkTo()`
-- `delete()`
+- `remove()`
+
+### Read methods:
 - `readText()`
-- `readTextLines()`
+- `readBuffer()`
+- `read()`: makes use of this file's `schema` to parse then validate the file contents
+- `createReadStream()`
+
+### Write methods:
+- `append()`
 - `writeText()`
+- `writeBuffer()`
+- `write()`: makes use of this file's `schema` to validate then stringify the file contents
+- `createWriteStream()`
+
+### Image methods:
+
+Uses [sharp](https://github.com/lovell/sharp) library
+
+- `metadata()`
+- `resize()`
+- `toAVIF()`
+- `phash()`: uses [sharp-phash](https://www.npmjs.com/package/sharp-phash) to create a [perceptual hash](https://en.wikipedia.org/wiki/Perceptual_hashing) of the image
+- plus all other `sharp` methods
+
+### Video methods:
+
+Uses [ffmpeg](https://www.ffmpeg.org/) commands
+
+- `metadata()`: using [ffprobe](https://ffmpeg.org/ffprobe.html)
+- `extractFrame()`
+
+### Transform methods:
+- `file()`: create `FluentFile` by resolving the path from this `FluentFile`
+- `folder()`: create `FluentFolder` by resolving the path from this `FluentFile`
 
-## JsonFile
-Extends [AFile](#afile)
-- the `constructor()` takes a [zod](https://zod.dev) schema
-- adds a `read()` method that reads the file as text, JSON parses it, then validates it using the zod schema
-- adds a `write(contents)` method that validates the contents using the zod schema, JSON stringifies it, then writes the text
-
-## YamlFile
-Extends [JsonFile](#jsonfile)
-- overrides `read()` to use `YAML.parse` instead of `JSON.parse`, but still validates using the zod schema
-- overrides `write(contents)` to use `YAML.stringify` instead of `JSON.stringify`, but still validates using the zod schema
-
-## ImageFile
-Extends [AFile](#afile)
-- adds a [sharp](https://github.com/lovell/sharp) property
-- adds a `convertToAvif()` method
-- adds a `getPhash()` method using [sharp-phash](https://www.npmjs.com/package/sharp-phash) to create a [perceptual hash](https://en.wikipedia.org/wiki/Perceptual_hashing) of the image
-
-## VideoFile
-Extends [AFile](#afile)
-- adds a [ffmpeg](http://www.ffmpeg.org/) property, provided by [fluent-ffmpeg](https://www.npmjs.com/package/fluent-ffmpeg)
-- adds a `getMetaData()` method
-- adds a `getThumbnail()` method
-
-## GitFolder
-Extends [Folder](#folder)
-- the `constructor()` takes the git owner, repo, and baseUrl (defaults to "https://github.com")
-- adds a [git](https://git-scm.com/) property, provided by [simple-git](https://www.npmjs.com/package/simple-git)
-- adds a `clone()` method, using the owner, repo and baseUrl provided in the constructor
-- adds a `pull()` method, that will clone the repo if it does not already exist

package/dist/index.d.ts

@@ -1,270 +1,494 @@
-import * as neverthrow from 'neverthrow';
-import { ResultAsync } from 'neverthrow';
-import * as fs from 'fs';
-import { inspect } from 'node:util';
-import { Options } from 'globby';
-import { ZodError, ZodTypeAny, z } from 'zod';
-import { JSONError } from 'parse-json';
-import { YAMLParseError, ParseOptions, DocumentOptions, SchemaOptions, ToJSOptions, CreateNodeOptions, ToStringOptions } from 'yaml';
-import { AvifOptions, Sharp } from 'sharp';
-import * as simple_git from 'simple-git';
-import { SimpleGitProgressEvent } from 'simple-git';
+import { createReadStream, createWriteStream } from "node:fs";
+import { inspect } from "node:util";
+import * as fluent_command1 from "fluent-command";
+import * as fluent_command0 from "fluent-command";
+import { WriteFileOptions } from "fs-extra/esm";
+import * as neverthrow0$1 from "neverthrow";
+import * as neverthrow0 from "neverthrow";
+import { ResultAsync } from "neverthrow";
+import sharpLib, { AvifOptions, ResizeOptions, SharpOptions } from "sharp";
+import * as zerde5 from "zerde";
+import * as zerde0 from "zerde";
+import { ParseOptions, Prettify, StringifyOptions } from "zerde";
+import * as zod0 from "zod";
+import z from "zod";
+import * as fs0$1 from "fs";
+import * as fs0 from "fs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
-declare class NodeError extends Error {
-    readonly code: string;
-    readonly dest: string | undefined;
-    readonly info: Record<string, unknown> | undefined;
-    readonly path: string | undefined;
-}
-declare enum FileEntryType {
-    BlockDevice = "BlockDevice",
-    CharacterDevice = "CharacterDevice",
-    Directory = "Directory",
-    FIFO = "FIFO",
-    File = "File",
-    Socket = "Socket",
-    SymbolicLink = "SymbolicLink"
-}
-
-declare class FolderWasNotFolderError extends Error {
-    actualFileEntryType: FileEntryType;
-    constructor(path: string, actualFileEntryType: FileEntryType, cause?: Error);
-}
-
-declare class FileNotFoundError extends Error {
-    constructor(path: string, cause: Error);
+//#region src/common/glob.d.ts
+type FindFoldersGlobOptions = {
+  recursive?: boolean;
+  glob?: string;
+};
+type FindFilesGlobOptions = FindFoldersGlobOptions & {
+  exts?: Array<string>;
+};
+//#endregion
+//#region src/common/node.d.ts
+declare const FsFlags: {
+  readonly Append: "a";
+  readonly AppendOrFail: "ax";
+  readonly AppendAndRead: "a+";
+  readonly AppendAndReadOrFail: "ax+";
+  readonly Read: "r";
+  readonly ReadAndWrite: "r+";
+  readonly Write: "w";
+  readonly WriteOrFailIfExists: "wx";
+};
+type FsFlag = (typeof FsFlags)[keyof typeof FsFlags];
+//#endregion
+//#region src/file/file.errors.d.ts
+type FileOperation = "Append" | "Chmod" | "Copy" | "Download" | "ImageConvert" | "ImageMetadata" | "ImagePhash" | "ImageResize" | "Link" | "Move" | "Read" | "Remove" | "Stat" | "SymLink" | "Write";
+declare abstract class FileError extends Error {
+  readonly operation: FileOperation;
+  readonly path: string;
+  constructor(path: string, cause: unknown);
 }
-declare class FileReadError extends Error {
-    constructor(path: string, cause: Error);
+declare class FileDownloadError extends FileError {
+  readonly url: string;
+  constructor(path: string, url: string, cause: unknown);
 }
-declare class FileWriteError extends Error {
-    constructor(path: string, cause: Error);
+declare class FileAppendError extends FileError {}
+declare class FileChmodError extends FileError {}
+declare class FileImageConvertError extends FileError {}
+declare class FileImageMetadataError extends FileError {}
+declare class FileImagePhashError extends FileError {}
+declare class FileImageResizeError extends FileError {}
+declare class FileReadError extends FileError {}
+declare class FileRemoveError extends FileError {}
+declare class FileStatError extends FileError {}
+declare class FileWriteError extends FileError {}
+declare const DESTINATION_FALLBACK = "DESTINATION_FALLBACK";
+declare abstract class FileRelocateError extends FileError {
+  readonly destinationPath: string;
+  constructor(path: string, destinationPath: string | null, cause: unknown);
 }
-declare class FileWasNotFileError extends Error {
-    actualFileEntryType: FileEntryType;
-    constructor(path: string, actualFileEntryType: FileEntryType, cause?: Error);
+declare class FileCopyError extends FileRelocateError {}
+declare class FileMoveError extends FileRelocateError {}
+declare class FileLinkError extends FileRelocateError {}
+declare class FileSymLinkError extends FileRelocateError {}
+//#endregion
+//#region src/folder/folder.errors.d.ts
+declare class FolderError extends Error {
+  readonly operation: string;
+  readonly path: string;
+  constructor(operation: string, path: string, cause?: unknown);
 }
-
-declare class StringifyError extends Error {
-    constructor(path: string, cause: Error);
+declare class FolderGlobError extends FolderError {
+  constructor(path: string, cause?: unknown);
 }
-
-type Strings = Array<string>;
-type UnknownObject<Key extends string = string> = Record<Key, unknown>;
-type Spacing = string | number | undefined;
-
-declare class Folder {
-    #private;
-    constructor(folder: string | Folder, ...extraPathPieces: Strings);
-    get path(): string;
-    get name(): string;
-    get parentName(): string;
-    get parentPath(): string;
-    get info(): {
-        path: string;
-        name: string;
-        parentName: string;
-        parentPath: string;
+//#endregion
+//#region src/folder/folder.d.ts
+declare class FluentFolder {
+  readonly path: string;
+  readonly name: string;
+  constructor(...pathPieces: PathPieces);
+  get info(): {
+    path: string;
+    name: string;
+  };
+  folder: (...pathPieces: PathPieces) => FluentFolder;
+  file: (file: string, ...extraPathPieces: PathPieces) => FluentFile<string, string>;
+  relativePath: (relativeTo?: FluentFolder) => string;
+  toString: () => string;
+  toJSON: () => {
+    FluentFolder: {
+      path: string;
+      name: string;
     };
-    relativePath: (relativeTo?: string) => string;
-    toString: () => string;
-    toJSON: () => {
-        Folder: {
-            path: string;
-            name: string;
-            parentName: string;
-            parentPath: string;
-        };
+  };
+  [inspect.custom]: () => {
+    FluentFolder: {
+      path: string;
+      name: string;
     };
-    [inspect.custom]: () => {
-        Folder: {
-            path: string;
-            name: string;
-            parentName: string;
-            parentPath: string;
-        };
-    };
-    getStats: () => neverthrow.ResultAsync<fs.Stats, NodeError | FolderWasNotFolderError>;
-    exists: () => Promise<boolean>;
-    ensureExists: () => Promise<void>;
-    ensureEmpty: () => Promise<void>;
-    delete: () => Promise<void>;
-    getParentFolder: () => Folder;
-    subFolder: (folder: string | Folder, ...extraPathPieces: Strings) => Folder;
-    childFolders: (globPattern?: AnyGlob) => neverthrow.ResultAsync<Folder[], NodeError | FolderWasNotFolderError>;
-    findFolders: (globPattern: AnyGlob) => neverthrow.ResultAsync<Folder[], NodeError | FolderWasNotFolderError>;
-}
-declare function folder(folder?: string | Folder): Folder;
-declare function folder(folder: string | Folder, ...extraPathPieces: Strings): Folder;
-declare function homeFolder(...extraPathPieces: Strings): Folder;
-declare function cwd(): string;
-
-type AnyGlob = string | Strings | GlobOptions;
-type GlobOptions = Omit<Options, "cwd"> & Partial<{
-    patterns: Strings;
-    extensions: Strings;
-}>;
-
-declare class AFile {
-    #private;
-    constructor(file: AFile | Folder | string, ...extraPathPieces: Strings);
-    get path(): string;
-    get fullName(): string;
-    get name(): string;
-    get ext(): string;
-    get parentName(): string;
-    get parentPath(): string;
-    get info(): {
-        path: string;
-        fullName: string;
-        name: string;
-        ext: string;
-        parentName: string;
-        parentPath: string;
-    };
-    relativePath: (relativeTo?: string) => string;
-    toString: () => string;
-    toJSON: () => {
-        File: {
-            path: string;
-            fullName: string;
-            name: string;
-            ext: string;
-            parentName: string;
-            parentPath: string;
-        };
-    };
-    [inspect.custom]: () => {
-        File: {
-            path: string;
-            fullName: string;
-            name: string;
-            ext: string;
-            parentName: string;
-            parentPath: string;
-        };
-    };
-    getParentFolder: () => Folder;
-    getStats: () => neverthrow.ResultAsync<fs.Stats, NodeError | FileWasNotFileError>;
-    exists: () => Promise<boolean>;
-    ensureExists: () => Promise<void>;
-    copyTo: (destination: AFile | Folder) => Promise<void>;
-    moveTo: (destination: AFile | Folder) => Promise<void>;
-    linkTo: (destination: AFile | Folder) => Promise<void>;
-    symlinkTo: (destination: AFile | Folder) => Promise<void>;
-    delete: () => Promise<void>;
-    readText: () => neverthrow.ResultAsync<string, FileNotFoundError | FileReadError | FileWasNotFileError>;
-    readTextLines: () => neverthrow.ResultAsync<string[], FileNotFoundError | FileReadError | FileWasNotFileError>;
-    writeText: (content: string) => neverthrow.ResultAsync<void, FileWriteError | FileWasNotFileError>;
-}
-declare function afile(file: AFile | Folder | string, ...extraPathPieces: Strings): AFile;
-declare function homeFile(file: AFile | Folder | string, ...extraPathPieces: Strings): AFile;
-declare function findFiles(inFolder?: Folder, anyGlob?: AnyGlob): neverthrow.ResultAsync<AFile[], NodeError | FolderWasNotFolderError>;
-
-declare class ZodParseError extends Error {
-    nestedErrors: UnknownObject;
-    constructor({ cause, nestedErrors, }: {
-        cause: ZodError;
-        nestedErrors: UnknownObject;
-    });
-}
-
-declare class JsonFile<FileSchema extends ZodTypeAny> extends AFile {
-    protected readonly fileSchema: FileSchema;
-    constructor(fileSchema: FileSchema, filePath: AFile | Folder | string, ...extraPathPieces: Strings);
-    protected validateUnknown: (unknownContents: unknown) => neverthrow.Result<z.TypeOf<FileSchema>, ZodParseError>;
-    read: () => neverthrow.ResultAsync<z.TypeOf<FileSchema>, FileNotFoundError | FileReadError | FileWasNotFileError | ZodParseError | JSONError>;
-    write: (contents: z.infer<FileSchema>, spacing?: Spacing) => neverthrow.ResultAsync<void, Error | FileWriteError | FileWasNotFileError | ZodParseError>;
-}
-declare function jsonFile<FileSchema extends ZodTypeAny>(fileSchema: FileSchema, filePath: AFile | Folder | string, ...extraPathPieces: Strings): JsonFile<FileSchema>;
-declare function findJsonFiles<FileSchema extends ZodTypeAny>(fileSchema: FileSchema, inFolder?: Folder, anyGlob?: AnyGlob): neverthrow.ResultAsync<JsonFile<FileSchema>[], NodeError | FolderWasNotFolderError>;
-
-type YamlParseOptions = ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions;
-type YamlStringifyOptions = (DocumentOptions & SchemaOptions & CreateNodeOptions & ToStringOptions) | Spacing;
-
-declare const YAML_EXTENSIONS: string[];
-declare class YamlFile<FileSchema extends ZodTypeAny> extends JsonFile<FileSchema> {
-    read: (parseOptions?: YamlParseOptions) => neverthrow.ResultAsync<z.TypeOf<FileSchema>, FileNotFoundError | FileReadError | FileWasNotFileError | ZodParseError | YAMLParseError>;
-    write: (contents: z.infer<FileSchema>, stringifyOptions?: YamlStringifyOptions) => neverthrow.ResultAsync<void, FileWriteError | FileWasNotFileError | StringifyError | ZodParseError>;
-}
-declare function yamlFile<FileSchema extends ZodTypeAny>(fileSchema: FileSchema, filePath: AFile | Folder | string, ...extraPathPieces: Strings): YamlFile<FileSchema>;
-declare function findYamlFiles<FileSchema extends ZodTypeAny>(fileSchema: FileSchema, inFolder?: Folder, anyGlob?: AnyGlob): neverthrow.ResultAsync<YamlFile<FileSchema>[], NodeError | FolderWasNotFolderError>;
-
-declare const IMAGE_EXTENSIONS: string[];
-type ToAvifOptions = {
-    newFolder?: Folder;
-    newName?: string;
-    height?: number;
-    width?: number;
-} & Pick<AvifOptions, "effort" | "quality">;
-declare class ImageFile extends AFile {
-    readonly sharp: Sharp;
-    constructor(file: AFile | Folder | string, ...extraPathPieces: Strings);
-    convertToAvif: ({ newFolder, newName, height, width, effort, quality, }?: ToAvifOptions) => Promise<ImageFile>;
-    getPhash: () => Promise<string>;
+  };
+  stats: () => ResultAsync<fs0$1.Stats, FolderError>;
+  exists: () => Promise<boolean>;
+  ensureExists: () => Promise<void>;
+  ensureEmpty: () => Promise<void>;
+  remove: () => Promise<void>;
+  findFolders: (findFoldersOptions?: FindFoldersGlobOptions | undefined) => ResultAsync<FluentFolder[], FolderGlobError>;
+  findFiles: (findFilesOptions?: FindFilesGlobOptions | undefined) => ResultAsync<FluentFile<string, string>[], FolderGlobError>;
 }
-declare function imageFile(file: AFile | Folder | string, ...extraPathPieces: Strings): ImageFile;
-declare function findImageFiles(inFolder?: Folder, anyGlob?: AnyGlob): neverthrow.ResultAsync<ImageFile[], NodeError | FolderWasNotFolderError>;
-declare function base2to36(base2: string): string;
-declare function base36to2(base36: string): string;
-declare function phashCheck(needle: string, haystack: Strings): {
-    case: PhashSimilarity;
-    phash: string;
+declare function folder(...pathPieces: PathPieces): FluentFolder;
+//#endregion
+//#region src/common/path.d.ts
+type PathPieces = ReadonlyArray<string | number>;
+type FileOutputOptions = {
+  newFolder?: FluentFolder;
+  newBaseName?: string;
 };
-declare enum PhashSimilarity {
-    Exact = "Exact",
-    Similar = "Similar",
-    Unique = "Unique"
-}
-type PhashSimilarityResult = {
-    case: PhashSimilarity;
-    phash: string;
+//#endregion
+//#region src/file/image.d.ts
+declare const MAX_DIFFERENCES = 6;
+declare const IMAGE_EXTENSIONS: string[];
+type ImageResizeOptions = FileOutputOptions & ResizeOptions;
+type ToAVIFOptions = FileOutputOptions & ResizeOptions & AvifOptions;
+type PhashSimilarity = "SAME" | "SIMILAR" | "DIFFERENT";
+type PhashSimilarityInfo = {
+  readonly level: PhashSimilarity;
+  readonly diff: number;
 };
+declare const binaryStringRegex: RegExp;
+declare const phashStringSchema: z.ZodCodec<z.ZodString, z.core.$ZodBranded<z.ZodCustomStringFormat<"hex">, "PhashString">>;
+type PhashString = z.output<typeof phashStringSchema>;
+declare const phashThresholdSchema: z.core.$ZodBranded<z.ZodInt, "PhashThreshold">;
+type PhashThreshold = z.infer<typeof phashThresholdSchema>;
+declare const DEFAULT_PHASH_THRESHOLD: number & z.core.$brand<"PhashThreshold">;
+/**
+ * Compares two phashes, and returns information about how similar the two phashes are, based on the (optional) threshold.
+ *
+ * @param {PhashString} phashA
+ * @param {PhashString} phashB
+ * @param {PhashThreshold} [threshold] - Must be an integer 0-64 (inclusive). Defaults to 6.
+ * If there are fewer than `threshold` differences, the images are similar
+ *
+ * @example Given a needle and a haystack:
+    ```ts
+    const phashNeedle = "1a...8f" // (hex-encoded string)
+    const phashHaystack = ["2b..3c", "4d..5e"] // (Array of hex-encoded strings)
+    ```
+ *
+ * Can be used for sorting by using the `diff` count of the return value
+ * @example
+    ```ts
+    const sorted = phashHaystack.sort((phashA, phashB) => {
+        const adiff = comparePhashes(phashNeedle, phashA).diff
+        const bdiff = comparePhashes(phashNeedle, phashB).diff
+        return adiff - bdiff
+    })
+    ```
 
-declare class VideoMetaDataError extends Error {
-    constructor(path: string, cause: Error);
-}
-declare class VideoThumbNailError extends Error {
-    constructor(path: string, cause: Error);
-}
-
+ * Can be used for filtering by checking the `level` of the return value
+ * @example
+    ```ts
+    // all items in haystack that are the same or similar to the needle
+    const matches = phashHaystack.filter(hay => comparePhashes(phashNeedle, hay).level !== "DIFFERENT")
+    ```
+ *
+ * @see `phashesMatch` For a simpler function that returns a boolean of whether the two phashes are similar
+ */
+declare function comparePhashes(phashA: PhashString, phashB: PhashString, threshold?: PhashThreshold): PhashSimilarityInfo;
+/**
+ * Checks if two phashes `match` based on the (optional) threshold
+ *
+ * @param {PhashString} phashA
+ * @param {PhashString} phashB
+ * @param {PhashThreshold} [threshold] - Must be an integer 0-64 (inclusive). Defaults to 6.
+ * If there are fewer than `threshold` differences, the images are similar
+ *
+ * @returns whether the two phashes are similar
+ */
+declare function phashesMatch(phashA: PhashString, phashB: PhashString, threshold?: PhashThreshold): boolean;
+//#endregion
+//#region src/file/video.d.ts
 declare const VIDEO_EXTENSIONS: string[];
-declare class VideoFile extends AFile {
-    getMetaData: () => ResultAsync<{
-        bitRate: number;
-        bytes: number;
-        height: number;
-        hours: number;
+declare function getVideoMetaData(path: string): neverthrow0$1.ResultAsync<{
+  millis: number;
+  seconds: number;
+  minutes: number;
+  hours: number;
+  hms: string;
+  nb_streams: number;
+  format_name: string;
+  format_long_name: string;
+  size: number;
+  bit_rate: number;
+  videoStream: {
+    millis: number;
+    seconds: number;
+    minutes: number;
+    hours: number;
+    hms: string;
+    codec_type: "video";
+    height: number;
+    width: number;
+    codec_name: string;
+    codec_long_name: string;
+    codec_tag_string: string;
+    nb_frames: number;
+    bit_rate: number;
+  };
+  audioStreams: {
+    millis: number;
+    seconds: number;
+    minutes: number;
+    hours: number;
+    hms: string;
+    codec_type: "audio";
+    channels: number;
+    channel_layout: string;
+    codec_name: string;
+    codec_long_name: string;
+    codec_tag_string: string;
+    nb_frames: number;
+    bit_rate: number;
+  }[];
+}, zerde5.ParseError | zerde5.ValidationError | fluent_command1.FluentCommandError>;
+type ExtractFrameOptions = FileOutputOptions & {
+  time?: number;
+  unit?: "s" | "ms" | "us";
+  ext?: "png" | "jpg";
+};
+//#endregion
+//#region src/file/download.d.ts
+type DownloadProgress = {
+  totalBytes: number;
+  downloadedBytes: number;
+};
+type DownloadFileOptions = Prettify<Partial<{
+  overwrite: boolean;
+  progressThrottle: number;
+  onProgress: (progressStats: DownloadProgress) => void;
+}>>;
+//#endregion
+//#region src/file/file.d.ts
+declare class FluentFile<Content = string, ParsedContent = Content> {
+  #private;
+  constructor(schema: StandardSchemaV1<Content, ParsedContent>, file: string | number, ...pathPieces: PathPieces);
+  toString: () => string;
+  toJSON: () => {
+    FluentFile: {
+      absolutePath: string;
+      folderPath: string;
+      name: string;
+      basename: string;
+      ext: string;
+    };
+  };
+  [inspect.custom]: () => {
+    FluentFile: {
+      absolutePath: string;
+      folderPath: string;
+      name: string;
+      basename: string;
+      ext: string;
+    };
+  };
+  path: () => string;
+  folderPath: () => string;
+  name(): string;
+  name(newName: string): this;
+  basename(): string;
+  basename(newBaseName: string): this;
+  ext(): string;
+  ext(newExtension: string): this;
+  schema: <NewSchema extends StandardSchemaV1>(newSchema: NewSchema) => FluentFile<StandardSchemaV1.InferInput<NewSchema>, StandardSchemaV1.InferOutput<NewSchema>>;
+  get info(): {
+    absolutePath: string;
+    folderPath: string;
+    name: string;
+    basename: string;
+    ext: string;
+  };
+  relativePath: (relativeTo?: FluentFolder) => string;
+  file: (file: string, ...extraPathPieces: PathPieces) => FluentFile<Content, ParsedContent>;
+  folder: (...extraPathPieces: PathPieces) => FluentFolder;
+  stats: () => ResultAsync<fs0.Stats, FileStatError>;
+  exists: () => Promise<boolean>;
+  ensureExists: () => Promise<void>;
+  chmod: (mode: string | number) => ResultAsync<void, FileChmodError>;
+  copyTo: (destination: FluentFolder | FluentFile<string, string>) => ResultAsync<void, FileCopyError>;
+  moveTo: (destination: FluentFolder | FluentFile<string, string>, dereferenceSymlinks?: boolean | undefined) => ResultAsync<void, FileMoveError>;
+  linkTo: (destination: FluentFolder | FluentFile<string, string>) => ResultAsync<void, FileLinkError>;
+  symlinkTo: (destination: FluentFolder | FluentFile<string, string>) => ResultAsync<void, FileSymLinkError>;
+  remove: () => ResultAsync<void, FileRemoveError>;
+  readText: (options?: FileReadOptions | undefined) => ResultAsync<string, FileReadError>;
+  readBuffer: (options?: Pick<FileReadOptions, "flag" | "signal"> | undefined) => ResultAsync<Buffer<ArrayBufferLike>, FileReadError>;
+  read: (options?: FileReadOptions) => ResultAsync<ParsedContent, FileReadError | zerde0.ParseError | zerde0.ValidationError>;
+  createReadStream: (readStreamOptions?: Parameters<typeof createReadStream>[1]) => fs0.ReadStream;
+  writeText: (textContent: string, writeOptions?: WriteFileOptions | undefined) => ResultAsync<void, FileWriteError>;
+  writeBuffer: (bufferContent: Buffer<ArrayBufferLike>, writeOptions?: WriteFileOptions | undefined) => ResultAsync<void, FileWriteError>;
+  write: (content: Content, options?: FileWriteOptions) => ResultAsync<void, FileWriteError | zerde0.ValidationError | zerde0.StringifyError>;
+  createWriteStream: (writeStreamOptions?: Parameters<typeof createWriteStream>[1]) => fs0.WriteStream;
+  append: (data: string | Buffer<ArrayBufferLike>, writeOptions?: WriteFileOptions | undefined) => ResultAsync<void, FileAppendError>;
+  image: (sharpOptions?: SharpOptions) => {
+    metadata: () => ResultAsync<sharpLib.Metadata, FileImageMetadataError>;
+    resize: (resizeOptions: ImageResizeOptions) => ResultAsync<FluentFile<string, string>, FileImageResizeError>;
+    toAVIF: (toAVIFOptions?: ToAVIFOptions | undefined) => ResultAsync<FluentFile<string, string>, FileImageConvertError>;
+    /**
+     * Calculate the perceptual hash of an image
+     * @returns A hex-encoded string
+     * @see Use `comparePhashes` or `phashesMatch` to compare the returned phash
+     */
+    phash: () => ResultAsync<string & zod0.$brand<"PhashString">, FileImagePhashError>;
+    removeAlpha(): sharpLib.Sharp;
+    ensureAlpha(alpha?: number): sharpLib.Sharp;
+    extractChannel(channel: 0 | 1 | 2 | 3 | "red" | "green" | "blue" | "alpha"): sharpLib.Sharp;
+    joinChannel(images: string | Buffer | ArrayLike<string | Buffer>, options?: SharpOptions): sharpLib.Sharp;
+    bandbool(boolOp: keyof sharpLib.BoolEnum): sharpLib.Sharp;
+    tint(tint: sharpLib.Colour | sharpLib.Color): sharpLib.Sharp;
+    greyscale(greyscale?: boolean): sharpLib.Sharp;
+    grayscale(grayscale?: boolean): sharpLib.Sharp;
+    pipelineColourspace(colourspace?: string): sharpLib.Sharp;
+    pipelineColorspace(colorspace?: string): sharpLib.Sharp;
+    toColourspace(colourspace?: string): sharpLib.Sharp;
+    toColorspace(colorspace: string): sharpLib.Sharp;
+    composite(images: sharpLib.OverlayOptions[]): sharpLib.Sharp;
+    clone(): sharpLib.Sharp;
+    keepMetadata(): sharpLib.Sharp;
+    stats(callback: (err: Error, stats: sharpLib.Stats) => void): sharpLib.Sharp;
+    stats(): Promise<sharpLib.Stats>;
+    rotate(angle?: number, options?: sharpLib.RotateOptions): sharpLib.Sharp;
+    autoOrient(): sharpLib.Sharp;
+    flip(flip?: boolean): sharpLib.Sharp;
+    flop(flop?: boolean): sharpLib.Sharp;
+    affine(matrix: [number, number, number, number] | sharpLib.Matrix2x2, options?: sharpLib.AffineOptions): sharpLib.Sharp;
+    sharpen(options?: sharpLib.SharpenOptions): sharpLib.Sharp;
+    sharpen(sigma?: number, flat?: number, jagged?: number): sharpLib.Sharp;
+    median(size?: number): sharpLib.Sharp;
+    blur(sigma?: number | boolean | sharpLib.BlurOptions): sharpLib.Sharp;
+    dilate(width?: number): sharpLib.Sharp;
+    erode(width?: number): sharpLib.Sharp;
+    flatten(flatten?: boolean | sharpLib.FlattenOptions): sharpLib.Sharp;
+    unflatten(): sharpLib.Sharp;
+    gamma(gamma?: number, gammaOut?: number): sharpLib.Sharp;
+    negate(negate?: boolean | sharpLib.NegateOptions): sharpLib.Sharp;
+    normalise(normalise?: sharpLib.NormaliseOptions): sharpLib.Sharp;
+    normalize(normalize?: sharpLib.NormaliseOptions): sharpLib.Sharp;
+    clahe(options: sharpLib.ClaheOptions): sharpLib.Sharp;
+    convolve(kernel: sharpLib.Kernel): sharpLib.Sharp;
+    threshold(threshold?: number, options?: sharpLib.ThresholdOptions): sharpLib.Sharp;
+    boolean(operand: string | Buffer, operator: keyof sharpLib.BoolEnum, options?: {
+      raw: sharpLib.Raw;
+    }): sharpLib.Sharp;
+    linear(a?: number | number[] | null, b?: number | number[]): sharpLib.Sharp;
+    recomb(inputMatrix: sharpLib.Matrix3x3 | sharpLib.Matrix4x4): sharpLib.Sharp;
+    modulate(options?: {
+      brightness?: number | undefined;
+      saturation?: number | undefined;
+      hue?: number | undefined;
+      lightness?: number | undefined;
+    }): sharpLib.Sharp;
+    toFile(fileOut: string, callback: (err: Error, info: sharpLib.OutputInfo) => void): sharpLib.Sharp;
+    toFile(fileOut: string): Promise<sharpLib.OutputInfo>;
+    toBuffer(callback: (err: Error, buffer: Buffer, info: sharpLib.OutputInfo) => void): sharpLib.Sharp;
+    toBuffer(options?: {
+      resolveWithObject: false;
+    }): Promise<Buffer>;
+    toBuffer(options: {
+      resolveWithObject: true;
+    }): Promise<{
+      data: Buffer;
+      info: sharpLib.OutputInfo;
+    }>;
+    keepExif(): sharpLib.Sharp;
+    withExif(exif: sharpLib.Exif): sharpLib.Sharp;
+    withExifMerge(exif: sharpLib.Exif): sharpLib.Sharp;
+    keepIccProfile(): sharpLib.Sharp;
+    withIccProfile(icc: string, options?: sharpLib.WithIccProfileOptions): sharpLib.Sharp;
+    keepXmp(): sharpLib.Sharp;
+    withXmp(xmp: string): sharpLib.Sharp;
+    withMetadata(withMetadata?: sharpLib.WriteableMetadata): sharpLib.Sharp;
+    jpeg(options?: sharpLib.JpegOptions): sharpLib.Sharp;
+    jp2(options?: sharpLib.Jp2Options): sharpLib.Sharp;
+    jxl(options?: sharpLib.JxlOptions): sharpLib.Sharp;
+    png(options?: sharpLib.PngOptions): sharpLib.Sharp;
+    webp(options?: sharpLib.WebpOptions): sharpLib.Sharp;
+    gif(options?: sharpLib.GifOptions): sharpLib.Sharp;
+    avif(options?: sharpLib.AvifOptions): sharpLib.Sharp;
+    heif(options?: sharpLib.HeifOptions): sharpLib.Sharp;
+    tiff(options?: sharpLib.TiffOptions): sharpLib.Sharp;
+    raw(options?: sharpLib.RawOptions): sharpLib.Sharp;
+    toFormat(format: keyof sharpLib.FormatEnum | sharpLib.AvailableFormatInfo, options?: sharpLib.OutputOptions | sharpLib.JpegOptions | sharpLib.PngOptions | sharpLib.WebpOptions | sharpLib.AvifOptions | sharpLib.HeifOptions | sharpLib.JxlOptions | sharpLib.GifOptions | sharpLib.Jp2Options | sharpLib.RawOptions | sharpLib.TiffOptions): sharpLib.Sharp;
+    tile(tile?: sharpLib.TileOptions): sharpLib.Sharp;
+    timeout(options: sharpLib.TimeoutOptions): sharpLib.Sharp;
+    extend(extend: number | sharpLib.ExtendOptions): sharpLib.Sharp;
+    extract(region: sharpLib.Region): sharpLib.Sharp;
+    trim(options?: sharpLib.TrimOptions): sharpLib.Sharp;
+    allowHalfOpen: boolean;
+    off<K>(eventName: string | symbol, listener: (...args: any[]) => void): sharpLib.Sharp;
+    removeAllListeners(eventName?: string | symbol | undefined): sharpLib.Sharp;
+    setMaxListeners(n: number): sharpLib.Sharp;
+    getMaxListeners(): number;
+    listeners<K>(eventName: string | symbol): Function[];
+    rawListeners<K>(eventName: string | symbol): Function[];
+    listenerCount<K>(eventName: string | symbol, listener?: Function | undefined): number;
+    eventNames(): (string | symbol)[];
+    readableAborted: boolean;
+    readable: boolean;
+    readableDidRead: boolean;
+    readableEncoding: BufferEncoding | null;
+    readableEnded: boolean;
+    readableFlowing: boolean | null;
+    readableHighWaterMark: number;
+    readableLength: number;
+    readableObjectMode: boolean;
+    destroyed: boolean;
+    closed: boolean;
+    errored: Error | null;
+    writable: boolean;
+    writableAborted: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    writableHighWaterMark: number;
+    writableLength: number;
+    writableObjectMode: boolean;
+    writableCorked: number;
+    writableNeedDrain: boolean;
+  };
+  video: () => {
+    metadata: () => ResultAsync<{
+      millis: number;
+      seconds: number;
+      minutes: number;
+      hours: number;
+      hms: string;
+      nb_streams: number;
+      format_name: string;
+      format_long_name: string;
+      size: number;
+      bit_rate: number;
+      videoStream: {
         millis: number;
-        minutes: number;
         seconds: number;
+        minutes: number;
+        hours: number;
+        hms: string;
+        codec_type: "video";
+        height: number;
         width: number;
-    }, NodeError | FileWasNotFileError | ZodParseError | VideoMetaDataError>;
-    getThumbnail: (timestamp: string | number, destination: ImageFile) => ResultAsync<ImageFile, VideoThumbNailError>;
-}
-declare function videoFile(file: AFile | Folder | string, ...extraPathPieces: Strings): VideoFile;
-declare function findVideoFiles(inFolder?: Folder, anyGlob?: AnyGlob): ResultAsync<VideoFile[], NodeError | FolderWasNotFolderError>;
-
-type GitFolderOptions = {
-    owner: string;
-    repo: string;
-    onProgress?: ProgressHandler;
-    baseUrl?: string;
-};
-type ProgressHandler = (progressEvent: SimpleGitProgressEvent) => void;
-declare class GitFolder extends Folder {
-    readonly owner: string;
-    readonly repo: string;
-    readonly baseUrl: string;
-    readonly shortUrl: string;
-    readonly fullUrl: string;
-    readonly progress: ProgressHandler;
-    constructor({ owner, repo, onProgress, baseUrl }: GitFolderOptions, folder: string | Folder, ...extraPathPieces: Strings);
-    get git(): simple_git.SimpleGit;
-    isaRepo: () => Promise<boolean>;
-    clone: () => Promise<void>;
-    pull: () => Promise<simple_git.PullResult>;
-    getReadMe: () => AFile;
+        codec_name: string;
+        codec_long_name: string;
+        codec_tag_string: string;
+        nb_frames: number;
+        bit_rate: number;
+      };
+      audioStreams: {
+        millis: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        hms: string;
+        codec_type: "audio";
+        channels: number;
+        channel_layout: string;
+        codec_name: string;
+        codec_long_name: string;
+        codec_tag_string: string;
+        nb_frames: number;
+        bit_rate: number;
+      }[];
+    }, zerde0.ParseError | zerde0.ValidationError | fluent_command0.FluentCommandError>;
+    extractFrame: (extractFrameOptions?: ExtractFrameOptions) => Promise<neverthrow0.Result<FluentFile<string, string>, fluent_command0.FluentCommandError>>;
+  };
+  download: (url: string, downloadOptions?: DownloadFileOptions) => ResultAsync<"ALREADY_EXISTS" | "SUCCESS", FileDownloadError>;
 }
-
-export { AFile, Folder, GitFolder, IMAGE_EXTENSIONS, ImageFile, JsonFile, PhashSimilarity, type PhashSimilarityResult, type ToAvifOptions, VIDEO_EXTENSIONS, VideoFile, YAML_EXTENSIONS, YamlFile, afile, base2to36, base36to2, cwd, findFiles, findImageFiles, findJsonFiles, findVideoFiles, findYamlFiles, folder, homeFile, homeFolder, imageFile, jsonFile, phashCheck, videoFile, yamlFile };
+type FileReadOptions = ParseOptions & Partial<{
+  encoding: BufferEncoding;
+  flag: FsFlag;
+  signal: AbortSignal;
+}>;
+type FileWriteOptions = StringifyOptions & Partial<{
+  encoding: BufferEncoding;
+  mode: number;
+  flag: FsFlag;
+  flush: boolean;
+  signal: AbortSignal;
+}>;
+declare function ffile(file: PathPieces[number], ...extraPathPieces: PathPieces): FluentFile<string, string>;
+declare function homeFile(file: PathPieces[number], ...extraPathPieces: PathPieces): FluentFile<string, string>;
+//#endregion
+export { DEFAULT_PHASH_THRESHOLD, DESTINATION_FALLBACK, ExtractFrameOptions, FileAppendError, FileChmodError, FileCopyError, FileDownloadError, FileImageConvertError, FileImageMetadataError, FileImagePhashError, FileImageResizeError, FileLinkError, FileMoveError, FileOperation, FileReadError, FileReadOptions, FileRemoveError, FileStatError, FileSymLinkError, FileWriteError, FileWriteOptions, FindFilesGlobOptions, FindFoldersGlobOptions, FluentFile, FluentFolder, FsFlag, FsFlags, IMAGE_EXTENSIONS, ImageResizeOptions, MAX_DIFFERENCES, PhashSimilarity, PhashSimilarityInfo, PhashString, PhashThreshold, ToAVIFOptions, VIDEO_EXTENSIONS, binaryStringRegex, comparePhashes, ffile, folder, getVideoMetaData, homeFile, phashStringSchema, phashThresholdSchema, phashesMatch };

package/dist/index.js

@@ -1,10 +1 @@
-import{constants as kt}from"node:fs";import{copyFile as Gt}from"node:fs/promises";import{homedir as $t}from"node:os";import{inspect as Ut}from"node:util";import{stat as V}from"node:fs/promises";var J=Object.keys;function F(e){if(!(e instanceof Error&&"code"in e&&typeof e.code=="string"))throw new Error("was not a Node error",{cause:e})}var T=(s=>(s.BlockDevice="BlockDevice",s.CharacterDevice="CharacterDevice",s.Directory="Directory",s.FIFO="FIFO",s.File="File",s.Socket="Socket",s.SymbolicLink="SymbolicLink",s))(T||{});function U(e){for(let t of J(T))if(e[`is${t}`]())return T[t];return"File"}var A=class extends Error{constructor(t,r){super(t,{cause:r}),this.name=this.constructor.name}},O=class extends Error{constructor(t,r){super(t,{cause:r}),this.name=this.constructor.name}},P=class extends Error{constructor(t,r){super(t,{cause:r}),this.name=this.constructor.name}},u=class extends Error{actualFileEntryType;constructor(t,r,o){let i=`${t}
-was actually a ${r} instead of a Folder`;o?super(i,{cause:o}):super(i),this.name=this.constructor.name,this.actualFileEntryType=r}};var E=class extends Error{actualFileEntryType;constructor(t,r,o){let i=`${t}
-was actually a ${r} instead of a Folder`;o?super(i,{cause:o}):super(i),this.name=this.constructor.name,this.actualFileEntryType=r}};import{ResultAsync as W}from"neverthrow";function w(e){return W.fromThrowable(async()=>{let t=await V(e.path);if(t.isDirectory())return t;throw new E(e.path,U(t))},t=>(t instanceof E||F(t),t))()}function _(e){return W.fromThrowable(async()=>{let t=await V(e.path);if(t.isFile())return t;throw new u(e.path,U(t))},t=>(t instanceof u||F(t),t))()}import{homedir as wt}from"node:os";import{inspect as bt}from"node:util";import{emptyDir as Tt,ensureDir as At,remove as Ot}from"fs-extra/esm";import{basename as X,dirname as Pt,resolve as K}from"pathe";var h=class e{#t;#e;#r;#o;constructor(t,...r){let o=t instanceof e?t.path:t;this.#t=K(o,...r),this.#e=X(this.#t),this.#e||(this.#e=this.#t),this.#o=Pt(this.path),this.#r=X(this.#o),this.#r||(this.#r=this.#e)}get path(){return this.#t}get name(){return this.#e}get parentName(){return this.#r}get parentPath(){return this.#o}get info(){return{path:this.#t,name:this.#e,parentName:this.#r,parentPath:this.#o}}relativePath=(t=N())=>this.#t.startsWith(t)?this.#t.slice(t.length+1):this.#t;toString=()=>this.#t;toJSON=()=>({Folder:this.info});[bt.custom]=()=>this.toJSON();getStats=()=>w(this);exists=async()=>(await this.getStats()).isOk();ensureExists=()=>At(this.#t);ensureEmpty=()=>Tt(this.#t);delete=()=>Ot(this.#t);getParentFolder=()=>new e(this.#o);subFolder=(t,...r)=>{let o=t instanceof e?t.path:t;return new e(this.#t,o,...r)};childFolders=t=>M(this,t,1);findFolders=t=>M(this,t)};function l(e,...t){return e===void 0?new h(""):new h(e,...t)}function Nt(...e){return new h(wt(),...e)}function N(){return K(process.cwd())}import{globby as It}from"globby";var j="**",vt={absolute:!0,gitignore:!0};async function q(e,t,r,o){let i={cwd:t.path,...vt,...r},a=j;if(typeof o=="string"||Array.isArray(o))a=o;else{let{patterns:n,extensions:s,expandDirectories:d,...m}=o;n&&(a=n),i={expandDirectories:s?{extensions:s}:!0,...m,...i}}return(await It(a,i)).sort().map(n=>e(n))}function f(e,t,r=j,o=Number.POSITIVE_INFINITY){return w(t).map(()=>q(e,t,{deep:o},r))}function M(e,t=j,r=Number.POSITIVE_INFINITY){return w(e).map(()=>q(l,e,{onlyDirectories:!0,deep:r},t))}import{readFile as Rt}from"node:fs/promises";import{outputFile as Dt}from"fs-extra/esm";import{ResultAsync as H}from"neverthrow";var B=/\n|\r|\r\n/;function Q(e){return H.fromThrowable(()=>Rt(e,"utf8"),t=>(F(t),t.code==="ENOENT"?new A(e,t):t.code==="EISDIR"?new u(e,"Directory",t):new O(e,t)))()}function tt(e,t){return H.fromThrowable(()=>Dt(e,t),r=>(F(r),r.code==="EISDIR"?new u(e,"Directory",r):new P(e,r)))()}import{ensureFile as Mt,ensureLink as jt,ensureSymlink as Ct,move as Yt,remove as zt}from"fs-extra/esm";import{basename as et,dirname as Lt,resolve as Zt}from"pathe";var c=class e{#t;#e;#r;#o;#i;#s;constructor(t,...r){let o=rt(t);this.#t=Zt(o,...r),this.#e=et(this.#t);let i=this.#e.lastIndexOf(".");i<=0?(this.#r=this.#e,this.#o=""):(this.#r=this.#e.slice(0,i),this.#o=this.#e.slice(i+1)),this.#s=Lt(this.path),this.#i=et(this.#s),this.#i||(this.#i=this.#e)}get path(){return this.#t}get fullName(){return this.#e}get name(){return this.#r}get ext(){return this.#o}get parentName(){return this.#i}get parentPath(){return this.#s}get info(){return{path:this.#t,fullName:this.#e,name:this.#r,ext:this.#o,parentName:this.#i,parentPath:this.#s}}relativePath=(t=N())=>this.#t.startsWith(t)?this.#t.slice(t.length+1):this.#t;toString=()=>this.#t;toJSON=()=>({File:this.info});[Ut.custom]=()=>this.toJSON();getParentFolder=()=>new h(this.#s);getStats=()=>_(this);exists=async()=>(await this.getStats()).isOk();ensureExists=()=>Mt(this.#t);copyTo=async t=>{let r=t instanceof e?t:g(t,this.#e);await r.getParentFolder().ensureExists(),await r.delete(),await Gt(this.#t,r.path,kt.COPYFILE_FICLONE)};moveTo=async t=>{let r=t instanceof e?t:g(t,this.#e);await r.getParentFolder().ensureExists(),await r.delete(),await Yt(this.#t,r.path)};linkTo=async t=>{let r=t instanceof e?t:g(t,this.#e);await r.getParentFolder().ensureExists(),await r.delete(),await jt(this.#t,r.path)};symlinkTo=async t=>{let r=t instanceof e?t:g(t,this.#e);await r.getParentFolder().ensureExists(),await r.delete(),await Ct(this.#t,r.path)};delete=()=>zt(this.#t);readText=()=>Q(this.path);readTextLines=()=>this.readText().map(t=>t.split(B));writeText=t=>tt(this.path,t)};function g(e,...t){return new c(e,...t)}function Jt(e,...t){return new c($t(),rt(e),...t)}function rt(e){return e instanceof c||e instanceof h?e.path:e}function Vt(e=l(),t){return f(g,e,t)}import{inspect as Wt}from"node:util";import{fromThrowable as _t}from"neverthrow";var C=class extends Error{nestedErrors;constructor({cause:t,nestedErrors:r}){super(`ZodParseError: ${Wt(r)}`,{cause:t}),this.nestedErrors=r}};function I(e,t){return _t(()=>e.parse(t),r=>{let o=r;return new C({cause:o,nestedErrors:o.format(i=>({...i,actual:Xt(t,i.path)}))})})()}function Xt(e,t){let r=e[t[0]];for(let o of t)r=r[o];return r}import{fromThrowable as ot}from"neverthrow";import Kt from"parse-json";import{configure as qt}from"safe-stable-stringify";var Ht=ot(e=>Kt(e),e=>e),Bt=qt({circularValue:Error,strict:!0}),Qt=ot((e,t)=>{let r=Bt(e,null,t);if(r===void 0)throw new Error("Undefined returned from stringify!!!");if(r.trim().length===0)throw new Error("Empty string returned from stringify!!!");return r},e=>e),x=class extends c{fileSchema;constructor(t,r,...o){super(r,...o),this.fileSchema=t}validateUnknown=t=>I(this.fileSchema,t);read=()=>this.readText().andThen(Ht).andThen(this.validateUnknown);write=(t,r=2)=>this.validateUnknown(t).andThen(o=>Qt(o,r)).asyncAndThen(this.writeText)};function it(e,t,...r){return new x(e,t,...r)}function te(e,t=l(),r="*.json"){return f(o=>it(e,o),t,r)}import{fromThrowable as st}from"neverthrow";import{parse as ee,stringify as Y}from"yaml";var nt=["yaml","yml"],re=st((e,t)=>ee(e,t),e=>e),oe=st((e,t=2)=>typeof t=="string"?Y(e,{indent:Number.parseInt(t),sortMapEntries:!0}):typeof t=="number"?Y(e,{indent:t,sortMapEntries:!0}):Y(e,{sortMapEntries:!0,...t}),e=>e),v=class extends x{read=t=>this.readText().andThen(r=>re(r,t)).andThen(r=>this.validateUnknown(r));write=(t,r)=>this.validateUnknown(t).andThen(o=>oe(o,r)).asyncAndThen(this.writeText)};function at(e,t,...r){return new v(e,t,...r)}function ie(e,t=l(),r={extensions:nt}){return f(o=>at(e,o),t,r)}import se from"sharp";import ne from"sharp-phash";var pt=6,lt=".avif",mt=["avif","gif","jpeg","jpg","png","svg","tiff","webp"],R=class extends c{sharp;constructor(t,...r){super(t,...r),this.sharp=se(this.path)}convertToAvif=async({newFolder:t,newName:r,height:o,width:i,effort:a=9,quality:n}={})=>{let s=t||this.getParentFolder(),d=r??this.name;d.endsWith(lt)||(d+=lt);let m=L(s,d);return await m.exists()||(await m.getParentFolder().ensureExists(),await this.sharp.resize({fit:"contain",height:o,width:i,withoutEnlargement:!0}).avif({effort:a,quality:n}).toFile(m.path)),m};getPhash=async()=>{let t=await ne(this.path);return ct(t)}};function L(e,...t){return new R(e,...t)}function ae(e=l(),t={extensions:mt}){return f(L,e,t)}function ct(e){return Number.parseInt(e,2).toString(36)}function z(e){return Number.parseInt(e,36).toString(2)}function pe(e,t){if(t.includes(e))return{case:"Exact",phash:e};let o=z(e);for(let i of t){let a=z(i),n=0,s=o.length;for(;s--&&n<=pt;)n+=Math.abs(o.charCodeAt(s)-a.charCodeAt(s));if(n<pt)return{case:"Similar",phash:i}}return{case:"Unique",phash:e}}var ht=(o=>(o.Exact="Exact",o.Similar="Similar",o.Unique="Unique",o))(ht||{});import p from"zod";var Pr=p.object({codec_type:p.literal("data")}),le=p.object({codec_type:p.literal("audio")}),me=p.object({codec_type:p.literal("video"),height:p.number().int().positive(),width:p.number().int().positive()}),ft=p.object({format:p.object({bit_rate:p.coerce.number(),duration:p.coerce.number(),size:p.coerce.number()}),streams:p.array(p.union([le,me]))}).transform(({format:{bit_rate:e,duration:t,size:r},streams:o},{addIssue:i})=>{for(let a of o)if(a.codec_type==="video"){let{height:n,width:s}=a,d=Math.round(t*1e3),m=Math.trunc(t%60),b=Math.trunc(t/60%60),$=Math.trunc(t/60/60%60);return{bitRate:e,bytes:r,height:n,hours:$,millis:d,minutes:b,seconds:m,width:s}}return i({code:p.ZodIssueCode.custom,message:"Video was missing video stream"}),p.NEVER});import ut from"fluent-ffmpeg";import{ResultAsync as dt}from"neverthrow";var D=class extends Error{constructor(t,r){super(t,{cause:r}),this.name=this.constructor.name}},k=class extends Error{constructor(t,r){super(t,{cause:r}),this.name=this.constructor.name}};var gt=["avi","flv","mkv","mov","mp4","mpeg","mpg","rm","rmvb","webm","wmv"],ce=e=>new Promise((t,r)=>ut.ffprobe(e,(o,i)=>{o&&r(o),t(i)})),he=(e,t,r,o)=>new Promise((i,a)=>ut(e).on("error",n=>a(n)).on("end",()=>i()).screenshot({filename:r,folder:t,timestamps:typeof o=="string"?[o]:[o]})),G=class extends c{getMetaData=()=>this.getStats().andThen(()=>dt.fromThrowable(()=>ce(this.path),t=>new D(this.path,t))().andThen(t=>I(ft,t)));getThumbnail=(t,r)=>dt.fromThrowable(async()=>{if(await r.exists())return r;let i=r.getParentFolder();return await i.ensureExists(),await he(this.path,i.path,`${r.name}.png`,t),r},o=>new k(this.path,o))()};function yt(e,...t){return new G(e,...t)}function fe(e=l(),t={extensions:gt}){return f(yt,e,t)}import y from"log-update";import{CheckRepoActions as de,simpleGit as Ft}from"simple-git";var ue=e=>e.padEnd(11),S="";function ge({method:e,stage:t,progress:r,processed:o,total:i}){let a=e.toUpperCase(),n=ue(t);if(n!==S){S&&(y(a,S,"completed"),y.done()),S=n;return}let s=i.toString().length,d=process.stdout.columns,m=Math.max(1,Math.ceil(d*r/100)),b=d-m,$="=".repeat(m),xt="_".repeat(b),St=[a,n,o.toString().padStart(s),"of",i.toString(),`(${r.toString().padStart(2)}%)`].join(" "),Et=`${$}${xt}`;y(`${St}
-${Et}`)}var Z=class extends h{owner;repo;baseUrl;shortUrl;fullUrl;progress;constructor({owner:t,repo:r,onProgress:o,baseUrl:i},a,...n){let s=[...n,t,r];super(a,...s),this.owner=t,this.repo=r,this.baseUrl=i??"https://github.com",this.shortUrl=`${t}/${r}`,this.fullUrl=`${this.baseUrl}/${this.shortUrl}`,this.progress=o??ge}get git(){return Ft({baseDir:this.path,progress:this.progress})}isaRepo=async()=>await Ft(this.path).checkIsRepo(de.IS_REPO_ROOT);clone=async()=>{if(console.log(`Cloning
-`,this.fullUrl,`
-into:
-`,this.relativePath()),await this.ensureExists(),await this.isaRepo()){console.log(this.fullUrl,"is already cloned");return}await this.git.clone(this.fullUrl,this.path),y("CLONE",S,"completed"),y.done(),console.log(`Cloned
-`,this.fullUrl,`
-into:
-`,this.relativePath())};pull=async()=>{console.log("Pulling",this.fullUrl),await this.ensureExists(),await this.isaRepo()||(console.log(this.fullUrl,"does not exist yet, cloning..."),await this.clone());let r=await this.git.pull();return y("PULL",S,"completed"),y.done(),console.log("Pulled",this.fullUrl),r};getReadMe=()=>g(this.path,"README.md")};export{c as AFile,h as Folder,Z as GitFolder,mt as IMAGE_EXTENSIONS,R as ImageFile,x as JsonFile,ht as PhashSimilarity,gt as VIDEO_EXTENSIONS,G as VideoFile,nt as YAML_EXTENSIONS,v as YamlFile,g as afile,ct as base2to36,z as base36to2,N as cwd,Vt as findFiles,ae as findImageFiles,te as findJsonFiles,fe as findVideoFiles,ie as findYamlFiles,l as folder,Jt as homeFile,Nt as homeFolder,L as imageFile,it as jsonFile,pe as phashCheck,yt as videoFile,at as yamlFile};
+import{constants as e,createReadStream as t,createWriteStream as n}from"node:fs";import{chmod as r,copyFile as i,opendir as a,readFile as o,stat as s}from"node:fs/promises";import{homedir as c,platform as l}from"node:os";import{inspect as u}from"node:util";import{fcmd as d}from"fluent-command";import{appendFile as f}from"fs-extra";import{emptyDir as ee,ensureDir as te,ensureFile as ne,ensureLink as re,ensureSymlink as ie,move as ae,outputFile as p,remove as m}from"fs-extra/esm";import{ResultAsync as h}from"neverthrow";import g,{basename as oe}from"pathe";import se from"sharp";import ce from"sharp-phash";import{parseString as le,zparse as _,zstringify as ue}from"zerde";import v from"zod";import y from"picomatch";import{pipeline as b}from"node:stream/promises";const de={Append:`a`,AppendOrFail:`ax`,AppendAndRead:`a+`,AppendAndReadOrFail:`ax+`,Read:`r`,ReadAndWrite:`r+`,Write:`w`,WriteOrFailIfExists:`wx`};function x(...e){let t=e.map((e,t)=>{if(typeof e==`number`)return e.toString();if(t===0&&e===`~`)return c();if(e.toUpperCase()!==e)return e;let n=``;if(e.startsWith(`$`)&&(n=e.slice(1)),l()===`win32`&&e.startsWith(`%`)&&e.endsWith(`%`)&&(n=e.slice(1,-1)),n!==``){let t=process.env[n];if(!t)throw Error(`Missing Environment variable ${e}`);return t}return e});return g.resolve(...t)}function S(e){let t=e.lastIndexOf(`.`);return t<0?e:e.slice(t+1)}function fe(e){return S(g.extname(e))}const pe=4,me=-5;var C=class extends Error{operation;path;constructor(e,t){super(),this.path=e,this.operation=this.constructor.name.slice(pe,me),this.message=`Error trying to ${this.operation} file: ${e}`,this.cause=t,this.name=this.constructor.name}},w=class extends C{url;constructor(e,t,n){super(e,n),this.url=t,this.message=`Error trying to download url: ${t} to file: ${e}`}},he=class extends C{},ge=class extends C{},T=class extends C{},E=class extends C{},D=class extends C{},O=class extends C{},k=class extends C{},A=class extends C{},j=class extends C{},M=class extends C{};const N=`DESTINATION_FALLBACK`;var P=class extends C{destinationPath;constructor(e,t,n){super(e,n),this.destinationPath=t??N}},F=class extends P{},I=class extends P{},L=class extends P{},R=class extends P{};const _e=6,ve=[`avif`,`gif`,`jpeg`,`jpg`,`png`,`svg`,`tiff`,`webp`],z=64,ye=16,B=/^[01]+$/,V=v.codec(v.string().regex(B).length(z),v.hex().brand(`PhashString`),{decode:e=>BigInt(`0b${e}`).toString(ye),encode:e=>BigInt(`0x${e}`).toString(2).padStart(z,`0`)}),H=v.int().nonnegative().max(z).brand(`PhashThreshold`),be=6,U=H.parse(be);function xe(e,t,n=U){if(e===t)return Object.freeze({level:`SAME`,diff:0});let r=V.encode(e),i=V.encode(t),a=0,o=z;for(;o--;)r[o]!==i[o]&&a++;let s=a<n?`SIMILAR`:`DIFFERENT`;return Object.freeze({level:s,diff:a})}function Se(e,t,n=U){if(e===t)return!0;let r=V.encode(e),i=V.encode(t),a=0,o=z;for(;o--;)if(r[o]!==i[o]&&a++,a>=n)return!1;return!0}const Ce=v.coerce.number().positive(),W=v.coerce.number().int(),we=W.nonnegative(),G=W.positive(),K=v.object({duration:Ce,bit_rate:G}),Te=1e3;function q(e){let t=Math.round(e*Te),n=Math.trunc(e%60),r=Math.trunc(e/60%60),i=Math.trunc(e/60/60%60),a=[i,r,n].filter((e,t)=>t>0||e>0).map((e,t)=>{let n=e.toString();return t>0&&(n=n.padStart(2,`0`)),n}).join(`:`);return{millis:t,seconds:n,minutes:r,hours:i,hms:a}}const J=v.object({...K.shape,codec_name:v.string(),codec_long_name:v.string(),codec_tag_string:v.string(),nb_frames:G}),Ee=v.object({...J.shape,codec_type:v.literal(`audio`),channels:G,channel_layout:v.string()}),De=v.object({...J.shape,codec_type:v.literal(`video`),height:G,width:G}),Oe=v.object({...K.shape,nb_streams:G,format_name:v.string(),format_long_name:v.string(),size:G}),ke=v.object({format:Oe,streams:v.array(v.union([Ee,De])).min(2)}).transform(({format:{duration:e,...t},streams:n},{addIssue:r})=>{let i=n.filter(e=>e.codec_type===`video`).map(({duration:e,...t})=>({...t,...q(e)})).at(0);if(!i)return r({code:`custom`,message:`Video was missing video stream`}),v.NEVER;let a=n.filter(e=>e.codec_type===`audio`).map(({duration:e,...t})=>({...t,...q(e)}));return a.length===0?(r({code:`custom`,message:`Video was missing audio stream`}),v.NEVER):{videoStream:i,audioStreams:a,...t,...q(e)}}),Ae=[`avi`,`flv`,`mkv`,`mov`,`mp4`,`mpeg`,`mpg`,`rm`,`rmvb`,`webm`,`wmv`];function Y(e){return d(`ffprobe`).opt(`hide_banner`).opt(`show_format`).opt(`show_streams`).opt({v:`error`,print_format:`json`}).args(e).read().andThen(e=>_(e.stdout,ke,`json`))}var X=class extends Error{operation;path;constructor(e,t,n){let r=`Error trying to ${e} folder: ${t}`;super(r,{cause:n}),this.path=t,this.operation=e,this.name=this.constructor.name}},je=class extends X{constructor(e,t){super(`glob`,e,t)}};function Me(){return Q(process.cwd())}var Z=class{path;name;constructor(...e){this.path=x(...e),this.name=oe(this.path),this.name||=this.path}get info(){return{path:this.path,name:this.name}}folder=(...e)=>Q(this.path,...e);file=(e,...t)=>$(this.path,e,...t);relativePath=(e=Me())=>{let t=this.path;return t.startsWith(e.path)&&(t=t.slice(e.path.length),t.startsWith(`/`))?t.slice(1):t};toString=()=>this.path;toJSON=()=>({FluentFolder:this.info});[u.custom]=()=>this.toJSON();stats=h.fromThrowable(async()=>{let e=await s(this.path);if(!e.isDirectory())throw new X(`stat`,this.path,`FolderWasNotFolder`);return e},e=>e instanceof X?e:new X(`stat`,this.path,e));exists=async()=>(await this.stats()).isOk();ensureExists=()=>te(this.path);ensureEmpty=()=>ee(this.path);remove=()=>m(this.path);findFolders=h.fromThrowable(async(e={})=>{let t=e.glob?y(e.glob,{cwd:this.path}):null,n=await a(this.path,{recursive:e.recursive??!0}),r=[];for await(let e of n){if(!e.isDirectory())continue;let n=g.resolve(e.parentPath,e.name);if(t&&!t(n))continue;r.push(n)}return r.sort().map(e=>Q(e))},e=>new je(this.path,e));findFiles=h.fromThrowable(async(e={})=>{let t=e.glob?y(e.glob,{cwd:this.path}):null,n=await a(this.path,{recursive:e.recursive??!0}),r=[],i=(e.exts??[]).map(S);for await(let e of n){if(!e.isFile())continue;let n=g.resolve(e.parentPath,e.name);if(i.length>0){let t=fe(e.name);if(!i.includes(t))continue}if(t&&!t(n))continue;r.push(n)}return r.sort().map(e=>$(e))},e=>new je(this.path,e))};function Q(...e){return new Z(...e)}const Ne=h.fromThrowable(async(e,t,n={})=>{try{let{overwrite:r=!1,progressThrottle:i=100,onProgress:a}=n;if(!r&&await t.exists())return`ALREADY_EXISTS`;await t.folder().ensureExists();let o=await fetch(e);if(!o.ok){let{status:t,statusText:n,redirected:r,type:i}=o,a={};throw o.headers.forEach((e,t)=>{a[t]=e}),Error(`Got ${o.status} ${o.statusText} for url: ${e}`,{cause:{status:t,statusText:n,headers:a,redirected:r,type:i}})}let s=G.parse(o.headers.get(`content-length`));if(!o.body)throw Error(`Request body was null for url: ${e}`,{cause:o});let c=o.body,l=t.createWriteStream();if(!a)return await b(c,l),`SUCCESS`;let u=0,d=null,f=e=>{u+=e,!d&&(a({downloadedBytes:u,totalBytes:s}),d=setTimeout(()=>{d=null},i))};return await b(c,async function*(e){for await(let t of e)f(t.length)},l),`SUCCESS`}catch(n){throw new w(t.path(),e,n)}},e=>e);var Pe=class a{#path;#folderPath;#name;#basename;#ext;#schema;#info;#ensureDestination=async e=>{let t=e instanceof a?e:e.file(this.#name);return await t.folder().ensureExists(),await t.remove(),t.path()};#prepareTarget=async e=>{let{newFolder:t=this.folder(),newBaseName:n=this.#basename,newExt:r=this.#ext}=e,i=t.file(`${n}.${r}`);return await i.remove(),await t.ensureExists(),i};constructor(e,t,...n){this.#path=x(t,...n),this.#schema=e;let r=Fe(this.#path);this.#folderPath=r.folderPath,this.#name=r.name,this.#basename=r.basename,this.#ext=r.ext,this.#info=r}toString=()=>this.#path;toJSON=()=>({FluentFile:this.info});[u.custom]=()=>this.toJSON();path=()=>this.#path;folderPath=()=>this.#folderPath;name(e){return e===void 0?this.#name:(this.#name=e,this.#path=`${this.#folderPath}/${e}`,this)}basename(e){return e===void 0?this.#basename:(this.#basename=e,this.#name=e+this.#ext,this.#path=`${this.#folderPath}/${this.#name}`,this)}ext(e){return e===void 0?this.#ext:(this.#ext=e,this.#name=this.#basename+e,this.#path=`${this.#folderPath}/${this.#name}`,this)}schema=e=>new a(e,this.#path);get info(){return this.#info}relativePath=(e=Me())=>{let t=this.#path;return t.startsWith(e.path)&&(t=t.slice(e.path.length),t.startsWith(`/`))?t.slice(1):t};file=(e,...t)=>new a(this.#schema,this.#folderPath,e,...t);folder=(...e)=>new Z(this.#folderPath,...e);stats=h.fromThrowable(async()=>{let e=await s(this.#path);if(!e.isFile())throw new j(this.#path,`FileWasNotFile`);return e},e=>e instanceof j?e:new j(this.#path,e));exists=async()=>(await this.stats()).isOk();ensureExists=()=>ne(this.#path);chmod=h.fromThrowable(async e=>{await r(this.#path,e)},e=>new ge(this.#path,e));copyTo=h.fromThrowable(async t=>{let n=null;try{n=await this.#ensureDestination(t),await i(this.#path,n,e.COPYFILE_FICLONE)}catch(e){throw new F(this.#path,n,e)}},e=>e);moveTo=h.fromThrowable(async(e,t)=>{let n=null;try{n=await this.#ensureDestination(e),await ae(this.#path,n,{overwrite:!0,dereference:t})}catch(e){throw new I(this.#path,n,e)}},e=>e);linkTo=h.fromThrowable(async e=>{let t=null;try{t=await this.#ensureDestination(e),await re(this.#path,t)}catch(e){throw new L(this.#path,t,e)}},e=>e);symlinkTo=h.fromThrowable(async e=>{let t=null;try{t=await this.#ensureDestination(e),await ie(this.#path,t)}catch(e){throw new R(this.#path,t,e)}},e=>e);remove=h.fromThrowable(()=>m(this.#path),e=>new A(this.#path,e));readText=h.fromThrowable((e={})=>o(this.#path,{encoding:`utf8`,...e}),e=>new k(this.#path,e));readBuffer=h.fromThrowable((e={})=>o(this.#path,e),e=>new k(this.#path,e));read=(e={})=>this.readText(e).andThen(t=>_(t,this.#schema,{format:this.#path,...e}));createReadStream=e=>t(this.#path,e);writeText=h.fromThrowable((e,t={})=>p(this.#path,e,t),e=>new M(this.#path,e));writeBuffer=h.fromThrowable((e,t={})=>p(this.#path,e,t),e=>new M(this.#path,e));write=(e,t={})=>ue(e,this.#schema,t).andThen(e=>this.writeText(e,t));createWriteStream=e=>n(this.#path,e);append=h.fromThrowable((e,t={})=>f(this.#path,e,t),e=>new he(this.#path,e));image=(e={})=>{let t=se(this.#path,e),n=h.fromThrowable(()=>t.metadata(),e=>new E(this.#path,e)),r=h.fromThrowable(async e=>{let n=await this.#prepareTarget(e);return await t.resize(e).toFile(n.path()),n},e=>new O(this.#path,e)),i=h.fromThrowable(async(e={})=>{let n=await this.#prepareTarget({...e,newExt:`avif`});return await t.resize(e).avif(e).toFile(n.path()),n},e=>new T(this.#path,e)),a=h.fromThrowable(async()=>{let t=await ce(this.#path,e);return V.decode(t)},e=>new D(this.#path,e));return{...t,metadata:n,resize:r,toAVIF:i,phash:a}};video=()=>({metadata:()=>Y(this.#path),extractFrame:async(e={})=>{let{time:t=1,unit:n=`s`,ext:r=`png`,...i}=e,a=n===`s`?t:`${t}${n}`,o=await this.#prepareTarget({newExt:r,...i});return d(`ffmpeg`).opt(`hide_banner`).opt({ss:a,i:this.#path,"frames:v":1,y:``}).args(o.path()).read().map(()=>o)}});download=(e,t={})=>Ne(e,this,t)};function Fe(e){let t=g.basename(e),n=g.dirname(e),r=``,i=``,a=t.lastIndexOf(`.`);return a<=0?(r=t,i=``):(r=t.slice(0,a),i=t.slice(a+1)),{absolutePath:e,folderPath:n,name:t,basename:r,ext:i}}function $(e,...t){return new Pe(le(),e,...t)}function Ie(e,...t){return $(c(),e,...t)}export{U as DEFAULT_PHASH_THRESHOLD,N as DESTINATION_FALLBACK,he as FileAppendError,ge as FileChmodError,F as FileCopyError,w as FileDownloadError,T as FileImageConvertError,E as FileImageMetadataError,D as FileImagePhashError,O as FileImageResizeError,L as FileLinkError,I as FileMoveError,k as FileReadError,A as FileRemoveError,j as FileStatError,R as FileSymLinkError,M as FileWriteError,Pe as FluentFile,Z as FluentFolder,de as FsFlags,ve as IMAGE_EXTENSIONS,_e as MAX_DIFFERENCES,Ae as VIDEO_EXTENSIONS,B as binaryStringRegex,xe as comparePhashes,$ as ffile,Q as folder,Y as getVideoMetaData,Ie as homeFile,V as phashStringSchema,H as phashThresholdSchema,Se as phashesMatch};

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "fluent-file",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "A fluent TypeScript library for working with files and folders",
   "keywords": [
     "files",
     "folders",
     "fluent"
   ],
-  "repository": "github:dannywexler/fluent-file",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dannywexler/fluent-file.git"
+  },
   "author": "Danny Wexler",
   "license": "MIT",
   "type": "module",
@@ -23,93 +26,37 @@
   "files": [
     "dist"
   ],
-  "overrides": {
-    "esbuild": "0.24.0"
-  },
   "dependencies": {
-    "fluent-ffmpeg": "^2.1.3",
+    "@standard-schema/spec": "^1.0.0",
+    "fluent-command": "^0.1.4",
     "fs-extra": "^11.2.0",
-    "globby": "^14.0.2",
-    "log-update": "^6.1.0",
     "neverthrow": "^8.1.1",
-    "parse-json": "^8.1.0",
     "pathe": "^1.1.2",
-    "safe-stable-stringify": "^2.5.0",
-    "sharp": "^0.33.5",
+    "picomatch": "^4.0.3",
+    "sharp": "^0.34.5",
     "sharp-phash": "^2.2.0",
-    "simple-git": "^3.27.0",
-    "yaml": "^2.6.1",
-    "zod": "^3.24.1"
+    "zerde": "^0.1.4",
+    "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.9.4",
+    "@biomejs/biome": "2.2.6",
     "@types/download": "^8.0.5",
     "@types/fluent-ffmpeg": "^2.1.27",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.10.2",
-    "download": "^8.0.0",
-    "tsup": "^8.3.5",
-    "typescript": "^5.7.2",
+    "@types/picomatch": "^4.0.2",
+    "lefthook": "^1.13.6",
+    "tsdown": "^0.12.9",
+    "typescript": "^5.9.3",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^2.1.8",
-    "wireit": "^0.14.9"
+    "vitest": "^3.2.4"
   },
   "scripts": {
-    "build": "wireit",
-    "test": "wireit",
+    "build": "lefthook run build",
     "test:watch": "vitest"
   },
-  "wireit": {
-    "lint": {
-      "command": "biome check --error-on-warnings --colors=force --write src",
-      "files": [
-        "src"
-      ],
-      "output": []
-    },
-    "check": {
-      "command": "tsc --build --pretty",
-      "dependencies": [
-        "lint"
-      ],
-      "files": [
-        "src/**/*.ts",
-        "tsconfig.json"
-      ],
-      "output": [
-        "tsconfig.tsbuildinfo"
-      ]
-    },
-    "test": {
-      "command": "vitest run",
-      "dependencies": [
-        "check"
-      ],
-      "files": [
-        "src",
-        "test"
-      ],
-      "output": []
-    },
-    "build": {
-      "command": "tsup",
-      "dependencies": [
-        "test"
-      ],
-      "files": [
-        "src",
-        "tsconfig.json",
-        "tsconfig.tsbuildinfo",
-        "tsup.config.ts"
-      ],
-      "output": [
-        "dist"
-      ]
-    }
-  },
   "trustedDependencies": [
     "@biomejs/biome",
-    "esbuild",
     "sharp"
   ]
 }