@easbot/utils 0.1.7

package/dist/index.d.cts

@@ -0,0 +1,468 @@
+import z, { z as z$1 } from 'zod';
+import { statSync } from 'fs';
+import { Readable } from 'stream';
+
+declare function findLast<T>(items: readonly T[], predicate: (item: T, index: number, items: readonly T[]) => boolean): T | undefined;
+
+declare namespace Binary {
+    function search<T>(array: T[], id: string, compare: (item: T) => string): {
+        found: boolean;
+        index: number;
+    };
+    function insert<T>(array: T[], item: T, compare: (item: T) => string): T[];
+}
+
+declare function base64Encode(value: string): string;
+declare function base64Decode(value: string): string;
+declare function hash(content: string, algorithm?: string): Promise<string>;
+declare function checksum(content: string): string | undefined;
+
+declare abstract class NamedError extends Error {
+    abstract schema(): z.core.$ZodType;
+    abstract toObject(): {
+        name: string;
+        data: any;
+    };
+    static create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
+        new (data: z.input<Data>, options?: ErrorOptions): {
+            readonly name: Name;
+            readonly data: z.core.input<Data>;
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, z.core.$strip>;
+            toObject(): {
+                name: Name;
+                data: z.core.input<Data>;
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<Name>;
+            data: Data;
+        }, z.core.$strip>;
+        isInstance(input: any): input is InstanceType<any>;
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+            readonly Unknown: any;
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    static readonly Unknown: {
+        new (data: {
+            message: string;
+        }, options?: ErrorOptions): {
+            readonly name: "UnknownError";
+            readonly data: {
+                message: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"UnknownError">;
+            data: z.ZodObject<{
+                message: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        isInstance(input: any): input is {
+            readonly name: "UnknownError";
+            readonly data: {
+                message: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
+            new (data: z.input<Data>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: z.core.input<Data>;
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: Name;
+                    data: z.core.input<Data>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, z.core.$strip>;
+            isInstance(input: any): input is InstanceType<any>;
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+            readonly Unknown: any;
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        readonly Unknown: any;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}
+
+declare namespace Filesystem {
+    function exists(p: string): Promise<boolean>;
+    function isDir(p: string): Promise<boolean>;
+    function stat(p: string): ReturnType<typeof statSync> | undefined;
+    function size(p: string): Promise<number>;
+    function readText(p: string): Promise<string>;
+    function readJson<T = any>(p: string): Promise<T>;
+    function readBytes(p: string): Promise<Buffer>;
+    function readArrayBuffer(p: string): Promise<ArrayBuffer>;
+    function write(p: string, content: string | Buffer | Uint8Array, mode?: number): Promise<void>;
+    function writeJson(p: string, data: unknown, mode?: number): Promise<void>;
+    function writeStream(p: string, stream: ReadableStream<Uint8Array> | Readable, mode?: number): Promise<void>;
+    function mimeType(p: string): string;
+    function normalizePath(p: string): string;
+    function overlaps(a: string, b: string): boolean;
+    function contains(parent: string, child: string): boolean;
+    function findUp(target: string, start: string, stop?: string): Promise<string[]>;
+    function up(options: {
+        targets: string[];
+        start: string;
+        stop?: string;
+    }): AsyncGenerator<string, void, unknown>;
+    function globUp(pattern: string, start: string, stop?: string): Promise<string[]>;
+}
+
+declare function fn<T extends z$1.ZodType, Result>(schema: T, cb: (input: z$1.infer<T>) => Result): {
+    (input: z$1.infer<T>): Result;
+    force(input: z$1.infer<T>): Result;
+    schema: T;
+};
+
+declare namespace Identifier {
+    function ascending(): string;
+    function descending(): string;
+    function create(descending: boolean, timestamp?: number): string;
+}
+
+declare function loadTextFile(relativePath: string, importMetaUrl?: string): {
+    (): Promise<string>;
+    reset(): void;
+};
+declare function loadTextFileAsync(relativePath: string, importMetaUrl?: string): {
+    (): Promise<string>;
+    reset(): void;
+};
+
+declare function iife<T>(fn: () => T): T;
+
+declare function lazy<T>(fn: () => T): {
+    (): T;
+    reset(): void;
+};
+
+declare const MarkdownStyleSchema: z$1.ZodEnum<{
+    bold: "bold";
+    code: "code";
+    italic: "italic";
+    strikethrough: "strikethrough";
+    code_block: "code_block";
+    spoiler: "spoiler";
+    blockquote: "blockquote";
+}>;
+type MarkdownStyle = z$1.infer<typeof MarkdownStyleSchema>;
+declare const MarkdownStyleSpanSchema: z$1.ZodObject<{
+    start: z$1.ZodNumber;
+    end: z$1.ZodNumber;
+    style: z$1.ZodEnum<{
+        bold: "bold";
+        code: "code";
+        italic: "italic";
+        strikethrough: "strikethrough";
+        code_block: "code_block";
+        spoiler: "spoiler";
+        blockquote: "blockquote";
+    }>;
+}, z$1.core.$strict>;
+type MarkdownStyleSpan = z$1.infer<typeof MarkdownStyleSpanSchema>;
+declare const MarkdownLinkSpanSchema: z$1.ZodObject<{
+    start: z$1.ZodNumber;
+    end: z$1.ZodNumber;
+    href: z$1.ZodString;
+}, z$1.core.$strict>;
+type MarkdownLinkSpan = z$1.infer<typeof MarkdownLinkSpanSchema>;
+declare const MarkdownIRSchema: z$1.ZodObject<{
+    text: z$1.ZodString;
+    styles: z$1.ZodArray<z$1.ZodObject<{
+        start: z$1.ZodNumber;
+        end: z$1.ZodNumber;
+        style: z$1.ZodEnum<{
+            bold: "bold";
+            code: "code";
+            italic: "italic";
+            strikethrough: "strikethrough";
+            code_block: "code_block";
+            spoiler: "spoiler";
+            blockquote: "blockquote";
+        }>;
+    }, z$1.core.$strict>>;
+    links: z$1.ZodArray<z$1.ZodObject<{
+        start: z$1.ZodNumber;
+        end: z$1.ZodNumber;
+        href: z$1.ZodString;
+    }, z$1.core.$strict>>;
+}, z$1.core.$strict>;
+type MarkdownIR = z$1.infer<typeof MarkdownIRSchema>;
+declare const MarkdownTableModeSchema: z$1.ZodEnum<{
+    code: "code";
+    off: "off";
+    bullets: "bullets";
+}>;
+type MarkdownTableMode = z$1.infer<typeof MarkdownTableModeSchema>;
+declare const MarkdownParseOptionsSchema: z$1.ZodDefault<z$1.ZodObject<{
+    linkify: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodBoolean>>;
+    enableSpoilers: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodBoolean>>;
+    headingStyle: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodEnum<{
+        bold: "bold";
+        none: "none";
+    }>>>;
+    blockquotePrefix: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodString>>;
+    autolink: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodBoolean>>;
+    tableMode: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodEnum<{
+        code: "code";
+        off: "off";
+        bullets: "bullets";
+    }>>>;
+}, z$1.core.$strip>>;
+type MarkdownParseOptions = z$1.infer<typeof MarkdownParseOptionsSchema>;
+declare const StyleMarkerSchema: z$1.ZodObject<{
+    open: z$1.ZodString;
+    close: z$1.ZodString;
+}, z$1.core.$strict>;
+type StyleMarker = z$1.infer<typeof StyleMarkerSchema>;
+type RenderOptions = {
+    styleMarkers?: Record<MarkdownStyle, StyleMarker>;
+    escapeText?: (text: string) => string;
+    buildLink?: (link: MarkdownLinkSpan, text: string) => RenderLink | null;
+};
+declare const RenderLinkSchema: z$1.ZodObject<{
+    start: z$1.ZodNumber;
+    end: z$1.ZodNumber;
+    open: z$1.ZodString;
+    close: z$1.ZodString;
+}, z$1.core.$strict>;
+type RenderLink = z$1.infer<typeof RenderLinkSchema>;
+declare const FormatOptionsSchema: z$1.ZodObject<{
+    indentSize: z$1.ZodDefault<z$1.ZodNumber>;
+    listMarker: z$1.ZodDefault<z$1.ZodEnum<{
+        "-": "-";
+        "\u2022": "•";
+        "*": "*";
+    }>>;
+    codeBlockMarker: z$1.ZodDefault<z$1.ZodEnum<{
+        "```": "```";
+        "~~~": "~~~";
+    }>>;
+    preserveFrontmatter: z$1.ZodDefault<z$1.ZodBoolean>;
+}, z$1.core.$strict>;
+type FormatOptions = z$1.infer<typeof FormatOptionsSchema>;
+declare const ParsedFrontmatterSchema: z$1.ZodRecord<z$1.ZodString, z$1.ZodString>;
+type ParsedFrontmatter = z$1.infer<typeof ParsedFrontmatterSchema>;
+declare const InlineCodeStateSchema: z$1.ZodObject<{
+    open: z$1.ZodBoolean;
+    ticks: z$1.ZodNumber;
+}, z$1.core.$strict>;
+type InlineCodeState$1 = z$1.infer<typeof InlineCodeStateSchema>;
+type CodeSpanIndex$1 = {
+    inlineState: InlineCodeState$1;
+    isInside: (offset: number) => boolean;
+};
+declare const FenceSpanSchema: z$1.ZodObject<{
+    start: z$1.ZodNumber;
+    end: z$1.ZodNumber;
+    openLine: z$1.ZodString;
+    marker: z$1.ZodString;
+    indent: z$1.ZodString;
+}, z$1.core.$strict>;
+type FenceSpan$1 = z$1.infer<typeof FenceSpanSchema>;
+declare const MarkdownConfigSchema: z$1.ZodObject<{
+    tables: z$1.ZodOptional<z$1.ZodEnum<{
+        code: "code";
+        off: "off";
+        bullets: "bullets";
+    }>>;
+}, z$1.core.$strict>;
+type MarkdownConfig = z$1.infer<typeof MarkdownConfigSchema>;
+
+declare function markdownToIR(markdown: string, options?: MarkdownParseOptions): MarkdownIR;
+declare function markdownToIRWithMeta(markdown: string, options?: MarkdownParseOptions): {
+    ir: MarkdownIR;
+    hasTables: boolean;
+};
+declare function chunkMarkdownIR(ir: MarkdownIR, limit: number): MarkdownIR[];
+
+declare function renderMarkdownWithMarkers(ir: MarkdownIR, options?: RenderOptions): string;
+declare function renderMarkdown(ir: MarkdownIR, options?: RenderOptions): string;
+
+declare function formatMarkdown(markdown: string, options?: FormatOptions): string;
+
+declare function parseFrontmatterBlock(content: string): ParsedFrontmatter;
+declare function serializeFrontmatter(data: ParsedFrontmatter): string;
+declare function extractFrontmatter(content: string): {
+    frontmatter: ParsedFrontmatter;
+    content: string;
+};
+
+declare function scanParenAwareBreakpoints(text: string, start: number, end: number, isAllowed?: (index: number) => boolean): {
+    lastNewline: number;
+    lastWhitespace: number;
+};
+declare function chunkText(text: string, limit: number): string[];
+declare function chunkTextByBreakResolver(text: string, limit: number, resolveBreakIndex: (window: string) => number): string[];
+
+type InlineCodeState = {
+    open: boolean;
+    ticks: number;
+};
+declare function createInlineCodeState(): InlineCodeState;
+type CodeSpanIndex = {
+    inlineState: InlineCodeState;
+    isInside: (index: number) => boolean;
+};
+declare function buildCodeSpanIndex(text: string, inlineState?: InlineCodeState): CodeSpanIndex;
+
+type FenceSpan = {
+    start: number;
+    end: number;
+    openLine: string;
+    marker: string;
+    indent: string;
+};
+declare function parseFenceSpans(buffer: string): FenceSpan[];
+declare function findFenceSpanAt(spans: FenceSpan[], index: number): FenceSpan | undefined;
+declare function isSafeFenceBreak(spans: FenceSpan[], index: number): boolean;
+
+declare function convertMarkdownTables(markdown: string, mode: MarkdownTableMode): string;
+
+declare namespace Markdown {
+    function parse(markdown: string, options?: MarkdownParseOptions): MarkdownIR;
+    function render(ir: MarkdownIR, options?: RenderOptions): string;
+    function format(markdown: string, options?: FormatOptions): string;
+    function parseFrontmatter(content: string): ParsedFrontmatter;
+    function serializeFrontmatter(data: ParsedFrontmatter): string;
+    function extractFrontmatter(content: string): {
+        frontmatter: ParsedFrontmatter;
+        content: string;
+    };
+    function chunk(text: string, limit: number): string[];
+    function buildCodeIndex(text: string, inlineState?: InlineCodeState$1): CodeSpanIndex$1;
+    function convertTables(markdown: string, tableMode: MarkdownTableMode): string;
+}
+
+declare function getFilename(path: string | undefined): string;
+declare function getDirectory(path: string | undefined): string;
+declare function getFileExtension(path: string | undefined): string | undefined;
+declare function getFilenameTruncated(path: string | undefined, maxLength?: number): string;
+declare function truncateMiddle(text: string, maxLength?: number): string;
+
+interface RetryOptions {
+    attempts?: number;
+    delay?: number;
+    factor?: number;
+    maxDelay?: number;
+    retryIf?: (error: unknown) => boolean;
+}
+declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+declare namespace Slug {
+    function create(): string;
+}
+
+export { Binary, type CodeSpanIndex$1 as CodeSpanIndex, type FenceSpan$1 as FenceSpan, Filesystem, type FormatOptions, Identifier, type InlineCodeState$1 as InlineCodeState, Markdown, type MarkdownConfig, type MarkdownIR, type MarkdownLinkSpan, type MarkdownParseOptions, type MarkdownStyle, type MarkdownStyleSpan, type MarkdownTableMode, NamedError, type ParsedFrontmatter, type RenderLink, type RenderOptions, Slug, type StyleMarker, base64Decode, base64Encode, buildCodeSpanIndex, checksum, chunkMarkdownIR, chunkText, chunkTextByBreakResolver, convertMarkdownTables, createInlineCodeState, extractFrontmatter, findFenceSpanAt, findLast, fn, formatMarkdown, getDirectory, getFileExtension, getFilename, getFilenameTruncated, hash, iife, isSafeFenceBreak, lazy, loadTextFile, loadTextFileAsync, markdownToIR, markdownToIRWithMeta, parseFenceSpans, parseFrontmatterBlock, renderMarkdown, renderMarkdownWithMarkers, retry, scanParenAwareBreakpoints, serializeFrontmatter, truncateMiddle };