@vef-framework/shared 1.0.134 → 2.0.0

package/dist/types/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './color-names';
+export * from './color-palettes';

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './color';
+export * from './constants';
+export * from './types';
+export * from './utils';

package/dist/types/types/color.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The color entry
+ */
+export type ColorEntry = [hex: string, name: string];
+/**
+ * The color number
+ */
+export type ColorNumber = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;
+/**
+ * The color swatch
+ */
+export interface ColorSwatch {
+    /**
+     * The color number
+     */
+    number: ColorNumber;
+    /**
+     * The color hex code
+     */
+    hex: string;
+}
+/**
+ * The color palette
+ */
+export interface ColorPalette {
+    /**
+     * The color name
+     */
+    name: string;
+    /**
+     * The color swatches
+     */
+    swatches: ColorSwatch[];
+}
+/**
+ * The color swatch with delta
+ */
+export interface ColorSwatchWithDelta extends ColorSwatch {
+    /**
+     * The color delta
+     */
+    delta: number;
+}
+/**
+ * The nearest color palette
+ */
+export interface NearestColorPalette extends ColorPalette {
+    /**
+     * The nearest swatch
+     */
+    nearestSwatch: ColorSwatchWithDelta;
+    /**
+     * The nearest lightness swatch
+     */
+    nearestLightnessSwatch: ColorSwatchWithDelta;
+}
+/**
+ * The matched color palette
+ */
+export interface MatchedColorPalette extends ColorPalette {
+    /**
+     * The color map of the palette
+     */
+    colorMap: Map<ColorNumber, string>;
+    /**
+     * The main color swatch of the palette which number is 500
+     */
+    main: ColorSwatch;
+    /**
+     * The matched color swatch of the palette
+     */
+    matched: ColorSwatch;
+}

package/dist/types/types/common.d.ts

@@ -0,0 +1,25 @@
+import { Primitive } from 'type-fest';
+export type Builtin = Primitive | Function | Date | Error | RegExp;
+export type Key = string;
+export type Awaitable<T> = T | Promise<T>;
+export type MaybeArray<T> = T | T[];
+export type MaybeNullish<T> = T | null | undefined;
+export type MaybeUndefined<T> = T | undefined;
+export type MaybeNull<T> = T | null;
+export type Expand<T> = T extends T ? T : never;
+export type Not<A extends boolean> = A extends true ? false : A extends false ? true : never;
+export type IsString<T> = T extends string ? true : false;
+export interface EmptyObject {
+}
+export type AnyObject = Record<keyof any, any>;
+export type RenameKey<T, TOldKey extends keyof T, TNewKey extends string> = {
+    [K in keyof T as K extends TOldKey ? TNewKey : K]: T[K];
+};
+export type NonFunctionGuard<T> = T extends Function ? never : T;
+/**
+ * Omits all symbol keys from an object type.
+ */
+export type OmitSymbol<T> = {
+    [K in keyof T as K extends symbol ? never : K]: T[K];
+};
+export type { And, Except, HasOptionalKeys, HasRequiredKeys, If, IsAny, IsBooleanLiteral, IsEqual, IsFloat, IsInteger, IsLiteral, IsNever, IsNull, IsNullable, IsNumericLiteral, IsOptional, IsOptionalKeyOf, IsReadonlyKeyOf, IsRequiredKeyOf, IsStringLiteral, IsSymbolLiteral, IsTuple, IsUndefined, IsUnknown, IsWritableKeyOf, IterableElement, KebabCase, LiteralUnion, NonEmptyObject, NonEmptyString, NonEmptyTuple, OptionalKeysOf, Or, OverrideProperties, PartialDeep, Simplify as Prettify, SimplifyDeep as PrettifyDeep, Primitive, RequiredDeep, RequiredKeysOf, SetFieldType, SetOptional, SetParameterType, SetReadonly, SetRequired, SetReturnType } from 'type-fest';

package/dist/types/types/deep-keys.d.ts

