@mnaoumov/typescript-lib 0.0.0 → 1.0.0

package/dist/lib/cjs/object-utils.d.cts

@@ -0,0 +1,298 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Contains utility functions for Objects.
+ */
+import type { RequiredKeysOf, UndefinedOnPartialDeep } from 'type-fest' with { 'resolution-mode': 'import' };
+import type { GenericObject } from './type-guards.cjs';
+import type { ExactMembers, StringKeys } from './type.cjs';
+/**
+ * Specifies how functions should be handled in the JSON output.
+ */
+export declare enum FunctionHandlingMode {
+    /**
+     * Excludes functions from the JSON output.
+     */
+    Exclude = "exclude",
+    /**
+     * Includes the full function definition in the JSON output.
+     */
+    Full = "full",
+    /**
+     * Includes only the function name in the JSON output.
+     */
+    NameOnly = "nameOnly"
+}
+/**
+ * Options for {@link toJson}.
+ */
+export interface ToJsonOptions {
+    /**
+     * Specifies how functions should be handled in the JSON output.
+     *
+     * @default {@link FunctionHandlingMode.Exclude}
+     */
+    readonly functionHandlingMode: FunctionHandlingMode;
+    /**
+     * Specifies the maximum depth of nested objects to include in the JSON output.
+     * Use `-1` for no limit.
+     *
+     * @default `-1`
+     */
+    readonly maxDepth: number;
+    /**
+     * Specifies whether to catch errors in `toJSON()` and replace them with a placeholder.
+     *
+     * @default `false`
+     */
+    readonly shouldCatchToJSONErrors: boolean;
+    /**
+     * Specifies whether to handle circular references in the JSON output.
+     *
+     * @default `false`
+     */
+    readonly shouldHandleCircularReferences: boolean;
+    /**
+     * Specifies whether to handle errors in the JSON output.
+     *
+     * @default `false`
+     */
+    readonly shouldHandleErrors: boolean;
+    /**
+     * Specifies whether to handle `undefined` values in the JSON output.
+     *
+     * @default `false`
+     */
+    readonly shouldHandleUndefined: boolean;
+    /**
+     * Specifies whether to sort the keys of the JSON output.
+     *
+     * @default `false`
+     */
+    readonly shouldSortKeys: boolean;
+    /**
+     * Specifies the indentation of the JSON output. This can be a number of spaces or a string.
+     *
+     * @default `2`
+     */
+    readonly space: number | string;
+    /**
+     * Specifies the substitutions to use in the JSON output.
+     */
+    readonly tokenSubstitutions: Partial<TokenSubstitutions>;
+}
+interface ModuleWithDefaultExport<T> {
+    default: T;
+}
+interface TokenSubstitutions {
+    circularReference: string;
+    maxDepthLimitReached: string;
+    toJSONFailed: string;
+}
+/**
+ * Parameters for {@link setNestedPropertyValue}.
+ */
+export interface SetNestedPropertyValueParams {
+    /**
+     * The object to set the nested property value in.
+     */
+    readonly $object: GenericObject;
+    /**
+     * The path to the nested property.
+     */
+    readonly path: string;
+    /**
+     * The value to set.
+     */
+    readonly value: unknown;
+}
+type KeysWithUndefined<T> = KeysWithUndefinedMap<T>[keyof T];
+type KeysWithUndefinedMap<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : never;
+};
+type MandatoryKeysWithUndefined<T extends object> = Extract<RequiredKeysOf<T> & StringKeys<T>, KeysWithUndefined<T>>;
+type RemoveUndefinedOverload<T extends object> = MandatoryKeysWithUndefined<T> extends never ? [obj: T] : never;
+type RemoveUndefinedWithKeysOverload<T extends object, K extends readonly string[]> = [obj: T, keysToKeep: ExactMembers<MandatoryKeysWithUndefined<T>, K>];
+/**
+ * Assigns properties from one or more source objects to a target object, including non-enumerable properties.
+ *
+ * @typeParam T - The target object type.
+ * @typeParam U - The source object type.
+ * @param target - The target object to assign properties to.
+ * @param source - The source object to assign properties from.
+ * @returns The target object with the assigned properties.
+ */
+export declare function assignWithNonEnumerableProperties<T extends object, U>(target: T, source: U): T & U;
+/**
+ * Assigns properties from one or more source objects to a target object, including non-enumerable properties.
+ *
+ * @typeParam T - The target object type.
+ * @typeParam U - The first source object type.
+ * @typeParam V - The second source object type.
+ * @param target - The target object to assign properties to.
+ * @param source1 - The first source object to assign properties from.
+ * @param source2 - The second source object to assign properties from.
+ * @returns The target object with the assigned properties.
+ */
+export declare function assignWithNonEnumerableProperties<T extends object, U, V>(target: T, source1: U, source2: V): T & U & V;
+/**
+ * Assigns properties from one or more source objects to a target object, including non-enumerable properties.
+ *
+ * @typeParam T - The target object type.
+ * @typeParam U - The first source object type.
+ * @typeParam V - The second source object type.
+ * @typeParam W - The third source object type.
+ * @param target - The target object to assign properties to.
+ * @param source1 - The first source object to assign properties from.
+ * @param source2 - The second source object to assign properties from.
+ * @param source3 - The third source object to assign properties from.
+ * @returns The target object with the assigned properties.
+ */
+export declare function assignWithNonEnumerableProperties<T extends object, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+/**
+ * Casts a value to a specific type.
+ *
+ * @typeParam T - The target type to cast to.
+ * @param value - The value to cast.
+ * @returns The value as the specified type.
+ */
+export declare function castTo<T>(value: unknown): T;
+/**
+ * Clones an object, including non-enumerable properties.
+ *
+ * @typeParam T - The type of the object.
+ * @param $object - The object to clone.
+ * @returns A new object with the same properties as the original object, including non-enumerable properties.
+ */
+export declare function cloneWithNonEnumerableProperties<T extends object>($object: T): T;
+/**
+ * Deletes multiple properties from an object.
+ *
+ * @typeParam T - The type of the object.
+ * @param $object - The object to delete the properties from.
+ * @param propertyNames - The names of the properties to delete.
+ * @returns `true` if any of the properties were present, otherwise `false`.
+ */
+export declare function deleteProperties<T extends object>($object: T, propertyNames: (keyof T)[]): boolean;
+/**
+ * Deletes a property from an object.
+ *
+ * @typeParam T - The type of the object.
+ * @param $object - The object to delete the property from.
+ * @param propertyName - The name of the property to delete.
+ * @returns `true` if the property was present, otherwise `false`.
+ */
+export declare function deleteProperty<T extends object>($object: T, propertyName: keyof T): boolean;
+/**
+ * Extracts the default export from a module.
+ *
+ * Useful to handle incorrect default export interop between ESM and CJS.
+ *
+ * @typeParam T - The type of the default export.
+ * @param module - The module to extract the default export from.
+ * @returns The default export.
+ */
+export declare function extractDefaultExportInterop<T>(module: ModuleWithDefaultExport<T> | T): T;
+/**
+ * Gets all entries of an object.
+ *
+ * @typeParam T - The type of the object.
+ * @param $object - The object to get the entries of.
+ * @returns An array of all entries of the object.
+ */
+export declare function getAllEntries<T extends object>($object: T): [StringKeys<T>, T[StringKeys<T>]][];
+/**
+ * Gets all keys of an object.
+ * Includes fields and properties.
+ *
+ * @typeParam T - The type of the object.
+ * @param $object - The object to get the keys of.
+ * @returns An array of all keys of the object.
+ */
+export declare function getAllKeys<T extends object>($object: T): StringKeys<T>[];
+/**
+ * Gets the value of a nested property from an object.
+ *
+ * @param $object - The object to get the nested property value from.
+ * @param path - The path to the nested property.
+ * @returns The value of the nested property.
+ */
+export declare function getNestedPropertyValue($object: GenericObject, path: string): unknown;
+/**
+ * Gets the prototype of the specified object.
+ *
+ * @typeParam T - The type of the object.
+ * @param instance - The object instance to retrieve the prototype of.
+ * @returns The prototype of the object.
+ */
+export declare function getPrototypeOf<T>(instance: T): T;
+/**
+ * Compares two values to determine if they are deeply equal.
+ *
+ * @param a - The first value to compare.
+ * @param b - The second value to compare.
+ * @returns `true` if the values are deeply equal, otherwise `false`.
+ */
+export declare function isDeepEqual(a: unknown, b: unknown): boolean;
+/**
+ * Retrieves the name of a property of a given type `T`.
+ *
+ * @typeParam T - The type of the object containing the property.
+ * @param name - The name of the property as a string.
+ * @returns The name of the property.
+ */
+export declare function nameof<T extends object>(name: StringKeys<T>): StringKeys<T>;
+/**
+ * Normalizes optional properties to allow `undefined` assignment in strict mode.
+ *
+ * This utility provides a workaround for the `exactOptionalPropertyTypes` TypeScript flag,
+ * which prohibits directly assigning `undefined` to optional properties when the type
+ * explicitly omits `undefined`.
+ *
+ * Example:
+ * ```typescript
+ * // With `exactOptionalPropertyTypes: true`
+ * const x: { prop?: string } = { prop: undefined }; // Compiler error
+ *
+ * // Using this utility:
+ * const y: { prop?: string } = normalizeOptionalProperties<{ prop?: string }>({ prop: undefined }); // Works
+ * ```
+ *
+ * @typeParam T - The target type with optional properties to normalize.
+ * @param $object - The object to normalize, allowing explicit `undefined` for optional properties.
+ * @returns The normalized object, compatible with `exactOptionalPropertyTypes`.
+ */
+export declare function normalizeOptionalProperties<T>($object: UndefinedOnPartialDeep<T>): T;
+/**
+ * Removes all `undefined` properties from an object when there are no mandatory keys with `undefined` values.
+ *
+ * @typeParam Type - The type of the object.
+ * @param $arguments - The arguments to the function.
+ * @returns The object with all `undefined` properties removed.
+ */
+export declare function removeUndefinedProperties<Type extends object>(...$arguments: RemoveUndefinedOverload<Type>): Type;
+/**
+ * Removes all `undefined` properties from an object when there are mandatory keys with `undefined` values.
+ *
+ * @typeParam Type - The type of the object.
+ * @typeParam KeysToKeep - The keys to keep.
+ * @param $arguments - The arguments to the function.
+ * @returns The object with all `undefined` properties removed.
+ */
+export declare function removeUndefinedProperties<Type extends object, const KeysToKeep extends readonly string[]>(...$arguments: RemoveUndefinedWithKeysOverload<Type, KeysToKeep>): Type;
+/**
+ * Sets the value of a nested property in an object.
+ *
+ * @param params - The parameters for setting the nested property value.
+ */
+export declare function setNestedPropertyValue(params: SetNestedPropertyValueParams): void;
+/**
+ * Converts a given value to a JSON string.
+ *
+ * @param value - The value to be converted to JSON. This can be of any type.
+ * @param options - Options for customizing the JSON conversion process.
+ * @returns The JSON string representation of the input value.
+ */
+export declare function toJson(value: unknown, options?: Partial<ToJsonOptions>): string;
+export {};

