@oscarpalmer/atoms 0.186.2 → 0.187.0

package/dist/value/clone.mjs

@@ -2,8 +2,8 @@ import { isArrayOrPlainObject, isTypedArray } from "../internal/is.mjs";
 import { getSelfHandlers } from "../internal/value/handlers.mjs";
 //#region src/value/clone.ts
 const CLONE_NAME = "clone";
-function clone(value) {
-	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap());
+function clone(value, flat) {
+	return flat === true ? copy(value) : cloneValue(value, 0, /* @__PURE__ */ new WeakMap(), false);
 }
 clone.handlers = getSelfHandlers(clone, {
 	callback: tryStructuredClone,
@@ -25,11 +25,11 @@ function cloneDataView(value, depth, references) {
 	references.set(value, cloned);
 	return cloned;
 }
-function cloneMap(map, depth, references) {
+function cloneMap(map, depth, references, flat) {
 	if (depth >= MAX_CLONE_DEPTH) return map;
 	const cloned = /* @__PURE__ */ new Map();
 	const entries = map.entries();
-	for (const entry of entries) cloned.set(cloneValue(entry[0], depth + 1, references), cloneValue(entry[1], depth + 1, references));
+	for (const entry of entries) cloned.set(flat ? entry[0] : cloneValue(entry[0], depth + 1, references, false), flat ? entry[1] : cloneValue(entry[1], depth + 1, references, false));
 	references.set(map, cloned);
 	return cloned;
 }
@@ -39,14 +39,14 @@ function cloneNode(node, depth, references) {
 	references.set(node, cloned);
 	return cloned;
 }
-function clonePlainObject(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
+function cloneObject(value, depth, references, flat) {
+	if (flat || depth >= MAX_CLONE_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
 	const cloned = Array.isArray(value) ? [] : {};
 	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
 	const { length } = keys;
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
-		cloned[key] = cloneValue(value[key], depth + 1, references);
+		cloned[key] = cloneValue(value[key], depth + 1, references, false);
 	}
 	references.set(value, cloned);
 	return cloned;
@@ -58,12 +58,12 @@ function cloneRegularExpression(value, depth, references) {
 	references.set(value, cloned);
 	return cloned;
 }
-function cloneSet(set, depth, references) {
+function cloneSet(set, depth, references, flat) {
 	if (depth >= MAX_CLONE_DEPTH) return set;
 	const cloned = /* @__PURE__ */ new Set();
 	const values = [...set.values()];
 	const { length } = values;
-	for (let index = 0; index < length; index += 1) cloned.add(cloneValue(values[index], depth + 1, references));
+	for (let index = 0; index < length; index += 1) cloned.add(flat ? values[index] : cloneValue(values[index], depth + 1, references, false));
 	references.set(set, cloned);
 	return cloned;
 }
@@ -73,32 +73,45 @@ function cloneTypedArray(value, depth, references) {
 	references.set(value, cloned);
 	return cloned;
 }
-function cloneValue(value, depth, references) {
+function cloneValue(value, depth, references, flat) {
 	switch (true) {
-		case value == null: return value;
-		case typeof value === "bigint": return BigInt(value);
-		case typeof value === "boolean": return Boolean(value);
+		case value == null:
+		case typeof value === "bigint":
+		case typeof value === "boolean":
+		case typeof value === "number":
+		case typeof value === "string": return value;
 		case typeof value === "function": return;
-		case typeof value === "number": return Number(value);
-		case typeof value === "string": return String(value);
 		case typeof value === "symbol": return Symbol(value.description);
 		case references.has(value): return references.get(value);
 		case value instanceof ArrayBuffer: return cloneArrayBuffer(value, depth, references);
 		case value instanceof DataView: return cloneDataView(value, depth, references);
 		case value instanceof Date: return new Date(value.getTime());
 		case value instanceof RegExp: return cloneRegularExpression(value, depth, references);
-		case value instanceof Map: return cloneMap(value, depth, references);
+		case value instanceof Map: return cloneMap(value, depth, references, flat);
 		case typeof Node !== "undefined" && value instanceof Node: return cloneNode(value, depth, references);
-		case value instanceof Set: return cloneSet(value, depth, references);
-		case isArrayOrPlainObject(value): return clonePlainObject(value, depth, references);
+		case value instanceof Set: return cloneSet(value, depth, references, flat);
+		case isArrayOrPlainObject(value): return cloneObject(value, depth, references, flat);
 		case isTypedArray(value): return cloneTypedArray(value, depth, references);
 		default: return clone.handlers.handle(value, depth, references);
 	}
 }
 /**
+* Copy any kind of value
+*
+* - Clones the value shallowly, without cloning nested values
+* - To copy a value deeply, use `clone` instead
+*
+* @param value Value to copy
+* @returns Copied value
+*/
+function copy(value) {
+	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap(), true);
+}
+/**
 * Deregister a clone handler for a specific class
 *
-* Available as `deregisterCloner` and `template.deregister`
+* _Available as `deregisterCloner` and `template.deregister`_
+*
 * @param constructor Class constructor
 */
 function deregisterCloner(constructor) {
@@ -107,9 +120,10 @@ function deregisterCloner(constructor) {
 /**
 * Register a clone handler for a specific class
 *
-* Available as `registerCloner` and `template.register`
+* _Available as `registerCloner` and `template.register`_
+*
 * @param constructor Class constructor
-* @param handler Method name or clone function _(defaults to `clone`)_
+* @param handler Method name or clone function _(defaults to method name `clone`)_
 */
 function registerCloner(constructor, handler) {
 	clone.handlers.register(constructor, handler);
@@ -127,4 +141,4 @@ function tryStructuredClone(value, depth, references) {
 }
 const MAX_CLONE_DEPTH = 100;
 //#endregion
-export { clone, deregisterCloner, registerCloner };
+export { clone, copy, deregisterCloner, registerCloner };

package/dist/value/collection.d.mts

@@ -1,22 +1,25 @@
 //#region src/value/collection.d.ts
 /**
- * Does the value exist for a key in a map?
- * @param map Map to check in
+ * Does the value exist for a key in a _Map_?
+ *
+ * @param map _Map_ to check in
  * @param value Value to check for
  * @returns `true` if the value exists, otherwise `false`
  */
 declare function inMap<Value>(map: Map<unknown, Value>, value: Value): boolean;
 /**
- * Does the value exist for a key in a map?
- * @param map Map to check in
+ * Does the value exist for a key in a _Map_?
+ *
+ * @param map _Map_ to check in
  * @param value Value to check for
  * @param key To return the key for the value
  * @returns The key for the value if it exists, otherwise `undefined`
  */
 declare function inMap<Key, Value>(map: Map<Key, Value>, value: Value, key: true): Key;
 /**
- * Does the value exist in a set?
- * @param set Set to check in
+ * Does the value exist in a _Set_?
+ *
+ * @param set _Set_ to check in
  * @param value Value to check for
  * @returns `true` if the value exists, otherwise `false`
  */

package/dist/value/collection.mjs

@@ -7,8 +7,9 @@ function inMap(map, value, key) {
 	for (const [key, item] of map) if (equal(item, value)) return key;
 }
 /**
-* Does the value exist in a set?
-* @param set Set to check in
+* Does the value exist in a _Set_?
+*
+* @param set _Set_ to check in
 * @param value Value to check for
 * @returns `true` if the value exists, otherwise `false`
 */

package/dist/value/diff.d.mts

@@ -21,7 +21,8 @@ type DiffResult<First, Second = First> = {
    */
   type: DiffType;
   /**
-   * - The differences between the two values
+   * The differences between the two values
+   *
    * - Keys are in dot notation
    * - Values are objects with `from` and `to` properties
    */
@@ -43,6 +44,7 @@ type DiffValue<First = unknown, Second = First> = {
 };
 /**
  * Find the differences between two values
+ *
  * @param first First value
  * @param second Second value
  * @param options Comparison options

package/dist/value/diff.mjs

@@ -4,6 +4,7 @@ import { equal } from "../internal/value/equal.mjs";
 //#region src/value/diff.ts
 /**
 * Find the differences between two values
+*
 * @param first First value
 * @param second Second value
 * @param options Comparison options

package/dist/value/freeze.d.mts

@@ -1,35 +1,144 @@
-import { ArrayOrPlainObject, GenericCallback, PlainObject } from "../models.mjs";
+import { PlainObject } from "../models.mjs";
 
 //#region src/value/freeze.d.ts
 /**
  * A frozen value with readonly properties _(going as deep as possible)_
  */
-type Frozen<Value extends ArrayOrPlainObject> = { readonly [Key in keyof Value]: Value[Key] extends ArrayOrPlainObject ? Frozen<Value[Key]> : Value[Key] };
+type Frozen<Value> = Value extends unknown[] ? Readonly<Value> : Value extends PlainObject ? { readonly [Key in keyof Value]: Frozen<Value[Key]> } : Value extends Map<infer Key, infer Value> ? ReadonlyMap<Key, Frozen<Value>> : Value extends Set<infer Item> ? ReadonlySet<Frozen<Item>> : Readonly<Value>;
 /**
- * Freeze an array and all its indices recursively
+ * Freeze an array and its indiced values, but not any nested values
+ *
+ * _Available as `flatFreeze` and `freeze.flat`_
+ *
+ * @param array Array to freeze
+ * @returns Frozen array
+ */
+declare function flatFreeze<Item>(array: Item[]): ReadonlyArray<Item>;
+/**
+ * Freeze a map and its values, but not any nested values
+ *
+ * _Available as `flatFreeze` and `freeze.flat`_
+ *
+ * @param map Map to freeze
+ * @returns Frozen map
+ */
+declare function flatFreeze<Key, Value>(map: Map<Key, Value>): ReadonlyMap<Key, Value>;
+/**
+ * Freeze an object and its properties, but not any nested values
+ *
+ * _Available as `flatFreeze` and `freeze.flat`_
+ *
+ * @param object Object to freeze
+ * @returns Frozen object
+ */
+declare function flatFreeze<Value extends PlainObject>(object: Value): Readonly<Value>;
+/**
+ * Freeze a set and its values, but not any nested values
+ *
+ * _Available as `flatFreeze` and `freeze.flat`_
+ *
+ * @param set Set to freeze
+ * @returns Frozen set
+ */
+declare function flatFreeze<Item>(set: Set<Item>): ReadonlySet<Item>;
+/**
+ * Freeze any value, if possible
+ *
+ * _(Only arrays, maps, plain objects, and sets are freezable)_
+ *
+ * _Available as `flatFreeze` and `freeze.flat`_
+ *
+ * @param value Value to freeze
+ * @returns Frozen value
+ */
+declare function flatFreeze<Value>(value: Value): Value;
+/**
+ * Freeze an array and its values _(but not any nested values)_, preventing modifications
+ *
+ * @param array Array to freeze
+ * @param flat Freeze _only_ the array, not any nested values
+ * @returns Frozen array
+ */
+declare function freeze<Item>(array: Item[], flat: true): ReadonlyArray<Item>;
+/**
+ * Freeze a map and its values _(but not any nested values)_, preventing modifications
+ *
+ * @param map Map to freeze
+ * @param flat Freeze _only_ the map, not any nested values
+ * @returns Frozen map
+ */
+declare function freeze<Key, Value>(map: Map<Key, Value>, flat: true): ReadonlyMap<Key, Value>;
+/**
+ * Freeze an object and its properties _(but not any nested values)_, preventing modifications
+ *
+ * @param object Object to freeze
+ * @param flat Freeze _only_ the object, not any nested values
+ * @returns Frozen object
+ */
+declare function freeze<Value extends PlainObject>(object: Value, flat: true): Readonly<Value>;
+/**
+ * Freeze a set and its values _(but not any nested values)_, preventing modifications
+ *
+ * @param set Set to freeze
+ * @param flat Freeze _only_ the set, not any nested values
+ * @returns Frozen set
+ */
+declare function freeze<Item>(set: Set<Item>, flat: true): ReadonlySet<Item>;
+/**
+ * Freeze an array and its values recursively, preventing modifications
+ *
+ * _(If you only want to freeze the array itself, but not any nested values, use `freeze(array, true)`, `freeze.flat(array)`, or `flatFreeze(array)` instead)_
+ *
  * @param array Array to freeze
  * @returns Frozen array
  */
 declare function freeze<Item>(array: Item[]): Frozen<Item[]>;
 /**
- * Freeze a function
- * @param fn Function to freeze
- * @returns Frozen function
+ * Freeze a map and its values recursively, preventing modifications
+ *
+ * _(If you only want to freeze the map itself, but not any nested values, use `freeze(map, true)`, `freeze.flat(map)`, or `flatFreeze(map)` instead)_
+ *
+ * @param map Map to freeze
+ * @returns Frozen map
  */
-declare function freeze<Fn extends GenericCallback>(fn: Fn): Readonly<Fn>;
+declare function freeze<Key, Value>(map: Map<Key, Value>): Frozen<Map<Key, Value>>;
 /**
  * Freeze an object and all its properties recursively
+ *
+ * _(If you only want to freeze the object itself, but not any nested values, use `freeze(object, true)`, `freeze.flat(object)`, or `flatFreeze(object)` instead)_
+ *
  * @param object Object to freeze
  * @returns Frozen object
  */
 declare function freeze<Value extends PlainObject>(object: Value): Frozen<Value>;
+/**
+ * Freeze a set and its values recursively
+ *
+ * _(If you only want to freeze the set itself, but not any nested values, use `freeze(set, true)`, `freeze.flat(set)`, or `flatFreeze(set)` instead)_
+ *
+ * @param set Set to freeze
+ * @returns Frozen set
+ */
+declare function freeze<Item>(set: Set<Item>): Frozen<Set<Item>>;
 /**
  * Freeze any value, if possible
  *
- * _(Only arrays, functions, and plain objects are freezable)_
+ * _(Only arrays, maps, plain objects, and sets are freezable)_
+ *
  * @param value Value to freeze
  * @returns Frozen value
  */
 declare function freeze<Value>(value: Value): Value;
+declare namespace freeze {
+  var flat: typeof flatFreeze;
+  var is: typeof isFrozen;
+}
+/**
+ * Is the value frozen?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is frozen, otherwise `false`
+ */
+declare function isFrozen(value: unknown): boolean;
 //#endregion
-export { Frozen, freeze };
+export { Frozen, flatFreeze, freeze, isFrozen };

package/dist/value/freeze.mjs

@@ -1,38 +1,80 @@
+import { noop } from "../internal/function/misc.mjs";
 import { isPlainObject } from "../internal/is.mjs";
 //#region src/value/freeze.ts
-function freeze(value) {
-	return freezeValue(value, /* @__PURE__ */ new WeakSet());
+function fakeDelete() {
+	return false;
 }
-function freezeArray(array, references) {
+function flatFreeze(value) {
+	return freezeValue(value, /* @__PURE__ */ new WeakSet(), true);
+}
+function freeze(value, flat) {
+	return freezeValue(value, /* @__PURE__ */ new WeakSet(), flat === true);
+}
+freeze.flat = flatFreeze;
+freeze.is = isFrozen;
+function freezeArray(array, references, flat) {
+	if (flat) return Object.freeze(array);
 	references.add(array);
 	const { length } = array;
 	for (let index = 0; index < length; index += 1) {
 		const value = array[index];
-		if (!references.has(value)) array[index] = freezeValue(array[index], references);
+		if (!references.has(value)) array[index] = freezeValue(array[index], references, false);
 	}
 	return Object.freeze(array);
 }
-function freezeFunction(fn, references) {
-	references.add(fn);
-	return Object.freeze(fn);
+function freezeMap(map, references, flat) {
+	frozenValues.add(map);
+	map.clear = noop;
+	map.delete = fakeDelete;
+	map.set = () => map;
+	if (flat) return map;
+	references.add(map);
+	const entries = map.entries();
+	for (const [key, value] of entries) if (!references.has(value)) map.set(key, freezeValue(value, references, false));
+	return map;
 }
-function freezeObject(object, references) {
+function freezeObject(object, references, flat) {
+	if (flat) return Object.freeze(object);
 	references.add(object);
 	const keys = Object.keys(object);
 	const { length } = keys;
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
-		if (!references.has(object[key])) object[key] = freezeValue(object[key], references);
+		if (!references.has(object[key])) object[key] = freezeValue(object[key], references, false);
 	}
 	return Object.freeze(object);
 }
-function freezeValue(value, references) {
+function freezeSet(set, references, flat) {
+	frozenValues.add(set);
+	set.clear = noop;
+	set.delete = fakeDelete;
+	set.add = () => set;
+	if (flat) return set;
+	references.add(set);
+	const values = set.values();
+	for (const value of values) if (!references.has(value)) set.add(freezeValue(value, references, false));
+	return set;
+}
+function freezeValue(value, references, flat) {
 	switch (true) {
-		case typeof value === "function": return freezeFunction(value, references);
-		case Array.isArray(value): return freezeArray(value, references);
-		case isPlainObject(value): return freezeObject(value, references);
+		case isFrozen(value): return value;
+		case value instanceof Map: return freezeMap(value, references, flat);
+		case value instanceof Set: return freezeSet(value, references, flat);
+		case Array.isArray(value): return freezeArray(value, references, flat);
+		case isPlainObject(value): return freezeObject(value, references, flat);
 		default: return value;
 	}
 }
+/**
+* Is the value frozen?
+*
+* @param value Value to check
+* @returns `true` if the value is frozen, otherwise `false`
+*/
+function isFrozen(value) {
+	if (value instanceof Map || value instanceof Set) return frozenValues.has(value);
+	return typeof value === "object" && value !== null && Object.isFrozen(value);
+}
+const frozenValues = /* @__PURE__ */ new WeakSet();
 //#endregion
-export { freeze };
+export { flatFreeze, freeze, isFrozen };

package/dist/value/index.d.mts

@@ -1,7 +1,6 @@
-import { Frozen, freeze } from "./freeze.mjs";
 import { omit } from "./omit.mjs";
 import { pick } from "./pick.mjs";
 import { Shaken, shake } from "./shake.mjs";
 import { Smushed, smush } from "./smush.mjs";
 import { Unsmushed, unsmush } from "./unsmush.mjs";
-export { type Frozen, type Shaken, type Smushed, type Unsmushed, freeze, omit, pick, shake, smush, unsmush };
+export { type Shaken, type Smushed, type Unsmushed, omit, pick, shake, smush, unsmush };

package/dist/value/index.mjs

@@ -1,7 +1,6 @@
-import { freeze } from "./freeze.mjs";
 import { omit } from "./omit.mjs";
 import { pick } from "./pick.mjs";
 import { shake } from "./shake.mjs";
 import { smush } from "./smush.mjs";
 import { unsmush } from "./unsmush.mjs";
-export { freeze, omit, pick, shake, smush, unsmush };
+export { omit, pick, shake, smush, unsmush };

package/dist/value/merge.d.mts

@@ -5,6 +5,9 @@ import { ArrayOrPlainObject, NestedPartial, PlainObject, UnionToIntersection } f
  * Options for assigning values
  */
 type AssignOptions = Omit<MergeOptions, 'assignValues'>;
+/**
+ * An assigner function for assigning values from one or more objects to the first one
+ */
 type Assigner = {
   /**
    * Assign values from one or more objects to the first one
@@ -27,7 +30,7 @@ type MergeOptions = {
    * Key _(or key epxressions)_ for values that should be replaced
    *
    * ```ts
-   * merge([{items: [1, 2, 3]}, {items: [99]}]); // {items: [99]}
+   * merge([{items: [1, 2, 3]}, {items: [99]}]); // => {items: [99]}
    * ```
    */
   replaceableObjects?: string | RegExp | Array<string | RegExp>;
@@ -35,7 +38,7 @@ type MergeOptions = {
    * Skip nullable values when merging objects?
    *
    * ```ts
-   * merge({a: 1, b: 2}, {b: null, c: 3}, {d: null}); // {a: 1, b: 2, c: 3}
+   * merge({a: 1, b: 2}, {b: null, c: 3}, {d: null}); // => {a: 1, b: 2, c: 3}
    * ```
    */
   skipNullableAny?: boolean;
@@ -43,11 +46,14 @@ type MergeOptions = {
    * Skip nullable values when merging arrays?
    *
    * ```ts
-   * merge([1, 2, 3], [null, null, 99]); // [1, 2, 99]
+   * merge([1, 2, 3], [null, null, 99]); // => [1, 2, 99]
    * ```
    */
   skipNullableInArrays?: boolean;
 };
+/**
+ * A merger function for merging multiple arrays or objects into a single one
+ */
 type Merger = {
   /**
    * Merge multiple arrays or objects into a single one
@@ -72,7 +78,7 @@ declare namespace assign {
 /**
  * Create an assigner with predefined options
  *
- * Available as `initializeAssigner` and `assign.initialize`
+ * _Available as `initializeAssigner` and `assign.initialize`_
  *
  * @param options Assigning options
  * @returns Assigner function
@@ -81,7 +87,7 @@ declare function initializeAssigner(options?: AssignOptions): Assigner;
 /**
  * Create a merger with predefined options
  *
- * Available as `initializeMerger` and `merge.initialize`
+ * _Available as `initializeMerger` and `merge.initialize`_
  *
  * @param options Merging options
  * @returns Merger function

package/dist/value/merge.mjs

@@ -35,7 +35,7 @@ function getReplaceableObjects(value) {
 /**
 * Create an assigner with predefined options
 *
-* Available as `initializeAssigner` and `assign.initialize`
+* _Available as `initializeAssigner` and `assign.initialize`_
 *
 * @param options Assigning options
 * @returns Assigner function
@@ -48,7 +48,7 @@ function initializeAssigner(options) {
 /**
 * Create a merger with predefined options
 *
-* Available as `initializeMerger` and `merge.initialize`
+* _Available as `initializeMerger` and `merge.initialize`_
 *
 * @param options Merging options
 * @returns Merger function

package/dist/value/omit.d.mts

@@ -3,6 +3,7 @@ import { PlainObject } from "../models.mjs";
 //#region src/value/omit.d.ts
 /**
  * Create a new object without the specified keys
+ *
  * @param value Original object
  * @param keys Keys to omit
  * @returns Partial object without the specified keys

package/dist/value/omit.mjs

@@ -2,6 +2,7 @@ import { partial } from "../internal/value/partial.mjs";
 //#region src/value/omit.ts
 /**
 * Create a new object without the specified keys
+*
 * @param value Original object
 * @param keys Keys to omit
 * @returns Partial object without the specified keys

package/dist/value/pick.d.mts

@@ -3,6 +3,7 @@ import { PlainObject } from "../models.mjs";
 //#region src/value/pick.d.ts
 /**
  * Create a new object with only the specified keys
+ *
  * @param value Original object
  * @param keys Keys to use
  * @returns Partial object with only the specified keys

package/dist/value/pick.mjs

@@ -2,6 +2,7 @@ import { partial } from "../internal/value/partial.mjs";
 //#region src/value/pick.ts
 /**
 * Create a new object with only the specified keys
+*
 * @param value Original object
 * @param keys Keys to use
 * @returns Partial object with only the specified keys

package/dist/value/shake.d.mts

@@ -7,6 +7,7 @@ import { PlainObject } from "../models.mjs";
 type Shaken<Value extends PlainObject> = { [Key in keyof Value]: Value[Key] extends undefined ? never : Value[Key] };
 /**
  * Shake an object, removing all keys with `undefined` values
+ *
  * @param value Object to shake
  * @returns Shaken object
  */

package/dist/value/shake.mjs

@@ -2,6 +2,7 @@ import { isNonPlainObject } from "../internal/is.mjs";
 //#region src/value/shake.ts
 /**
 * Shake an object, removing all keys with `undefined` values
+*
 * @param value Object to shake
 * @returns Shaken object
 */

package/dist/value/smush.d.mts

@@ -7,6 +7,7 @@ import { NestedKeys, NestedValue, PlainObject, Simplify, ToString } from "../mod
 type Smushed<Value extends PlainObject> = Simplify<{ [NestedKey in NestedKeys<Value>]: NestedValue<Value, ToString<NestedKey>> }>;
 /**
  * Smush an object into a flat object that uses dot notation keys
+ *
  * @param value Object to smush
  * @returns Smushed object with dot notation keys
  */

package/dist/value/smush.mjs

@@ -27,6 +27,7 @@ function flattenObject(value, depth, smushed, prefix) {
 }
 /**
 * Smush an object into a flat object that uses dot notation keys
+*
 * @param value Object to smush
 * @returns Smushed object with dot notation keys
 */

package/dist/value/transform.d.mts

@@ -18,7 +18,8 @@ type Transformer<Value extends PlainObject> = {
 /**
  * Initialize a transformer for an object with a transformer function
  *
- * Available as `initializeTransformer` and `transform.initialize`
+ * _Available as `initializeTransformer` and `transform.initialize`_
+ *
  * @param transform Transformer function
  * @returns Transformer
  */
@@ -26,13 +27,15 @@ declare function initializeTransformer<Value extends PlainObject>(transform: Tra
 /**
  * Initialize a transformer for an object with transformer functions
  *
- * Available as `initializeTransformer` and `transform.initialize`
+ * _Available as `initializeTransformer` and `transform.initialize`_
+ *
  * @param transformers Keyed transformer functions
  * @returns Transformer
  */
 declare function initializeTransformer<Value extends PlainObject>(transformers: TransformCallbacks<Value>): Transformer<Value>;
 /**
- * Transform and objects properties using a transformer functior
+ * Transform and objects properties using a transformer function
+ *
  * @param value Object to transform
  * @param transform Transformer function
  * @returns Transformed object
@@ -40,6 +43,7 @@ declare function initializeTransformer<Value extends PlainObject>(transformers:
 declare function transform<Value extends PlainObject, Key extends keyof Value>(value: Value, transform: TransformCallback<Value, Key>): Value;
 /**
  * Transform and objects properties using a transformer object
+ *
  * @param value Object to transform
  * @param transformers Keyed transformer functions
  * @returns Transformed object