@@ -0,0 +1,9 @@
+type ComputeRange<N extends number, Result extends unknown[] = []> = Result["length"] extends N ? Result : ComputeRange<N, [...Result, Result["length"]]>;
+type Index40 = ComputeRange<40>[number];
+type IsTuple<T> = T extends readonly any[] & {
+    length: infer Length;
+} ? Length extends Index40 ? T : never : never;
+type AllowedIndexes<Tuple extends readonly any[], Keys extends number = never> = Tuple extends readonly [] ? Keys : Tuple extends readonly [infer _, ...infer Tail] ? AllowedIndexes<Tail, Keys | Tail["length"]> : Keys;
+type DeepKeysPrefix<T, TPrefix, TDepth extends any[]> = TPrefix extends keyof T & (number | string) ? `${TPrefix}.${DeepKeys<T[TPrefix], [...TDepth, any]> & string}` : never;
+export type DeepKeys<T, TDepth extends any[] = []> = TDepth["length"] extends 5 ? never : unknown extends T ? string : T extends readonly any[] & IsTuple<T> ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>, TDepth> : T extends any[] ? DeepKeys<T[number], [...TDepth, any]> : T extends Date ? never : T extends object ? (keyof T & string) | DeepKeysPrefix<T, keyof T, TDepth> : never;
+export {};

package/dist/types/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './color';
+export * from './common';
+export * from './deep-keys';

package/dist/types/utils/chrono.d.ts

