@oscarpalmer/atoms 0.201.0 → 0.203.0

package/dist/string/fuzzy.d.mts

@@ -3,7 +3,7 @@ import { PlainObject } from "../models.mjs";
 /**
  * Fuzzy searcher for an array of items
  */
-type Fuzzy<Item> = {
+export type Fuzzy<Item> = {
   /**
    * Get items currently being searched through
    *
@@ -39,7 +39,7 @@ type Fuzzy<Item> = {
    */
   search(value: string, limit: number): FuzzyResult<Item>;
 };
-type FuzzyConfiguration<Item> = {
+export type FuzzyConfiguration<Item> = {
   /**
    * Handler to stringify items
    *
@@ -55,7 +55,7 @@ type FuzzyConfiguration<Item> = {
    */
   key?: keyof Item;
 } : {}) & FuzzyOptions;
-type FuzzyOptions = {
+export type FuzzyOptions = {
   /**
    * Maximum number of combined items to return in `exact` and `similar` _(defaults to all matches)_
    */
@@ -71,7 +71,7 @@ type FuzzyOptions = {
 /**
  * Search results from a fuzzy search, with exact and similar matches
  */
-type FuzzyResult<Item> = {
+export type FuzzyResult<Item> = {
   /**
    * Ordered items that exactly match the search value
    */
@@ -84,7 +84,7 @@ type FuzzyResult<Item> = {
 /**
  * Options for fuzzy searching
  */
-type FuzzySearchOptions = FuzzyOptions;
+export type FuzzySearchOptions = FuzzyOptions;
 /**
  * Create a fuzzy searcher for an array of items
  *
@@ -92,7 +92,7 @@ type FuzzySearchOptions = FuzzyOptions;
  * @param key Key to use to stringify items
  * @returns Fuzzy searcher
  */
-declare function fuzzy<Item extends PlainObject, ItemKey extends keyof Item>(items: Item[], key?: ItemKey): Fuzzy<Item>;
+export declare function fuzzy<Item extends PlainObject, ItemKey extends keyof Item>(items: Item[], key?: ItemKey): Fuzzy<Item>;
 /**
  * Create a fuzzy searcher for an array of items
  *
@@ -100,7 +100,7 @@ declare function fuzzy<Item extends PlainObject, ItemKey extends keyof Item>(ite
  * @param handler Handler to stringify items
  * @returns Fuzzy searcher
  */
-declare function fuzzy<Item>(items: Item[], handler?: (item: Item) => string): Fuzzy<Item>;
+export declare function fuzzy<Item>(items: Item[], handler?: (item: Item) => string): Fuzzy<Item>;
 /**
  * Create a fuzzy searcher for an array of items
  *
@@ -108,8 +108,9 @@ declare function fuzzy<Item>(items: Item[], handler?: (item: Item) => string): F
  * @param configuration Fuzzy configuration
  * @returns Fuzzy searcher
  */
-declare function fuzzy<Item>(items: Item[], configuration?: FuzzyConfiguration<Item>): Fuzzy<Item>;
-declare namespace fuzzy {
+export declare function fuzzy<Item>(items: Item[], configuration?: FuzzyConfiguration<Item>): Fuzzy<Item>;
+export declare namespace fuzzy {
+  var is: typeof isFuzzy;
   var match: typeof fuzzyMatch;
 }
 /**
@@ -121,6 +122,14 @@ declare namespace fuzzy {
  * @param needle Needle to search for
  * @returns `true` if the needle matches the haystack in a fuzzy way, otherwise `false`
  */
-declare function fuzzyMatch(haystack: string, needle: string): boolean;
-//#endregion
-export { Fuzzy, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, fuzzy, fuzzyMatch };
+export declare function fuzzyMatch(haystack: string, needle: string): boolean;
+/**
+ * Is the value a fuzzy searcher?
+ *
+ * _Available as `isFuzzy` and `fuzzy.is`_
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a fuzzy searcher, otherwise `false`
+ */
+export declare function isFuzzy<Item = unknown>(value: unknown): value is Fuzzy<Item>;
+//#endregion

package/dist/string/fuzzy.mjs

@@ -3,6 +3,30 @@ import { getString } from "../internal/string/misc.mjs";
 import { lowerCase } from "../internal/string/case.mjs";
 import { includes } from "./match.mjs";
 //#region src/string/fuzzy.ts
+const FUZZY_PROPERTY = "$fuzzy";
+const FUZZY_SYMBOL = Symbol(FUZZY_PROPERTY);
+function Fuzzy(state) {
+	Object.defineProperty(this, FUZZY_SYMBOL, { value: state });
+}
+Object.defineProperties(Fuzzy.prototype, {
+	[FUZZY_PROPERTY]: { value: true },
+	items: {
+		enumerable: true,
+		get() {
+			return this[FUZZY_SYMBOL].items.slice();
+		},
+		set(value) {
+			setItems(this[FUZZY_SYMBOL], value);
+		}
+	},
+	search: { value: search },
+	strings: {
+		enumerable: true,
+		get() {
+			return this[FUZZY_SYMBOL].strings.slice();
+		}
+	}
+});
 function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
@@ -22,43 +46,13 @@ function createFuzzyState(items, input) {
 		tolerance: options.tolerance
 	};
 }
-function getHandler(input) {
-	if (input == null || input === getString) return getString;
-	switch (typeof input) {
-		case "function": return input;
-		case "string": return (item) => item[input];
-		default:
-			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
-			throw new TypeError(FUZZY_MESSAGE_HANDLER);
-	}
-}
-function getFuzzyItems(items) {
-	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
-}
-function getTolerance(input, state) {
-	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
-	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
-}
 function fuzzy(items, configuration) {
 	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
-	const state = createFuzzyState(items, configuration);
-	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : createFuzzyOptions(options, state)) };
-	Object.defineProperties(instance, {
-		items: {
-			enumerable: true,
-			get: () => state.items.slice(),
-			set: (value) => setItems(state, value)
-		},
-		strings: {
-			enumerable: true,
-			get: () => state.strings.slice()
-		}
-	});
-	return Object.freeze(instance);
+	return new Fuzzy(createFuzzyState(items, configuration));
 }
 /**
 * Does the needle match the haystack in a fuzzy way?
-* 
+*
 * _Available as `fuzzyMatch` and `fuzzy.match`_
 *
 * @param haystack Haystack to search through
@@ -71,17 +65,18 @@ function fuzzyMatch(haystack, needle) {
 	if (includes(haystack, trimmed, true)) return true;
 	return getScore(haystack, trimmed) > -1;
 }
-function isSubsequence(haystack, needle) {
-	const lowerCaseHaystack = lowerCase(haystack);
-	const lowerCaseNeedle = lowerCase(needle);
-	const haystackLength = lowerCaseHaystack.length;
-	const needleLength = lowerCaseNeedle.length;
-	let needleIndex = 0;
-	for (let haystackIndex = 0; haystackIndex < haystackLength; haystackIndex += 1) {
-		if (lowerCaseHaystack[haystackIndex] === lowerCaseNeedle[needleIndex]) needleIndex += 1;
-		if (needleIndex === needleLength) return true;
+function getHandler(input) {
+	if (input == null || input === getString) return getString;
+	switch (typeof input) {
+		case "function": return input;
+		case "string": return (item) => item[input];
+		default:
+			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
+			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
-	return false;
+}
+function getFuzzyItems(items) {
+	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
 }
 function getScore(haystack, needle) {
 	if (!isSubsequence(haystack, needle)) return -1;
@@ -107,23 +102,52 @@ function getScore(haystack, needle) {
 	score -= Math.floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
 	return Math.max(0, score);
 }
-function search(items, strings, input, options) {
+function getTolerance(input, state) {
+	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
+	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
+}
+/**
+* Is the value a fuzzy searcher?
+*
+* _Available as `isFuzzy` and `fuzzy.is`_
+*
+* @param value Value to check
+* @returns `true` if the value is a fuzzy searcher, otherwise `false`
+*/
+function isFuzzy(value) {
+	return typeof value === "object" && value !== null && FUZZY_PROPERTY in value && value[FUZZY_PROPERTY] === true;
+}
+function isSubsequence(haystack, needle) {
+	const lowerCaseHaystack = lowerCase(haystack);
+	const lowerCaseNeedle = lowerCase(needle);
+	const haystackLength = lowerCaseHaystack.length;
+	const needleLength = lowerCaseNeedle.length;
+	let needleIndex = 0;
+	for (let haystackIndex = 0; haystackIndex < haystackLength; haystackIndex += 1) {
+		if (lowerCaseHaystack[haystackIndex] === lowerCaseNeedle[needleIndex]) needleIndex += 1;
+		if (needleIndex === needleLength) return true;
+	}
+	return false;
+}
+function search(input, option) {
+	const state = this[FUZZY_SYMBOL];
+	const options = option == null ? state : createFuzzyOptions(option, state);
 	const result = {
 		exact: [],
 		similar: []
 	};
 	const value = typeof input === "string" ? input.trim() : "";
 	if (value.length === 0) {
-		result.exact = items.slice(0, options.limit);
+		result.exact = state.items.slice(0, options.limit);
 		return result;
 	}
-	let { length } = items;
+	let { length } = state.items;
 	const exact = [];
 	const similar = [];
 	const scored = {};
 	for (let index = 0; index < length; index += 1) {
-		const item = items[index];
-		const haystack = strings[index];
+		const item = state.items[index];
+		const haystack = state.strings[index];
 		if (includes(haystack, value, true)) {
 			exact.push({
 				item,
@@ -164,7 +188,11 @@ const FUZZY_LENGTH_DIVISOR = 3;
 const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
 const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
 const FUZZY_PROXIMITY_THRESHOLD = 5;
+fuzzy.is = isFuzzy;
 fuzzy.match = fuzzyMatch;
-Object.defineProperty(fuzzy, "match", { value: fuzzyMatch });
+Object.defineProperties(fuzzy, {
+	is: { value: isFuzzy },
+	match: { value: fuzzyMatch }
+});
 //#endregion
-export { fuzzy, fuzzyMatch };
+export { fuzzy, fuzzyMatch, isFuzzy };

package/dist/string/index.d.mts

@@ -5,27 +5,27 @@ import { getString, join, words } from "../internal/string/misc.mjs";
  *
  * @returns Dedented string
  */
-declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
+export declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
 /**
  * Dedent a string, removing common leading whitespace from each line
  *
  * @param value String to dedent
  * @returns Dedented string
  */
-declare function dedent(value: string): string;
+export declare function dedent(value: string): string;
 /**
  * Get a new UUID string _(version 4)_ for use in _HTML_
  *
  * @param html Use _HTML_-friendly format
  * @returns UUID string
  */
-declare function getUuid(html: true): string;
+export declare function getUuid(html: true): string;
 /**
  * Get a new UUID string _(version 4)_
  *
  * @returns UUID string
  */
-declare function getUuid(): string;
+export declare function getUuid(): string;
 /**
  * Parse a JSON string into its proper value _(or `undefined` if it fails)_
  *
@@ -33,14 +33,14 @@ declare function getUuid(): string;
  * @param reviver Reviver function to transform the parsed values
  * @returns Parsed value or `undefined` if parsing fails
  */
-declare function parse(value: string, reviver?: (this: unknown, key: string, value: unknown) => unknown): unknown;
+export declare function parse(value: string, reviver?: (this: unknown, key: string, value: unknown) => unknown): unknown;
 /**
  * Trim a string _(removing whitespace from both ends)_
  *
  * @param value String to trim
  * @returns Trimmed string
  */
-declare function trim(value: string): string;
+export declare function trim(value: string): string;
 /**
  * Truncate a string to a specified length
  *
@@ -49,6 +49,6 @@ declare function trim(value: string): string;
  * @param suffix Suffix to append to the truncated string
  * @returns Truncated string
  */
-declare function truncate(value: string, length: number, suffix?: string): string;
+export declare function truncate(value: string, length: number, suffix?: string): string;
 //#endregion
-export { dedent, getString, getUuid, join, parse, trim, truncate, words };
+export { getString, join, words };

package/dist/string/match.d.mts

@@ -7,7 +7,7 @@
  * @param ignoreCase Ignore case when matching? _(defaults to `false`)_
  * @returns `true` if the string ends with the given substring, otherwise `false`
  */
-declare function endsWith(haystack: string, needle: string, ignoreCase?: boolean): boolean;
+export declare function endsWith(haystack: string, needle: string, ignoreCase?: boolean): boolean;
 /**
  * Check if a string includes a specified substring
  *
@@ -16,7 +16,7 @@ declare function endsWith(haystack: string, needle: string, ignoreCase?: boolean
  * @param ignoreCase Ignore case when matching? _(defaults to `false`)_
  * @returns `true` if the string includes the given substring, otherwise `false`
  */
-declare function includes(haystack: string, needle: string, ignoreCase?: boolean): boolean;
+export declare function includes(haystack: string, needle: string, ignoreCase?: boolean): boolean;
 /**
  * Check if a string starts with a specified substring
  *
@@ -25,6 +25,5 @@ declare function includes(haystack: string, needle: string, ignoreCase?: boolean
  * @param ignoreCase Ignore case when matching? _(defaults to `false`)_
  * @returns `true` if the string starts with the given substring, otherwise `false`
  */
-declare function startsWith(haystack: string, needle: string, ignoreCase?: boolean): boolean;
-//#endregion
-export { endsWith, includes, startsWith };
+export declare function startsWith(haystack: string, needle: string, ignoreCase?: boolean): boolean;
+//#endregion

package/dist/string/normalize.d.mts

@@ -2,7 +2,7 @@
 /**
  * Options for normalizing a string
  */
-type NormalizeOptions = {
+export type NormalizeOptions = {
   /**
    * Remove diacritical marks from the string? _(defaults to `true`)_
    */
@@ -29,14 +29,14 @@ type NormalizeOptions = {
 /**
  * String normalizer function
  */
-type Normalizer = {
+export type Normalizer = {
   /**
    * Normalize a string
    *
    * @param value String to normalize
    * @returns Normalized string
    */
-  (value: string): string;
+  normalize(value: string): string;
 };
 /**
  * Deburr a string, removing diacritical marks
@@ -44,7 +44,7 @@ type Normalizer = {
  * @param value String to deburr
  * @returns Deburred string
  */
-declare function deburr(value: string): string;
+export declare function deburr(value: string): string;
 /**
  * Initialize a string normalizer
  *
@@ -53,7 +53,7 @@ declare function deburr(value: string): string;
  * @param options Normalization options
  * @returns Normalizer function
  */
-declare function initializeNormalizer(options?: NormalizeOptions): Normalizer;
+export declare function initializeNormalizer(options?: NormalizeOptions): Normalizer;
 /**
  * Normalize a string
  *
@@ -63,9 +63,8 @@ declare function initializeNormalizer(options?: NormalizeOptions): Normalizer;
  * @param options Normalization options
  * @returns Normalized string
  */
-declare function normalize(value: string, options?: NormalizeOptions): string;
-declare namespace normalize {
+export declare function normalize(value: string, options?: NormalizeOptions): string;
+export declare namespace normalize {
   var initialize: typeof initializeNormalizer;
 }
-//#endregion
-export { NormalizeOptions, Normalizer, deburr, initializeNormalizer, normalize };
+//#endregion

package/dist/string/normalize.mjs

@@ -2,6 +2,10 @@ import { isPlainObject } from "../internal/is.mjs";
 import { memoize } from "../internal/function/memoize.mjs";
 import { lowerCase } from "../internal/string/case.mjs";
 //#region src/string/normalize.ts
+function Normalizer(options) {
+	Object.defineProperty(this, NORMALIZE_SYMBOL, { value: options });
+}
+Object.defineProperties(Normalizer.prototype, { normalize: { value: normalizeString } });
 function createNormalizeOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -36,8 +40,7 @@ function deburr(value) {
 * @returns Normalizer function
 */
 function initializeNormalizer(options) {
-	const normalization = createNormalizeOptions(options);
-	return (value) => normalizeString(value, normalization);
+	return new Normalizer(createNormalizeOptions(options));
 }
 /**
 * Normalize a string
@@ -49,10 +52,11 @@ function initializeNormalizer(options) {
 * @returns Normalized string
 */
 function normalize(value, options) {
-	return normalizeString(value, createNormalizeOptions(options));
+	return normalizeString.call(createNormalizeOptions(options), value);
 }
-function normalizeString(value, options) {
+function normalizeString(value) {
 	if (typeof value !== "string") return "";
+	const options = NORMALIZE_SYMBOL in this ? this[NORMALIZE_SYMBOL] : this;
 	let result = value;
 	if (options.trim) result = result.trim();
 	if (options.whitespace) result = result.replace(NORMALIZE_WHITESPACE_PATTERN, NORMALIZE_WHITESPACE_REPLACEMENT);
@@ -99,6 +103,7 @@ const NORMALIZE_DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
 const NORMALIZE_NORMALIZATION_NORMALIZATION = "NFC";
 const NORMALIZE_SPECIAL_PATTERN = /[\p{P}\p{S}]/gu;
 const NORMALIZE_SPECIAL_REPLACEMENT = "";
+const NORMALIZE_SYMBOL = Symbol("normalize");
 const NORMALIZE_WHITESPACE_PATTERN = /\s+/g;
 const NORMALIZE_WHITESPACE_REPLACEMENT = " ";
 let deburrMemoizer;

package/dist/string/template.d.mts

@@ -11,7 +11,7 @@ type Renderer = (variables?: PlainObject, options?: Partial<TemplateOptions>) =>
 /**
  * Options for templating strings
  */
-type TemplateOptions = {
+export type TemplateOptions = {
   /**
    * Ignore case when searching for variables?
    */
@@ -27,7 +27,7 @@ type Templater = {
    *
    * @returns Templated string
    */
-  (strings: TemplateStringsArray, ...values: unknown[]): TemplaterRenderer;
+  render(strings: TemplateStringsArray, ...values: unknown[]): TemplaterRenderer;
   /**
    * Render a string from a template with variables
    *
@@ -35,12 +35,13 @@ type Templater = {
    * @param variables Variables to use
    * @returns Templated string
    */
-  (value: string, variables?: PlainObject): string;
+  render(value: string, variables?: PlainObject): string;
 };
 /**
  * Render a template string with variables
  */
 type TemplaterRenderer = (variables?: PlainObject) => string;
+declare function Templater(this: any, options: Required<TemplateOptions>): void;
 /**
  * Create a _Templater_ with predefined options
  *
@@ -49,13 +50,13 @@ type TemplaterRenderer = (variables?: PlainObject) => string;
  * @param options Templating options
  * @returns _Templater_ function
  */
-declare function initializeTemplater(options?: Partial<TemplateOptions>): Templater;
+export declare function initializeTemplater(options?: Partial<TemplateOptions>): Templater;
 /**
  * Get a _Renderer_ for a string template
  *
  * @returns _Renderer_ function
  */
-declare function template(strings: TemplateStringsArray, ...values: unknown[]): Renderer;
+export declare function template(strings: TemplateStringsArray, ...values: unknown[]): Renderer;
 /**
  * Render a string from a template with variables
  *
@@ -64,9 +65,8 @@ declare function template(strings: TemplateStringsArray, ...values: unknown[]):
  * @param options Templating options
  * @returns Templated string
  */
-declare function template(value: string, variables?: PlainObject, options?: Partial<TemplateOptions>): string;
-declare namespace template {
+export declare function template(value: string, variables?: PlainObject, options?: Partial<TemplateOptions>): string;
+export declare namespace template {
   var initialize: typeof initializeTemplater;
 }
-//#endregion
-export { TemplateOptions, initializeTemplater, template };
+//#endregion

package/dist/string/template.mjs

@@ -2,6 +2,10 @@ import { isPlainObject, isTemplateStringsArray } from "../internal/is.mjs";
 import { getString, interpolate } from "../internal/string/misc.mjs";
 import { getValue } from "../internal/value/get.mjs";
 //#region src/string/template.ts
+function Templater(options) {
+	Object.defineProperty(this, TEMPLATE_SYMBOL, { value: options });
+}
+Object.defineProperties(Templater.prototype, { render: { value: render } });
 function createTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -35,10 +39,12 @@ function handleTemplate(value, pattern, ignoreCase, variables) {
 * @returns _Templater_ function
 */
 function initializeTemplater(options) {
-	const { ignoreCase, pattern } = createTemplateOptions(options);
-	return ((value, ...parameters) => {
-		return isTemplateStringsArray(value) ? (variables) => handleTemplate(interpolate(value, parameters), pattern, ignoreCase, variables) : handleTemplate(value, pattern, ignoreCase, parameters[0]);
-	});
+	return new Templater(createTemplateOptions(options));
+}
+function render(value, ...parameters) {
+	const { ignoreCase, pattern } = this[TEMPLATE_SYMBOL];
+	if (isTemplateStringsArray(value)) return (variables) => handleTemplate(interpolate(value, parameters), pattern, ignoreCase, variables);
+	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
 function template(value, ...parameters) {
 	if (isTemplateStringsArray(value)) return getRenderer(value, parameters);
@@ -46,6 +52,7 @@ function template(value, ...parameters) {
 	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
 const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+const TEMPLATE_SYMBOL = Symbol("template");
 template.initialize = initializeTemplater;
 Object.defineProperty(template, "initialize", { value: initializeTemplater });
 //#endregion

package/dist/value/clone.d.mts

@@ -1,6 +1,6 @@
 import { Constructor, GenericCallback } from "../models.mjs";
 //#region src/value/clone.d.ts
-type CloneOptions = {
+export type CloneOptions = {
   /**
    * Copy functions instead of returning `undefined`? _(defaults to `false`)_
    */
@@ -13,14 +13,14 @@ type CloneOptions = {
 /**
  * A cloning function with predefined options
  */
-type Cloner = {
+export type Cloner = {
   /**
    * Clone any kind of value
    *
    * @param value Value to clone
    * @returns Cloned value
    */
-  <Value>(value: Value): Value;
+  clone<Value>(value: Value): Value;
   /**
    * Deregister a clone handler for a specific class
    *
@@ -46,13 +46,22 @@ type Cloner = {
  * @param options Clone options
  * @returns Cloned value
  */
-declare function clone<Value>(value: Value, options?: CloneOptions): Value;
-declare namespace clone {
+export declare function clone<Value>(value: Value, options?: CloneOptions): Value;
+export declare namespace clone {
   var deregister: typeof deregisterCloner;
   var handlers: {
-    deregister(constructor: Constructor): void;
+    base: {
+      handlers: WeakMap<Constructor, string | GenericCallback>;
+      options: {
+        callback: GenericCallback;
+        method?: string;
+      };
+      owner: GenericCallback;
+      deregister: (constructor: Constructor) => void;
+      get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
+      register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+    };
     handle(value: unknown, ...parameters: unknown[]): unknown;
-    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
   var initialize: typeof initializeCloner;
   var register: typeof registerCloner;
@@ -66,7 +75,7 @@ declare namespace clone {
  * @param value Value to copy
  * @returns Copied value
  */
-declare function copy<Value>(value: Value): Value;
+export declare function copy<Value>(value: Value): Value;
 /**
  * Deregister a clone handler for a specific class
  *
@@ -74,7 +83,7 @@ declare function copy<Value>(value: Value): Value;
  *
  * @param constructor Class constructor
  */
-declare function deregisterCloner<Instance>(constructor: Constructor<Instance>): void;
+export declare function deregisterCloner<Instance>(constructor: Constructor<Instance>): void;
 /**
  * Create a cloner with predefined options
  *
@@ -83,7 +92,7 @@ declare function deregisterCloner<Instance>(constructor: Constructor<Instance>):
  * @param options Clone options
  * @returns Cloner function
  */
-declare function initializeCloner(options?: CloneOptions): Cloner;
+export declare function initializeCloner(options?: CloneOptions): Cloner;
 /**
  * Register a clone handler for a specific class
  *
@@ -92,6 +101,5 @@ declare function initializeCloner(options?: CloneOptions): Cloner;
  * @param constructor Class constructor
  * @param handler Method name or clone function _(defaults to method name `clone`)_
  */
-declare function registerCloner<Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)): void;
-//#endregion
-export { CloneOptions, Cloner, clone, copy, deregisterCloner, initializeCloner, registerCloner };
+export declare function registerCloner<Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)): void;
+//#endregion