@gtkx/utils 1.0.0-rc.3 → 1.0.0

package/dist/string/upper-first.js.map

@@ -1 +1 @@
-{"version":3,"file":"upper-first.js","sourceRoot":"","sources":["../../src/string/upper-first.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,SAAS,UAAU,CAAC,GAAW;IAC3B,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACtD,CAAC;AAED,OAAO,EAAE,UAAU,EAAE,CAAC","sourcesContent":["/**\n * Converts the first character of a string to upper case.\n *\n * @param str - The string to transform.\n * @returns The string with its first character upper-cased.\n *\n * @example\n * upperFirst(\"fred\"); // \"Fred\"\n * upperFirst(\"Fred\"); // \"Fred\"\n */\nfunction upperFirst(str: string): string {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nexport { upperFirst };\n"]}
+{"version":3,"file":"upper-first.js","sourceRoot":"","sources":["../../src/string/upper-first.ts"],"names":[],"mappings":"AAAA,SAAS,UAAU,CAAC,GAAW;IAC3B,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACtD,CAAC;AAED,OAAO,EAAE,UAAU,EAAE,CAAC","sourcesContent":["function upperFirst(str: string): string {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nexport { upperFirst };\n"]}

package/dist/util/index.d.ts

@@ -1,2 +1,2 @@
-export { packageVersion } from "./package-version.js";
+export { packageVersion } from "./package-version.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/util/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/util/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC","sourcesContent":["export { packageVersion } from \"./package-version.js\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/util/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC","sourcesContent":["export { packageVersion } from \"./package-version.ts\";\n"]}

package/dist/util/package-version.d.ts

@@ -1,12 +1,3 @@
-/**
- * Reads the `version` field from the `package.json` next to the calling module.
- *
- * @param importMetaUrl - The caller's `import.meta.url`, used to resolve the sibling `package.json`.
- * @returns The package's version string.
- *
- * @example
- * packageVersion(import.meta.url); // "1.2.3"
- */
-declare function packageVersion(importMetaUrl: string): string;
+declare function packageVersion(importMetaUrl: string, specifier: string): string;
 export { packageVersion };
 //# sourceMappingURL=package-version.d.ts.map

package/dist/util/package-version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-version.d.ts","sourceRoot":"","sources":["../../src/util/package-version.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,iBAAS,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"package-version.d.ts","sourceRoot":"","sources":["../../src/util/package-version.ts"],"names":[],"mappings":"AAEA,iBAAS,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/util/package-version.js

@@ -1,15 +1,6 @@
 import { createRequire } from "node:module";
-/**
- * Reads the `version` field from the `package.json` next to the calling module.
- *
- * @param importMetaUrl - The caller's `import.meta.url`, used to resolve the sibling `package.json`.
- * @returns The package's version string.
- *
- * @example
- * packageVersion(import.meta.url); // "1.2.3"
- */
-function packageVersion(importMetaUrl) {
-    return createRequire(importMetaUrl)("../package.json").version;
+function packageVersion(importMetaUrl, specifier) {
+    return createRequire(importMetaUrl)(specifier).version;
 }
 export { packageVersion };
 //# sourceMappingURL=package-version.js.map

package/dist/util/package-version.js.map

@@ -1 +1 @@
-{"version":3,"file":"package-version.js","sourceRoot":"","sources":["../../src/util/package-version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;GAQG;AACH,SAAS,cAAc,CAAC,aAAqB;IACzC,OAAQ,aAAa,CAAC,aAAa,CAAC,CAAC,iBAAiB,CAAyB,CAAC,OAAO,CAAC;AAC5F,CAAC;AAED,OAAO,EAAE,cAAc,EAAE,CAAC","sourcesContent":["import { createRequire } from \"node:module\";\n\n/**\n * Reads the `version` field from the `package.json` next to the calling module.\n *\n * @param importMetaUrl - The caller's `import.meta.url`, used to resolve the sibling `package.json`.\n * @returns The package's version string.\n *\n * @example\n * packageVersion(import.meta.url); // \"1.2.3\"\n */\nfunction packageVersion(importMetaUrl: string): string {\n    return (createRequire(importMetaUrl)(\"../package.json\") as { version: string }).version;\n}\n\nexport { packageVersion };\n"]}
+{"version":3,"file":"package-version.js","sourceRoot":"","sources":["../../src/util/package-version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,SAAS,cAAc,CAAC,aAAqB,EAAE,SAAiB;IAC5D,OAAQ,aAAa,CAAC,aAAa,CAAC,CAAC,SAAS,CAAyB,CAAC,OAAO,CAAC;AACpF,CAAC;AAED,OAAO,EAAE,cAAc,EAAE,CAAC","sourcesContent":["import { createRequire } from \"node:module\";\n\nfunction packageVersion(importMetaUrl: string, specifier: string): string {\n    return (createRequire(importMetaUrl)(specifier) as { version: string }).version;\n}\n\nexport { packageVersion };\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/utils",
-  "version": "1.0.0-rc.3",
+  "version": "1.0.0",
   "description": "Cross-package utilities shared by the GTKX packages and toolchain: logging, error formatting, string and class helpers",
   "keywords": [
     "gtkx",

package/src/array/index-before-or-end.ts

@@ -1,15 +1,3 @@
-/**
- * Finds the index of the first item matching `before`, or `list.length` when `before` is `null` or
- * nothing matches. Use it to resolve where a new item should be inserted so it lands before the
- * referenced one, defaulting to the end.
- *
- * @template T - The list item type.
- * @template B - The reference value type.
- * @param list - The list to search.
- * @param before - The item to insert before, or `null` to target the end.
- * @param isMatch - Called with each item and the non-null `before`; return `true` on a match.
- * @returns The matched index, or `list.length`.
- */
 const indexBeforeOrEnd = <T, B>(
     list: T[],
     before: B | null,

package/src/array/index.ts

@@ -1,5 +1,5 @@
-export { indexBeforeOrEnd } from "./index-before-or-end.js";
-export { remove } from "./remove.js";
-export { sortStringsBy } from "./sort-strings-by.js";
-export { sortStrings } from "./sort-strings.js";
-export { uniqBy } from "./uniq-by.js";
+export { indexBeforeOrEnd } from "./index-before-or-end.ts";
+export { remove } from "./remove.ts";
+export { sortStringsBy } from "./sort-strings-by.ts";
+export { sortStrings } from "./sort-strings.ts";
+export { uniqBy } from "./uniq-by.ts";

package/src/array/remove.ts

@@ -1,14 +1,3 @@
-/**
- * Removes the first strictly-equal (`===`) occurrence of `value` from `arr` in place.
- *
- * @template T - The type of the array elements.
- * @param arr - The array to mutate.
- * @param value - The value to remove.
- *
- * @example
- * const items = ["a", "b", "c"];
- * remove(items, "b"); // items is now ["a", "c"]
- */
 function remove<T>(arr: T[], value: T): void {
     const index = arr.indexOf(value);
 

package/src/array/sort-strings-by.ts

@@ -1,15 +1,3 @@
-/**
- * Returns the items sorted by a string key using locale-aware comparison.
- *
- * @template T - The type of items being sorted.
- * @param items - The items to sort.
- * @param key - Maps an item to the string its order is decided by.
- * @returns A new array of the items in ascending locale order of their keys.
- *
- * @example
- * sortStringsBy([{ name: "b" }, { name: "a" }], (item) => item.name);
- * // [{ name: "a" }, { name: "b" }]
- */
 function sortStringsBy<T>(items: Iterable<T>, key: (item: T) => string): T[] {
     return [...items].toSorted((a, b) => key(a).localeCompare(key(b)));
 }

package/src/array/sort-strings.ts

@@ -1,12 +1,3 @@
-/**
- * Returns the values sorted as strings using locale-aware comparison.
- *
- * @param values - The strings to sort.
- * @returns A new array of the values in ascending locale order.
- *
- * @example
- * sortStrings(["b", "a", "c"]); // ["a", "b", "c"]
- */
 function sortStrings(values: Iterable<string>): string[] {
     return [...values].toSorted((a, b) => a.localeCompare(b));
 }

package/src/array/uniq-by.ts

@@ -1,18 +1,3 @@
-/**
- * Returns a new array of the unique elements of `arr`, keyed by the value the `mapper` returns.
- *
- * When two elements map to the same key the first occurrence is kept and later ones discarded,
- * preserving first-seen order.
- *
- * @template T - The type of elements in the array.
- * @param arr - The array to deduplicate.
- * @param mapper - Maps an element to the key its uniqueness is decided by.
- * @returns A new array containing only the first element seen for each distinct key.
- *
- * @example
- * uniqBy([2.1, 1.2, 2.3], Math.floor); // [2.1, 1.2]
- * uniqBy([{ id: "a" }, { id: "a" }, { id: "b" }], (item) => item.id); // [{ id: "a" }, { id: "b" }]
- */
 function uniqBy<T>(arr: T[], mapper: (item: T, index: number, array: T[]) => unknown): T[] {
     const seen: Map<unknown, T> = new Map();
     let index = 0;

package/src/class/any-class.ts

@@ -1,9 +1,8 @@
-/**
- * A constructor value of any (possibly abstract) class producing instances of `T`.
- */
+/** Any class constructor, abstract ones included, whose instances are `T`. */
 type AnyClass<T extends object = object> = (abstract new (
     ...args: never[]
 ) => T) & {
+    /** Object the class's instances inherit from. */
     prototype: T;
 };
 

package/src/class/get-parent-class.ts

@@ -1,11 +1,5 @@
-import type { AnyClass } from "./any-class.js";
+import type { AnyClass } from "./any-class.ts";
 
-/**
- * Returns the direct superclass of `cls`, or `null` when it has no class ancestor.
- *
- * @param cls - The class whose prototype parent to inspect.
- * @returns The parent class, or `null` when there is none.
- */
 function getParentClass(cls: AnyClass): AnyClass | null {
     const parent: unknown = Object.getPrototypeOf(cls);
 

package/src/class/index.ts

@@ -1,3 +1,3 @@
-export type { AnyClass } from "./any-class.js";
-export { getParentClass } from "./get-parent-class.js";
-export { walkClassChain } from "./walk-class-chain.js";
+export type { AnyClass } from "./any-class.ts";
+export { getParentClass } from "./get-parent-class.ts";
+export { walkClassChain } from "./walk-class-chain.ts";

package/src/class/walk-class-chain.ts

@@ -1,15 +1,6 @@
-import type { AnyClass } from "./any-class.js";
-import { getParentClass } from "./get-parent-class.js";
+import type { AnyClass } from "./any-class.ts";
+import { getParentClass } from "./get-parent-class.ts";
 
-/**
- * Walks the class chain from `cls` up through its ancestors, calling `visit` on each and returning
- * the first result that is not `undefined`.
- *
- * @template T - The type produced by the visitor.
- * @param cls - The class to start from, or `null` to visit nothing.
- * @param visit - Called with each class in the chain; a defined return value stops the walk.
- * @returns The first defined result from `visit`, or `undefined` when none was produced.
- */
 function walkClassChain<T>(cls: AnyClass | null, visit: (ancestor: AnyClass) => T | undefined): T | undefined {
     let current = cls;
 

package/src/error/error-like.ts

@@ -1,4 +1,4 @@
-import { isRecord } from "../predicate/is-record.js";
+import { isRecord } from "../predicate/is-record.ts";
 
 function isErrorLike(value: unknown): value is { message: string } {
     return isRecord(value) && "message" in value && typeof value.message === "string";

package/src/error/error-message.ts

@@ -1,15 +1,5 @@
-import { isErrorLike } from "./error-like.js";
+import { isErrorLike } from "./error-like.ts";
 
-/**
- * Extracts a human-readable message from an unknown thrown value, falling back to its string form.
- *
- * @param error - The caught value to describe.
- * @returns The value's message when it has one, otherwise its string form.
- *
- * @example
- * errorMessage(new Error("boom")); // "boom"
- * errorMessage(42); // "42"
- */
 function errorMessage(error: unknown): string {
     return Error.isError(error) || isErrorLike(error) ? error.message : String(error);
 }

package/src/error/format-child-process-error.ts

@@ -1,15 +1,6 @@
-import { isRecord } from "../predicate/is-record.js";
-import { readStream } from "./error-like.js";
+import { isRecord } from "../predicate/is-record.ts";
+import { readStream } from "./error-like.ts";
 
-/**
- * Combines the `stderr` and `stdout` of a failed child-process error into a single trimmed string.
- *
- * @param error - The child-process error to read output from.
- * @returns The joined output, or `undefined` when neither stream carried any text.
- *
- * @example
- * formatChildProcessError({ stderr: "boom" }); // "boom"
- */
 function formatChildProcessError(error: unknown): string | undefined {
     if (!isRecord(error)) {
         return undefined;

package/src/error/index.ts

@@ -1,3 +1,3 @@
-export { errorMessage } from "./error-message.js";
-export { formatChildProcessError } from "./format-child-process-error.js";
-export { normalizeError } from "./normalize-error.js";
+export { errorMessage } from "./error-message.ts";
+export { formatChildProcessError } from "./format-child-process-error.ts";
+export { normalizeError } from "./normalize-error.ts";

package/src/error/normalize-error.ts

@@ -1,16 +1,6 @@
-import { isErrorLike } from "./error-like.js";
-import { errorMessage } from "./error-message.js";
+import { isErrorLike } from "./error-like.ts";
+import { errorMessage } from "./error-message.ts";
 
-/**
- * Coerces an unknown thrown value into an `Error`, reusing it when it already is one and otherwise
- * wrapping its message while copying any error-like own properties.
- *
- * @param error - The caught value to normalize.
- * @returns The value itself when it is an `Error`, otherwise a new `Error` carrying its message.
- *
- * @example
- * normalizeError("boom"); // Error: boom
- */
 function normalizeError(error: unknown): Error {
     if (Error.isError(error)) {
         return error;

package/src/index.ts

@@ -1,13 +1,12 @@
-export * from "./array/index.js";
-export * from "./class/index.js";
-export * from "./error/index.js";
-export * from "./function/index.js";
-export * from "./log/index.js";
-export * from "./map/index.js";
-export * from "./object/index.js";
-export * from "./predicate/index.js";
-export * from "./process/index.js";
-export * from "./set/index.js";
-export * from "./source/index.js";
-export * from "./string/index.js";
-export * from "./util/index.js";
+export * from "./array/index.ts";
+export * from "./class/index.ts";
+export * from "./error/index.ts";
+export * from "./log/index.ts";
+export * from "./map/index.ts";
+export * from "./object/index.ts";
+export * from "./predicate/index.ts";
+export * from "./process/index.ts";
+export * from "./set/index.ts";
+export * from "./source/index.ts";
+export * from "./string/index.ts";
+export * from "./util/index.ts";

package/src/log/create-logger.ts

@@ -1,16 +1,5 @@
-import { Logger, type LoggerOptions } from "./logger.js";
+import { Logger, type LoggerOptions } from "./logger.ts";
 
-/**
- * Creates a {@link Logger} scoped to the given namespace.
- *
- * @param namespace - Namespace added to the log prefix and matched against debug configuration.
- * @param options - Further logger options, excluding the namespace.
- * @returns A new namespaced logger.
- *
- * @example
- * const log = createLogger("react");
- * log.info("mounted");
- */
 function createLogger(namespace: string, options: Omit<LoggerOptions, "namespace"> = {}): Logger {
     return new Logger({ ...options, namespace });
 }

package/src/log/default-logger.ts

@@ -1,49 +1,23 @@
-import { Logger } from "./logger.js";
+import { Logger } from "./logger.ts";
 
-/**
- * The default namespace-less {@link Logger} backing the module-level {@link info}, {@link warn},
- * {@link error}, and {@link debug} functions.
- */
 const logger: Logger = new Logger();
 
-/**
- * Writes an informational line through the shared {@link logger}.
- *
- * @param message - The message text.
- * @param rest - Extra values appended after the message, formatted for display.
- */
 function info(message: string, ...rest: unknown[]): void {
     logger.info(message, ...rest);
 }
 
-/**
- * Writes a warning line through the shared {@link logger}.
- *
- * @param message - The message text.
- * @param rest - Extra values appended after the message, formatted for display.
- */
 function warn(message: string, ...rest: unknown[]): void {
     logger.warn(message, ...rest);
 }
 
-/**
- * Writes an error line through the shared {@link logger}.
- *
- * @param message - The message text.
- * @param rest - Extra values appended after the message, formatted for display.
- */
 function error(message: string, ...rest: unknown[]): void {
     logger.error(message, ...rest);
 }
 
-/**
- * Writes a debug line through the shared {@link logger} when debug output is enabled.
- *
- * @param message - The message text.
- * @param rest - Extra values appended after the message, formatted for display.
- */
 function debug(message: string, ...rest: unknown[]): void {
     logger.debug(message, ...rest);
 }
 
-export { logger, info, warn, error, debug };
+export { logger, info, warn, error };
+/** @internal */
+export { debug };

package/src/log/index.ts

@@ -1,3 +1,5 @@
-export { createLogger } from "./create-logger.js";
-export { debug, error, info, logger, warn } from "./default-logger.js";
-export { Logger, type LoggerOptions, type OutputStream } from "./logger.js";
+export { createLogger } from "./create-logger.ts";
+export { error, info, logger, warn } from "./default-logger.ts";
+/** @internal */
+export { debug } from "./default-logger.ts";
+export { Logger, type OutputStream } from "./logger.ts";

package/src/log/logger.ts

@@ -2,25 +2,15 @@ import pc from "picocolors";
 
 type Colors = ReturnType<typeof pc.createColors>;
 
-/**
- * Minimal writable-stream shape a {@link Logger} writes formatted lines to.
- */
 type OutputStream = {
     write(chunk: string): unknown;
-    /** Whether the stream is a terminal, used to decide if colored output is emitted. */
     isTTY?: boolean | undefined;
 };
 
-/**
- * Options for constructing a {@link Logger}.
- */
 type LoggerOptions = {
-    /** Namespace appended to the log prefix and matched against debug configuration. */
     namespace?: string | undefined;
-    /** Stream to write log lines to; defaults to `process.stderr`. */
     stream?: OutputStream | undefined;
-    /** Forces debug output on or off; when omitted it is resolved from `--debug` and `GTKX_DEBUG`. */
-    debugEnabled?: boolean | undefined;
+    isDebugEnabled?: boolean | undefined;
 };
 
 const BASE_PREFIX = "[gtkx]";
@@ -69,23 +59,16 @@ function getPrefix(namespace: string | undefined): string {
     return namespace === undefined ? BASE_PREFIX : `[gtkx:${namespace}]`;
 }
 
-/**
- * Writes prefixed, optionally colored log lines to an output stream, with debug lines gated by
- * command-line and environment configuration.
- */
 class Logger {
     private stream: OutputStream;
     private prefix: string;
-    private debugEnabled: boolean;
+    private isDebugEnabled: boolean;
     private colors: Colors;
 
-    /**
-     * @param options - Namespace, target stream, and debug configuration for the logger.
-     */
     constructor(options: LoggerOptions = {}) {
         this.stream = options.stream ?? process.stderr;
         this.prefix = getPrefix(options.namespace);
-        this.debugEnabled = options.debugEnabled ?? isDebugEnabled(options.namespace, process.argv, process.env);
+        this.isDebugEnabled = options.isDebugEnabled ?? isDebugEnabled(options.namespace, process.argv, process.env);
         this.colors = getColors(this.stream);
     }
 
@@ -94,44 +77,20 @@ class Logger {
         this.stream.write(`${this.prefix} ${message}${suffix}\n`);
     }
 
-    /**
-     * Writes an informational line.
-     *
-     * @param message - The message text.
-     * @param rest - Extra values appended after the message, formatted for display.
-     */
     info(message: string, ...rest: unknown[]): void {
         this.write(message, rest);
     }
 
-    /**
-     * Writes a line marked as a warning.
-     *
-     * @param message - The message text.
-     * @param rest - Extra values appended after the message, formatted for display.
-     */
     warn(message: string, ...rest: unknown[]): void {
         this.write(`${this.colors.yellow("warn")} ${message}`, rest);
     }
 
-    /**
-     * Writes a line marked as an error.
-     *
-     * @param message - The message text.
-     * @param rest - Extra values appended after the message, formatted for display.
-     */
     error(message: string, ...rest: unknown[]): void {
         this.write(`${this.colors.red("error")} ${message}`, rest);
     }
 
-    /**
-     * Writes a line only when debug output is enabled for this logger.
-     *
-     * @param message - The message text.
-     * @param rest - Extra values appended after the message, formatted for display.
-     */
     debug(message: string, ...rest: unknown[]): void {
-        if (!this.debugEnabled) {
+        if (!this.isDebugEnabled) {
             return;
         }
 

package/src/map/get-or-insert.ts

@@ -4,21 +4,6 @@ type GetSet<K, V> = {
     has(key: K): boolean;
 };
 
-/**
- * Returns the value stored under `key`, or inserts and returns the value produced by `factory` when
- * the key is absent. Works with both `Map` and `WeakMap`, and caches a computed `undefined` value.
- *
- * @template K - The key type.
- * @template V - The value type.
- * @param map - The `Map` or `WeakMap` to read from and populate.
- * @param key - The key to look up.
- * @param factory - Produces the value to insert when `key` is absent; called at most once.
- * @returns The existing or newly-inserted value.
- *
- * @example
- * const counts = new Map<string, number[]>();
- * getOrInsert(counts, "a", () => []).push(1); // counts is Map { "a" => [1] }
- */
 function getOrInsert<K, V>(map: GetSet<K, V>, key: K, factory: (key: K) => V): V {
     if (map.has(key)) {
         return map.get(key) as V;
@@ -30,4 +15,4 @@ function getOrInsert<K, V>(map: GetSet<K, V>, key: K, factory: (key: K) => V): V
     return value;
 }
 
-export { getOrInsert, type GetSet };
+export { getOrInsert };

package/src/map/index.ts

@@ -1 +1 @@
-export { getOrInsert } from "./get-or-insert.js";
+export { getOrInsert } from "./get-or-insert.ts";

package/src/object/index.ts

@@ -1,3 +1,3 @@
-export { omit } from "./omit.js";
-export { pickBy } from "./pick-by.js";
-export { structuredClone } from "./structured-clone.js";
+export { omit } from "./omit.ts";
+export { pickBy } from "./pick-by.ts";
+export { structuredClone } from "./structured-clone.ts";

package/src/object/omit.ts

@@ -1,15 +1,3 @@
-/**
- * Creates a new object holding every entry of `obj` except the named keys.
- *
- * @template T - The type of the source object.
- * @template K - The keys to leave out.
- * @param obj - The object to copy entries from.
- * @param keys - The keys to leave out of the result.
- * @returns A new object without the named keys.
- *
- * @example
- * omit({ a: 1, b: 2 }, ["a"]); // { b: 2 }
- */
 function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {
     const excluded: Set<PropertyKey> = new Set(keys);
     const result: Record<string, unknown> = {};

package/src/object/pick-by.ts

@@ -1,15 +1,3 @@
-/**
- * Creates a new object of the entries of `obj` that satisfy the predicate.
- *
- * @template T - The type of the source object.
- * @param obj - The object to pick entries from.
- * @param shouldPick - Called with each value and key; return `true` to keep the entry.
- * @returns A new object holding only the entries the predicate kept.
- *
- * @example
- * pickBy({ a: 1, b: 2 }, (value) => value > 1); // { b: 2 }
- * pickBy({ a: 1, b: 2 }, (_value, key) => key !== "a"); // { b: 2 }
- */
 function pickBy<T extends Record<string, unknown>>(
     obj: T,
     shouldPick: (value: T[keyof T], key: keyof T) => boolean,

package/src/object/structured-clone.ts

@@ -1,21 +1,5 @@
-import { isPlainObject } from "../predicate/is-plain-object.js";
+import { isPlainObject } from "../predicate/is-plain-object.ts";
 
-/**
- * Recursively copies arrays and plain objects, sharing every other value by reference. The result
- * mirrors exactly the structure `isDeepEqual` traverses, so comparing a value against its earlier
- * clone detects in-place mutations of the original. Unlike the global of the same name, class
- * instances such as `Date` and `Map` are shared rather than copied, and no value is ever rejected.
- *
- * @template T - The type of the value.
- * @param value - The value to clone.
- * @returns A clone whose arrays and plain objects are fresh and whose other values are shared.
- *
- * @example
- * const source = { a: [{ b: 1 }] };
- * const copy = structuredClone(source);
- * source.a[0].b = 2;
- * copy.a[0].b; // 1
- */
 function structuredClone<T>(value: T): T {
     if (Array.isArray(value)) {
         return value.map((item: unknown) => structuredClone(item)) as T;

package/src/predicate/index.ts

@@ -1,6 +1,6 @@
-export { isDeepEqual } from "./is-deep-equal.js";
-export { isPlainObject } from "./is-plain-object.js";
-export { isRecord } from "./is-record.js";
-export { isSameArrayBy } from "./is-same-array-by.js";
-export { isSameArray } from "./is-same-array.js";
-export { isShallowEqual } from "./is-shallow-equal.js";
+export { isDeepEqual } from "./is-deep-equal.ts";
+export { isPlainObject } from "./is-plain-object.ts";
+export { isRecord } from "./is-record.ts";
+export { isSameArrayBy } from "./is-same-array-by.ts";
+export { isSameArray } from "./is-same-array.ts";
+export { isShallowEqual } from "./is-shallow-equal.ts";

package/src/predicate/is-deep-equal.ts

@@ -1,19 +1,6 @@
-import { areObjectKeysEqual } from "./are-object-keys-equal.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { areObjectKeysEqual } from "./are-object-keys-equal.ts";
+import { isPlainObject } from "./is-plain-object.ts";
 
-/**
- * Checks whether two values are deeply equal: identical, arrays of the same length whose elements
- * are deeply equal in order, or plain objects with the same own enumerable keys and deeply equal
- * values. Values that are neither both arrays nor both plain objects are equal only when identical.
- *
- * @param a - The first value.
- * @param b - The second value.
- * @returns `true` when the values are deeply equal.
- *
- * @example
- * isDeepEqual({ a: [1, { b: 2 }] }, { a: [1, { b: 2 }] }); // true
- * isDeepEqual({ a: [1] }, { a: [2] }); // false
- */
 const isDeepArrayEqual = (a: unknown, b: unknown): boolean => {
     if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
         return false;