@@ -0,0 +1,162 @@
+import { DurationUnitType } from 'dayjs/plugin/duration';
+import { MaybeNull } from '../types';
+import { default as dayjs } from 'dayjs';
+export type Dayjs = dayjs.Dayjs;
+/**
+ * Temporal picker mode type.
+ * Defines the granularity of date/time selection.
+ */
+export type TemporalMode = "minute" | "hour" | "time" | "date" | "datetime" | "week" | "month" | "quarter" | "year";
+export declare const DEFAULT_DATE_FORMAT = "YYYY-MM-DD";
+export declare const DEFAULT_TIME_FORMAT = "HH:mm:ss";
+export declare const DEFAULT_DATETIME_FORMAT = "YYYY-MM-DD HH:mm:ss";
+export declare const LOCALIZED_DATETIME_FORMAT = "LLLL";
+export declare const LOCALIZED_DATE_FORMAT = "LLdddd";
+/**
+ * Format duration in seconds to human readable string
+ *
+ * @param seconds - Duration in seconds
+ * @param unit - The unit of the duration (default: "seconds")
+ * @returns Formatted duration string
+ *
+ * @example
+ * ```ts
+ * formatDuration(60) // "1分钟"
+ * formatDuration(3600) // "1小时0分钟"
+ * formatDuration(86400) // "1天0小时0分钟"
+ * formatDuration(90061) // "1天1小时1分钟"
+ * ```
+ */
+export declare function formatDuration(seconds: number, unit?: DurationUnitType): string;
+/**
+ * Parses a date string into a dayjs instance with optional format.
+ *
+ * @param date - The date string or Date object to parse
+ * @param format - The format string to use for parsing (optional, ignored for Date objects)
+ * @returns A dayjs instance
+ *
+ * @example
+ * ```ts
+ * parseDate("2025-11-10") // dayjs instance
+ * parseDate("2025-11-10 16:30:45") // dayjs instance
+ * parseDate("20251110", "YYYYMMDD") // dayjs instance with custom format
+ * parseDate("10/11/2025", "DD/MM/YYYY") // dayjs instance with custom format
+ * parseDate(new Date()) // dayjs instance from Date object
+ * ```
+ */
+export declare function parseDate(date: string | Date, format?: MaybeNull<string>): Dayjs;
+/**
+ * Attempts to parse a date string by trying various datetime and date formats.
+ * Returns null if parsing fails with all formats.
+ *
+ * @param date - The date string to parse
+ * @returns A dayjs instance if parsing succeeds, null otherwise
+ *
+ * @example
+ * ```ts
+ * tryParseDate("2025-11-10 16:30:45") // dayjs instance
+ * tryParseDate("2025/11/10") // dayjs instance
+ * tryParseDate("20251110") // dayjs instance
+ * tryParseDate("invalid date") // null
+ * ```
+ */
+export declare function tryParseDate(date: string): MaybeNull<Dayjs>;
+/**
+ * Formats a dayjs instance with the specified format.
+ *
+ * @param date - The dayjs instance to format
+ * @param format - The format string (defaults to "YYYY-MM-DD HH:mm:ss")
+ * @returns The formatted date string
+ *
+ * @example
+ * ```ts
+ * formatDate(dayjs()) // "2025-11-10 16:30:45"
+ * formatDate(dayjs(), "YYYY-MM-DD") // "2025-11-10"
+ * formatDate(dayjs(), "HH:mm:ss") // "16:30:45"
+ * ```
+ */
+export declare function formatDate(date: Dayjs, format?: string): string;
+/**
+ * Gets the current time as a dayjs instance.
+ *
+ * @returns The current time as a dayjs instance
+ *
+ * @example
+ * ```ts
+ * const now = getNow() // dayjs instance
+ * now.format("YYYY-MM-DD") // "2025-11-10"
+ * ```
+ */
+export declare function getNow(): Dayjs;
+/**
+ * Gets the current date string in "YYYY-MM-DD" format.
+ *
+ * @returns The current date string
+ *
+ * @example
+ * ```ts
+ * getNowDateString() // "2025-11-10"
+ * ```
+ */
+export declare function getNowDateString(): string;
+/**
+ * Gets the current time string in "HH:mm:ss" format.
+ *
+ * @returns The current time string
+ *
+ * @example
+ * ```ts
+ * getNowTimeString() // "16:30:45"
+ * ```
+ */
+export declare function getNowTimeString(): string;
+/**
+ * Gets the current date time string in "YYYY-MM-DD HH:mm:ss" format.
+ *
+ * @returns The current date time string
+ *
+ * @example
+ * ```ts
+ * getNowDateTimeString() // "2025-11-10 16:30:45"
+ * ```
+ */
+export declare function getNowDateTimeString(): string;
+/**
+ * Gets the current date time in a localized full format.
+ *
+ * @returns The localized date time string
+ *
+ * @example
+ * ```ts
+ * // With zh-cn locale
+ * getLocalizedDateTime() // "2025年11月10日星期日下午4点30分45秒"
+ * getLocalizedDateTime(false) // "2025年11月10日星期日"
+ * ```
+ */
+export declare function getLocalizedDateTime(includeTime?: boolean): string;
+declare const FORMAT_MAP: {
+    readonly year: readonly ["YYYY"];
+    readonly quarter: readonly ["YYYY-Q季度"];
+    readonly month: readonly ["YYYY-MM", "YYYY/MM", "YYYY.MM", "YYYYMM"];
+    readonly week: readonly ["YYYY-wo"];
+    readonly date: readonly ["YYYY-MM-DD", "YYYY/MM/DD", "YYYY.MM.DD", "YYYYMMDD", "YY/MM/DD", "YY.MM.DD", "YYMMDD"];
+    readonly time: readonly ["HH:mm:ss", "HH.mm.ss", "HHmmss"];
+    readonly hour: readonly ["HH"];
+    readonly minute: readonly ["HH:mm", "HH.mm", "HHmm"];
+    readonly datetime: readonly ["YYYY-MM-DD HH:mm:ss", "YYYY/MM/DD HH:mm:ss", "YYYY.MM.DD HH.mm.ss", "YYYYMMDDHHmmss", "YY/MM/DD HH:mm:ss", "YY.MM.DD HH:mm:ss", "YY.MM.DD HH.mm.ss", "YYMMDDHHmmss"];
+};
+/**
+ * Gets the available format patterns for a temporal picker mode.
+ *
+ * @param mode - The temporal picker mode
+ * @returns An array of format strings for the specified mode
+ *
+ * @example
+ * ```ts
+ * getTemporalFormats("date") // ["YYYY-MM-DD", "YYYY/MM/DD", ...]
+ * getTemporalFormats("time") // ["HH:mm:ss", "HH.mm.ss", "HHmmss"]
+ * getTemporalFormats("datetime") // ["YYYY-MM-DD HH:mm:ss", ...]
+ * ```
+ */
+export declare function getTemporalFormats<const T extends TemporalMode>(mode: T): typeof FORMAT_MAP[T];
+export {};