package/dist/lib/cjs/path.cjs

@@ -0,0 +1,202 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var path_exports = {};
+__export(path_exports, {
+  basename: () => basename,
+  delimiter: () => delimiter,
+  dirname: () => dirname,
+  extname: () => extname,
+  format: () => format,
+  getFileName: () => getFileName,
+  getFolderName: () => getFolderName,
+  isAbsolute: () => isAbsolute,
+  join: () => join,
+  makeFileName: () => makeFileName,
+  normalizeIfRelative: () => normalizeIfRelative,
+  normalizePath: () => normalizePath,
+  parse: () => parse,
+  posix: () => posix,
+  relative: () => relative,
+  resolve: () => resolve,
+  separator: () => separator,
+  toPosixBuffer: () => toPosixBuffer,
+  toPosixPath: () => toPosixPath
+});
+module.exports = __toCommonJS(path_exports);
+var import_path_browserify = __toESM(__extractDefault(require('path-browserify')), 1);
+var import_string = require('./string.cjs');
+const WINDOWS_DRIVE_REG_EXP = /^[a-zA-Z]:\//;
+const WINDOWS_POSIX_LIKE_PATH_REG_EXP = /[a-zA-Z]:\/[^:]*$/;
+const posix = import_path_browserify.default.posix;
+const delimiter = posix.delimiter;
+const separator = import_path_browserify.default.posix.sep;
+const basename = posix.basename;
+const dirname = posix.dirname;
+const extname = posix.extname;
+const format = posix.format;
+function isAbsolute(path) {
+  return posix.isAbsolute(path) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path)?.[0] === path;
+}
+const join = posix.join;
+const normalizePath = posix.normalize;
+const parse = posix.parse;
+function getFileName(importMetaUrl) {
+  return resolve(decodeURI(new URL(importMetaUrl).pathname));
+}
+function getFolderName(importMetaUrl) {
+  return dirname(getFileName(importMetaUrl));
+}
+function makeFileName(params) {
+  return params.fileExtension ? `${params.fileBaseName}.${params.fileExtension}` : params.fileBaseName;
+}
+function normalizeIfRelative(path) {
+  return path.startsWith("/") || path.includes(":") ? path : (0, import_string.ensureStartsWith)({
+    $string: path,
+    prefix: "./"
+  });
+}
+function relative(from, to) {
+  const resolvedFrom = resolve(from);
+  const resolvedTo = resolve(to);
+  const fromDrive = WINDOWS_DRIVE_REG_EXP.exec(resolvedFrom)?.[0].toUpperCase();
+  const toDrive = WINDOWS_DRIVE_REG_EXP.exec(resolvedTo)?.[0].toUpperCase();
+  return fromDrive === toDrive ? posix.relative(toRootedPosixPath(upperCaseDrive(resolvedFrom)), toRootedPosixPath(upperCaseDrive(resolvedTo))) : resolvedTo;
+}
+function resolve(...pathSegments) {
+  const rootedSegments = pathSegments.map((segment) => toRootedPosixPath(segment));
+  if (rootedSegments.every((segment) => !segment.startsWith("/"))) {
+    rootedSegments.unshift(toRootedPosixPath(process.cwd()));
+  }
+  const path = posix.resolve(...rootedSegments);
+  const match = WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path);
+  return match?.[0] ?? path;
+}
+function toPosixBuffer(buffer) {
+  return Buffer.from(toPosixPath(String(buffer)));
+}
+function toPosixPath(path) {
+  return (0, import_string.replaceAll)({
+    $string: path,
+    replacer: "/",
+    searchValue: "\\"
+  });
+}
+function toRootedPosixPath(path) {
+  const posixPath = toPosixPath(path);
+  return WINDOWS_DRIVE_REG_EXP.test(posixPath) ? `/${posixPath}` : posixPath;
+}
+function upperCaseDrive(path) {
+  return path.replace(WINDOWS_DRIVE_REG_EXP, (drive) => drive.toUpperCase());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  basename,
+  delimiter,
+  dirname,
+  extname,
+  format,
+  getFileName,
+  getFolderName,
+  isAbsolute,
+  join,
+  makeFileName,
+  normalizeIfRelative,
+  normalizePath,
+  parse,
+  posix,
+  relative,
+  resolve,
+  separator,
+  toPosixBuffer,
+  toPosixPath
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/path.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for handling paths.\n */\n\nimport pathBrowserify from 'path-browserify';\n\nimport {\n  ensureStartsWith,\n  replaceAll\n} from './string.ts';\n\nconst WINDOWS_DRIVE_REG_EXP = /^[a-zA-Z]:\\//;\nconst WINDOWS_POSIX_LIKE_PATH_REG_EXP = /[a-zA-Z]:\\/[^:]*$/;\n\n/**\n * Provides methods for handling POSIX paths.\n */\nexport const posix = pathBrowserify.posix;\n\n/**\n * A POSIX path delimiter.\n */\nexport const delimiter = posix.delimiter;\n\n/**\n * A POSIX segment separator.\n */\nexport const separator = pathBrowserify.posix.sep;\n\n/**\n * Returns the base name of a file, optionally removing the file extension.\n *\n * @param path - The path to get the base name from.\n * @param ext - An optional extension to remove from the base name.\n * @returns The base name of the file.\n */\nexport const basename = posix.basename;\n\n/**\n * Returns the directory name of a path.\n *\n * `directory` is used instead of `folder` to preserve compatibility with `node:path` module.\n *\n * @param path - The path to get the directory name from.\n * @returns The directory name of the path.\n */\nexport const dirname = posix.dirname;\n\n/**\n * Returns the file extension of a path.\n *\n * @param path - The path to get the extension from.\n * @returns The file extension of the path.\n */\nexport const extname = posix.extname;\n\n/**\n * Formats a path object into a path string.\n *\n * @param pathObject - The path object to format.\n * @returns The formatted path string.\n */\nexport const format = posix.format;\n\n/**\n * Determines if a path is absolute.\n *\n * @param path - The path to check.\n * @returns `true` if the path is absolute, `false` otherwise.\n */\nexport function isAbsolute(path: string): boolean {\n  return posix.isAbsolute(path) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path)?.[0] === path;\n}\n\n/**\n * Joins multiple path segments into a single path.\n *\n * @param paths - The path segments to join.\n * @returns The joined path.\n */\nexport const join = posix.join;\n\n/**\n * Normalizes a path, resolving '..' and '.' segments.\n *\n * @param path - The path to normalize.\n * @returns The normalized path.\n */\nexport const normalizePath = posix.normalize;\n\n/**\n * Parses a path string into a path object.\n *\n * @param path - The path string to parse.\n * @returns The parsed path object.\n */\nexport const parse = posix.parse;\n\n/**\n * Parameters for {@link makeFileName}.\n */\nexport interface MakeFileNameParams {\n  /**\n   * The file name to append the extension to.\n   */\n  readonly fileBaseName: string;\n\n  /**\n   * The extension to append to the file name.\n   */\n  readonly fileExtension: string;\n}\n\n/**\n * Gets the file name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.\n *\n * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the file name.\n * @returns The POSIX-style file name.\n */\nexport function getFileName(importMetaUrl: string): string {\n  return resolve(decodeURI(new URL(importMetaUrl).pathname));\n}\n\n/**\n * Gets the folder name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.\n *\n * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the folder name.\n * @returns The POSIX-style folder name.\n */\nexport function getFolderName(importMetaUrl: string): string {\n  return dirname(getFileName(importMetaUrl));\n}\n\n/**\n * Makes a file name by appending an extension to a given file name.\n * If the extension is empty, the file name is returned as is.\n *\n * @param params - The parameters for making the file name.\n * @returns The file name with the extension appended.\n */\nexport function makeFileName(params: MakeFileNameParams): string {\n  return params.fileExtension ? `${params.fileBaseName}.${params.fileExtension}` : params.fileBaseName;\n}\n\n/**\n * Normalizes a given path by ensuring it is relative, adding \"./\" if necessary.\n *\n * @param path - The path to normalize.\n * @returns The normalized path, starting with \"./\" if it was relative.\n */\nexport function normalizeIfRelative(path: string): string {\n  return path.startsWith('/') || path.includes(':')\n    ? path\n    : ensureStartsWith({\n      $string: path,\n      prefix: './'\n    });\n}\n\n/**\n * Returns the relative path from one path to another.\n *\n * `path-browserify`'s own `relative` cannot be used directly: it resolves a relative argument against\n * `process.cwd()`, which on Windows is `F:\\...` rather than a POSIX absolute path, and its slicing then assumes a\n * leading `/` - so `relative('src', '../x')` came back as `'../..x'`. Both arguments are resolved through\n * {@link resolve} here instead, and rooted at `/` before the POSIX comparison.\n *\n * @param from - The starting path.\n * @param to - The destination path.\n * @returns The relative path from `from` to `to`.\n */\nexport function relative(from: string, to: string): string {\n  const resolvedFrom = resolve(from);\n  const resolvedTo = resolve(to);\n  const fromDrive = WINDOWS_DRIVE_REG_EXP.exec(resolvedFrom)?.[0].toUpperCase();\n  const toDrive = WINDOWS_DRIVE_REG_EXP.exec(resolvedTo)?.[0].toUpperCase();\n  return fromDrive === toDrive\n    ? posix.relative(toRootedPosixPath(upperCaseDrive(resolvedFrom)), toRootedPosixPath(upperCaseDrive(resolvedTo)))\n    : resolvedTo;\n}\n\n/**\n * Resolves a sequence of paths or path segments into an absolute path.\n *\n * @param pathSegments - The sequence of path segments to resolve.\n * @returns The resolved absolute path.\n */\nexport function resolve(...pathSegments: string[]): string {\n  /*\n   * `path-browserify` treats only a leading `/` as absolute and joins `process.cwd()` in as an opaque segment, so on\n   * Windows a `..` climbing out of the working folder cancelled the whole `F:\\...` cwd. Every segment is made POSIX\n   * and a drive root is given a leading `/`, which makes it a root `path-browserify` understands; the `/` is dropped\n   * again below.\n   */\n  const rootedSegments = pathSegments.map((segment) => toRootedPosixPath(segment));\n  if (rootedSegments.every((segment) => !segment.startsWith('/'))) {\n    rootedSegments.unshift(toRootedPosixPath(process.cwd()));\n  }\n  const path = posix.resolve(...rootedSegments);\n  const match = WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path);\n  return match?.[0] ?? path;\n}\n\n/**\n * Converts a buffer containing a path to a POSIX-style buffer by replacing backslashes with forward slashes.\n *\n * @param buffer - The buffer to convert.\n * @returns A new buffer containing the POSIX-style path.\n */\nexport function toPosixBuffer(buffer: Buffer): Buffer {\n  return Buffer.from(toPosixPath(String(buffer)));\n}\n\n/**\n * Converts a given path to a POSIX-style path by replacing backslashes with forward slashes.\n *\n * @param path - The path to convert.\n * @returns The POSIX-style path.\n */\nexport function toPosixPath(path: string): string {\n  return replaceAll({\n    $string: path,\n    replacer: '/',\n    searchValue: '\\\\'\n  });\n}\n\nfunction toRootedPosixPath(path: string): string {\n  const posixPath = toPosixPath(path);\n  return WINDOWS_DRIVE_REG_EXP.test(posixPath) ? `/${posixPath}` : posixPath;\n}\n\nfunction upperCaseDrive(path: string): string {\n  return path.replace(WINDOWS_DRIVE_REG_EXP, (drive) => drive.toUpperCase());\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,6BAA2B;AAE3B,oBAGO;AAEP,MAAM,wBAAwB;AAC9B,MAAM,kCAAkC;AAKjC,MAAM,QAAQ,uBAAAA,QAAe;AAK7B,MAAM,YAAY,MAAM;AAKxB,MAAM,YAAY,uBAAAA,QAAe,MAAM;AASvC,MAAM,WAAW,MAAM;AAUvB,MAAM,UAAU,MAAM;AAQtB,MAAM,UAAU,MAAM;AAQtB,MAAM,SAAS,MAAM;AAQrB,SAAS,WAAW,MAAuB;AAChD,SAAO,MAAM,WAAW,IAAI,KAAK,gCAAgC,KAAK,IAAI,IAAI,CAAC,MAAM;AACvF;AAQO,MAAM,OAAO,MAAM;AAQnB,MAAM,gBAAgB,MAAM;AAQ5B,MAAM,QAAQ,MAAM;AAuBpB,SAAS,YAAY,eAA+B;AACzD,SAAO,QAAQ,UAAU,IAAI,IAAI,aAAa,EAAE,QAAQ,CAAC;AAC3D;AAQO,SAAS,cAAc,eAA+B;AAC3D,SAAO,QAAQ,YAAY,aAAa,CAAC;AAC3C;AASO,SAAS,aAAa,QAAoC;AAC/D,SAAO,OAAO,gBAAgB,GAAG,OAAO,YAAY,IAAI,OAAO,aAAa,KAAK,OAAO;AAC1F;AAQO,SAAS,oBAAoB,MAAsB;AACxD,SAAO,KAAK,WAAW,GAAG,KAAK,KAAK,SAAS,GAAG,IAC5C,WACA,gCAAiB;AAAA,IACjB,SAAS;AAAA,IACT,QAAQ;AAAA,EACV,CAAC;AACL;AAcO,SAAS,SAAS,MAAc,IAAoB;AACzD,QAAM,eAAe,QAAQ,IAAI;AACjC,QAAM,aAAa,QAAQ,EAAE;AAC7B,QAAM,YAAY,sBAAsB,KAAK,YAAY,IAAI,CAAC,EAAE,YAAY;AAC5E,QAAM,UAAU,sBAAsB,KAAK,UAAU,IAAI,CAAC,EAAE,YAAY;AACxE,SAAO,cAAc,UACjB,MAAM,SAAS,kBAAkB,eAAe,YAAY,CAAC,GAAG,kBAAkB,eAAe,UAAU,CAAC,CAAC,IAC7G;AACN;AAQO,SAAS,WAAW,cAAgC;AAOzD,QAAM,iBAAiB,aAAa,IAAI,CAAC,YAAY,kBAAkB,OAAO,CAAC;AAC/E,MAAI,eAAe,MAAM,CAAC,YAAY,CAAC,QAAQ,WAAW,GAAG,CAAC,GAAG;AAC/D,mBAAe,QAAQ,kBAAkB,QAAQ,IAAI,CAAC,CAAC;AAAA,EACzD;AACA,QAAM,OAAO,MAAM,QAAQ,GAAG,cAAc;AAC5C,QAAM,QAAQ,gCAAgC,KAAK,IAAI;AACvD,SAAO,QAAQ,CAAC,KAAK;AACvB;AAQO,SAAS,cAAc,QAAwB;AACpD,SAAO,OAAO,KAAK,YAAY,OAAO,MAAM,CAAC,CAAC;AAChD;AAQO,SAAS,YAAY,MAAsB;AAChD,aAAO,0BAAW;AAAA,IAChB,SAAS;AAAA,IACT,UAAU;AAAA,IACV,aAAa;AAAA,EACf,CAAC;AACH;AAEA,SAAS,kBAAkB,MAAsB;AAC/C,QAAM,YAAY,YAAY,IAAI;AAClC,SAAO,sBAAsB,KAAK,SAAS,IAAI,IAAI,SAAS,KAAK;AACnE;AAEA,SAAS,eAAe,MAAsB;AAC5C,SAAO,KAAK,QAAQ,uBAAuB,CAAC,UAAU,MAAM,YAAY,CAAC;AAC3E;",
  "names": ["pathBrowserify"]
}