package/dist/types/utils/equal.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shallowly compares two values.
+ *
+ * @param value1 - The first value to compare.
+ * @param value2 - The second value to compare.
+ * @returns `true` if the values are shallowly equal, `false` otherwise.
+ */
+export declare function isShallowEqual(value1: unknown, value2: unknown): boolean;
+/**
+ * Deeply compares two values, with support for circular references.
+ *
+ * @param value1 - The first value to compare.
+ * @param value2 - The second value to compare.
+ * @returns `true` if the values are deeply equal, `false` otherwise.
+ */
+export declare function isDeepEqual(value1: unknown, value2: unknown): boolean;

package/dist/types/utils/error.d.ts

@@ -0,0 +1,38 @@
+import * as stackTrace from "stacktrace-js";
+export type StackFrame = stackTrace.StackFrame;
+/**
+ * Parse the error stack, filter the stack frames
+ *
+ * @param error The error to parse
+ * @param filter The filter function to filter the stack frames
+ * @returns The parsed stack frames
+ */
+export declare function parseErrorStack(error: Error, filter?: (frame: StackFrame) => boolean): Promise<StackFrame[]>;
+/**
+ * Filter the user frame
+ *
+ * @param stackFrame The stack frame to filter
+ * @returns The filtered stack frame
+ */
+export declare function filterUserFrame(stackFrame: StackFrame): boolean;
+/**
+ * Get the sanitized error stack
+ *
+ * @param error The error to sanitize
+ * @returns The sanitized error stack
+ */
+export declare function getSanitizedErrorStack(error: Error): Promise<string>;
+/**
+ * Get the current stack
+ *
+ * @param filter The filter function to filter the stack frames
+ * @returns The current stack
+ */
+export declare function getCurrentStack(filter?: (frame: StackFrame) => boolean): Promise<StackFrame[]>;
+/**
+ * Get the current stack synchronously
+ *
+ * @param filter The filter function to filter the stack frames
+ * @returns The current stack
+ */
+export declare function getCurrentStackSync(filter?: (frame: StackFrame) => boolean): StackFrame[];

package/dist/types/utils/event.d.ts

@@ -0,0 +1,68 @@
+import { EventHandlerMap, EventType, Handler } from 'mitt';
+/**
+ * A type-safe event emitter wrapper around mitt library.
+ * Provides a clean API for event subscription, emission, and cleanup.
+ *
+ * @template TEvents - A record type defining the available events and their payload types
+ */
+export declare class EventEmitter<TEvents extends Record<EventType, unknown>> {
+    #private;
+    /**
+     * Subscribe to an event with a listener function.
+     * Returns an unsubscribe function for easy cleanup.
+     *
+     * @param eventType - The type of event to listen for
+     * @param eventListener - The function to call when the event is emitted
+     * @returns A function that removes this specific listener when called
+     */
+    on<const TEventType extends keyof TEvents>(eventType: TEventType, eventListener: Handler<TEvents[TEventType]>): () => void;
+    /**
+     * Emit an event with the specified payload.
+     * All registered listeners for this event type will be called synchronously.
+     *
+     * @param eventType - The type of event to emit
+     * @param eventPayload - The data to pass to all listeners
+     */
+    emit<const TEventType extends keyof TEvents>(eventType: undefined extends TEvents[TEventType] ? TEventType : never): void;
+    emit<const TEventType extends keyof TEvents>(eventType: TEventType, eventPayload: TEvents[TEventType]): void;
+    /**
+     * Remove a specific listener for an event type.
+     * If no listener is provided, removes all listeners for that event type.
+     *
+     * @param eventType - The type of event to remove listeners from
+     * @param eventListener - Optional specific listener to remove
+     */
+    off<const TEventType extends keyof TEvents>(eventType: TEventType, eventListener?: Handler<TEvents[TEventType]>): void;
+    /**
+     * Remove all event listeners from all event types.
+     * Useful for cleanup when the emitter is no longer needed.
+     */
+    clear(): void;
+    /**
+     * Get all registered listeners for debugging purposes.
+     * Returns a Map of event types to their listener arrays.
+     */
+    getAllListeners(): EventHandlerMap<TEvents>;
+}
+/**
+ * Factory function to create a new EventEmitter instance.
+ * Provides a more functional approach to creating event emitters.
+ *
+ * @template TEvents - A record type defining the available events and their payload types
+ * @returns A new EventEmitter instance
+ *
+ * @example
+ * ```typescript
+ * interface AppEvents {
+ *   'user:login': { userId: string };
+ *   'user:logout': void;
+ * }
+ *
+ * const emitter = createEventEmitter<AppEvents>();
+ * const unsubscribe = emitter.on('user:login', ({ userId }) => {
+ *   console.log(`User ${userId} logged in`);
+ * });
+ * ```
+ */
+export declare function createEventEmitter<TEvents extends Record<EventType, unknown>>(): EventEmitter<TEvents>;
+export { type Handler as EventHandler, type EventType } from 'mitt';

package/dist/types/utils/format.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Format bytes to human readable string
+ *
+ * @param bytes - Number of bytes
+ * @param decimals - Number of decimal places (default: 2)
+ * @returns Formatted string with unit (B, KB, MB, GB, TB, PB)
+ *
+ * @example
+ * ```ts
+ * formatBytes(1024) // "1 KB"
+ * formatBytes(1536, 1) // "1.5 KB"
+ * formatBytes(1048576) // "1 MB"
+ * formatBytes(0) // "0 B"
+ * ```
+ */
+export declare function formatBytes(bytes: number, decimals?: number): string;
+/**
+ * Format large numbers to human readable string with units (K, M, B, T)
+ *
+ * @param num - Number to format
+ * @param decimals - Number of decimal places (default: 2)
+ * @returns Formatted string with unit (K, M, B, T)
+ *
+ * @example
+ * ```ts
+ * formatNumber(1000) // "1 K"
+ * formatNumber(1500, 1) // "1.5 K"
+ * formatNumber(1234567) // "1.23 M"
+ * formatNumber(999) // "999"
+ * formatNumber(0) // "0"
+ * ```
+ */
+export declare function formatNumber(num: number, decimals?: number): string;

package/dist/types/utils/function.d.ts

@@ -0,0 +1,59 @@
+import { Awaitable, MaybeUndefined } from '../types';
+/**
+ * Awaitable function invocation options.
+ */
+export interface AwaitableFnInvocationOptions<in TResult, in out TContext = unknown> {
+    /**
+     * The function to call before invoking the awaitable function.
+     */
+    onInvoke?: () => MaybeUndefined<TContext>;
+    /**
+     * The function to call when the awaitable function succeeds.
+     */
+    onSuccess?: (result: TResult, context: MaybeUndefined<TContext>) => void;
+    /**
+     * The function to call when the awaitable function fails.
+     */
+    onError?: (error: unknown, context: MaybeUndefined<TContext>) => void;
+    /**
+     * The function to call after invoking the awaitable function.
+     */
+    onFinally?: (context: MaybeUndefined<TContext>) => void;
+}
+/**
+ * Checks if a function is an async function.
+ *
+ * @param fn - The function to check.
+ * @returns `true` if the function is an async function, `false` otherwise.
+ */
+export declare function isAsyncFunction(fn: Function): fn is (...args: any[]) => Promise<any>;
+/**
+ * Invokes an awaitable function.
+ *
+ * @param fn - The awaitable function to invoke.
+ * @param args - The arguments to pass to the awaitable function.
+ * @param options - The options to pass to the awaitable function.
+ * @returns The result of the awaitable function.
+ */
+export declare function invokeAwaitableFn<TArgs extends any[] = any[], TResult = unknown, TContext = unknown>(fn: (...args: TArgs) => Awaitable<TResult>, args: NoInfer<TArgs>, options: AwaitableFnInvocationOptions<NoInfer<TResult>, TContext>): Promise<TResult>;
+/**
+ * Returns the value itself.
+ *
+ * @param value - The value to return.
+ * @returns The value itself.
+ */
+export declare function identity<T>(value: T): T;
+/**
+ * Creates a function that throws an error indicating the feature/function is not implemented.
+ *
+ * @param feature - The feature/function name to include in the error message.
+ * @returns A function that throws an error indicating the feature/function is not implemented.
+ */
+export declare function createThrowNotImplementedFn(feature?: string): () => never;
+/**
+ * Throws an error indicating the feature/function is not implemented.
+ *
+ * @param feature - The feature/function name to include in the error message.
+ * @throws Always throws an Error to indicate a missing implementation.
+ */
+export declare function throwNotImplemented(feature?: string): never;