package/dist/lib/cjs/path.d.cts

@@ -0,0 +1,154 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Contains utility functions for handling paths.
+ */
+import pathBrowserify from 'path-browserify';
+/**
+ * Provides methods for handling POSIX paths.
+ */
+export declare const posix: pathBrowserify.Path;
+/**
+ * A POSIX path delimiter.
+ */
+export declare const delimiter: string;
+/**
+ * A POSIX segment separator.
+ */
+export declare const separator: string;
+/**
+ * Returns the base name of a file, optionally removing the file extension.
+ *
+ * @param path - The path to get the base name from.
+ * @param ext - An optional extension to remove from the base name.
+ * @returns The base name of the file.
+ */
+export declare const basename: (this: void, path: string, ext?: string) => string;
+/**
+ * Returns the directory name of a path.
+ *
+ * `directory` is used instead of `folder` to preserve compatibility with `node:path` module.
+ *
+ * @param path - The path to get the directory name from.
+ * @returns The directory name of the path.
+ */
+export declare const dirname: (this: void, path: string) => string;
+/**
+ * Returns the file extension of a path.
+ *
+ * @param path - The path to get the extension from.
+ * @returns The file extension of the path.
+ */
+export declare const extname: (this: void, path: string) => string;
+/**
+ * Formats a path object into a path string.
+ *
+ * @param pathObject - The path object to format.
+ * @returns The formatted path string.
+ */
+export declare const format: (this: void, pathObject: Partial<pathBrowserify.PathObject>) => string;
+/**
+ * Determines if a path is absolute.
+ *
+ * @param path - The path to check.
+ * @returns `true` if the path is absolute, `false` otherwise.
+ */
+export declare function isAbsolute(path: string): boolean;
+/**
+ * Joins multiple path segments into a single path.
+ *
+ * @param paths - The path segments to join.
+ * @returns The joined path.
+ */
+export declare const join: (this: void, ...paths: string[]) => string;
+/**
+ * Normalizes a path, resolving '..' and '.' segments.
+ *
+ * @param path - The path to normalize.
+ * @returns The normalized path.
+ */
+export declare const normalizePath: (this: void, path: string) => string;
+/**
+ * Parses a path string into a path object.
+ *
+ * @param path - The path string to parse.
+ * @returns The parsed path object.
+ */
+export declare const parse: (this: void, path: string) => pathBrowserify.PathObject;
+/**
+ * Parameters for {@link makeFileName}.
+ */
+export interface MakeFileNameParams {
+    /**
+     * The file name to append the extension to.
+     */
+    readonly fileBaseName: string;
+    /**
+     * The extension to append to the file name.
+     */
+    readonly fileExtension: string;
+}
+/**
+ * Gets the file name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.
+ *
+ * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the file name.
+ * @returns The POSIX-style file name.
+ */
+export declare function getFileName(importMetaUrl: string): string;
+/**
+ * Gets the folder name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.
+ *
+ * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the folder name.
+ * @returns The POSIX-style folder name.
+ */
+export declare function getFolderName(importMetaUrl: string): string;
+/**
+ * Makes a file name by appending an extension to a given file name.
+ * If the extension is empty, the file name is returned as is.
+ *
+ * @param params - The parameters for making the file name.
+ * @returns The file name with the extension appended.
+ */
+export declare function makeFileName(params: MakeFileNameParams): string;
+/**
+ * Normalizes a given path by ensuring it is relative, adding "./" if necessary.
+ *
+ * @param path - The path to normalize.
+ * @returns The normalized path, starting with "./" if it was relative.
+ */
+export declare function normalizeIfRelative(path: string): string;
+/**
+ * Returns the relative path from one path to another.
+ *
+ * `path-browserify`'s own `relative` cannot be used directly: it resolves a relative argument against
+ * `process.cwd()`, which on Windows is `F:\...` rather than a POSIX absolute path, and its slicing then assumes a
+ * leading `/` - so `relative('src', '../x')` came back as `'../..x'`. Both arguments are resolved through
+ * {@link resolve} here instead, and rooted at `/` before the POSIX comparison.
+ *
+ * @param from - The starting path.
+ * @param to - The destination path.
+ * @returns The relative path from `from` to `to`.
+ */
+export declare function relative(from: string, to: string): string;
+/**
+ * Resolves a sequence of paths or path segments into an absolute path.
+ *
+ * @param pathSegments - The sequence of path segments to resolve.
+ * @returns The resolved absolute path.
+ */
+export declare function resolve(...pathSegments: string[]): string;
+/**
+ * Converts a buffer containing a path to a POSIX-style buffer by replacing backslashes with forward slashes.
+ *
+ * @param buffer - The buffer to convert.
+ * @returns A new buffer containing the POSIX-style path.
+ */
+export declare function toPosixBuffer(buffer: Buffer): Buffer;
+/**
+ * Converts a given path to a POSIX-style path by replacing backslashes with forward slashes.
+ *
+ * @param path - The path to convert.
+ * @returns The POSIX-style path.
+ */
+export declare function toPosixPath(path: string): string;