package/{types → dist/types/utils}/id.d.ts

@@ -1,6 +1,6 @@
 /**
- * Generate a unique id
+ * Generates a unique ID.
  *
- * @returns {string} A unique id
+ * @returns A unique ID.
  */
 export declare function generateId(): string;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,17 @@
+export * from './chrono';
+export * from './equal';
+export * from './error';
+export * from './event';
+export * from './format';
+export * from './function';
+export * from './id';
+export * from './key';
+export * from './lib';
+export * from './object';
+export * from './path';
+export * from './pinyin';
+export * from './security';
+export * from './string';
+export * from './task';
+export * from './tree';
+export * from './zod';

package/dist/types/utils/key.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generate a hash key from the given value.
+ *
+ * @param key - The value to generate a hash key from.
+ * @returns The hash key.
+ */
+export declare function hashKey(key: unknown): string;

package/dist/types/utils/lib.d.ts

@@ -0,0 +1,5 @@
+export declare const alwaysTrue: () => boolean;
+export declare const alwaysFalse: () => boolean;
+export { klona as cloneDeep } from 'klona';
+export { parse as decodeQueryString, stringify as encodeQueryString } from 'qs';
+export { always, assign, camel as camelCase, capitalize, cluster, debounce, first, get, isArray, isBigInt, isBoolean, isDate, isEmpty, isError, isFloat, isFunction, isInt, isIntString, isMap, isNullish, isNumber, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isUndefined, isWeakMap, isWeakSet, dash as kebabCase, last, max, memo as memoize, min, noop, omit, once, pascal as pascalCase, pick, set, similarity, snake as snakeCase, sum, template, throttle, toFloat, toInt, trim, unique } from 'radashi';

package/dist/types/utils/object.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Merges the source object into the target object
+ *
+ * @param target - The target object
+ * @param source - The source object
+ * @param overrideExisting - Whether to override existing values
+ * @returns The merged object with the source object merged into the target object
+ */
+export declare function mergeWith<T extends object>(target: T, source: Partial<T>, overrideExisting?: boolean): T;

package/dist/types/utils/path.d.ts

@@ -0,0 +1,76 @@
+import { default as path } from 'path-browserify';
+declare const pathSeparator: string;
+export type PathObject = path.PathObject;
+/**
+ * Get the base name from a path
+ *
+ * @param path The path
+ * @param keepExt Whether to keep the extension
+ * @returns The base name
+ */
+export declare function getBaseName(path: string, keepExt?: boolean): string;
+/**
+ * Get the extension name from a path
+ *
+ * @param path The path
+ * @returns The extension name
+ */
+export declare function getExtName(path: string): string;
+/**
+ * Get the dir name from a path
+ *
+ * @param path The path
+ * @returns The dir name
+ */
+export declare function getDirName(path: string): string;
+/**
+ * Joins paths
+ *
+ * @param paths The paths
+ * @returns The joined path
+ */
+export declare function joinPaths(...paths: string[]): string;
+/**
+ * Checks if a path is absolute
+ *
+ * @param path The path
+ * @returns Whether the path is absolute
+ */
+export declare function isAbsolutePath(path: string): boolean;
+/**
+ * Normalizes a path
+ *
+ * @param path The path
+ * @returns The normalized path
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * Parse a path
+ *
+ * @param path The path
+ * @returns The parsed path
+ */
+export declare function parsePath(path: string): PathObject;
+/**
+ * Format a path object
+ *
+ * @param pathObject The path object
+ * @returns The formatted path
+ */
+export declare function formatPath(pathObject: PathObject): string;
+/**
+ * Get the relative path from one path to another
+ *
+ * @param from The starting path
+ * @param to The destination path
+ * @returns The relative path
+ */
+export declare function getRelativePath(from: string, to: string): string;
+/**
+ * Resolve a path
+ *
+ * @param pathSegments The path segments
+ * @returns The resolved path
+ */
+export declare function resolvePath(...pathSegments: string[]): string;
+export { pathSeparator };