		import { Result } from './result';
		import { Brand } from './brand';
		declare type OnError = 'failOnError' \| 'ignoreErrors';
		/**
		* Converter traits.
		* @public
		*/
		@@ -11,3 +13,4 @@ export interface ConverterTraits {
		/**
		* Options for @see Converter @see withConstraint
		* Options for {@link Converter.withConstraint}.
		* @public
		*/
		@@ -22,97 +25,142 @@ export interface ConstraintOptions {
		/**
		* Helper type to brand a simple type to prevent inappropriate use
		* Generic converter to convert unknown to a templated type `<T>`, using
		* intrinsic rules or as modified by an optional conversion context
		* of optional templated type `<TC>` (default `undefined`).
		* @public
		*/
		export declare type Brand<T, B> = T & {
		__brand: B;
		};
		export interface Converter<T, TC = undefined> extends ConverterTraits {
		/**
		* Indicates whether this element is explicitly optional
		* Indicates whether this element is explicitly optional.
		*/
		readonly isOptional: boolean;
		/**
		* Returns the brand for a branded type
		* Returns the brand for a branded type.
		*/
		readonly brand?: string;
		/**
		* Converts from unknown to <T>
		* @param from The unknown to be converted
		* @param context An optional context applied to the conversion
		* @returns An @see Result with a value or an error message
		* Converts from `unknown` to `<T>`.
		* @param from - The `unknown` to be converted
		* @param context - An optional conversion context of type `<TC>` to be used in
		* the conversion.
		* @returns A {@link Result} with a {@link Success} and a value on success or an
		* {@link Failure} with a a message on failure.
		*/
		convert(from: unknown, context?: TC): Result<T>;
		/**
		* Converts from unknown to <T> or undefined, as appropriate.
		* If 'onError' is 'failOnError', the converter succeeds for
		* 'undefined' or any convertible value, but reports an error
		* if it encounters a value that cannot be converted. If 'onError'
		* is 'ignoreErrors' (default) then values that cannot be converted
		* result in a successful return of 'undefined'.
		* @param from The unknown to be converted
		* @param context Optional context for use by the converter
		* @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'
		* Converts from `unknown` to `<T>` or `undefined`, as appropriate.
		*
		* @remarks
		* If `onError` is `failOnError`, the converter succeeds for
		* `undefined` or any convertible value, but reports an error
		* if it encounters a value that cannot be converted.
		*
		* If `onError` is `ignoreErrors` (default) then values that
		* cannot be converted result in a successful return of `undefined`.
		* @param from - The `unknown` to be converted
		* @param context - An optional conversion context of type `<TC>` to be used in
		* the conversion.
		* @param onError - Specifies handling of values that cannot be converted (default `ignoreErrors`).
		* @returns A {@link Result} with a {@link Success} and a value on success or an
		* {@link Failure} with a a message on failure.
		*/
		convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T \| undefined>;
		/**
		* Creates a converter for an optional value. If 'onError'
		* is 'failOnError', the converter accepts 'undefined' or a
		* convertible value, but reports an error if it encounters
		* a value that cannot be converted. If 'onError' is 'ignoreErrors'
		* (default) then values that cannot be converted result in a
		* successful return of 'undefined'.
		* Creates a {@link Converter} for an optional value.
		*
		* @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'
		* @remarks
		* If `onError` is `failOnError`, the resulting converter will accept `undefined`
		* or a convertible value, but report an error if it encounters a value that cannot be
		* converted.
		*
		* If `onError` is `ignoreErrors` (default) then values that cannot be converted will
		* result in a successful return of `undefined`.
		*
		* @param onError - Specifies handling of values that cannot be converted (default `ignoreErrors`).
		* @returns A new {@link Converter} returning `<T\|undefined>`.
		* */
		optional(onError?: OnError): Converter<T \| undefined, TC>;
		/**
		* Applies a (possibly) mapping conversion to the converted value.
		* @param mapper A function which maps from the converted type to some other type.
		* Creates a {@link Converter} which applies a (possibly) mapping conversion to
		* the converted value of this {@link Converter}.
		* @param mapper - A function which maps from the the result type `<T>` of this
		* converter to a new result type `<T2>`.
		* @returns A new {@link Converter} returning `<T2>`.
		*/
		map<T2>(mapper: (from: T) => Result<T2>): Converter<T2, TC>;
		/**
		* Applies an additional converter to the converted value.
		* @param mapConverter The converter to be applied to the converted value
		* Creates a {@link Converter} which applies an additional supplied
		* converter to the result of this converter.
		*
		* @param mapConverter - The {@link Converter} to be applied to the
		* converted result from this {@link Converter}.
		* @returns A new {@link Converter} returning `<T2>`.
		*/
		mapConvert<T2>(mapConverter: Converter<T2>): Converter<T2, TC>;
		/**
		* Maps the individual items of the resulting value with the supplied
		* map function. Fails if 'from' is not an array.
		* @param mapper The map function
		* Creates a {@link Converter} which maps the individual items of a collection
		* resulting from this {@link Converter} using the supplied map fuction.
		*
		* @remarks
		* Fails if `from` is not an array.
		*
		* @param mapper - The map function to be applied to each element of the
		* result of this {@link Converter}.
		* @returns A new {@link Converter} returning `<TI[]>`.
		*/
		mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC>;
		/**
		* Maps the individual items of the resulting value with the supplied
		* converter function. Fails if 'from' is not an array.
		* @param mapConverter The map
		* Creates a {@link Converter} which maps the individual items of a collection
		* resulting from this {@link Converter} using the supplied {@link Converter}.
		*
		* @remarks
		* Fails if `from` is not an array.
		*
		* @param mapConverter - The {@link Converter} to be applied to each element of the
		* result of this {@link Converter}.
		* @returns A new {@link Converter} returning `<TI[]>`.
		*/
		mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC>;
		/**
		* Applies a type guard to the conversion result.
		* @param guard The type guard function to apply
		* @param message Optional message to be reported on failure
		* Creates a {@link Converter} which applies a supplied type guard to the conversion
		* result.
		* @param guard - The type guard function to apply.
		* @param message - Optional message to be reported if the type guard fails.
		* @returns A new {@link Converter} returning `<TI>`.
		*/
		withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI, TC>;
		/**
		* Applies a type guard to each member of the conversion result. Fails
		* if the conversion result is not an array or if any member fails the
		* Creates a {@link Converter} which applies a supplied type guard to each member of
		* the conversion result from this converter.
		*
		* @remarks
		* Fails if the conversion result is not an array or if any member fails the
		* type guard.
		* @param guard The type guard function to apply to each element
		* @param message Optional message to be reported on failure
		* @param guard - The type guard function to apply to each element.
		* @param message - Optional message to be reported if the type guard fails.
		* @returns A new {@link Converter} returning `<TI>`.
		*/
		withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI[], TC>;
		/**
		* Creates a converter with an optional constraint. If the base converter
		* succeeds, calls a supplied constraint evaluation function with the
		* value and fails the conversion if the function returns either false
		* or Failure<T>.
		* Creates a {@link Converter} which applies an optional constraint to the result
		* of this conversion. If this {@link Converter} (the base converter) succeeds, the new
		* converter calls a supplied constraint evaluation function with the conversion, which
		* fails the entire conversion if the constraint function returns either `false` or
		* {@link Failure \| Failure<T>}.
		*
		* @param constraint Constraint evaluation function
		* @param options Options for constraint evaluation
		* @param constraint - Constraint evaluation function.
		* @param options - {@link ConstraintOptions \| Options} for constraint evaluation.
		* @returns A new {@link Converter} returning `<T>`.
		*/
		withConstraint(constraint: (val: T) => boolean \| Result<T>, options?: ConstraintOptions): Converter<T, TC>;
		/**
		* Adds a brand to the type to prevent mismatched usage of simple types
		* returns a converter which adds a brand to the type to prevent mismatched usage
		* of simple types.
		* @param brand - The brand to be applied to the result value.
		* @returns A {@link Converter} returning `Brand<T, B>`.
		*/
		withBrand<B extends string>(brand: B): Converter<Brand<T, B>, TC>;
		}
		/**
		* internal
		*/
		declare type InnerInferredType<TCONV> = TCONV extends Converter<infer TTO> ? (TTO extends Array<infer TTOELEM> ? InnerInferredType<TTOELEM>[] : TTO) : (TCONV extends Array<infer TELEM> ? InnerInferredType<TELEM>[] : TCONV);
		@@ -122,3 +170,4 @@ /**
		* for complex as well as simple types.
		* @example Infer<typeof Converters.mapOf(Converters.stringArray)> is Map<string, string[]>
		* @example `Infer<typeof Converters.mapOf(Converters.stringArray)>` is `Map<string, string[]>`
		* @beta
		*/
		@@ -129,102 +178,97 @@ export declare type Infer<TCONV> = TCONV extends Converter<infer TTO> ? InnerInferredType<TTO> : never;
		* @deprecated use @see Infer instead
		* @internal
		*/
		export declare type ConvertedToType<TCONV> = Infer<TCONV>;
		/**
		* Simple templated converter wrapper to simplify typed conversion from unknown.
		* Base templated wrapper to simplify creation of new {@link Converter}s.
		* @public
		*/
		export declare class BaseConverter<T, TC = undefined> implements Converter<T, TC> {
		/**
		* @internal
		*/
		protected readonly _defaultContext?: TC;
		/**
		* @internal
		*/
		protected _isOptional: boolean;
		/**
		* @internal
		*/
		protected _brand?: string;
		private readonly _converter;
		/**
		* Constructs a new {@link Converter} which uses the supplied function to perform the conversion.
		* @param converter - The conversion function to be applied.
		* @param defaultContext - Optional conversion context to be used by default.
		* @param traits - Optional {@link ConverterTraits \| traits} to be assigned to the resulting
		* converter.
		*/
		constructor(converter: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>, defaultContext?: TC, traits?: ConverterTraits);
		/**
		* Converts from unknown to <T>
		* @param from The unknown to be converted
		* @returns An @see Result with a value or an error message
		* {@inheritdoc Converter.isOptional}
		*/
		convert(from: unknown, context?: TC): Result<T>;
		get isOptional(): boolean;
		/**
		* Converts from unknown to <T> or undefined, as appropriate.
		* If 'onError' is 'failOnError', the converter succeeds for
		* 'undefined' or any convertible value, but reports an error
		* if it encounters a value that cannot be converted. If 'onError'
		* is 'ignoreErrors' (default) then values that cannot be converted
		* result in a successful return of 'undefined'.
		* @param from The unknown to be converted
		* @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'
		* {@inheritdoc Converter.brand}
		*/
		convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T \| undefined>;
		get brand(): string \| undefined;
		/**
		* Creates a converter for an optional value. If 'onError'
		* is 'failOnError', the converter accepts 'undefined' or a
		* convertible value, but reports an error if it encounters
		* a value that cannot be converted. If 'onError' is 'ignoreErrors'
		* then values that cannot be converted result in a
		* successful return of 'undefined'.
		*
		* @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'
		* */
		optional(onError?: OnError): Converter<T \| undefined, TC>;
		* {@inheritdoc Converter.convert}
		*/
		convert(from: unknown, context?: TC): Result<T>;
		/**
		* Reports whether this value is explicitly optional
		* {@inheritdoc Converter.convertOptional}
		*/
		get isOptional(): boolean;
		convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T \| undefined>;
		/**
		* Reports the brand of a branded type.
		* {@inheritdoc Converter.optional}
		*/
		get brand(): string \| undefined;
		optional(onError?: OnError): Converter<T \| undefined, TC>;
		/**
		* Applies a (possibly) mapping conversion to the converted value.
		* @param mapper A function which maps from the converted type to some other type.
		* {@inheritdoc Converter.map}
		*/
		map<T2>(mapper: (from: T) => Result<T2>): Converter<T2, TC>;
		/**
		* Applies an additional converter to the converted value.
		* @param mapConverter The converter to be applied to the converted value
		* {@inheritdoc Converter.mapConvert}
		*/
		mapConvert<T2>(mapConverter: Converter<T2>): Converter<T2, TC>;
		/**
		* Maps the individual items of the resulting value with the supplied
		* map function. Fails if 'from' is not an array.
		* @param mapper The map function
		* {@inheritdoc Converter.mapItems}
		*/
		mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC>;
		/**
		* Maps the individual items of the resulting value with the supplied
		* converter function. Fails if 'from' is not an array.
		* @param mapConverter The map
		* {@inheritdoc Converter.mapConvertItems}
		*/
		mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC>;
		/**
		* Applies a type guard to the conversion result.
		* @param guard The type guard function to apply
		* @param message Optional message to be reported on failure
		* {@inheritdoc Converter.withTypeGuard}
		*/
		withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI, TC>;
		/**
		* Applies a type guard to each member of the conversion result. Fails
		* if the conversion result is not an array or if any member fails the
		* type guard.
		* @param guard The type guard function to apply to each element
		* @param message Optional message to be reported on failure
		* {@inheritdoc Converter.withItemTypeGuard}
		*/
		withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI[], TC>;
		/**
		* Creates a converter with an optional constraint. If the base converter
		* succeeds, calls a supplied constraint evaluation function with the
		* value and fails the conversion if the function returns either false
		* or Failure<T>.
		*
		* @param constraint Constraint evaluation function
		* {@inheritdoc Converter.withConstraint}
		*/
		withConstraint(constraint: (val: T) => boolean \| Result<T>, options?: ConstraintOptions): Converter<T, TC>;
		/**
		* Adds a brand to the type to prevent mismatched usage of simple types
		* {@inheritdoc Converter.withBrand}
		*/
		withBrand<B extends string>(brand: B): Converter<Brand<T, B>, TC>;
		/**
		* @internal
		*/
		protected _context(supplied?: TC): TC \| undefined;
		/**
		* @internal
		*/
		protected _traits(traits?: Partial<ConverterTraits>): ConverterTraits;
		/**
		* @internal
		*/
		protected _with(traits: Partial<ConverterTraits>): this;
		}
		export {};
		//# sourceMappingURL=converter.d.ts.map

105

converter.js

		@@ -27,6 +27,17 @@ "use strict";
		/**
		* Simple templated converter wrapper to simplify typed conversion from unknown.
		* Base templated wrapper to simplify creation of new {@link Converter}s.
		* @public
		*/
		class BaseConverter {
		/**
		* Constructs a new {@link Converter} which uses the supplied function to perform the conversion.
		* @param converter - The conversion function to be applied.
		* @param defaultContext - Optional conversion context to be used by default.
		* @param traits - Optional {@link ConverterTraits \| traits} to be assigned to the resulting
		* converter.
		*/
		constructor(converter, defaultContext, traits) {
		/**
		* @internal
		*/
		this._isOptional = false;
		@@ -39,6 +50,16 @@ this._converter = converter;
		/**
		* Converts from unknown to <T>
		* @param from The unknown to be converted
		* @returns An @see Result with a value or an error message
		* {@inheritdoc Converter.isOptional}
		*/
		get isOptional() {
		return this._isOptional;
		}
		/**
		* {@inheritdoc Converter.brand}
		*/
		get brand() {
		return this._brand;
		}
		/**
		* {@inheritdoc Converter.convert}
		*/
		convert(from, context) {
		@@ -48,10 +69,3 @@ return this._converter(from, this, context !== null && context !== void 0 ? context : this._defaultContext);
		/**
		* Converts from unknown to <T> or undefined, as appropriate.
		* If 'onError' is 'failOnError', the converter succeeds for
		* 'undefined' or any convertible value, but reports an error
		* if it encounters a value that cannot be converted. If 'onError'
		* is 'ignoreErrors' (default) then values that cannot be converted
		* result in a successful return of 'undefined'.
		* @param from The unknown to be converted
		* @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'
		* {@inheritdoc Converter.convertOptional}
		*/
		@@ -67,11 +81,4 @@ convertOptional(from, context, onError) {
		/**
		* Creates a converter for an optional value. If 'onError'
		* is 'failOnError', the converter accepts 'undefined' or a
		* convertible value, but reports an error if it encounters
		* a value that cannot be converted. If 'onError' is 'ignoreErrors'
		* then values that cannot be converted result in a
		* successful return of 'undefined'.
		*
		* @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'
		* */
		* {@inheritdoc Converter.optional}
		*/
		optional(onError) {
		@@ -84,17 +91,4 @@ return new BaseConverter((from, _self, context) => {
		/**
		* Reports whether this value is explicitly optional
		* {@inheritdoc Converter.map}
		*/
		get isOptional() {
		return this._isOptional;
		}
		/**
		* Reports the brand of a branded type.
		*/
		get brand() {
		return this._brand;
		}
		/**
		* Applies a (possibly) mapping conversion to the converted value.
		* @param mapper A function which maps from the converted type to some other type.
		*/
		map(mapper) {
		@@ -110,4 +104,3 @@ return new BaseConverter((from, _self, context) => {
		/**
		* Applies an additional converter to the converted value.
		* @param mapConverter The converter to be applied to the converted value
		* {@inheritdoc Converter.mapConvert}
		*/
		@@ -125,5 +118,3 @@ mapConvert(mapConverter) {
		/**
		* Maps the individual items of the resulting value with the supplied
		* map function. Fails if 'from' is not an array.
		* @param mapper The map function
		* {@inheritdoc Converter.mapItems}
		*/
		@@ -141,5 +132,3 @@ mapItems(mapper) {
		/**
		* Maps the individual items of the resulting value with the supplied
		* converter function. Fails if 'from' is not an array.
		* @param mapConverter The map
		* {@inheritdoc Converter.mapConvertItems}
		*/
		@@ -157,5 +146,3 @@ mapConvertItems(mapConverter) {
		/**
		* Applies a type guard to the conversion result.
		* @param guard The type guard function to apply
		* @param message Optional message to be reported on failure
		* {@inheritdoc Converter.withTypeGuard}
		*/
		@@ -171,7 +158,3 @@ withTypeGuard(guard, message) {
		/**
		* Applies a type guard to each member of the conversion result. Fails
		* if the conversion result is not an array or if any member fails the
		* type guard.
		* @param guard The type guard function to apply to each element
		* @param message Optional message to be reported on failure
		* {@inheritdoc Converter.withItemTypeGuard}
		*/
		@@ -192,8 +175,3 @@ withItemTypeGuard(guard, message) {
		/**
		* Creates a converter with an optional constraint. If the base converter
		* succeeds, calls a supplied constraint evaluation function with the
		* value and fails the conversion if the function returns either false
		* or Failure<T>.
		*
		* @param constraint Constraint evaluation function
		* {@inheritdoc Converter.withConstraint}
		*/
		@@ -217,3 +195,3 @@ withConstraint(constraint, options) {
		/**
		* Adds a brand to the type to prevent mismatched usage of simple types
		* {@inheritdoc Converter.withBrand}
		*/
		@@ -230,5 +208,11 @@ withBrand(brand) {
		}
		/**
		* @internal
		*/
		_context(supplied) {
		return supplied !== null && supplied !== void 0 ? supplied : this._defaultContext;
		}
		/**
		* @internal
		*/
		_traits(traits) {
		@@ -241,2 +225,5 @@ return {
		}
		/**
		* @internal
		*/
		_with(traits) {
		@@ -249,2 +236,2 @@ this._isOptional = (traits.isOptional === true);
		exports.BaseConverter = BaseConverter;
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"converter.js","sourceRoot":"","sources":["../src/converter.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2020 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nimport { Result, fail, mapResults, succeed } from './result';\n\ntype OnError = 'failOnError' | 'ignoreErrors';\n\n/**\n * Converter traits.\n */\nexport interface ConverterTraits {\n    readonly isOptional: boolean;\n    readonly brand?: string;\n}\n\n/**\n * Options for @see Converter @see withConstraint\n */\nexport interface ConstraintOptions {\n    /**\n     * Optional description for error messages when constraint\n     * function returns false.\n     */\n    readonly description: string;\n}\n\n/**\n * Helper type to brand a simple type to prevent inappropriate use\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport type Brand<T, B> = T & { __brand: B };\n\nexport interface Converter<T, TC=undefined> extends ConverterTraits {\n    /**\n     * Indicates whether this element is explicitly optional\n     */\n     readonly isOptional: boolean;\n\n     /**\n      * Returns the brand for a branded type\n      */\n     readonly brand?: string;\n\n     /**\n     * Converts from unknown to <T>\n     * @param from The unknown to be converted\n     * @param context An optional context applied to the conversion\n     * @returns An @see Result with a value or an error message\n     */\n    convert(from: unknown, context?: TC): Result<T>;\n\n    /**\n     * Converts from unknown to <T> or undefined, as appropriate.\n     * If 'onError' is 'failOnError', the converter succeeds for\n     * 'undefined' or any convertible value, but reports an error\n     * if it encounters a value that cannot be converted.  If 'onError'\n     * is 'ignoreErrors' (default) then values that cannot be converted\n     * result in a successful return of 'undefined'.\n     * @param from The unknown to be converted\n     * @param context Optional context for use by the converter\n     * @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'\n     */\n    convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T|undefined>;\n\n    /**\n     * Creates a converter for an optional value. If 'onError'\n     * is 'failOnError', the converter accepts 'undefined' or a\n     * convertible value, but reports an error if it encounters\n     * a value that cannot be converted.  If 'onError' is 'ignoreErrors'\n     * (default) then values that cannot be converted result in a\n     * successful return of 'undefined'.\n     *\n     * @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'\n     * */\n    optional(onError?: OnError): Converter<T|undefined, TC>;\n\n    /**\n     * Applies a (possibly) mapping conversion to the converted value.\n     * @param mapper A function which maps from the converted type to some other type.\n     */\n    map<T2>(mapper: (from: T) => Result<T2>): Converter<T2, TC>;\n\n    /**\n     * Applies an additional converter to the converted value.\n     * @param mapConverter The converter to be applied to the converted value\n     */\n    mapConvert<T2>(mapConverter: Converter<T2>): Converter<T2, TC>;\n\n    /**\n     * Maps the individual items of the resulting value with the supplied\n     * map function.  Fails if 'from' is not an array.\n     * @param mapper The map function\n     */\n    mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC>;\n\n    /**\n     * Maps the individual items of the resulting value with the supplied\n     * converter function.  Fails if 'from' is not an array.\n     * @param mapConverter The map\n     */\n     mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC>;\n\n     /**\n      * Applies a type guard to the conversion result.\n      * @param guard The type guard function to apply\n      * @param message Optional message to be reported on failure\n      */\n    withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI, TC>;\n\n     /**\n      * Applies a type guard to each member of the conversion result. Fails\n      * if the conversion result is not an array or if any member fails the\n      * type guard.\n      * @param guard The type guard function to apply to each element\n      * @param message Optional message to be reported on failure\n      */\n      withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI[], TC>;\n\n    /**\n     * Creates a converter with an optional constraint.  If the base converter\n     * succeeds, calls a supplied constraint evaluation function with the\n     * value and fails the conversion if the function returns either false\n     * or Failure<T>.\n     *\n     * @param constraint Constraint evaluation function\n     * @param options Options for constraint evaluation\n     */\n    withConstraint(\n        constraint: (val: T) => boolean|Result<T>,\n        options?: ConstraintOptions,\n    ): Converter<T, TC>;\n\n    /**\n     * Adds a brand to the type to prevent mismatched usage of simple types\n     */\n    withBrand<B extends string>(brand: B): Converter<Brand<T, B>, TC>;\n}\n\ntype InnerInferredType<TCONV> =\n    TCONV extends Converter<infer TTO>\n        ? (TTO extends Array<infer TTOELEM> ? InnerInferredType<TTOELEM>[] : TTO)\n        : (TCONV extends Array<infer TELEM> ? InnerInferredType<TELEM>[] : TCONV);\n\n/**\n * Infers the type that will be returned by an intstantiated converter.  Works\n * for complex as well as simple types.\n * @example Infer<typeof Converters.mapOf(Converters.stringArray)> is Map<string, string[]>\n */\nexport type Infer<TCONV> = TCONV extends Converter<infer TTO> ? InnerInferredType<TTO> : never;\n\n/**\n * Deprecated name for Infer<T> retained for compatibility\n * @deprecated use @see Infer instead\n */\nexport type ConvertedToType<TCONV> = Infer<TCONV>;\n\n/**\n * Simple templated converter wrapper to simplify typed conversion from unknown.\n */\nexport class BaseConverter<T, TC=undefined> implements Converter<T, TC> {\n    protected readonly _defaultContext?: TC;\n    protected _isOptional = false;\n    protected _brand?: string;\n\n    private readonly _converter: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>;\n\n    public constructor(\n        converter: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>,\n        defaultContext?: TC,\n        traits?: ConverterTraits,\n    ) {\n        this._converter = converter;\n        this._defaultContext = defaultContext;\n        this._isOptional = (traits?.isOptional === true);\n        this._brand = (traits?.brand);\n    }\n\n    /**\n     * Converts from unknown to <T>\n     * @param from The unknown to be converted\n     * @returns An @see Result with a value or an error message\n     */\n    public convert(from: unknown, context?: TC): Result<T> {\n        return this._converter(from, this, context ?? this._defaultContext);\n    }\n\n    /**\n     * Converts from unknown to <T> or undefined, as appropriate.\n     * If 'onError' is 'failOnError', the converter succeeds for\n     * 'undefined' or any convertible value, but reports an error\n     * if it encounters a value that cannot be converted.  If 'onError'\n     * is 'ignoreErrors' (default) then values that cannot be converted\n     * result in a successful return of 'undefined'.\n     * @param from The unknown to be converted\n     * @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'\n     */\n    public convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T|undefined> {\n        const result = this._converter(from, this, this._context(context));\n        if (result.isFailure()) {\n            onError = onError ?? 'ignoreErrors';\n            return ((from === undefined) || onError === 'ignoreErrors') ? succeed(undefined) : result;\n        }\n        return result;\n    }\n\n    /**\n     * Creates a converter for an optional value. If 'onError'\n     * is 'failOnError', the converter accepts 'undefined' or a\n     * convertible value, but reports an error if it encounters\n     * a value that cannot be converted.  If 'onError' is 'ignoreErrors'\n     * then values that cannot be converted result in a\n     * successful return of 'undefined'.\n     *\n     * @param onError Specifies handling of values that cannot be converted, default 'ignoreErrors'\n     * */\n    public optional(onError?: OnError): Converter<T|undefined, TC> {\n        return new BaseConverter((from: unknown, _self: Converter<T|undefined, TC>, context?: TC) => {\n            onError = onError ?? 'failOnError';\n            return this.convertOptional(from, this._context(context), onError);\n        })._with(this._traits({ isOptional: true }));\n    }\n\n    /**\n     * Reports whether this value is explicitly optional\n     */\n    public get isOptional(): boolean {\n        return this._isOptional;\n    }\n\n    /**\n     * Reports the brand of a branded type.\n     */\n    public get brand(): string|undefined {\n        return this._brand;\n    }\n\n    /**\n     * Applies a (possibly) mapping conversion to the converted value.\n     * @param mapper A function which maps from the converted type to some other type.\n     */\n    public map<T2>(mapper: (from: T) => Result<T2>): Converter<T2, TC> {\n        return new BaseConverter<T2, TC>((from: unknown, _self: Converter<T2, TC>, context?: TC) => {\n            const innerResult = this._converter(from, this, this._context(context));\n            if (innerResult.isSuccess()) {\n                return mapper(innerResult.value);\n            }\n            return fail(innerResult.message);\n        })._with(this._traits());\n    }\n\n    /**\n     * Applies an additional converter to the converted value.\n     * @param mapConverter The converter to be applied to the converted value\n     */\n    public mapConvert<T2>(mapConverter: Converter<T2>): Converter<T2, TC> {\n        return new BaseConverter<T2, TC>((from: unknown, _self: Converter<T2, TC>, context?: TC) => {\n            const innerResult = this._converter(from, this, this._context(context));\n            if (innerResult.isSuccess()) {\n                return mapConverter.convert(innerResult.value);\n            }\n            return fail(innerResult.message);\n        // eslint-disable-next-line no-return-assign\n        })._with(this._traits());\n    }\n\n    /**\n     * Maps the individual items of the resulting value with the supplied\n     * map function.  Fails if 'from' is not an array.\n     * @param mapper The map function\n     */\n    public mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC> {\n        return new BaseConverter<TI[], TC>((from: unknown, _self: Converter<TI[], TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((items) => {\n                if (Array.isArray(items)) {\n                    return mapResults(items.map((i) => mapper(i)));\n                }\n                return fail('Cannot map items - not an array');\n            });\n        });\n    }\n\n    /**\n     * Maps the individual items of the resulting value with the supplied\n     * converter function.  Fails if 'from' is not an array.\n     * @param mapConverter The map\n     */\n    public mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC> {\n        return new BaseConverter<TI[], TC>((from: unknown, _self: Converter<TI[], TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((items) => {\n                if (Array.isArray(items)) {\n                    return mapResults(items.map((i) => mapConverter.convert(i)));\n                }\n                return fail('Cannot map items - not an array');\n            });\n        });\n    }\n\n    /**\n     * Applies a type guard to the conversion result.\n     * @param guard The type guard function to apply\n     * @param message Optional message to be reported on failure\n     */\n    public withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI, TC> {\n        return new BaseConverter<TI, TC>((from: unknown, _self: Converter<TI, TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((inner) => {\n                message = message ?? 'invalid type';\n                return guard(inner) ? succeed(inner) : fail(`${message}: ${JSON.stringify(from)}`);\n            });\n        });\n    }\n\n    /**\n     * Applies a type guard to each member of the conversion result. Fails\n     * if the conversion result is not an array or if any member fails the\n     * type guard.\n     * @param guard The type guard function to apply to each element\n     * @param message Optional message to be reported on failure\n     */\n    public withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI[], TC> {\n        return new BaseConverter<TI[], TC>((from: unknown, _self: Converter<TI[], TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((items) => {\n                if (Array.isArray(items)) {\n                    return mapResults(items.map((i) => {\n                        message = message ?? 'invalid type';\n                        return guard(i) ? succeed(i) : fail(`${message}: ${JSON.stringify(from)}`);\n                    }));\n                }\n                return fail('Cannot guard item type - not an array');\n            });\n        });\n    }\n\n    /**\n     * Creates a converter with an optional constraint.  If the base converter\n     * succeeds, calls a supplied constraint evaluation function with the\n     * value and fails the conversion if the function returns either false\n     * or Failure<T>.\n     *\n     * @param constraint Constraint evaluation function\n     */\n    public withConstraint(\n        constraint: (val: T) => boolean|Result<T>,\n        options?: ConstraintOptions,\n    ): Converter<T, TC> {\n        return new BaseConverter<T, TC>((from: unknown, _self: Converter<T, TC>, context?: TC) => {\n            const result = this._converter(from, this, this._context(context));\n            if (result.isSuccess()) {\n                const constraintResult = constraint(result.value);\n                if (typeof constraintResult === 'boolean') {\n                    return constraintResult\n                        ? result\n                        : fail(\n                            `\"${JSON.stringify(result.value)}\": ${options?.description ?? 'does not meet constraint'}`\n                        );\n                }\n                return constraintResult;\n            }\n            return result;\n        })._with(this._traits());\n    }\n\n    /**\n     * Adds a brand to the type to prevent mismatched usage of simple types\n     */\n    public withBrand<B extends string>(brand: B): Converter<Brand<T, B>, TC> {\n        if (this._brand) {\n            throw new Error(`Cannot replace existing brand \"${this._brand}\" with \"${brand}\".`);\n        }\n\n        return new BaseConverter<Brand<T, B>, TC>((from: unknown, _self: Converter<T, TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((v) => {\n                return succeed(v as Brand<T, B>);\n            });\n        })._with(this._traits({ brand }));\n    }\n\n    protected _context(supplied?: TC): TC|undefined {\n        return supplied ?? this._defaultContext;\n    }\n\n    protected _traits(traits?: Partial<ConverterTraits>): ConverterTraits {\n        return {\n            isOptional: this.isOptional,\n            brand: this.brand,\n            ...(traits ?? {}),\n        };\n    }\n\n    protected _with(traits: Partial<ConverterTraits>): this {\n        this._isOptional = (traits.isOptional === true);\n        this._brand = (traits.brand);\n        return this;\n    }\n}\n"]}
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"converter.js","sourceRoot":"","sources":["../src/converter.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2020 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nimport { Result, fail, mapResults, succeed } from './result';\nimport { Brand } from './brand';\n\ntype OnError = 'failOnError' | 'ignoreErrors';\n\n/**\n * Converter traits.\n * @public\n */\nexport interface ConverterTraits {\n    readonly isOptional: boolean;\n    readonly brand?: string;\n}\n\n/**\n * Options for {@link Converter.withConstraint}.\n * @public\n */\nexport interface ConstraintOptions {\n    /**\n     * Optional description for error messages when constraint\n     * function returns false.\n     */\n    readonly description: string;\n}\n\n/**\n * Generic converter to convert unknown to a templated type `<T>`, using\n * intrinsic rules or as modified by an optional conversion context\n * of optional templated type `<TC>` (default `undefined`).\n * @public\n */\nexport interface Converter<T, TC=undefined> extends ConverterTraits {\n    /**\n     * Indicates whether this element is explicitly optional.\n     */\n     readonly isOptional: boolean;\n\n     /**\n      * Returns the brand for a branded type.\n      */\n     readonly brand?: string;\n\n     /**\n     * Converts from `unknown` to `<T>`.\n     * @param from - The `unknown` to be converted\n     * @param context - An optional conversion context of type `<TC>` to be used in\n     * the conversion.\n     * @returns A {@link Result} with a {@link Success} and a value on success or an\n     * {@link Failure} with a a message on failure.\n     */\n    convert(from: unknown, context?: TC): Result<T>;\n\n    /**\n     * Converts from `unknown` to `<T>` or `undefined`, as appropriate.\n     *\n     * @remarks\n     * If `onError` is `failOnError`, the converter succeeds for\n     * `undefined` or any convertible value, but reports an error\n     * if it encounters a value that cannot be converted.\n     *\n     * If `onError` is `ignoreErrors` (default) then values that\n     * cannot be converted result in a successful return of `undefined`.\n     * @param from - The `unknown` to be converted\n     * @param context - An optional conversion context of type `<TC>` to be used in\n     * the conversion.\n     * @param onError - Specifies handling of values that cannot be converted (default `ignoreErrors`).\n     * @returns A {@link Result} with a {@link Success} and a value on success or an\n     * {@link Failure} with a a message on failure.\n     */\n    convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T|undefined>;\n\n    /**\n     * Creates a {@link Converter} for an optional value.\n     *\n     * @remarks\n     * If `onError` is `failOnError`, the resulting converter will accept `undefined`\n     * or a convertible value, but report an error if it encounters a value that cannot be\n     * converted.\n     *\n     * If `onError` is `ignoreErrors` (default) then values that cannot be converted will\n     * result in a successful return of `undefined`.\n     *\n     * @param onError - Specifies handling of values that cannot be converted (default `ignoreErrors`).\n     * @returns A new {@link Converter} returning `<T|undefined>`.\n     * */\n    optional(onError?: OnError): Converter<T|undefined, TC>;\n\n    /**\n     * Creates a {@link Converter} which applies a (possibly) mapping conversion to\n     * the converted value of this {@link Converter}.\n     * @param mapper - A function which maps from the the result type `<T>` of this\n     * converter to a new result type `<T2>`.\n     * @returns A new {@link Converter} returning `<T2>`.\n     */\n    map<T2>(mapper: (from: T) => Result<T2>): Converter<T2, TC>;\n\n    /**\n     * Creates a {@link Converter} which applies an additional supplied\n     * converter to the result of this converter.\n     *\n     * @param mapConverter - The {@link Converter} to be applied to the\n     * converted result from this {@link Converter}.\n     * @returns A new {@link Converter} returning `<T2>`.\n     */\n    mapConvert<T2>(mapConverter: Converter<T2>): Converter<T2, TC>;\n\n    /**\n     * Creates a {@link Converter} which maps the individual items of a collection\n     * resulting from this {@link Converter} using the supplied map fuction.\n     *\n     * @remarks\n     * Fails if `from` is not an array.\n     *\n     * @param mapper - The map function to be applied to each element of the\n     * result of this {@link Converter}.\n     * @returns A new {@link Converter} returning `<TI[]>`.\n     */\n    mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC>;\n\n    /**\n     * Creates a {@link Converter} which maps the individual items of a collection\n     * resulting from this {@link Converter} using the supplied {@link Converter}.\n     *\n     * @remarks\n     * Fails if `from` is not an array.\n     *\n     * @param mapConverter - The {@link Converter} to be applied to each element of the\n     * result of this {@link Converter}.\n     * @returns A new {@link Converter} returning `<TI[]>`.\n     */\n     mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC>;\n\n     /**\n      * Creates a {@link Converter} which applies a supplied type guard to the conversion\n      * result.\n      * @param guard - The type guard function to apply.\n      * @param message - Optional message to be reported if the type guard fails.\n      * @returns A new {@link Converter} returning `<TI>`.\n      */\n    withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI, TC>;\n\n     /**\n      * Creates a {@link Converter} which applies a supplied type guard to each member of\n      * the conversion result from this converter.\n      *\n      * @remarks\n      * Fails if the conversion result is not an array or if any member fails the\n      * type guard.\n      * @param guard - The type guard function to apply to each element.\n      * @param message - Optional message to be reported if the type guard fails.\n      * @returns A new {@link Converter} returning `<TI>`.\n      */\n      withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI[], TC>;\n\n    /**\n     * Creates a {@link Converter} which applies an optional constraint to the result\n     * of this conversion.  If this {@link Converter} (the base converter) succeeds, the new\n     * converter calls a supplied constraint evaluation function with the conversion, which\n     * fails the entire conversion if the constraint function returns either `false` or\n     * {@link Failure | Failure<T>}.\n     *\n     * @param constraint - Constraint evaluation function.\n     * @param options - {@link ConstraintOptions | Options} for constraint evaluation.\n     * @returns A new {@link Converter} returning `<T>`.\n     */\n    withConstraint(\n        constraint: (val: T) => boolean|Result<T>,\n        options?: ConstraintOptions,\n    ): Converter<T, TC>;\n\n    /**\n     * returns a converter which adds a brand to the type to prevent mismatched usage\n     * of simple types.\n     * @param brand - The brand to be applied to the result value.\n     * @returns A {@link Converter} returning `Brand<T, B>`.\n     */\n    withBrand<B extends string>(brand: B): Converter<Brand<T, B>, TC>;\n}\n\n/**\n * internal\n */\ntype InnerInferredType<TCONV> =\n    TCONV extends Converter<infer TTO>\n        ? (TTO extends Array<infer TTOELEM> ? InnerInferredType<TTOELEM>[] : TTO)\n        : (TCONV extends Array<infer TELEM> ? InnerInferredType<TELEM>[] : TCONV);\n\n/**\n * Infers the type that will be returned by an intstantiated converter.  Works\n * for complex as well as simple types.\n * @example `Infer<typeof Converters.mapOf(Converters.stringArray)>` is `Map<string, string[]>`\n * @beta\n */\nexport type Infer<TCONV> = TCONV extends Converter<infer TTO> ? InnerInferredType<TTO> : never;\n\n/**\n * Deprecated name for Infer<T> retained for compatibility\n * @deprecated use @see Infer instead\n * @internal\n */\nexport type ConvertedToType<TCONV> = Infer<TCONV>;\n\n/**\n * Base templated wrapper to simplify creation of new {@link Converter}s.\n * @public\n */\nexport class BaseConverter<T, TC=undefined> implements Converter<T, TC> {\n    /**\n     * @internal\n     */\n    protected readonly _defaultContext?: TC;\n    /**\n     * @internal\n     */\n    protected _isOptional = false;\n    /**\n     * @internal\n     */\n    protected _brand?: string;\n\n    private readonly _converter: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>;\n\n    /**\n     * Constructs a new {@link Converter} which uses the supplied function to perform the conversion.\n     * @param converter - The conversion function to be applied.\n     * @param defaultContext - Optional conversion context to be used by default.\n     * @param traits - Optional {@link ConverterTraits | traits} to be assigned to the resulting\n     * converter.\n     */\n    public constructor(\n        converter: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>,\n        defaultContext?: TC,\n        traits?: ConverterTraits,\n    ) {\n        this._converter = converter;\n        this._defaultContext = defaultContext;\n        this._isOptional = (traits?.isOptional === true);\n        this._brand = (traits?.brand);\n    }\n\n    /**\n     * {@inheritdoc Converter.isOptional}\n     */\n    public get isOptional(): boolean {\n        return this._isOptional;\n    }\n\n    /**\n     * {@inheritdoc Converter.brand}\n     */\n    public get brand(): string|undefined {\n        return this._brand;\n    }\n\n    /**\n     * {@inheritdoc Converter.convert}\n     */\n    public convert(from: unknown, context?: TC): Result<T> {\n        return this._converter(from, this, context ?? this._defaultContext);\n    }\n\n    /**\n     * {@inheritdoc Converter.convertOptional}\n     */\n    public convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T|undefined> {\n        const result = this._converter(from, this, this._context(context));\n        if (result.isFailure()) {\n            onError = onError ?? 'ignoreErrors';\n            return ((from === undefined) || onError === 'ignoreErrors') ? succeed(undefined) : result;\n        }\n        return result;\n    }\n\n    /**\n     * {@inheritdoc Converter.optional}\n     */\n    public optional(onError?: OnError): Converter<T|undefined, TC> {\n        return new BaseConverter((from: unknown, _self: Converter<T|undefined, TC>, context?: TC) => {\n            onError = onError ?? 'failOnError';\n            return this.convertOptional(from, this._context(context), onError);\n        })._with(this._traits({ isOptional: true }));\n    }\n\n    /**\n     * {@inheritdoc Converter.map}\n     */\n    public map<T2>(mapper: (from: T) => Result<T2>): Converter<T2, TC> {\n        return new BaseConverter<T2, TC>((from: unknown, _self: Converter<T2, TC>, context?: TC) => {\n            const innerResult = this._converter(from, this, this._context(context));\n            if (innerResult.isSuccess()) {\n                return mapper(innerResult.value);\n            }\n            return fail(innerResult.message);\n        })._with(this._traits());\n    }\n\n    /**\n     * {@inheritdoc Converter.mapConvert}\n     */\n    public mapConvert<T2>(mapConverter: Converter<T2>): Converter<T2, TC> {\n        return new BaseConverter<T2, TC>((from: unknown, _self: Converter<T2, TC>, context?: TC) => {\n            const innerResult = this._converter(from, this, this._context(context));\n            if (innerResult.isSuccess()) {\n                return mapConverter.convert(innerResult.value);\n            }\n            return fail(innerResult.message);\n        // eslint-disable-next-line no-return-assign\n        })._with(this._traits());\n    }\n\n    /**\n     * {@inheritdoc Converter.mapItems}\n     */\n    public mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC> {\n        return new BaseConverter<TI[], TC>((from: unknown, _self: Converter<TI[], TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((items) => {\n                if (Array.isArray(items)) {\n                    return mapResults(items.map((i) => mapper(i)));\n                }\n                return fail('Cannot map items - not an array');\n            });\n        });\n    }\n\n    /**\n     * {@inheritdoc Converter.mapConvertItems}\n     */\n    public mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC> {\n        return new BaseConverter<TI[], TC>((from: unknown, _self: Converter<TI[], TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((items) => {\n                if (Array.isArray(items)) {\n                    return mapResults(items.map((i) => mapConverter.convert(i)));\n                }\n                return fail('Cannot map items - not an array');\n            });\n        });\n    }\n\n    /**\n     * {@inheritdoc Converter.withTypeGuard}\n     */\n    public withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI, TC> {\n        return new BaseConverter<TI, TC>((from: unknown, _self: Converter<TI, TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((inner) => {\n                message = message ?? 'invalid type';\n                return guard(inner) ? succeed(inner) : fail(`${message}: ${JSON.stringify(from)}`);\n            });\n        });\n    }\n\n    /**\n     * {@inheritdoc Converter.withItemTypeGuard}\n     */\n    public withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI[], TC> {\n        return new BaseConverter<TI[], TC>((from: unknown, _self: Converter<TI[], TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((items) => {\n                if (Array.isArray(items)) {\n                    return mapResults(items.map((i) => {\n                        message = message ?? 'invalid type';\n                        return guard(i) ? succeed(i) : fail(`${message}: ${JSON.stringify(from)}`);\n                    }));\n                }\n                return fail('Cannot guard item type - not an array');\n            });\n        });\n    }\n\n    /**\n     * {@inheritdoc Converter.withConstraint}\n     */\n    public withConstraint(\n        constraint: (val: T) => boolean|Result<T>,\n        options?: ConstraintOptions,\n    ): Converter<T, TC> {\n        return new BaseConverter<T, TC>((from: unknown, _self: Converter<T, TC>, context?: TC) => {\n            const result = this._converter(from, this, this._context(context));\n            if (result.isSuccess()) {\n                const constraintResult = constraint(result.value);\n                if (typeof constraintResult === 'boolean') {\n                    return constraintResult\n                        ? result\n                        : fail(\n                            `\"${JSON.stringify(result.value)}\": ${options?.description ?? 'does not meet constraint'}`\n                        );\n                }\n                return constraintResult;\n            }\n            return result;\n        })._with(this._traits());\n    }\n\n    /**\n     * {@inheritdoc Converter.withBrand}\n     */\n    public withBrand<B extends string>(brand: B): Converter<Brand<T, B>, TC> {\n        if (this._brand) {\n            throw new Error(`Cannot replace existing brand \"${this._brand}\" with \"${brand}\".`);\n        }\n\n        return new BaseConverter<Brand<T, B>, TC>((from: unknown, _self: Converter<T, TC>, context?: TC) => {\n            return this._converter(from, this, this._context(context)).onSuccess((v) => {\n                return succeed(v as Brand<T, B>);\n            });\n        })._with(this._traits({ brand }));\n    }\n\n    /**\n     * @internal\n     */\n    protected _context(supplied?: TC): TC|undefined {\n        return supplied ?? this._defaultContext;\n    }\n\n    /**\n     * @internal\n     */\n    protected _traits(traits?: Partial<ConverterTraits>): ConverterTraits {\n        return {\n            isOptional: this.isOptional,\n            brand: this.brand,\n            ...(traits ?? {}),\n        };\n    }\n\n    /**\n     * @internal\n     */\n    protected _with(traits: Partial<ConverterTraits>): this {\n        this._isOptional = (traits.isOptional === true);\n        this._brand = (traits.brand);\n        return this;\n    }\n}\n"]}

626

converters.d.ts

		@@ -7,3 +7,5 @@ import { BaseConverter, Converter, ConverterTraits } from './converter';
		/**
		* Options for @see StringConverter maching method
		* Options for {@link Converters.StringConverter \| StringConverter}
		* matching method
		* @public
		*/
		@@ -18,49 +20,60 @@ export interface StringMatchOptions {
		/**
		* The @see StringConverter class extends @see BaseConverter to provide string-specific helper
		* functions.
		* The {@link Converters.StringConverter \| StringConverter} class extends {@link BaseConverter}
		* to provide string-specific helper methods.
		* @public
		*/
		export declare class StringConverter<T extends string = string, TC = unknown> extends BaseConverter<T, TC> {
		/**
		* Construct a new @see StringConverter
		* @param defaultContext Optional context used by the conversion
		* @param traits Optional traits to be applied to the conversion
		* @param converter Optional converter to be used for the conversion
		* Construct a new {@link Converters.StringConverter \| StringConverter}.
		* @param defaultContext - Optional context used by the conversion.
		* @param traits - Optional traits to be applied to the conversion.
		* @param converter - Optional conversion function to be used for the conversion.
		*/
		constructor(defaultContext?: TC, traits?: ConverterTraits, converter?: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>);
		/**
		* @internal
		*/
		protected static _convert<T extends string>(from: unknown): Result<T>;
		/**
		* @internal
		*/
		protected static _wrap<T extends string, TC>(wrapped: StringConverter<T, TC>, converter: (from: T) => Result<T>, traits?: ConverterTraits): StringConverter<T, TC>;
		/**
		* Returns a @see StringConverter which constrains the result to match a supplied
		* string.
		* @param match The string to be matched
		* @param options Optional @see StringMatchOptions for this conversion
		* @returns @see Success with a matching string or @see Failure with an informative
		* Returns a {@link Converters.StringConverter \| StringConverter} which constrains the result to match
		* a supplied string.
		* @param match - The string to be matched
		* @param options - Optional {@link Converters.StringMatchOptions} for this conversion.
		* @returns {@link Success} with a matching string or {@link Failure} with an informative
		* error if the string does not match.
		* {@label string}
		*/
		matching(match: string, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
		/**
		* Returns a @see StringConverter which constrains the result to match one of a supplied
		* array of strings.
		* @param match The array to be searched
		* @param options Optional @see StringMatchOptions for this conversion
		* @returns @see Success with a matching string or @see Failure with an informative
		* Returns a {@link Converters.StringConverter \| StringConverter} which constrains the result to match
		* one of a supplied array of strings.
		* @param match - The array of allowed strings.
		* @param options - Optional {@link Converters.StringMatchOptions} for this conversion.
		* @returns {@link Success} with a matching string or {@link Failure} with an informative
		* error if the string does not match.
		* {@label array}
		*/
		matching(match: string[], options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
		/**
		* Returns a @see StringConverter which constrains the result to match one of a supplied
		* Set of strings.
		* @param match The Set to be tested
		* @param options Optional @see StringMatchOptions for this conversion
		* @returns @see Success with a matching string or @see Failure with an informative
		* Returns a {@link Converters.StringConverter \| StringConverter} which constrains the result to match
		* one of a supplied `Set` of strings.
		* @param match - The `Set` of allowed strings.
		* @param options - Optional {@link Converters.StringMatchOptions} for this conversion.
		* @returns {@link Success} with a matching string or {@link Failure} with an informative
		* error if the string does not match.
		* {@label set}
		*/
		matching(match: Set<T>, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
		/**
		* Returns a @see StringConverter which constrains the result to match a supplied regular
		* expression.
		* @param match The @see RegExp to be tested
		* @param options Optional @see StringMatchOptions for this conversion
		* @returns @see Success with a matching string or @see Failure with an informative
		* Returns a {@link Converters.StringConverter \| StringConverter} which constrains the result to match
		* a supplied regular expression.
		* @param match - The regular expression to be used as a constraint.
		* @param options - Optional {@link Converters.StringMatchOptions} for this conversion
		* @returns {@link Success} with a matching string or {@link Failure} with an informative
		* error if the string does not match.
		* {@label regexp}
		*/
		@@ -72,31 +85,47 @@ matching(match: RegExp, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
		* string succeed. Anything else fails.
		* @public
		*/
		export declare const string: StringConverter<string, unknown>;
		/**
		* Helper function to create a converter which converts unknown to string, applying
		* template conversions supplied at construction time or at runtime as context.
		* @param defaultContext optional default context to use for template values
		* Helper function to create a {@link Converters.StringConverter \| StringConverter} which converts
		* `unknown` to `string`, applying template conversions supplied at construction time or at
		* runtime as context.
		* @remarks
		* Template conversions are applied using `mustache` syntax.
		* @param defaultContext - Optional default context to use for template values.
		* @returns A new {@link Converter} returning `string`.
		* @public
		*/
		export declare function templateString(defaultContext?: unknown): StringConverter<string, unknown>;
		/**
		* A converter to convert unknown to one of a set of supplied enumerated values. Anything else fails.
		* Helper function to create a {@link Converter} which converts `unknown` to one of a set of supplied
		* enumerated values. Anything else fails.
		*
		* @remarks
		* Allowed enumerated values can also be supplied as context at conversion time.
		* @param values Array of allowed values
		* @param values - Array of allowed values.
		* @returns A new {@link Converter} returning `<T>`.
		* @public
		*/
		export declare function enumeratedValue<T>(values: T[]): Converter<T, T[]>;
		/**
		* Converts unknown to one of a set of supplied enumerated values, mapping any of multiple supplied
		* values to the enumeration. Enables mapping of multiple input values to a consistent internal
		* representation (so e.g. 'y', 'yes', 'true' and true can all map to boolean true)
		* @param map An array of tuples describing the mapping. The first element of each tuple is the result
		* Helper function to create a {@link Converter} which converts `unknown` to one of a set of supplied enumerated
		* values, mapping any of multiple supplied values to the enumeration.
		* @remarks
		* Enables mapping of multiple input values to a consistent internal representation (so e.g. `'y'`, `'yes'`,
		* `'true'`, `1` and `true` can all map to boolean `true`)
		* @param map - An array of tuples describing the mapping. The first element of each tuple is the result
		* value, the second is the set of values that map to the result. Tuples are evaluated in the order
		* supplied and are not checked for duplicates.
		* @param message an optional error message
		* @returns The mapped value
		* @param message - An optional error message.
		* @returns A {@link Converter} which applies the mapping and yields `<T>` on success.
		* @public
		*/
		export declare function mappedEnumeratedValue<T>(map: [T, unknown[]][], message?: string): Converter<T, undefined>;
		/**
		* A converter to convert unknown to some value. Succeeds with the supplied value if an identity
		* comparison succeeds, fails otherwise.
		* @param value The value to be compared
		* Helper function to create a {@link Converter} which converts `unknown` to some supplied literal value. Succeeds with
		* the supplied value if an identity comparison succeeds, fails otherwise.
		* @param value - The value to be compared.
		* @returns A {@link Converter} which returns the supplied value on success.
		* @public
		*/
		@@ -106,185 +135,275 @@ export declare function literal<T>(value: T): Converter<T, unknown>;
		* Deprecated alias for @see literal
		* @param value The value to be compared
		* @deprecated use literal instead
		* @param value - The value to be compared.
		* @deprecated Use {@link Converters.literal} instead.
		* @internal
		*/
		export declare const value: typeof literal;
		/**
		* A converter to convert unknown to a number. Numbers and strings
		* with a numeric format succeed. Anything else fails.
		* A {@link Converter} which converts `unknown` to a `number`.
		* @remarks
		* Numbers and strings with a numeric format succeed. Anything else fails.
		* @public
		*/
		export declare const number: BaseConverter<number, undefined>;
		/**
		* A converter to convert unknown to boolean. Boolean values or the
		* case-insensitive strings 'true' and 'false' succeed. Anything
		* else fails.
		* A {@link Converter} which converts `unknown` to `boolean`.
		* @remarks
		* Boolean values or the case-insensitive strings `'true'` and `'false'` succeed.
		* Anything else fails.
		* @public
		*/
		export declare const boolean: BaseConverter<boolean, undefined>;
		/**
		* A converter to convert an optional string value. Values of type string
		* are returned. Anything else returns success with an undefined value.
		* A {@link Converter} which converts an optional `string` value. Values of type
		* `string` are returned. Anything else returns {@link Success} with value `undefined`.
		* @public
		*/
		export declare const optionalString: Converter<string \| undefined, unknown>;
		/**
		* Creates a converter which converts any string into an array of strings
		* by separating at a supplied delimiter. Delimeter may also be supplied
		* as context at conversion time.
		* @param delimiter The delimiter at which to split.
		* Helper function to create a {@link Converter} which converts any `string` into an
		* array of `string`, by separating at a supplied delimiter.
		* @remarks
		* Delimeter may also be supplied as context at conversion time.
		* @param delimiter - The delimiter at which to split.
		* @returns A new {@link Converter} returning `string[]`.
		* @public
		*/
		export declare function delimitedString(delimiter: string, options?: 'filtered' \| 'all'): Converter<string[], string>;
		/**
		* A converter to convert an iso formatted string, a number or a Date object to a Date object
		* A {@link Converter} which converts an iso formatted string, a number or a `Date` object to
		* a `Date` object.
		* @public
		*/
		export declare const isoDate: BaseConverter<Date, undefined>;
		/**
		* A converter to convert an optional number value. Values of type number
		* or numeric strings are converted and returned. Anything else returns
		* success with an undefined value.
		* A {@link Converter} which converts an optional `number` value.
		* @remarks
		* Values of type `number` or numeric strings are converted and returned.
		* Anything else returns {@link Success} with value `undefined`.
		* @public
		*/
		export declare const optionalNumber: Converter<number \| undefined, undefined>;
		/**
		* A converter to convert an optional boolean value. Values of type boolean
		* or strings that match (case-insensitive) 'true' or 'false' are converted
		* and returned. Anything else returns success with an undefined value.
		* A {@link Converter} to convert an optional `boolean` value.
		* @remarks
		* Values of type `boolean` or strings that match (case-insensitive) `'true'`
		* or `'false'` are converted and returned. Anything else returns {@link Success}
		* with value `undefined`.
		* @public
		*/
		export declare const optionalBoolean: Converter<boolean \| undefined, undefined>;
		/**
		* A helper wrapper for polymorphic fields. Invokes the wrapped converters
		* in sequence, returning the first successful result. Returns an error
		* if none of the supplied converters can convert the value.
		*
		* If onError is 'ignoreErrors' (default), then errors from any of the
		* A helper function to create a {@link Converter} for polymorphic values. Returns a
		* converter which Invokes the wrapped converters in sequence, returning the first successful
		* result. Returns an error if none of the supplied converters can convert the value.
		* @remarks
		* If `onError` is `ignoreErrors` (default), then errors from any of the
		* converters are ignored provided that some converter succeeds. If
		* onError is 'failOnError', then an error from any converter fails the entire
		* onError is `failOnError`, then an error from any converter fails the entire
		* conversion.
		*
		* @param converters An ordered list of converters to be considered
		* @param onError Specifies treatment of unconvertable elements
		* @param converters - An ordered list of {@link Converter \| converters} to be considered.
		* @param onError - Specifies treatment of unconvertable elements.
		* @returns A new {@link Converter} which yields a value from the union of the types returned
		* by the wrapped converters.
		* @public
		*/
		export declare function oneOf<T, TC = unknown>(converters: Array<Converter<T, TC>>, onError?: OnError): Converter<T, TC>;
		/**
		* A helper wrapper for converting an array of <T>. If onError is 'failOnError' (default),
		* then the entire conversion fails if any element cannot be converted. If onError
		* is 'ignoreErrors', failing elements are silently ignored.
		* @param converter Converter used to convert each item in the array
		* @param ignoreErrors Specifies treatment of unconvertable elements
		* A helper function to create a {@link Converter} which converts `unknown` to an array of `<T>`.
		* @remarks
		* If `onError` is `'failOnError'` (default), then the entire conversion fails if any element cannot
		* be converted. If `onError` is `'ignoreErrors'`, then failing elements are silently ignored.
		* @param converter - {@link Converter} used to convert each item in the array.
		* @param ignoreErrors - Specifies treatment of unconvertable elements.
		* @returns A {@link Converter} which returns an array of `<T>`.
		* @public
		*/
		export declare function arrayOf<T, TC = undefined>(converter: Converter<T, TC>, onError?: OnError): Converter<T[], TC>;
		/**
		* A helper wrapper for converting to Itemrray<T>. If onError is 'failOnError' (default),
		* then the entire conversion fails if any element cannot be converted. If onError
		* is 'ignoreErrors', failing elements are silently ignored.
		* @param converter Converter used to convert each item in the array
		* @param ignoreErrors Specifies treatment of unconvertable elements
		* A helper function to create a {@link Converter} which converts `unknown` to {@link ExtendedArray \| ExtendedArray<T>}.
		* @remarks
		* If `onError` is `'failOnError'` (default), then the entire conversion fails if any element cannot
		* be converted. If `onError` is `'ignoreErrors'`, then failing elements are silently ignored.
		* @param converter - {@link Converter} used to convert each item in the array
		* @param ignoreErrors - Specifies treatment of unconvertable elements
		* @beta
		*/
		export declare function extendedArrayOf<T, TC = undefined>(label: string, converter: Converter<T, TC>, onError?: OnError): Converter<ExtendedArray<T>, TC>;
		/**
		* Converter to convert an unknown to an array of strings. Conversion succeeds
		* and returns the supplied value if it as an array of strings, fails otherwise.
		* {@link Converter} to convert an `unknown` to an array of `string`.
		* @remarks
		* Returns {@link Success} with the the supplied value if it as an array
		* of strings, returns {@link Failure} with an error message otherwise.
		* @public
		*/
		export declare const stringArray: Converter<string[], unknown>;
		/**
		* Converter to convert an unknown to an array of numbers. Conversion succeeds
		* and returns the supplied value if it as an array of numbers, fails otherwise.
		* {@link Converter} to convert an `unknown` to an array of `number`.
		* @remarks
		* Returns {@link Success} with the the supplied value if it as an array
		* of numbers, returns {@link Failure} with an error message otherwise.
		* @public
		*/
		export declare const numberArray: Converter<number[], undefined>;
		/**
		* Options for 'recordOf' and 'mapOf' converters
		* Options for {@link Converters.(recordOf:withOptions)} and {@link Converters.(mapOf:withOptions)}
		* helper functions.
		* @public
		*/
		export interface KeyedConverterOptions<T extends string = string, TC = undefined> {
		/**
		* if `onError` is `'fail'` (default), then the entire conversion fails if any key or element
		* cannot be converted. If `onError` is `'ignore'`, failing elements are silently ignored.
		*/
		onError?: 'fail' \| 'ignore';
		/**
		* If present, `keyConverter` is used to convert the source object property names to
		* keys in the resulting map or record.
		* @remarks
		* Can be used to coerce key names to supported values and/or strong types.
		*/
		keyConverter?: Converter<T, TC>;
		}
		/**
		* A helper wrapper to convert the string-keyed properties of an object to a Record of T.
		* Conversion fails if any element cannot be converted. If onError is 'ignore' failing
		* elements are silently ignored.
		* @param converter Converter used to convert each item in the record
		* A helper function to create a {@link Converter} which converts the `string`-keyed properties
		* using a supplied {@link Converter \| Converter<T>} to produce a `Record<string, T>`.
		* @remarks
		* The resulting converter fails conversion if any element cannot be converted.
		* @param converter - {@link Converter} used to convert each item in the source object.
		* @returns A {@link Converter} which returns `Record<string, T>`.
		* {@label default}
		* @public
		*/
		export declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>): Converter<Record<TK, T>, TC>;
		/**
		* A helper wrapper to convert the string-keyed properties of an object to a Record of T.
		* If onError is 'fail' (default), then the entire conversion fails if any element
		* cannot be converted. If onError is 'ignore' failing elements are silently ignored.
		* @param converter Converter used to convert each item in the record
		* @param onError Specifies treatment of unconvertable elements
		* A helper function to create a {@link Converter} which converts the `string`-keyed properties
		* using a supplied {@link Converter \| Converter<T>} to produce a `Record<string, T>` and optionally
		* specified handling of elements that cannot be converted.
		* @remarks
		* if `onError` is `'fail'` (default), then the entire conversion fails if any key or element
		* cannot be converted. If `onError` is `'ignore'`, failing elements are silently ignored.
		* @param converter - {@link Converter} used to convert each item in the source object.
		* @returns A {@link Converter} which returns `Record<string, T>`.
		* {@label withOnError}
		* @public
		*/
		export declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, onError: 'fail' \| 'ignore'): Converter<Record<TK, T>, TC>;
		/**
		* A helper wrapper to convert the string-keyed properties of an object to a Record of T.
		* If options specify a key converter it will be applied to each key.
		* If onError is 'fail' (default), then the entire conversion fails if any key or element
		* cannot be converted. If onError is 'ignore' failing elements are silently ignored.
		* @param converter Converter used to convert each item in the record
		* @param options Optional @see KeyedConverterOptions
		* A helper function to create a {@link Converter} which converts the `string`-keyed properties
		* using a supplied {@link Converter \| Converter<T>} to produce a `Record<TK, T>`.
		* @remarks
		* If present, the supplied {@link Converters.KeyedConverterOptions \| options} can provide a strongly-typed
		* converter for keys and/or control the handling of elements that fail conversion.
		* @param converter - {@link Converter} used to convert each item in the source object.
		* @param options - Optional {@link Converters.KeyedConverterOptions \| KeyedConverterOptions<TK, TC>} which
		* supplies a key converter and/or error-handling options.
		* @returns A {@link Converter} which returns `Record<TK, T>`.
		* {@label withOptions}
		* @public
		*/
		export declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, options: KeyedConverterOptions<TK, TC>): Converter<Record<TK, T>, TC>;
		/**
		* A helper wrapper to convert the string-keyed properties of an object to a Map of T.
		* Conversion fails if any element cannot be converted.
		* @param converter Converter used to convert each item in the map
		* A helper function to create a {@link Converter} which converts the `string`-keyed properties
		* using a supplied {@link Converter \| Converter<T>} to produce a `Map<string, T>`.
		* @remarks
		* The resulting converter fails conversion if any element cannot be converted.
		* @param converter - {@link Converter} used to convert each item in the source object.
		* @returns A {@link Converter} which returns `Map<string, T>`.
		* {@label default}
		* @public
		*/
		export declare function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>): Converter<Map<TK, T>, TC>;
		/**
		* A helper wrapper to convert the string-keyed properties of an object to a Map of T.
		* If onError is 'fail' (default), then the entire conversion fails if any element
		* cannot be converted. If onError is 'ignore' failing elements are silently ignored.
		* @param converter Converter used to convert each item in the map
		* @param onError Specifies treatment of unconvertable elements
		* A helper function to create a {@link Converter} which converts the `string`-keyed properties
		* using a supplied {@link Converter \| Converter<T>} to produce a `Map<string, T>` and optionally
		* specified handling of elements that cannot be converted.
		* @remarks
		* if `onError` is `'fail'` (default), then the entire conversion fails if any key or element
		* cannot be converted. If `onError` is `'ignore'`, failing elements are silently ignored.
		* @param converter - {@link Converter} used to convert each item in the source object.
		* @returns A {@link Converter} which returns `Map<string, T>`.
		* {@label withOnError}
		* @public
		*/
		export declare function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, onError: 'fail' \| 'ignore'): Converter<Map<TK, T>, TC>;
		/**
		* A helper wrapper to convert the string-keyed properties of an object to a Map of T.
		* If options specify a key converter it will be applied to each key.
		* If onError is 'fail' (default), then the entire conversion fails if any key or element
		* cannot be converted. If onError is 'ignore' failing elements are silently ignored.
		* @param converter Converter used to convert each item in the map
		* @param options Optional @see KeyedConverterOptions
		* A helper function to create a {@link Converter} which converts the `string`-keyed properties
		* using a supplied {@link Converter \| Converter<T>} to produce a `Map<TK, T>`.
		* @remarks
		* If present, the supplied {@link Converters.KeyedConverterOptions \| options} can provide a strongly-typed
		* converter for keys and/or control the handling of elements that fail conversion.
		* @param converter - {@link Converter} used to convert each item in the source object.
		* @param options - Optional {@link Converters.KeyedConverterOptions \| KeyedConverterOptions<TK, TC>} which
		* supplies a key converter and/or error-handling options.
		* @returns A {@link Converter} which returns `Map<TK, T>`.
		* {@label withOptions}
		* @public
		*/
		export declare function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, options: KeyedConverterOptions<TK, TC>): Converter<Map<TK, T>, TC>;
		/**
		* Gets a converter which validates that a supplied value is of a type validated by
		* a supplied validator and returns it.
		* @param validator A validator function to determine if the converted value is valid
		* @param description A description of the validate type for use in error messages
		* @returns If validator returns true, suceeds with from coerced to T. Fails with an error
		* message otherwise.
		* Helper function to create a {@link Converter} which validates that a supplied value is
		* of a type validated by a supplied validator function and returns it.
		* @remarks
		* If `validator` succeeds, this {@link Converter} returns {@link Success} with the supplied
		* value of `from` coerced to type `<T>`. Returns a {@link Failure} with additional
		* information otherwise.
		* @param validator - A validator function to determine if the converted value is valid.
		* @param description - A description of the validated type for use in error messages.
		* @returns A new {@link Converter \| Converter<T>} which applies the supplied validation.
		* @public
		*/
		export declare function validateWith<T, TC = undefined>(validator: (from: unknown) => from is T, description?: string): Converter<T, TC>;
		/**
		* A helper function to extract and convert an element from an array. Succeeds and returns
		* the converted value if the element exists in the supplied parameter and can be converted.
		* Fails otherwise.
		* @param index The index of the field to be extracted.
		* @param converter Converter used to convert the extracted element.
		* A helper function to create a {@link Converter} which extracts and converts an element from an array.
		* @remarks
		* The returned {@link Converter} returns {@link Success} with the converted value if the element exists
		* in the supplied array and can be converted. Returns {@link Failure} with an error message otherwise.
		* @param index - The index of the element to be extracted.
		* @param converter - A {@link Converter} used to convert the extracted element.
		* @returns A {@link Converter \| Converter<T>} which extracts the specified element from an array.
		* @public
		*/
		export declare function element<T, TC = undefined>(index: number, converter: Converter<T, TC>): Converter<T, TC>;
		/**
		* A helper function to extract and convert an optional element from an array. Succeeds
		* and returns the converted value if the element exists in the supplied parameter and can
		* be converted. Succeeds with undefined if the parameter is an array but the index is too
		* large. Fails if the supplied parameter is not an array, if the requested index is negative,
		* or if the element cannot be converted.
		* @param name The name of the field to be extracted.
		* @param converter Converter used to convert the extracted field.
		* A helper function to create a {@link Converter} which extracts and converts an optional element from an array.
		* @remarks
		* The resulting {@link Converter} returns {@link Success} with the converted value if the element exsist
		* in the supplied array and can be converted. Returns {@link Success} with value `undefined` if the parameter
		* is an array but the index is out of range. Returns {@link Failure} with a message if the supplied parameter
		* is not an array, if the requested index is negative, or if the element cannot be converted.
		* @param index - The index of the element to be extracted.
		* @param converter - A {@link Converter} used to convert the extracted element.
		* @returns A {@link Converter \| Converter<T>} which extracts the specified element from an array.
		* @public
		*/
		export declare function optionalElement<T, TC = undefined>(index: number, converter: Converter<T, TC>): Converter<T \| undefined, TC>;
		/**
		* A helper function to extract and convert a field from an object. Succeeds and returns
		* the converted value if the field exists in the supplied parameter and can be converted.
		* Fails otherwise.
		* @param name The name of the field to be extracted.
		* @param converter Converter used to convert the extracted field.
		* A helper function to create a {@link Converter} which extracts and convert a property specified
		* by name from an object.
		* @remarks
		* The resulting {@link Converter} returns {@link Success} with the converted value of the correpsonding
		* object property if the field exists and can be converted. Returns {@link Failure} with an error message
		* otherwise.
		* @param name - The name of the field to be extracted.
		* @param converter - {@link Converter} used to convert the extracted field.
		* @public
		*/
		export declare function field<T, TC = undefined>(name: string, converter: Converter<T, TC>): Converter<T, TC>;
		/**
		* A helper function to extract and convert an optional field from an object. Succeeds
		* and returns the converted value if the field exists in the supplied parameter and can
		* be converted. Succeeds with undefined if the parameter is an object but the named field
		* is not present. Fails if the supplied parameter is not an object.
		* @param name The name of the field to be extracted.
		* @param converter Converter used to convert the extracted field.
		* A helper function to create a {@link Converter} which extracts and convert a property specified
		* by name from an object.
		* @remarks
		* The resulting {@link Converter} returns {@link Success} with the converted value of the correpsonding
		* object property if the field exists and can be converted. Returns {@link Success} with value `undefined`
		* if the supplied parametr is an object but the named field is not present. Returns {@link Failure} with
		* an error message otherwise.
		* @param name - The name of the field to be extracted.
		* @param converter - {@link Converter} used to convert the extracted field.
		* @public
		*/
		export declare function optionalField<T, TC = undefined>(name: string, converter: Converter<T, TC>): Converter<T \| undefined, TC>;
		/**
		* Options for an @see ObjectConverter.
		* Options for an {@link Converters.ObjectConverter \| ObjectConverter}.
		* @public
		*/
		@@ -304,2 +423,5 @@ export interface ObjectConverterOptions<T> {
		* Per-property converters for each of the properties in type T.
		* @remarks
		* Used to construct a {@link Converters.ObjectConverter \| ObjectConverter}
		* @public
		*/
		@@ -310,79 +432,183 @@ export declare type FieldConverters<T, TC = unknown> = {
		/**
		* Converter to convert an object of type T without changing shape, given a @see FieldConverters<T>.
		* If all of the required fields exist and can be converted, returns a new object with the converted
		* values under the original key names. If any required fields do not exist or cannot be converted,
		* the entire conversion fails. See @see ObjectConverterOptions for other conversion options.
		* A {@link Converter} which converts an object of type `<T>` without changing shape, given
		* a {@link Converters.FieldConverters \| FieldConverters<T>} for the fields in the object.
		* @remarks
		* By default, if all of the required fields exist and can be converted, returns a new object with
		* the converted values under the original key names. If any required fields do not exist or cannot
		* be converted, the entire conversion fails. See {@link Converters.ObjectConverterOptions \| ObjectConverterOptions}
		* for other conversion options.
		* @public
		*/
		export declare class ObjectConverter<T, TC = unknown> extends BaseConverter<T, TC> {
		/**
		* Fields converted by this {@link Converters.ObjectConverter \| ObjectConverter}.
		*/
		readonly fields: FieldConverters<T>;
		/**
		* Options used to initialize this {@link Converters.ObjectConverter \| ObjectConverter}.
		*/
		readonly options: ObjectConverterOptions<T>;
		/**
		* Constructs a new @see ObjectConverter<T> using options supplied in an
		* optional @see ObjectConverterOptions<T>.
		* @param fields A @see FieldConverters<T> containing converters for each field
		* @param options An optional @see ObjectConverterOptions to configure the conversion
		* Constructs a new {@link Converters.ObjectConverter \| ObjectConverter<T>} using options
		* supplied in a {@link Converters.ObjectConverterOptions \| ObjectConverterOptions<T>}.
		* @param fields - A {@link Converters.FieldConverters \| FieldConverters<T>} containing
		* a {@link Converter} for each field
		* @param options - An optional @see ObjectConverterOptions to configure the conversion
		* {@label withOptions}
		*/
		constructor(fields: FieldConverters<T, TC>, options?: ObjectConverterOptions<T>);
		/**
		* Constructs a new @see ObjectConverter<T> using optional fields supplied in an
		* optional array of keyof T.
		* @param fields A @see FieldConverters<T> containing converters for each field
		* @param optional An optional array of keyof T listing fields that are not required.
		* Constructs a new {@link Converters.ObjectConverter \| ObjectConverter<T>} with optional
		* properties specified as an array of `keyof T`.
		* @param fields - A {@link Converters.FieldConverters \| FieldConverters<T>} containing
		* a {@link Converter} for each field.
		* @param optional - An array of `keyof T` listing fields that are not required.
		* {@label withKeys}
		*/
		constructor(fields: FieldConverters<T, TC>, optional?: (keyof T)[]);
		/**
		* Creates a new {@link Converters.ObjectConverter \| ObjectConverter} derived from this one but with
		* new optional properties as specified by a supplied {@link Converters.ObjectConverterOptions \| ObjectConverterOptions<T>}.
		* @param options - The {@link Converters.ObjectConverterOptions \| options} to be applied to the new
		* converter.
		* @returns A new {@link Converters.ObjectConverter \| ObjectConverter} with the additional optional source properties.
		* {@label withOptions}
		*/
		partial(options: ObjectConverterOptions<T>): ObjectConverter<Partial<T>, TC>;
		/**
		* Creates a new {@link Converters.ObjectConverter \| ObjectConverter} derived from this one but with
		* new optional properties as specified by a supplied array of `keyof T`.
		* @param optional - The keys of the source object properties to be made optional.
		* @returns A new {@link Converters.ObjectConverter \| ObjectConverter} with the additional optional source
		* properties.
		* {@label withKeys}
		*/
		partial(optional?: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
		addPartial(addOptionalFields: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
		/**
		* Creates a new {@link Converters.ObjectConverter \| ObjectConverter} derived from this one but with
		* new optional properties as specified by a supplied array of `keyof T`.
		* @param addOptionalProperties - The keys to be made optional.
		* @returns A new {@link Converters.ObjectConverter \| ObjectConverter} with the additional optional source
		* properties.
		*/
		addPartial(addOptionalProperties: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
		}
		/**
		* Helper to convert an object without changing shape. The source parameter is an object with
		* key names that correspond to the target object and the appropriate corresponding converter
		* as the property value. If all of the requested fields exist and can be converted, returns a
		* new object with the converted values under the original key names. If any fields do not exist
		* or cannot be converted, the entire conversion fails.
		* Helper function to create a {@link Converters.ObjectConverter \| ObjectConverter<T>} which converts an object
		* without changing shape, given a {@link Converters.FieldConverters \| FieldConverters<T>} and an optional
		* {@link Converters.ObjectConverterOptions \| ObjectConverterOptions<T>} to further refine conversion beavior.
		* @remarks
		* By default, if all of the requested fields exist and can be converted, returns {@link Success}
		* with a new object that contains the converted values under the original key names. If any requried properties
		* do not exist or cannot be converted, the entire conversion fails, returning {@link Failure} with additional
		* error information.
		*
		* Fields that succeed but convert to undefined are omitted from the result object but do not
		* fail the conversion.
		* @param fields An object containing defining the shape and converters to be applied.
		* @param opt An @see ObjectConverterOptions<T> containing options for the object converter, or
		* an array of (keyof T) containing optional keys.
		* @param properties - An {@link Converters.FieldConverters \| FieldConverters<T>} defining the shape of the
		* source object and {@link Converter \| converters} to be applied to each properties.
		* @param options - An {@link Converters.ObjectConverterOptions \| ObjectConverterOptions<T>} containing options
		* for the object converter.
		* @returns A new {@link Converters.ObjectConverter \| ObjectConverter} which applies the specified conversions.
		* {@label withOptions}
		* @public
		*/
		export declare function object<T>(fields: FieldConverters<T>, opt?: (keyof T)[] \| ObjectConverterOptions<T>): ObjectConverter<T>;
		export declare function object<T>(properties: FieldConverters<T>, options?: ObjectConverterOptions<T>): ObjectConverter<T>;
		/**
		* Helper to convert an object without changing shape. The source parameter is an object with
		* key names that correspond to the target object and the appropriate corresponding converter
		* as the property value. If all of the requested fields exist and can be converted, returns a
		* new object with the converted values under the original key names. If any fields do not exist
		* or cannot be converted, the entire conversion fails.
		* Helper function to create a {@link Converters.ObjectConverter \| ObjectConverter<T>} which converts an object
		* without changing shape, given a {@link Converters.FieldConverters \| FieldConverters<T>} and a set of
		* optional properties.
		* @remarks
		* By default, if all of the requested fields exist and can be converted, returns {@link Success}
		* with a new object that contains the converted values under the original key names. If any requried properties
		* do not exist or cannot be converted, the entire conversion fails, returning {@link Failure} with additional
		* error information.
		*
		* Fields that succeed but convert to undefined are omitted from the result object but do not
		* fail the conversion.
		* @param properties - An {@link Converters.FieldConverters \| FieldConverters<T>} defining the shape of the
		* source object and {@link Converter \| converters} to be applied to each properties.
		* @param optional - An array of `(keyof T)` listing the keys to be considered optional.
		* {@label withKeys}
		* @returns A new {@link Converters.ObjectConverter \| ObjectConverter} which applies the specified conversions.
		* @public
		* @deprecated Use {@link Converters.(object:withOptions) \| Converters.object(fields, options)} instead.
		*/
		export declare function object<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;
		/**
		* Options for the {@link Converters.(strictObject:withOptions)} helper function.
		* @public
		*/
		export declare type StrictObjectConverterOptions<T> = Omit<ObjectConverterOptions<T>, 'strict'>;
		/**
		* Helper function to create a {@link Converters.ObjectConverter \| ObjectConverter} which converts an object
		* without changing shape, a {@link Converters.FieldConverters \| FieldConverters<T>} and an optional
		* {@link Converters.StrictObjectConverterOptions \| StrictObjectConverterOptions<T>} to further refine
		* conversion behavior.
		*
		* @remarks
		* Fields that succeed but convert to undefined are omitted from the result object but do not
		* fail the conversion.
		*
		* The conversion fails if any unexpected fields are encountered.
		*
		* @param fields An object containing defining the shape and converters to be applied.
		* @param opt - An @see ObjectConverterOptions<T> containing options for the object converter, or
		* an array of (keyof T) containing optional keys.
		* @param properties - An object containing defining the shape and converters to be applied.
		* @param options - An optional @see StrictObjectConverterOptions<T> containing options for the object converter.
		* @returns A new {@link Converters.ObjectConverter \| ObjectConverter} which applies the specified conversions.
		* {@label withOptions}
		* @public
		*/
		export declare function strictObject<T>(fields: FieldConverters<T>, opt?: (keyof T)[] \| Omit<ObjectConverterOptions<T>, 'strict'>): ObjectConverter<T>;
		export declare function strictObject<T>(properties: FieldConverters<T>, options?: StrictObjectConverterOptions<T>): ObjectConverter<T>;
		/**
		* Helper function to create a {@link Converters.ObjectConverter \| ObjectConverter} which converts an object
		* without changing shape, a {@link Converters.FieldConverters \| FieldConverters<T>} and an optional
		* {@link Converters.StrictObjectConverterOptions \| StrictObjectConverterOptions<T>} to further refine
		* conversion behavior.
		*
		* @remarks
		* Fields that succeed but convert to undefined are omitted from the result object but do not
		* fail the conversion.
		*
		* The conversion fails if any unexpected fields are encountered.
		*
		* @param properties - An object containing defining the shape and converters to be applied.
		* @param optional - An array of `keyof T` containing keys to be considered optional.
		* @returns A new {@link Converters.ObjectConverter \| ObjectConverter} which applies the specified conversions.
		* {@label withKeys}
		* @deprecated Use {@link Converters.(strictObject:withOptions) \| Converters.strictObject(options)} instead.
		* @public
		*/
		export declare function strictObject<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;
		/**
		* A string-keyed `Record<string, Converter>` which maps specific {@link Converter \| converters} to the
		* value of a discriminator property.
		* @public
		*/
		export declare type DiscriminatedObjectConverters<T, TD extends string = string, TC = unknown> = Record<TD, Converter<T, TC>>;
		/**
		* Helper to convert a discriminated property without changing shape. Takes the name of the
		* discriminator property and a string-keyed record of object converters, and invokes the
		* converter that corresponds to the value of the discriminator property in the source object.
		* Fails if the source is not an object or if the discriminator property is missing or has
		* a value not present in the converters.
		* @param discriminatorProp Name of the property used to discriminate types
		* @param converters String-keyed record of converters to invoke, where key corresponds to a value of the
		* discriminator property.
		* Helper to create a {@link Converter} whhich converts a discriminated object without changing shape.
		* @remarks
		* Takes the name of the discriminator property and a
		* {@link Converters.DiscriminatedObjectConverters \| string-keyed Record of converters}. During conversion,
		* the resulting {@link Converter} invokes the converter from `converters` that corresponds to the value of
		* the discriminator property in the source object.
		*
		* If the source is not an object, the discriminator property is missing, or the discriminator has
		* a value not present in the converters, conversion fails and returns {@link Failure} with more information.
		* @param discriminatorProp - Name of the property used to discriminate types.
		* @param converters - {@link Converters.DiscriminatedObjectConverters \| String-keyed record of converters} to
		* invoke, where each key corresponds to a value of the discriminator property.
		* @returns A {@link Converter} which converts the corresponding discriminated object.
		* @public
		*/
		export declare function discriminatedObject<T, TD extends string = string, TC = unknown>(discriminatorProp: string, converters: DiscriminatedObjectConverters<T, TD>): Converter<T, TC>;
		/**
		* Helper to convert an object to a new object with a different shape. The source parameter is
		* an object with key names that correspond to the target object, and an approriate _field_
		* converter that will extract and convert a single field from the source object.
		* Helper to create a {@link Converter} which converts a source object to a new object with a
		* different shape.
		*
		* If all of the extracted fields exist and can be converted, returns a new object with the
		* converted values under the original key names. If any fields to be extracted do not exist
		* or cannot be converted, the entire conversion fails.
		* @remarks
		* On successful conversion, the resulting {@link Converter} returns {@link Success} with a new
		* object, which contains the converted values under the key names specified at initialization time.
		* It returns {@link Failure} with an error message if any fields to be extracted do not exist
		* or cannot be converted.
		*
		@@ -392,13 +618,25 @@ * Fields that succeed but convert to undefined are omitted from the result object but do not
		*
		* @param fields An object defining the shape of the target object and the field converters
		* to be used to construct it.
		* @param properties - An object with key names that correspond to the target object and an
		* appropriate {@link Converters.FieldConverters \| FieldConverter} which extracts and converts
		* a single filed from the source object.
		* @returns A {@link Converter} with the specified conversion behavior.
		* @public
		*/
		export declare function transform<T, TC = unknown>(fields: FieldConverters<T, TC>): Converter<T, TC>;
		export declare function transform<T, TC = unknown>(properties: FieldConverters<T, TC>): Converter<T, TC>;
		/**
		* A helper wrapper to convert a range of some other comparable type
		* @param converter Converter used to convert min and max extent of the raid
		* @param constructor Optional static constructor to instantiate the object
		* A helper wrapper to construct a {@link Converter} which converts to an arbitrary strongly-typed
		* range of some comparable type.
		* @param converter - {@link Converter} used to convert `min` and `max` extent of the range.
		* @param constructor - Static constructor to instantiate the object.
		* @public
		*/
		export declare function rangeTypeOf<T, RT extends RangeOf<T>, TC = unknown>(converter: Converter<T, TC>, constructor: (init: RangeOfProperties<T>) => Result<RT>): Converter<RT, TC>;
		/**
		* A helper wrapper to construct a {@link Converter} which converts to {@link RangeOf \| RangeOf<T>}
		* where `<T>` is some comparable type.
		* @param converter - {@link Converter} used to convert `min` and `max` extent of the range.
		* @public
		*/
		export declare function rangeOf<T, TC = unknown>(converter: Converter<T, TC>): Converter<RangeOf<T>, TC>;
		export {};
		//# sourceMappingURL=converters.d.ts.map

csvHelpers.d.ts

		import { Result } from './result';
		/**
		* Reads a CSV file from a supplied path.
		* @param srcPath - Source path from which the file is read.
		* @returns The contents of the file.
		* @beta
		*/
		export declare function readCsvFileSync(srcPath: string): Result<unknown>;
		//# sourceMappingURL=csvHelpers.d.ts.map

csvHelpers.js

		@@ -25,3 +25,7 @@ "use strict";
		if (k2 === undefined) k2 = k;
		Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc \|\| ("get" in desc ? !m.__esModule : desc.writable \|\| desc.configurable)) {
		desc = { enumerable: true, get: function() { return m[k]; } };
		}
		Object.defineProperty(o, k2, desc);
		}) : (function(o, m, k, k2) {
		@@ -52,2 +56,8 @@ if (k2 === undefined) k2 = k;
		const sync_1 = __importDefault(require("csv-parse/lib/sync"));
		/**
		* Reads a CSV file from a supplied path.
		* @param srcPath - Source path from which the file is read.
		* @returns The contents of the file.
		* @beta
		*/
		function readCsvFileSync(srcPath) {
		@@ -62,2 +72,2 @@ return (0, result_1.captureResult)(() => {
		exports.readCsvFileSync = readCsvFileSync;
		//# sourceMappingURL=data:application/json;base64,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
		//# sourceMappingURL=data:application/json;base64,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

extendedArray.d.ts

		import { Result } from './result';
		/**
		* An experimental array template which extend built-in `Array` to include a handful
		* of predicates which return {@link Result \| Result<T>}.
		* @beta
		*/
		export declare class ExtendedArray<T> extends Array<T> {
		readonly itemDescription: string;
		/**
		* Constructs an {@link ExtendedArray}.
		* @param itemDescription - Brief description of the type of each item in this array.
		* @param items - The initial contents of the array.
		*/
		constructor(itemDescription: string, ...items: T[]);
		/**
		* Type guard to determine if some arbitrary array is an
		* {@link ExtendedArray}
		* @param a - The `Array` to be tested.
		* @returns Returns `true` if `a` is an {@link ExtendedArray},
		* `false` otherwise.
		*/
		static isExtendedArray<T>(a?: T[]): a is ExtendedArray<T>;
		/**
		* Determines if this array contains exactly one element which matches
		* a supplied predicate.
		* @param predicate - The predicate function to be applied.
		* @returns Returns {@link Success \| Success<T>} with the single matching
		* result if exactly one item matches `predicate`. Returns {@link Failure}
		* with an error message if there are no matches or more than one match.
		*/
		single(predicate?: (item: T) => boolean): Result<T>;
		/**
		* Returns the first element of an {@link ExtendedArray}. Fails with an
		* error message if the array is empty.
		* @param failMessage - Optional message to be displayed in the event of failure.
		* @returns Returns {@link Success \| Success<T>} with the value of the first element
		* in the array, or {@link Failure} with an error message if the array is empty.
		*/
		first(failMessage?: string): Result<T>;
		/**
		* Returns an array containing all elements of an {@link ExtendedArray}. Fails with
		* an error message if the array is empty.
		* @param failMessage - Optional message to be displayed in the event of failure.
		* @returns Returns {@link Success \| Success<T[]>} with a new (non-extended) `Array`
		* containing the elements of this array, or {@link Failure} with an error message
		* if the array is empty.
		*/
		atLeastOne(failMessage?: string): Result<T[]>;
		/**
		* Gets a new (non-extended) `Array` containing all of the elements from this
		* {@link ExtendedArray}.
		* @returns A new (non-extended) `Array<T>`.
		*/
		all(): T[];
		}
		//# sourceMappingURL=extendedArray.d.ts.map

extendedArray.js

		@@ -26,3 +26,13 @@ "use strict";
		const result_1 = require("./result");
		/**
		* An experimental array template which extend built-in `Array` to include a handful
		* of predicates which return {@link Result \| Result<T>}.
		* @beta
		*/
		class ExtendedArray extends Array {
		/**
		* Constructs an {@link ExtendedArray}.
		* @param itemDescription - Brief description of the type of each item in this array.
		* @param items - The initial contents of the array.
		*/
		constructor(itemDescription, ...items) {
		@@ -32,5 +42,20 @@ super(...items);
		}
		/**
		* Type guard to determine if some arbitrary array is an
		* {@link ExtendedArray}
		* @param a - The `Array` to be tested.
		* @returns Returns `true` if `a` is an {@link ExtendedArray},
		* `false` otherwise.
		*/
		static isExtendedArray(a) {
		return a instanceof ExtendedArray;
		}
		/**
		* Determines if this array contains exactly one element which matches
		* a supplied predicate.
		* @param predicate - The predicate function to be applied.
		* @returns Returns {@link Success \| Success<T>} with the single matching
		* result if exactly one item matches `predicate`. Returns {@link Failure}
		* with an error message if there are no matches or more than one match.
		*/
		single(predicate) {
		@@ -46,2 +71,9 @@ const match = (predicate ? this.filter(predicate) : this);
		}
		/**
		* Returns the first element of an {@link ExtendedArray}. Fails with an
		* error message if the array is empty.
		* @param failMessage - Optional message to be displayed in the event of failure.
		* @returns Returns {@link Success \| Success<T>} with the value of the first element
		* in the array, or {@link Failure} with an error message if the array is empty.
		*/
		first(failMessage) {
		@@ -53,2 +85,10 @@ if (this.length > 0) {
		}
		/**
		* Returns an array containing all elements of an {@link ExtendedArray}. Fails with
		* an error message if the array is empty.
		* @param failMessage - Optional message to be displayed in the event of failure.
		* @returns Returns {@link Success \| Success<T[]>} with a new (non-extended) `Array`
		* containing the elements of this array, or {@link Failure} with an error message
		* if the array is empty.
		*/
		atLeastOne(failMessage) {
		@@ -60,2 +100,7 @@ if (this.length > 0) {
		}
		/**
		* Gets a new (non-extended) `Array` containing all of the elements from this
		* {@link ExtendedArray}.
		* @returns A new (non-extended) `Array<T>`.
		*/
		all() {
		@@ -66,2 +111,2 @@ return Array.from(this);
		exports.ExtendedArray = ExtendedArray;
		//# sourceMappingURL=data:application/json;base64,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
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extendedArray.js","sourceRoot":"","sources":["../src/extendedArray.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,qCAAiD;AAEjD;;;;GAIG;AACH,MAAa,aAAiB,SAAQ,KAAQ;IAG1C;;;;OAIG;IACH,YAAmB,eAAuB,EAAE,GAAG,KAAU;QACrD,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC;QAChB,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;IAC3C,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,eAAe,CAAI,CAAO;QACpC,OAAO,CAAC,YAAY,aAAa,CAAC;IACtC,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,SAAgC;QAC1C,MAAM,KAAK,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC1D,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACpB,OAAO,IAAA,gBAAO,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;SAC5B;QACD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACpB,OAAO,IAAA,aAAI,EAAC,GAAG,IAAI,CAAC,eAAe,YAAY,CAAC,CAAC;SACpD;QACD,OAAO,IAAA,aAAI,EAAC,GAAG,IAAI,CAAC,eAAe,YAAY,KAAK,CAAC,MAAM,QAAQ,CAAC,CAAC;IACzE,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,WAAoB;QAC7B,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YACjB,OAAO,IAAA,gBAAO,EAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SAC3B;QACD,OAAO,IAAA,aAAI,EAAC,WAAW,aAAX,WAAW,cAAX,WAAW,GAAI,GAAG,IAAI,CAAC,eAAe,YAAY,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;OAOG;IACI,UAAU,CAAC,WAAoB;QAClC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YACjB,OAAO,IAAA,gBAAO,EAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;SACpC;QACD,OAAO,IAAA,aAAI,EAAC,WAAW,aAAX,WAAW,cAAX,WAAW,GAAI,GAAG,IAAI,CAAC,eAAe,YAAY,CAAC,CAAC;IACpE,CAAC;IAED;;;;OAIG;IACI,GAAG;QACN,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;CACJ;AAhFD,sCAgFC","sourcesContent":["/*\r\n * Copyright (c) 2020 Erik Fortune\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\n\r\nimport { Result, fail, succeed } from './result';\r\n\r\n/**\r\n * An experimental array template which extend built-in `Array` to include a handful\r\n * of predicates which return {@link Result | Result<T>}.\r\n * @beta\r\n */\r\nexport class ExtendedArray<T> extends Array<T> {\r\n    public readonly itemDescription: string;\r\n\r\n    /**\r\n     * Constructs an {@link ExtendedArray}.\r\n     * @param itemDescription - Brief description of the type of each item in this array.\r\n     * @param items - The initial contents of the array.\r\n     */\r\n    public constructor(itemDescription: string, ...items: T[]) {\r\n        super(...items);\r\n        this.itemDescription = itemDescription;\r\n    }\r\n\r\n    /**\r\n     * Type guard to determine if some arbitrary array is an\r\n     * {@link ExtendedArray}\r\n     * @param a - The `Array` to be tested.\r\n     * @returns Returns `true` if `a` is an {@link ExtendedArray},\r\n     * `false` otherwise.\r\n     */\r\n    public static isExtendedArray<T>(a?: T[]): a is ExtendedArray<T> {\r\n        return a instanceof ExtendedArray;\r\n    }\r\n\r\n    /**\r\n     * Determines if this array contains exactly one element which matches\r\n     * a supplied predicate.\r\n     * @param predicate - The predicate function to be applied.\r\n     * @returns Returns {@link Success | Success<T>} with the single matching\r\n     * result if exactly one item matches `predicate`.  Returns {@link Failure}\r\n     * with an error message if there are no matches or more than one match.\r\n     */\r\n    public single(predicate?: (item: T) => boolean): Result<T> {\r\n        const match = (predicate ? this.filter(predicate) : this);\r\n        if (match.length === 1) {\r\n            return succeed(match[0]);\r\n        }\r\n        if (match.length === 0) {\r\n            return fail(`${this.itemDescription} not found`);\r\n        }\r\n        return fail(`${this.itemDescription} matches ${match.length} items`);\r\n    }\r\n\r\n    /**\r\n     * Returns the first element of an {@link ExtendedArray}. Fails with an\r\n     * error message if the array is empty.\r\n     * @param failMessage - Optional message to be displayed in the event of failure.\r\n     * @returns Returns {@link Success | Success<T>} with the value of the first element\r\n     * in the array, or {@link Failure} with an error message if the array is empty.\r\n     */\r\n    public first(failMessage?: string): Result<T> {\r\n        if (this.length > 0) {\r\n            return succeed(this[0]);\r\n        }\r\n        return fail(failMessage ?? `${this.itemDescription} not found`);\r\n    }\r\n\r\n    /**\r\n     * Returns an array containing all elements of an {@link ExtendedArray}. Fails with\r\n     * an error message if the array is empty.\r\n     * @param failMessage - Optional message to be displayed in the event of failure.\r\n     * @returns Returns {@link Success | Success<T[]>} with a new (non-extended) `Array`\r\n     * containing the elements of this array, or {@link Failure} with an error message\r\n     * if the array is empty.\r\n     */\r\n    public atLeastOne(failMessage?: string): Result<T[]> {\r\n        if (this.length > 0) {\r\n            return succeed(Array.from(this));\r\n        }\r\n        return fail(failMessage ?? `${this.itemDescription} not found`);\r\n    }\r\n\r\n    /**\r\n     * Gets a new (non-extended) `Array` containing all of the elements from this\r\n     * {@link ExtendedArray}.\r\n     * @returns A new (non-extended) `Array<T>`.\r\n     */\r\n    public all(): T[] {\r\n        return Array.from(this);\r\n    }\r\n}\r\n"]}

formatter.d.ts

		import { Result } from './result';
		/**
		* Destination format for some formatted string.
		* @beta
		*/
		export declare type FormatTargets = 'text' \| 'markdown' \| 'embed';
		/**
		* Interface for an object that can be formatted.
		* @beta
		*/
		export interface Formattable {
		/**
		* Formats an object using the supplied mustache template.
		* @param format - A mustache template used to format the object.
		* @returns {@link Success} with the resulting string, or {@link Failure}
		* with an error message if an error occurs.
		*/
		format(format: string): Result<string>;
		}
		/**
		* Base class which adds common formatting.
		* @beta
		*/
		export declare class FormattableBase {
		/**
		* Helper enables derived classes to add named details to a formatted presentation.
		* @param details - An array of detail description strings.
		* @param label - Label to use for the new detail.
		* @param value - Value to use for the new detail.
		* @internal
		*/
		protected static _tryAddDetail(details: string[], label: string, value: string \| undefined): void;
		/**
		* {@inheritdoc Formattable.format}
		*/
		format(template: string): Result<string>;
		}
		/**
		* Type definition for a formatting function, which takes a `string` and an
		* item and returns {@link Result \| Result<string>}.
		* @beta
		*/
		export declare type Formatter<T> = (format: string, item: T) => Result<string>;
		/**
		* A collection of {@link Formatter \| formatters} indexed by target name, to enable
		* different format methods per output target.
		* @beta
		*/
		export declare type FormattersByExtendedTarget<TFT extends FormatTargets, T> = Record<TFT, Formatter<T>>;
		/**
		* A collection of {@link Formatter \| formatters} indexed by the {@link FormatTargets \| default supported
		* target formats}.
		* @beta
		*/
		export declare type FormattersByTarget<T> = FormattersByExtendedTarget<FormatTargets, T>;
		/**
		* Formats a list of items using the supplied template and formatter, one result
		* per output line.
		* @param format - A mustache template used to format each item.
		* @param items - The items to be formatted.
		* @param itemFormatter - The {@link Formatter \| Formatter<T>} used to format each item.
		* @returns The resulting string.
		* @beta
		*/
		export declare function formatList<T>(format: string, items: T[], itemFormatter: Formatter<T>): Result<string>;
		//# sourceMappingURL=formatter.d.ts.map

formatter.js

		@@ -31,3 +31,14 @@ "use strict";
		mustache_1.default.escape = (s) => s;
		/**
		* Base class which adds common formatting.
		* @beta
		*/
		class FormattableBase {
		/**
		* Helper enables derived classes to add named details to a formatted presentation.
		* @param details - An array of detail description strings.
		* @param label - Label to use for the new detail.
		* @param value - Value to use for the new detail.
		* @internal
		*/
		static _tryAddDetail(details, label, value) {
		@@ -39,2 +50,5 @@ if (value !== undefined) {
		}
		/**
		* {@inheritdoc Formattable.format}
		*/
		format(template) {
		@@ -45,2 +59,11 @@ return (0, result_1.captureResult)(() => mustache_1.default.render(template, this));
		exports.FormattableBase = FormattableBase;
		/**
		* Formats a list of items using the supplied template and formatter, one result
		* per output line.
		* @param format - A mustache template used to format each item.
		* @param items - The items to be formatted.
		* @param itemFormatter - The {@link Formatter \| Formatter<T>} used to format each item.
		* @returns The resulting string.
		* @beta
		*/
		function formatList(format, items, itemFormatter) {
		@@ -55,2 +78,2 @@ return (0, result_1.mapResults)(items.map((item) => {
		exports.formatList = formatList;
		//# sourceMappingURL=data:application/json;base64,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
		//# sourceMappingURL=data:application/json;base64,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

hash.d.ts

		import { Result } from './result';
		/**
		* Computes an md5 hash from an array of strings. Not secure and not intended to be secure.
		* @param parts The strings to be hashed
		* @param parts - The strings to be hashed
		* @returns An md5 hash of the parts
		* @public
		*/
		export declare function computeHash(parts: string[]): string;
		/**
		* Computes a normalized hash for an arbitrary javascript value.
		* @public
		*/
		export declare class Normalizer {
		@@ -16,9 +21,32 @@ /**
		*
		* @param from The arbitrary unknown to be hashed
		* @returns An md5 hash
		* @param from - The arbitrary `unknown` to be hashed.
		* @returns A normalized md5 hash for the supplied value.
		*/
		computeHash(from: unknown): Result<string>;
		/**
		* Compares two property names from some object being normalized.
		* @param k1 - First key to be compared.
		* @param k2 - Second key to be compared.
		* @returns `1` if `k1` is greater, `-1` if `k2` is greater and
		* `0` if they are equal.
		* @internal
		*/
		protected _compareKeys(k1: unknown, k2: unknown): number;
		/**
		* Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).
		* @remarks
		* Converts property names (entry key) to string and then sorts as string.
		* @param entries - The entries to be normalized.
		* @returns A normalized sorted array of entries.
		* @internal
		*/
		protected _normalizeEntries(entries: Iterable<[unknown, unknown]>): [unknown, unknown][];
		/**
		* Constructs a normalized string representation of some literal value.
		* @param from - The literal value to be normalized.
		* @returns A normalized string representation of the literal.
		* @internal
		*/
		protected _normalizeLiteral(from: string \| number \| bigint \| boolean \| symbol \| undefined \| Date \| RegExp \| null): Result<string>;
		}
		//# sourceMappingURL=hash.d.ts.map

hash.js

		@@ -25,3 +25,7 @@ "use strict";
		if (k2 === undefined) k2 = k;
		Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc \|\| ("get" in desc ? !m.__esModule : desc.writable \|\| desc.configurable)) {
		desc = { enumerable: true, get: function() { return m[k]; } };
		}
		Object.defineProperty(o, k2, desc);
		}) : (function(o, m, k, k2) {
		@@ -49,4 +53,5 @@ if (k2 === undefined) k2 = k;
		* Computes an md5 hash from an array of strings. Not secure and not intended to be secure.
		* @param parts The strings to be hashed
		* @param parts - The strings to be hashed
		* @returns An md5 hash of the parts
		* @public
		*/
		@@ -57,2 +62,6 @@ function computeHash(parts) {
		exports.computeHash = computeHash;
		/**
		* Computes a normalized hash for an arbitrary javascript value.
		* @public
		*/
		class Normalizer {
		@@ -66,4 +75,4 @@ /**
		*
		* @param from The arbitrary unknown to be hashed
		* @returns An md5 hash
		* @param from - The arbitrary `unknown` to be hashed.
		* @returns A normalized md5 hash for the supplied value.
		*/
		@@ -99,2 +108,10 @@ computeHash(from) {
		}
		/**
		* Compares two property names from some object being normalized.
		* @param k1 - First key to be compared.
		* @param k2 - Second key to be compared.
		* @returns `1` if `k1` is greater, `-1` if `k2` is greater and
		* `0` if they are equal.
		* @internal
		*/
		_compareKeys(k1, k2) {
		@@ -113,5 +130,19 @@ const cs1 = String(k1);
		}
		/**
		* Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).
		* @remarks
		* Converts property names (entry key) to string and then sorts as string.
		* @param entries - The entries to be normalized.
		* @returns A normalized sorted array of entries.
		* @internal
		*/
		_normalizeEntries(entries) {
		return Array.from(entries).sort((e1, e2) => this._compareKeys(e1[0], e2[0]));
		}
		/**
		* Constructs a normalized string representation of some literal value.
		* @param from - The literal value to be normalized.
		* @returns A normalized string representation of the literal.
		* @internal
		*/
		_normalizeLiteral(from) {
		@@ -143,2 +174,2 @@ switch (typeof from) {
		exports.Normalizer = Normalizer;
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hash.js","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2021 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as crypto from 'crypto';\nimport { Result, captureResult, fail, mapResults, succeed } from './result';\n\n/**\n * Computes an md5 hash from an array of strings. Not secure and not intended to be secure.\n * @param parts The strings to be hashed\n * @returns An md5 hash of the parts\n */\nexport function computeHash(parts: string[]): string {\n    return crypto.createHash('md5').update(parts.join('|'), 'utf8').digest('hex');\n}\n\nexport class Normalizer {\n    /**\n     * Computes a normalized md5 hash from an arbitrary supplied object.  Not secure and not\n     * intended to be secure.  Also not fast and not intended to be fast.\n     *\n     * Normalization just sorts Maps, Sets and object keys by hash so that differences in order\n     * do not affect the hash.\n     *\n     * @param from The arbitrary unknown to be hashed\n     * @returns An md5 hash\n     */\n    public computeHash(from: unknown): Result<string> {\n        switch (typeof from) {\n            case 'string':\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return this._normalizeLiteral(from).onSuccess((v) => {\n                    return captureResult(() => computeHash([v]));\n                });\n            case 'object':\n                if ((from === null) || (from instanceof Date) || (from instanceof RegExp)) {\n                    return this._normalizeLiteral(from).onSuccess((v) => {\n                        return captureResult(() => computeHash([v]));\n                    });\n                }\n                else if (Array.isArray(from)) {\n                    return mapResults(from.map((e) => this.computeHash(e))).onSuccess((a) => {\n                        return captureResult(() => computeHash(a));\n                    });\n                }\n                else if ((from instanceof Map) || (from instanceof Set)) {\n                    return this.computeHash(this._normalizeEntries(from.entries()));\n                }\n                return this.computeHash(this._normalizeEntries(Object.entries(from)));\n        }\n        return fail(`computeHash: Unexpected type - cannot hash '${typeof from}'`);\n    }\n\n    protected _compareKeys(k1: unknown, k2: unknown): number {\n        const cs1 = String(k1);\n        const cs2 = String(k2);\n        if (cs1 > cs2) {\n            return 1;\n        }\n        // istanbul ignore else\n        if (cs2 > cs1) {\n            return -1;\n        }\n\n        // istanbul ignore next\n        return 0;\n    }\n\n    protected _normalizeEntries(entries: Iterable<[unknown, unknown]>): [unknown, unknown][] {\n        return Array.from(entries).sort((e1, e2) => this._compareKeys(e1[0], e2[0]));\n    }\n\n    protected _normalizeLiteral(from: string|number|bigint|boolean|symbol|undefined|Date|RegExp|null): Result<string> {\n        switch (typeof from) {\n            case 'string':\n                return succeed(from);\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return succeed(`${typeof from}:[[[${String(from)}]]]`);\n        }\n        if (from === null) {\n            return succeed('object:[[[null]]');\n        }\n        if (from instanceof Date) {\n            return succeed(`Date:[[[${String(from.valueOf())}]]]`);\n        }\n        // istanbul ignore else\n        if (from instanceof RegExp) {\n            return succeed(`RegExp:[[[${from.toString()}]]]`);\n        }\n        // istanbul ignore next\n        return fail(`cannot normalize ${JSON.stringify(from)}`);\n    }\n}\n"]}
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hash.js","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2021 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as crypto from 'crypto';\nimport { Result, captureResult, fail, mapResults, succeed } from './result';\n\n/**\n * Computes an md5 hash from an array of strings. Not secure and not intended to be secure.\n * @param parts - The strings to be hashed\n * @returns An md5 hash of the parts\n * @public\n */\nexport function computeHash(parts: string[]): string {\n    return crypto.createHash('md5').update(parts.join('|'), 'utf8').digest('hex');\n}\n\n/**\n * Computes a normalized hash for an arbitrary javascript value.\n * @public\n */\nexport class Normalizer {\n    /**\n     * Computes a normalized md5 hash from an arbitrary supplied object.  Not secure and not\n     * intended to be secure.  Also not fast and not intended to be fast.\n     *\n     * Normalization just sorts Maps, Sets and object keys by hash so that differences in order\n     * do not affect the hash.\n     *\n     * @param from - The arbitrary `unknown` to be hashed.\n     * @returns A normalized md5 hash for the supplied value.\n     */\n    public computeHash(from: unknown): Result<string> {\n        switch (typeof from) {\n            case 'string':\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return this._normalizeLiteral(from).onSuccess((v) => {\n                    return captureResult(() => computeHash([v]));\n                });\n            case 'object':\n                if ((from === null) || (from instanceof Date) || (from instanceof RegExp)) {\n                    return this._normalizeLiteral(from).onSuccess((v) => {\n                        return captureResult(() => computeHash([v]));\n                    });\n                }\n                else if (Array.isArray(from)) {\n                    return mapResults(from.map((e) => this.computeHash(e))).onSuccess((a) => {\n                        return captureResult(() => computeHash(a));\n                    });\n                }\n                else if ((from instanceof Map) || (from instanceof Set)) {\n                    return this.computeHash(this._normalizeEntries(from.entries()));\n                }\n                return this.computeHash(this._normalizeEntries(Object.entries(from)));\n        }\n        return fail(`computeHash: Unexpected type - cannot hash '${typeof from}'`);\n    }\n\n    /**\n     * Compares two property names from some object being normalized.\n     * @param k1 - First key to be compared.\n     * @param k2 - Second key to be compared.\n     * @returns `1` if `k1` is greater, `-1` if `k2` is greater and\n     * `0` if they are equal.\n     * @internal\n     */\n    protected _compareKeys(k1: unknown, k2: unknown): number {\n        const cs1 = String(k1);\n        const cs2 = String(k2);\n        if (cs1 > cs2) {\n            return 1;\n        }\n        // istanbul ignore else\n        if (cs2 > cs1) {\n            return -1;\n        }\n\n        // istanbul ignore next\n        return 0;\n    }\n\n    /**\n     * Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).\n     * @remarks\n     * Converts property names (entry key) to string and then sorts as string.\n     * @param entries - The entries to be normalized.\n     * @returns A normalized sorted array of entries.\n     * @internal\n     */\n    protected _normalizeEntries(entries: Iterable<[unknown, unknown]>): [unknown, unknown][] {\n        return Array.from(entries).sort((e1, e2) => this._compareKeys(e1[0], e2[0]));\n    }\n\n    /**\n     * Constructs a normalized string representation of some literal value.\n     * @param from - The literal value to be normalized.\n     * @returns A normalized string representation of the literal.\n     * @internal\n     */\n    protected _normalizeLiteral(from: string|number|bigint|boolean|symbol|undefined|Date|RegExp|null): Result<string> {\n        switch (typeof from) {\n            case 'string':\n                return succeed(from);\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return succeed(`${typeof from}:[[[${String(from)}]]]`);\n        }\n        if (from === null) {\n            return succeed('object:[[[null]]');\n        }\n        if (from instanceof Date) {\n            return succeed(`Date:[[[${String(from.valueOf())}]]]`);\n        }\n        // istanbul ignore else\n        if (from instanceof RegExp) {\n            return succeed(`RegExp:[[[${from.toString()}]]]`);\n        }\n        // istanbul ignore next\n        return fail(`cannot normalize ${JSON.stringify(from)}`);\n    }\n}\n"]}

index.d.ts

		@@ -0,9 +1,13 @@
		export * from './brand';
		export * from './converter';
		export * as Converters from './converters';
		export * as Csv from './csvHelpers';
		export * from './extendedArray';
		export * from './formatter';
		export * as Hash from './hash';
		export * from './rangeOf';
		export * from './result';
		export * from './utils';
		import * as Converters from './converters';
		import * as Csv from './csvHelpers';
		import * as Hash from './hash';
		import * as Validation from './validation';
		export { Converters, Csv, Hash, Validation };
		//# sourceMappingURL=index.d.ts.map

index.js

		"use strict";
		var __createBinding = (this && this.__createBinding) \|\| (Object.create ? (function(o, m, k, k2) {
		if (k2 === undefined) k2 = k;
		Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc \|\| ("get" in desc ? !m.__esModule : desc.writable \|\| desc.configurable)) {
		desc = { enumerable: true, get: function() { return m[k]; } };
		}
		Object.defineProperty(o, k2, desc);
		}) : (function(o, m, k, k2) {
		@@ -25,3 +29,3 @@ if (k2 === undefined) k2 = k;
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.Hash = exports.Csv = exports.Converters = void 0;
		exports.Validation = exports.Hash = exports.Csv = exports.Converters = void 0;
		/*
		@@ -48,11 +52,17 @@ * Copyright (c) 2020 Erik Fortune
		*/
		__exportStar(require("./brand"), exports);
		__exportStar(require("./converter"), exports);
		exports.Converters = __importStar(require("./converters"));
		exports.Csv = __importStar(require("./csvHelpers"));
		__exportStar(require("./extendedArray"), exports);
		__exportStar(require("./formatter"), exports);
		exports.Hash = __importStar(require("./hash"));
		__exportStar(require("./rangeOf"), exports);
		__exportStar(require("./result"), exports);
		__exportStar(require("./utils"), exports);
		//# sourceMappingURL=data:application/json;base64,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
		const Converters = __importStar(require("./converters"));
		exports.Converters = Converters;
		const Csv = __importStar(require("./csvHelpers"));
		exports.Csv = Csv;
		const Hash = __importStar(require("./hash"));
		exports.Hash = Hash;
		const Validation = __importStar(require("./validation"));
		exports.Validation = Validation;
		//# sourceMappingURL=data:application/json;base64,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

logger.d.ts

		@@ -25,7 +25,7 @@ import { Failure, Success } from './result';
		export declare class InMemoryLogger extends LoggerBase {
		get messages(): string[];
		get silent(): string[];
		protected _messages: string[];
		protected _silent: string[];
		constructor(logLevel?: LogLevel);
		get messages(): string[];
		get silent(): string[];
		clear(): void;
		@@ -38,1 +38,2 @@ protected _innerLog(message: string): Success<string \| undefined>;
		}
		//# sourceMappingURL=logger.d.ts.map

logger.js

		@@ -115,2 +115,2 @@ "use strict";
		exports.NoOpLogger = NoOpLogger;
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2020 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nimport { Failure, Success, fail, succeed } from './result';\n\nexport type LogLevel = 'detail'|'info'|'warning'|'error'|'silent';\n\nexport interface Logger {\n    log(message?: unknown, ...parameters: unknown[]): Success<string|undefined>;\n    detail(message?: unknown, ...parameters: unknown[]): Success<string|undefined>;\n    info(message?: unknown, ...parameters: unknown[]): Success<string|undefined>;\n    warn(message?: unknown, ...parameters: unknown[]): Success<string|undefined>;\n    warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;\n    error<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;\n}\n\nexport abstract class LoggerBase {\n    public logLevel: LogLevel = 'info';\n\n    public constructor(logLevel?: LogLevel) {\n        this.logLevel = logLevel ?? 'info';\n    }\n\n    public detail(message?: unknown, ...parameters: unknown[]): Success<string|undefined> {\n        if (this.logLevel === 'detail') {\n            return this.log(message, parameters);\n        }\n        return succeed(undefined);\n    }\n\n    public info(message?: unknown, ...parameters: unknown[]): Success<string|undefined> {\n        if ((this.logLevel === 'detail') || (this.logLevel === 'info')) {\n            return this.log(message, parameters);\n        }\n        return succeed(undefined);\n    }\n\n    public warn(message?: unknown, ...parameters: unknown[]): Success<string|undefined> {\n        if ((this.logLevel !== 'error') && (this.logLevel !== 'silent')) {\n            return this.log(message, parameters);\n        }\n        return succeed(undefined);\n    }\n\n    public warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T> {\n        const formatted = this._format(message, ...parameters);\n        if ((this.logLevel !== 'error') && (this.logLevel !== 'silent')) {\n            const result = this.log(formatted);\n            return fail(result.value ?? formatted);\n        }\n        return fail(formatted);\n    }\n\n    public error<T>(message?: unknown, ...parameters: unknown[]): Failure<T> {\n        const formatted = this._format(message, ...parameters);\n        if (this.logLevel !== 'silent') {\n            const result = this.log(formatted);\n            return fail(result.value ?? formatted);\n        }\n        return fail(formatted);\n    }\n\n    public log(message?: unknown, ...parameters: unknown[]): Success<string|undefined> {\n        const messageString = this._format(message, ...parameters);\n        if (this.logLevel === 'silent') {\n            return this._innerSilent(messageString);\n        }\n        return this._innerLog(messageString);\n    }\n\n    protected _format(message?: unknown, ...parameters: unknown[]): string {\n        const raw = [message, ...parameters];\n        const filtered = raw.filter((m): m is string => (m !== undefined));\n        const strings = filtered.map((m) => m.toString());\n        const joined = strings.join('');\n        return joined;\n    }\n\n    protected _innerSilent(_message: string): Success<string|undefined> {\n        return succeed(undefined);\n    }\n\n    protected abstract _innerLog(message: string): Success<string|undefined>;\n}\n\nexport class InMemoryLogger extends LoggerBase {\n    public get messages(): string[] { return this._messages; }\n    public get silent(): string[] { return this._silent; }\n\n    protected _messages: string[] = [];\n    protected _silent: string[] = [];\n\n    public constructor(logLevel?: LogLevel) {\n        super(logLevel);\n    }\n\n    public clear(): void {\n        this._messages = [];\n        this._silent = [];\n    }\n\n    protected _innerLog(message: string): Success<string|undefined> {\n        this._messages.push(message);\n        return succeed(message);\n    }\n\n    protected _innerSilent(message: string): Success<string|undefined> {\n        this._silent.push(message);\n        return succeed(undefined);\n    }\n}\n\nexport class NoOpLogger extends LoggerBase {\n    protected _innerLog(message: string): Success<string|undefined> {\n        // no-op\n        return succeed(message);\n    }\n}\n"]}
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2020 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nimport { Failure, Success, fail, succeed } from './result';\n\nexport type LogLevel = 'detail'|'info'|'warning'|'error'|'silent';\n\nexport interface Logger {\n    log(message?: unknown, ...parameters: unknown[]): Success<string|undefined>;\n    detail(message?: unknown, ...parameters: unknown[]): Success<string|undefined>;\n    info(message?: unknown, ...parameters: unknown[]): Success<string|undefined>;\n    warn(message?: unknown, ...parameters: unknown[]): Success<string|undefined>;\n    warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;\n    error<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;\n}\n\nexport abstract class LoggerBase {\n    public logLevel: LogLevel = 'info';\n\n    public constructor(logLevel?: LogLevel) {\n        this.logLevel = logLevel ?? 'info';\n    }\n\n    public detail(message?: unknown, ...parameters: unknown[]): Success<string|undefined> {\n        if (this.logLevel === 'detail') {\n            return this.log(message, parameters);\n        }\n        return succeed(undefined);\n    }\n\n    public info(message?: unknown, ...parameters: unknown[]): Success<string|undefined> {\n        if ((this.logLevel === 'detail') || (this.logLevel === 'info')) {\n            return this.log(message, parameters);\n        }\n        return succeed(undefined);\n    }\n\n    public warn(message?: unknown, ...parameters: unknown[]): Success<string|undefined> {\n        if ((this.logLevel !== 'error') && (this.logLevel !== 'silent')) {\n            return this.log(message, parameters);\n        }\n        return succeed(undefined);\n    }\n\n    public warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T> {\n        const formatted = this._format(message, ...parameters);\n        if ((this.logLevel !== 'error') && (this.logLevel !== 'silent')) {\n            const result = this.log(formatted);\n            return fail(result.value ?? formatted);\n        }\n        return fail(formatted);\n    }\n\n    public error<T>(message?: unknown, ...parameters: unknown[]): Failure<T> {\n        const formatted = this._format(message, ...parameters);\n        if (this.logLevel !== 'silent') {\n            const result = this.log(formatted);\n            return fail(result.value ?? formatted);\n        }\n        return fail(formatted);\n    }\n\n    public log(message?: unknown, ...parameters: unknown[]): Success<string|undefined> {\n        const messageString = this._format(message, ...parameters);\n        if (this.logLevel === 'silent') {\n            return this._innerSilent(messageString);\n        }\n        return this._innerLog(messageString);\n    }\n\n    protected _format(message?: unknown, ...parameters: unknown[]): string {\n        const raw = [message, ...parameters];\n        const filtered = raw.filter((m): m is string => (m !== undefined));\n        const strings = filtered.map((m) => m.toString());\n        const joined = strings.join('');\n        return joined;\n    }\n\n    protected _innerSilent(_message: string): Success<string|undefined> {\n        return succeed(undefined);\n    }\n\n    protected abstract _innerLog(message: string): Success<string|undefined>;\n}\n\nexport class InMemoryLogger extends LoggerBase {\n    protected _messages: string[] = [];\n    protected _silent: string[] = [];\n\n    public constructor(logLevel?: LogLevel) {\n        super(logLevel);\n    }\n\n    public get messages(): string[] { return this._messages; }\n    public get silent(): string[] { return this._silent; }\n\n    public clear(): void {\n        this._messages = [];\n        this._silent = [];\n    }\n\n    protected _innerLog(message: string): Success<string|undefined> {\n        this._messages.push(message);\n        return succeed(message);\n    }\n\n    protected _innerSilent(message: string): Success<string|undefined> {\n        this._silent.push(message);\n        return succeed(undefined);\n    }\n}\n\nexport class NoOpLogger extends LoggerBase {\n    protected _innerLog(message: string): Success<string|undefined> {\n        // no-op\n        return succeed(message);\n    }\n}\n"]}

package.json

		{
		"name": "@fgv/ts-utils",
		"version": "1.2.1",
		"version": "1.3.0",
		"description": "Assorted Typescript Utilities",
		"main": "index.js",
		"scripts": {
		"api-extractor": "$(npm bin)/api-extractor run --local --verbose -c ./config/api-extractor.json",
		"build": "rimraf dist && tsc && ./prep.sh",
		"build-docs": "$(npm bin)/api-documenter markdown --input-folder ./temp --output-folder docs",
		"build-all": "npm run build; npm run api-extractor; npm run build-docs",
		"clean": "rimraf dist",
		@@ -31,16 +34,17 @@ "test": "jest",
		"devDependencies": {
		"@microsoft/api-documenter": "^7.16.0",
		"@microsoft/api-extractor": "^7.19.5",
		"@types/jest": "^27.0.2",
		"@types/luxon": "^2.0.4",
		"@types/mustache": "^4.1.2",
		"@types/node": "^15.0.1",
		"@typescript-eslint/eslint-plugin": "^4.32.0",
		"@typescript-eslint/parser": "^4.32.0",
		"eslint": "^7.32.0",
		"eslint-config-standard": "^16.0.3",
		"@types/node": "^17.0.21",
		"@typescript-eslint/eslint-plugin": "^5.15.0",
		"@typescript-eslint/parser": "^5.15.0",
		"eslint": "^8.11.0",
		"eslint-config-standard": "^17.0.0-1",
		"eslint-plugin-import": "^2.24.2",
		"eslint-plugin-node": "^11.1.0",
		"eslint-plugin-promise": "^5.1.0",
		"eslint-plugin-standard": "^5.0.0",
		"eslint-plugin-promise": "^6.0.0",
		"jest": "^27.2.4",
		"jest-extended": "^0.11.5",
		"jest-extended": "^2.0.0",
		"jest-matcher-utils": "^27.2.4",
		@@ -47,0 +51,0 @@ "rimraf": "^3.0.2",

rangeOf.d.ts

		import { Result } from './result';
		/**
		* Represents a generic range of some comparable type `<T>`.
		* @public
		*/
		export interface RangeOfProperties<T> {
		@@ -6,2 +10,8 @@ readonly min?: T;
		}
		/**
		* Format strings (in mustache format) to
		* use for both open-ended and complete
		* {@link RangeOf \| RangeOf<T>}.
		* @public
		*/
		export interface RangeOfFormats {
		@@ -12,2 +22,7 @@ minOnly: string;
		}
		/**
		* Default {@link RangeOfFormats \| formats} to use for both
		* open-ended and complete {@link RangeOf \| RangeOf<T>}.
		* @public
		*/
		export declare const DEFAULT_RANGEOF_FORMATS: {
		@@ -18,15 +33,96 @@ minOnly: string;
		};
		/**
		* Simple implementation of a possibly open-ended range of some comparable
		* type `<T>` with test and formatting.
		* @public
		*/
		export declare class RangeOf<T> implements RangeOfProperties<T> {
		/**
		* Minimum extent of the range.
		*/
		readonly min?: T;
		/**
		* Maximum extent of the range.
		*/
		readonly max?: T;
		/**
		* Creates a new {@link RangeOf \| RangeOf<T>}.
		* @param min - Optional mininum extent of the range.
		* @param max - Optional maximum extent of the range.
		*/
		constructor(min?: T, max?: T);
		/**
		* Static constructor for a {@link RangeOf \| RangeOf<T>}.
		* @param init - {@link RangeOfProperties \| Range initializer}.
		* @returns A new {@link RangeOf \| RangeOf<T>}.
		*/
		static createRange<T>(init?: RangeOfProperties<T>): Result<RangeOf<T>>;
		/**
		* Gets a formatted description of a {@link RangeOfProperties \| RangeOfProperties<T>} given an
		* optional set of formats and 'empty' value to use.
		* @param range - The {@link RangeOfProperties \| RangeOfProperties<T>} to be formatted.
		* @param formats - Optionas {@link RangeOfFormats \| formats} to use. Default is
		* {@link DEFAULT_RANGEOF_FORMATS \| DEFAULT_RANGEOF_FORMATS}.
		* @param emptyValue - Value which represents unbounded minimum or maximum for this range. Default is `undefined`.
		* @returns A string representation of the range.
		*/
		static propertiesToString<T>(range: RangeOfProperties<T>, formats?: RangeOfFormats, emptyValue?: T): string \| undefined;
		/**
		* Default comparison uses javascript built-in comparison.
		* @param t1 - First value to be compared.
		* @param t2 - Second value to be compared.
		* @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
		* and `'equal'` if `t1` and `t2` are equal.
		* @internal
		*/
		protected static _defaultCompare<T>(t1: T, t2: T): 'less' \| 'equal' \| 'greater';
		/**
		* Checks if a supplied value is within this range.
		* @param t - The value to be tested.
		* @returns `'included'` if `t` falls within the range, `'less'` if `t` falls
		* below the minimum extent of the range and `'greater'` if `t` is above the
		* maximum extent.
		*/
		check(t: T): 'less' \| 'included' \| 'greater';
		/**
		* Determines if a supplied value is within this range.
		* @param t - The value to be tested.
		* @returns Returns `true` if `t` falls within the range, `false` otherwise.
		*/
		includes(t: T): boolean;
		/**
		* Finds the transition value that would bring a supplied value `t` into
		* range.
		* @param t - The value to be tested.
		* @returns The minimum extent of the range if `t` is below the range or
		* the maximum extent of the range if `t` is above the range. Returns
		* `undefined` if `t` already falls within the range.
		*/
		findTransition(t: T): T \| undefined;
		/**
		* Formats the minimum and maximum values of this range.
		* @param format - A format function used to format the values.
		* @returns A {@link RangeOfProperties \| RangeOfProperties<string>} contaning the
		* formatted representation of the {@link RangeOf.min \| minimum} and {@link RangeOf.max \| maximum}
		* extent of the range, or `undefined` for an extent that is not present.
		*/
		toFormattedProperties(format: (value: T) => string \| undefined): RangeOfProperties<string>;
		/**
		* Formats this range using the supplied format function.
		* @param format - Format function used to format minimum and maxiumum extent values.
		* @param formats - The {@link RangeOfFormats \| format strings} used to format the range
		* (default {@link DEFAULT_RANGEOF_FORMATS}).
		* @returns Returns a formatted representation of this range.
		*/
		format(format: (value: T) => string \| undefined, formats?: RangeOfFormats): string \| undefined;
		/**
		* Inner compare method can be overriden by a derived class.
		* @param t1 - First value to compare.
		* @param t2 - Second value to compare.
		* @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
		* and `'equal'` if `t1` and `t2` are equal.
		* @internal
		*/
		protected _compare(t1: T, t2: T): 'less' \| 'equal' \| 'greater';
		}
		//# sourceMappingURL=rangeOf.d.ts.map

rangeOf.js

		@@ -30,2 +30,7 @@ "use strict";
		const mustache_1 = __importDefault(require("mustache"));
		/**
		* Default {@link RangeOfFormats \| formats} to use for both
		* open-ended and complete {@link RangeOf \| RangeOf<T>}.
		* @public
		*/
		exports.DEFAULT_RANGEOF_FORMATS = {
		@@ -36,3 +41,13 @@ minOnly: '{{min}}-',
		};
		/**
		* Simple implementation of a possibly open-ended range of some comparable
		* type `<T>` with test and formatting.
		* @public
		*/
		class RangeOf {
		/**
		* Creates a new {@link RangeOf \| RangeOf<T>}.
		* @param min - Optional mininum extent of the range.
		* @param max - Optional maximum extent of the range.
		*/
		constructor(min, max) {
		@@ -46,5 +61,19 @@ if (((min !== undefined) && (max !== undefined)) &&
		}
		/**
		* Static constructor for a {@link RangeOf \| RangeOf<T>}.
		* @param init - {@link RangeOfProperties \| Range initializer}.
		* @returns A new {@link RangeOf \| RangeOf<T>}.
		*/
		static createRange(init) {
		return (0, result_1.captureResult)(() => new RangeOf(init === null \|\| init === void 0 ? void 0 : init.min, init === null \|\| init === void 0 ? void 0 : init.max));
		}
		/**
		* Gets a formatted description of a {@link RangeOfProperties \| RangeOfProperties<T>} given an
		* optional set of formats and 'empty' value to use.
		* @param range - The {@link RangeOfProperties \| RangeOfProperties<T>} to be formatted.
		* @param formats - Optionas {@link RangeOfFormats \| formats} to use. Default is
		* {@link DEFAULT_RANGEOF_FORMATS \| DEFAULT_RANGEOF_FORMATS}.
		* @param emptyValue - Value which represents unbounded minimum or maximum for this range. Default is `undefined`.
		* @returns A string representation of the range.
		*/
		static propertiesToString(range, formats, emptyValue) {
		@@ -65,2 +94,10 @@ formats = formats !== null && formats !== void 0 ? formats : exports.DEFAULT_RANGEOF_FORMATS;
		}
		/**
		* Default comparison uses javascript built-in comparison.
		* @param t1 - First value to be compared.
		* @param t2 - Second value to be compared.
		* @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
		* and `'equal'` if `t1` and `t2` are equal.
		* @internal
		*/
		static _defaultCompare(t1, t2) {
		@@ -75,2 +112,9 @@ if (t1 < t2) {
		}
		/**
		* Checks if a supplied value is within this range.
		* @param t - The value to be tested.
		* @returns `'included'` if `t` falls within the range, `'less'` if `t` falls
		* below the minimum extent of the range and `'greater'` if `t` is above the
		* maximum extent.
		*/
		check(t) {
		@@ -85,5 +129,18 @@ if ((this.min !== undefined) && (this._compare(t, this.min) === 'less')) {
		}
		/**
		* Determines if a supplied value is within this range.
		* @param t - The value to be tested.
		* @returns Returns `true` if `t` falls within the range, `false` otherwise.
		*/
		includes(t) {
		return this.check(t) === 'included';
		}
		/**
		* Finds the transition value that would bring a supplied value `t` into
		* range.
		* @param t - The value to be tested.
		* @returns The minimum extent of the range if `t` is below the range or
		* the maximum extent of the range if `t` is above the range. Returns
		* `undefined` if `t` already falls within the range.
		*/
		findTransition(t) {
		@@ -98,2 +155,9 @@ switch (this.check(t)) {
		}
		/**
		* Formats the minimum and maximum values of this range.
		* @param format - A format function used to format the values.
		* @returns A {@link RangeOfProperties \| RangeOfProperties<string>} contaning the
		* formatted representation of the {@link RangeOf.min \| minimum} and {@link RangeOf.max \| maximum}
		* extent of the range, or `undefined` for an extent that is not present.
		*/
		toFormattedProperties(format) {
		@@ -105,5 +169,20 @@ return {
		}
		/**
		* Formats this range using the supplied format function.
		* @param format - Format function used to format minimum and maxiumum extent values.
		* @param formats - The {@link RangeOfFormats \| format strings} used to format the range
		* (default {@link DEFAULT_RANGEOF_FORMATS}).
		* @returns Returns a formatted representation of this range.
		*/
		format(format, formats) {
		return RangeOf.propertiesToString(this.toFormattedProperties(format), formats);
		}
		/**
		* Inner compare method can be overriden by a derived class.
		* @param t1 - First value to compare.
		* @param t2 - Second value to compare.
		* @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
		* and `'equal'` if `t1` and `t2` are equal.
		* @internal
		*/
		_compare(t1, t2) {
		@@ -114,2 +193,2 @@ return RangeOf._defaultCompare(t1, t2);
		exports.RangeOf = RangeOf;
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rangeOf.js","sourceRoot":"","sources":["../src/rangeOf.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2020 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Result, captureResult } from './result';\nimport Mustache from 'mustache';\n\nexport interface RangeOfProperties<T> {\n    readonly min?: T;\n    readonly max?: T;\n}\n\nexport interface RangeOfFormats {\n    minOnly: string;\n    maxOnly: string;\n    minMax: string;\n}\n\nexport const DEFAULT_RANGEOF_FORMATS = {\n    minOnly: '{{min}}-',\n    maxOnly: '-{{max}}',\n    minMax: '{{min}}-{{max}}',\n};\n\nexport class RangeOf<T> implements RangeOfProperties<T> {\n    public readonly min?: T;\n    public readonly max?: T;\n\n    public constructor(min?: T, max?: T) {\n        if (((min !== undefined) && (max !== undefined)) &&\n            this._compare(min, max) === 'greater') {\n            throw new Error(`Inverted range - ${JSON.stringify(min)} must be <= ${JSON.stringify(max)}.`);\n        }\n        this.min = min;\n        this.max = max;\n    }\n\n    public static createRange<T>(init?: RangeOfProperties<T>): Result<RangeOf<T>> {\n        return captureResult(() => new RangeOf<T>(init?.min, init?.max));\n    }\n\n    public static propertiesToString<T>(range: RangeOfProperties<T>, formats?: RangeOfFormats, emptyValue?: T): string|undefined {\n        formats = formats ?? DEFAULT_RANGEOF_FORMATS;\n        if ((range.min !== undefined) && (range.min !== emptyValue)) {\n            if ((range.max !== undefined) && (range.max !== emptyValue)) {\n                return Mustache.render(formats.minMax, range);\n            }\n            else {\n                return Mustache.render(formats.minOnly, range);\n            }\n        }\n        else if ((range.max !== undefined) && (range.max !== emptyValue)) {\n            return Mustache.render(formats.maxOnly, range);\n        }\n        return undefined;\n    }\n\n    protected static _defaultCompare<T>(t1: T, t2: T): 'less'|'equal'|'greater' {\n        if (t1 < t2) {\n            return 'less';\n        }\n        else if (t1 > t2) {\n            return 'greater';\n        }\n        return 'equal';\n    }\n\n    public check(t: T): 'less'|'included'|'greater' {\n        if ((this.min !== undefined) && (this._compare(t, this.min) === 'less')) {\n            return 'less';\n        }\n        if ((this.max !== undefined) && (this._compare(t, this.max) !== 'less')) {\n            return 'greater';\n        }\n        return 'included';\n    }\n\n    public includes(t: T): boolean {\n        return this.check(t) === 'included';\n    }\n\n    public findTransition(t: T): T|undefined {\n        switch (this.check(t)) {\n            case 'less':\n                return this.min;\n            case 'included':\n                return this.max;\n        }\n        return undefined;\n    }\n\n    public toFormattedProperties(format: (value: T) => string|undefined): RangeOfProperties<string> {\n        return {\n            min: (this.min !== undefined) ? format(this.min) : undefined,\n            max: (this.max !== undefined) ? format(this.max) : undefined,\n        };\n    }\n\n    public format(format: (value: T) => string|undefined, formats?: RangeOfFormats): string|undefined {\n        return RangeOf.propertiesToString(this.toFormattedProperties(format), formats);\n    }\n\n    protected _compare(t1: T, t2: T): 'less'|'equal'|'greater' {\n        return RangeOf._defaultCompare(t1, t2);\n    }\n}\n"]}
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rangeOf.js","sourceRoot":"","sources":["../src/rangeOf.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2020 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Result, captureResult } from './result';\nimport Mustache from 'mustache';\n\n/**\n * Represents a generic range of some comparable type `<T>`.\n * @public\n */\nexport interface RangeOfProperties<T> {\n    readonly min?: T;\n    readonly max?: T;\n}\n\n/**\n * Format strings (in mustache format) to\n * use for both open-ended and complete\n * {@link RangeOf | RangeOf<T>}.\n * @public\n */\nexport interface RangeOfFormats {\n    minOnly: string;\n    maxOnly: string;\n    minMax: string;\n}\n\n/**\n * Default {@link RangeOfFormats | formats} to use for both\n * open-ended and complete {@link RangeOf | RangeOf<T>}.\n * @public\n */\nexport const DEFAULT_RANGEOF_FORMATS = {\n    minOnly: '{{min}}-',\n    maxOnly: '-{{max}}',\n    minMax: '{{min}}-{{max}}',\n};\n\n/**\n * Simple implementation of a possibly open-ended range of some comparable\n * type `<T>` with test and formatting.\n * @public\n */\nexport class RangeOf<T> implements RangeOfProperties<T> {\n    /**\n     * Minimum extent of the range.\n     */\n    public readonly min?: T;\n    /**\n     * Maximum extent of the range.\n     */\n    public readonly max?: T;\n\n    /**\n     * Creates a new {@link RangeOf | RangeOf<T>}.\n     * @param min - Optional mininum extent of the range.\n     * @param max - Optional maximum extent of the range.\n     */\n    public constructor(min?: T, max?: T) {\n        if (((min !== undefined) && (max !== undefined)) &&\n            this._compare(min, max) === 'greater') {\n            throw new Error(`Inverted range - ${JSON.stringify(min)} must be <= ${JSON.stringify(max)}.`);\n        }\n        this.min = min;\n        this.max = max;\n    }\n\n    /**\n     * Static constructor for a {@link RangeOf | RangeOf<T>}.\n     * @param init - {@link RangeOfProperties | Range initializer}.\n     * @returns A new {@link RangeOf | RangeOf<T>}.\n     */\n    public static createRange<T>(init?: RangeOfProperties<T>): Result<RangeOf<T>> {\n        return captureResult(() => new RangeOf<T>(init?.min, init?.max));\n    }\n\n    /**\n     * Gets a formatted description of a {@link RangeOfProperties | RangeOfProperties<T>} given an\n     * optional set of formats and 'empty' value to use.\n     * @param range - The {@link RangeOfProperties | RangeOfProperties<T>} to be formatted.\n     * @param formats - Optionas {@link RangeOfFormats | formats} to use. Default is\n     * {@link DEFAULT_RANGEOF_FORMATS | DEFAULT_RANGEOF_FORMATS}.\n     * @param emptyValue - Value which represents unbounded minimum or maximum for this range. Default is `undefined`.\n     * @returns A string representation of the range.\n     */\n    public static propertiesToString<T>(range: RangeOfProperties<T>, formats?: RangeOfFormats, emptyValue?: T): string|undefined {\n        formats = formats ?? DEFAULT_RANGEOF_FORMATS;\n        if ((range.min !== undefined) && (range.min !== emptyValue)) {\n            if ((range.max !== undefined) && (range.max !== emptyValue)) {\n                return Mustache.render(formats.minMax, range);\n            }\n            else {\n                return Mustache.render(formats.minOnly, range);\n            }\n        }\n        else if ((range.max !== undefined) && (range.max !== emptyValue)) {\n            return Mustache.render(formats.maxOnly, range);\n        }\n        return undefined;\n    }\n\n    /**\n     * Default comparison uses javascript built-in comparison.\n     * @param t1 - First value to be compared.\n     * @param t2 - Second value to be compared.\n     * @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger\n     * and `'equal'` if `t1` and `t2` are equal.\n     * @internal\n     */\n    protected static _defaultCompare<T>(t1: T, t2: T): 'less'|'equal'|'greater' {\n        if (t1 < t2) {\n            return 'less';\n        }\n        else if (t1 > t2) {\n            return 'greater';\n        }\n        return 'equal';\n    }\n\n    /**\n     * Checks if a supplied value is within this range.\n     * @param t - The value to be tested.\n     * @returns `'included'` if `t` falls within the range, `'less'` if `t` falls\n     * below the minimum extent of the range and `'greater'` if `t` is above the\n     * maximum extent.\n     */\n    public check(t: T): 'less'|'included'|'greater' {\n        if ((this.min !== undefined) && (this._compare(t, this.min) === 'less')) {\n            return 'less';\n        }\n        if ((this.max !== undefined) && (this._compare(t, this.max) !== 'less')) {\n            return 'greater';\n        }\n        return 'included';\n    }\n\n    /**\n     * Determines if a supplied value is within this range.\n     * @param t - The value to be tested.\n     * @returns Returns `true` if `t` falls within the range, `false` otherwise.\n     */\n    public includes(t: T): boolean {\n        return this.check(t) === 'included';\n    }\n\n    /**\n     * Finds the transition value that would bring a supplied value `t` into\n     * range.\n     * @param t - The value to be tested.\n     * @returns The minimum extent of the range if `t` is below the range or\n     * the maximum extent of the range if `t` is above the range.  Returns\n     * `undefined` if `t` already falls within the range.\n     */\n    public findTransition(t: T): T|undefined {\n        switch (this.check(t)) {\n            case 'less':\n                return this.min;\n            case 'included':\n                return this.max;\n        }\n        return undefined;\n    }\n\n    /**\n     * Formats the minimum and maximum values of this range.\n     * @param format - A format function used to format the values.\n     * @returns A {@link RangeOfProperties | RangeOfProperties<string>} contaning the\n     * formatted representation of the {@link RangeOf.min | minimum} and {@link RangeOf.max | maximum}\n     * extent of the range, or `undefined` for an extent that is not present.\n     */\n    public toFormattedProperties(format: (value: T) => string|undefined): RangeOfProperties<string> {\n        return {\n            min: (this.min !== undefined) ? format(this.min) : undefined,\n            max: (this.max !== undefined) ? format(this.max) : undefined,\n        };\n    }\n\n    /**\n     * Formats this range using the supplied format function.\n     * @param format - Format function used to format minimum and maxiumum extent values.\n     * @param formats - The {@link RangeOfFormats | format strings} used to format the range\n     * (default {@link DEFAULT_RANGEOF_FORMATS}).\n     * @returns Returns a formatted representation of this range.\n     */\n    public format(format: (value: T) => string|undefined, formats?: RangeOfFormats): string|undefined {\n        return RangeOf.propertiesToString(this.toFormattedProperties(format), formats);\n    }\n\n    /**\n     * Inner compare method can be overriden by a derived class.\n     * @param t1 - First value to compare.\n     * @param t2 - Second value to compare.\n     * @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger\n     * and `'equal'` if `t1` and `t2` are equal.\n     * @internal\n     */\n    protected _compare(t1: T, t2: T): 'less'|'equal'|'greater' {\n        return RangeOf._defaultCompare(t1, t2);\n    }\n}\n"]}

README.md

		@@ -24,2 +24,3 @@ <div align="center">
		- [Installation](#installation)
		- [API Documentation](#api-documentation)
		- [Overview](#overview)
		@@ -44,2 +45,5 @@ - [The Result Pattern](#the-result-pattern)

		## API Documentation
		Extracted API documentation is [here](./docs/ts-utils.md).

		## Overview
		@@ -46,0 +50,0 @@ ### The Result Pattern

432

result.d.ts

		@@ -0,122 +1,474 @@
		/**
		* Represents the {@link IResult \| result} of some operation or sequence of operations.
		* @remarks
		* {@link Success \| Success<T>} and {@link Failure \| Failure<T>} share the common
		* contract {@link IResult}, enabling comingled discriminated usage.
		* @public
		*/
		export declare type Result<T> = Success<T> \| Failure<T>;
		/**
		* Continuation callback to be called in the event that an
		* {@link Result} is successful.
		* @public
		*/
		export declare type SuccessContinuation<T, TN> = (value: T) => Result<TN>;
		/**
		* Continuation callback to be called in the event that an
		* {@link Result} fails.
		* @public
		*/
		export declare type FailureContinuation<T> = (message: string) => Result<T>;
		/**
		* Type inference to determine the result type of an {@link Result}.
		* @beta
		*/
		export declare type ResultValueType<T> = T extends Result<infer TV> ? TV : never;
		/**
		* Simple logger interface used by {@link IResult.getValueOrThrow}.
		* @public
		*/
		export interface IResultLogger {
		/**
		* Log an error message.
		* @param message - The message to be logged.
		*/
		error(message: string): void;
		}
		/**
		* Represents the result of some operation of sequence of operations.
		* @remarks
		* This common contract enables comingled discriminated usage of {@link Success \| Success<T>}
		* and {@link Failure \| Failure<T>}.
		* @public
		*/
		export interface IResult<T> {
		/**
		* Indicates whether the operation was successful.
		*/
		readonly success: boolean;
		/**
		* Indicates whether this operation was successful. Functions
		* as a type guard for {@link Success \| Success<T>}.
		*/
		isSuccess(): this is Success<T>;
		/**
		* Indicates whether this operation failed. Functions
		* as a type guard for {@link Failure \| Failure<T>}.
		*/
		isFailure(): this is Failure<T>;
		/**
		* Gets the value associated with a successful {@link IResult \| result},
		* or throws the error message if the corresponding operation failed.
		* @param logger - An optional {@link IResultLogger \| logger} to which the
		* error will also be reported.
		* @returns The return value, if the operation was successful.
		* @throws The error message if the operation failed.
		*/
		getValueOrThrow(logger?: IResultLogger): T;
		/**
		* Gets the value associated with a successful {@link IResult \| result},
		* or a default value if the corresponding operation failed.
		* @param dflt - The value to be returned if the operation failed (default is
		* `undefined`).
		* @returns The return value, if the operation was successful. Returns
		* the supplied default value or `undefined` if no default is supplied.
		*/
		getValueOrDefault(dflt?: T): T \| undefined;
		/**
		* Calls a supplied {@link SuccessContinuation \| success continuation} if
		* the operation was a success.
		* @remarks
		* The {@link SuccessContinuation \| success continuation} might return a
		* different result type than {@link IResult} on which it is invoked. This
		* enables chaining of operations with heterogenous return types.
		*
		* @param cb - The {@link SuccessContinuation \| success continuation} to
		* be called in the event of success.
		* @returns If this operation was successful, returns the value returned
		* by the {@link SuccessContinuation \| success continuation}. If this result
		* failed, propagates the error message from this failure.
		*/
		onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN>;
		/**
		* Calls a supplied {@link FailureContinuation \| failed continuation} if
		* the operation failed.
		* @param cb - The {@link FailureContinuation \| failure continuation} to
		* be called in the event of failure.
		* @returns If this operation failed, returns the value returned by the
		* {@link FailureContinuation \| failure continuation}. If this result
		* was successful, propagates the result value from the successful event.
		*/
		onFailure(cb: FailureContinuation<T>): Result<T>;
		/**
		* Converts a {@link IResult \| IResult<T>} to a {@link DetailedResult \| DetailedResult<T, TD>},
		* adding a supplied detail if the operation failed.
		* @param detail - The detail to be added if this operation failed.
		* @returns A new {@link DetailedResult \| DetailedResult<T, TD>} with either
		* the success result or the error message from this {@link IResult}, with
		* the supplied detail (if this event failed) or detail `undefined` (if
		* this result succeeded).
		*/
		withFailureDetail<TD>(detail: TD): DetailedResult<T, TD>;
		/**
		* Converts a {@link IResult \| IResult<T>} to a {@link DetailedResult \| DetailedResult<T, TD>},
		* adding supplied details.
		* @param detail - The default detail to be added to the new {@link DetailedResult}.
		* @param successDetail - An optional detail to be added if this result was successful.
		* @returns A new {@link DetailedResult \| DetailedResult<T, TD>} with either
		* the success result or the error message from this {@link IResult} and the
		* appopriate added detail.
		*/
		withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;
		}
		/**
		* Reports a successful {@link IResult \| result} from some operation and the
		* corresponding value.
		* @public
		*/
		export declare class Success<T> implements IResult<T> {
		/**
		* {@inheritdoc IResult.success}
		*/
		readonly success = true;
		/**
		* @internal
		*/
		private readonly _value;
		/**
		* Constructs a {@link Success} with the supplied value.
		* @param value - The value to be returned.
		*/
		constructor(value: T);
		/**
		* The result value returned by the successful operation.
		*/
		get value(): T;
		/**
		* {@inheritdoc IResult.isSuccess}
		*/
		isSuccess(): this is Success<T>;
		/**
		* {@inheritdoc IResult.isFailure}
		*/
		isFailure(): this is Failure<T>;
		get value(): T;
		/**
		* {@inheritdoc IResult.getValueOrThrow}
		*/
		getValueOrThrow(_logger?: IResultLogger): T;
		/**
		* {@inheritdoc IResult.getValueOrDefault}
		*/
		getValueOrDefault(dflt?: T): T \| undefined;
		/**
		* {@inheritdoc IResult.onSuccess}
		*/
		onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN>;
		/**
		* {@inheritdoc IResult.onFailure}
		*/
		onFailure(_: FailureContinuation<T>): Result<T>;
		/**
		* {@inheritdoc IResult.withFailureDetail}
		*/
		withFailureDetail<TD>(_detail: TD): DetailedResult<T, TD>;
		/**
		* {@inheritdoc IResult.withDetail}
		*/
		withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;
		}
		/**
		* Reports a failed {@link IResult \| result} from some operation, with an error message.
		* @public
		*/
		export declare class Failure<T> implements IResult<T> {
		/**
		* {@inheritdoc IResult.success}
		*/
		readonly success = false;
		/**
		* @internal
		*/
		private readonly _message;
		/**
		* Constructs a {@link Failure} with the supplied message.
		* @param message - Error message to be reported.
		*/
		constructor(message: string);
		/**
		* Gets the error message associated with this error.
		*/
		get message(): string;
		/**
		* {@inheritdoc IResult.isSuccess}
		*/
		isSuccess(): this is Success<T>;
		/**
		* {@inheritdoc IResult.isFailure}
		*/
		isFailure(): this is Failure<T>;
		get message(): string;
		/**
		* {@inheritdoc IResult.getValueOrThrow}
		*/
		getValueOrThrow(logger?: IResultLogger): never;
		/**
		* {@inheritdoc IResult.getValueOrDefault}
		*/
		getValueOrDefault(dflt?: T): T \| undefined;
		/**
		* {@inheritdoc IResult.onSuccess}
		*/
		onSuccess<TN>(_: SuccessContinuation<T, TN>): Result<TN>;
		/**
		* {@inheritdoc IResult.onFailure}
		*/
		onFailure(cb: FailureContinuation<T>): Result<T>;
		/**
		* {@inheritdoc IResult.withFailureDetail}
		*/
		withFailureDetail<TD>(detail: TD): DetailedResult<T, TD>;
		/**
		* {@inheritdoc IResult.withDetail}
		*/
		withDetail<TD>(detail: TD, _successDetail?: TD): DetailedResult<T, TD>;
		/**
		* Get a 'friendly' string representation of this object.
		* @remarks
		* The string representation of a {@link Failure} value is the error message.
		* @returns A string representing this object.
		*/
		toString(): string;
		}
		/**
		* Helper function for successful return
		* @param val The value to be returned
		* Returns {@link Success \| Success<T>} with the supplied result value.
		* @param value - The successful result value to be returned
		* @public
		*/
		export declare function succeed<T>(val: T): Success<T>;
		export declare function succeed<T>(value: T): Success<T>;
		/**
		* Helper function for error return
		* @param message Error message to be returned
		* Returns {@link Failure \| Failure<T>} with the supplied error message.
		* @param message - Error message to be returned.
		* @public
		*/
		export declare function fail<T>(message: string): Failure<T>;
		/**
		* Callback to be called when a {@link DetailedResult} encounters success.
		* @remarks
		* A success callback can return a different result type than it receives, allowing
		* success results to chain through intermediate result types.
		* @public
		*/
		export declare type DetailedSuccessContinuation<T, TD, TN> = (value: T, detail?: TD) => DetailedResult<TN, TD>;
		/**
		* Callback to be called when a {@link DetailedResult} encounters a failure.
		* @remarks
		* A failure callback can change {@link Failure} to {@link Success} (e.g. by returning a default value)
		* or it can change or embellish the error message, but it cannot change the success return type.
		* @public
		*/
		export declare type DetailedFailureContinuation<T, TD> = (message: string, detail: TD) => DetailedResult<T, TD>;
		/**
		* A {@link DetailedSuccess} extends {@link Success} to report optional success details in
		* addition to the error message.
		* @public
		*/
		export declare class DetailedSuccess<T, TD> extends Success<T> {
		/**
		* @internal
		*/
		protected _detail?: TD;
		/**
		* Constructs a new {@link DetailedSuccess \| DetailedSuccess<T, TD>} with the supplied
		* value and detail.
		* @param value - The value to be returned.
		* @param detail - An optional successful detail to be returned. If omitted, detail
		* will be `undefined`.
		*/
		constructor(value: T, detail?: TD);
		/**
		* The success detail associated with this {@link DetailedSuccess}, or `undefined` if
		* no detail was supplied.
		*/
		get detail(): TD \| undefined;
		/**
		* Reports that this {@link DetailedSuccess} is a success.
		* @remarks
		* Always true for {@link DetailedSuccess} but can be used as type guard
		* to discriminate {@link DetailedSuccess} from {@link DetailedFailure} in
		* a {@link DetailedResult}.
		* @returns `true`
		*/
		isSuccess(): this is DetailedSuccess<T, TD>;
		/**
		* Invokes the supplied {@link DetailedSuccessContinuation \| success callback} and propagates
		* its returned {@link DetailedResult \| DetailedResult<TN, TD>}.
		* @remarks
		* The success callback mutates the return type from `<T>` to `<TN>`.
		* @param cb - The {@link DetailedSuccessContinuation \| success callback} to be invoked.
		* @returns The {@link DetailedResult \| DetailedResult<T, TD>} returned by the success callback.
		*/
		onSuccess<TN>(cb: DetailedSuccessContinuation<T, TD, TN>): DetailedResult<TN, TD>;
		/**
		* Propagates this {@link DetailedSuccess}.
		* @remarks
		* Failure does not mutate return type so we can return this event directly.
		* @param _cb - {@link DetailedFailureContinuation \| Failure callback} to be called
		* on a {@link DetailedResult} in case of failure (ignored).
		* @returns `this`
		*/
		onFailure(_cb: DetailedFailureContinuation<T, TD>): DetailedResult<T, TD>;
		}
		/**
		* A DetailedFailure reports optional failure details in addition
		* to the standard failure message.
		* A {@link DetailedFailure} extends {@link Failure} to report optional failure details in
		* addition to the error message.
		* @public
		*/
		export declare class DetailedFailure<T, TD> extends Failure<T> {
		/**
		* @internal
		*/
		protected _detail: TD;
		/**
		* Constructs a new {@link DetailedFailure \| DetailedFailure<T, TD>} with the supplied
		* message and detail.
		* @param message - The message to be returned.
		* @param detail - The error detail to be returned.
		*/
		constructor(message: string, detail: TD);
		/**
		* The error detail associated with this {@link DetailedFailure}.
		*/
		get detail(): TD;
		/**
		* Reports that this {@link DetailedFailure} is a failure.
		* @remarks
		* Always true for {@link DetailedFailure} but can be used as type guard
		* to discriminate {@link DetailedSuccess} from {@link DetailedFailure} in
		* a {@link DetailedResult}.
		* @returns `true`
		*/
		isFailure(): this is DetailedFailure<T, TD>;
		/**
		* Propagates the error message and detail from this result.
		* @remarks
		* Mutates the success type as the success callback would have, but does not
		* call the success callback.
		* @param _cb - {@link DetailedSuccessContinuation \| Success callback} to be called
		* on a {@link DetailedResult} in case of success (ignored).
		* @returns A new {@link DetailedFailure \| DetailedFailure<TN, TD>} which contains
		* the error message and detail from this one.
		*/
		onSuccess<TN>(_cb: DetailedSuccessContinuation<T, TD, TN>): DetailedResult<TN, TD>;
		/**
		* Invokes the supplied {@link DetailedFailureContinuation \| failure callback} and propagates
		* its returned {@link DetailedResult \| DetailedResult<T, TD>}.
		* @param cb - The {@link DetailedFailureContinuation \| failure callback} to be invoked.
		* @returns The {@link DetailedResult \| DetailedResult<T, TD>} returned by the failure callback.
		*/
		onFailure(cb: DetailedFailureContinuation<T, TD>): DetailedResult<T, TD>;
		}
		/**
		* Type inference to determine the result type `T` of a {@link DetailedResult \| DetailedResult<T, TD>}.
		* @beta
		*/
		export declare type DetailedResult<T, TD> = DetailedSuccess<T, TD> \| DetailedFailure<T, TD>;
		/**
		* Type inference to determine the detail type `TD` of a {@link DetailedResult \| DetailedResult<T, TD>}.
		* @beta
		*/
		export declare type ResultDetailType<T> = T extends DetailedResult<unknown, infer TD> ? TD : never;
		/**
		* Returns {@link DetailedSuccess \| DetailedSuccess<T, TD>} with a supplied value and optional
		* detail.
		* @param value - The value of type `<T>` to be returned.
		* @param detail - An optional detail of type `<TD>` to be returned.
		* @returns A {@link DetailedSuccess \| DetailedSuccess<T, TD>} with the supplied value
		* and detail, if supplied.
		* @public
		*/
		export declare function succeedWithDetail<T, TD>(value: T, detail?: TD): DetailedSuccess<T, TD>;
		/**
		* Returns {@link DetailedFailure \| DetailedFailure<T, TD>} with a supplied error message and detail.
		* @param message - The error message to be returned.
		* @param detail - The event detail to be returned.
		* @returns An {@link DetailedFailure \| DetailedFailure<T, TD>} with the supplied error
		* message and detail.
		* @public
		*/
		export declare function failWithDetail<T, TD>(message: string, detail: TD): DetailedFailure<T, TD>;
		/**
		* Propagates a {@link Success} or {@link Failure} {@link Result}, adding supplied
		* event details as appropriate.
		* @param result - The {@link Result} to be propagated.
		* @param detail - The event detail (type `<TD>`) to be added to the {@link Result \| result}.
		* @param successDetail - An optional distinct event detail to be added to {@link Success} results. If `successDetail`
		* is omitted or `undefined`, then `detail` will be applied to {@link Success} results.
		* @returns A new {@link DetailedResult \| DetailedResult<T, TD>} with the success value or error
		* message from the original `result` but with the specified detail added.
		* @public
		*/
		export declare function propagateWithDetail<T, TD>(result: Result<T>, detail: TD, successDetail?: TD): DetailedResult<T, TD>;
		/**
		* Wraps a function which returns a value of type <T> or throws
		* to produce Success<T> or Failure<T>
		* @param func The method to be captured
		* Wraps a function which might throw to convert exception results
		* to {@link Failure}.
		* @param func - The function to be captured.
		* @returns Returns {@link Success} with a value of type `<T>` on
		* success , or {@link Failure} with the thrown error message if
		* `func` throws an `Error`.
		* @public
		*/
		export declare function captureResult<T>(func: () => T): Result<T>;
		/**
		* Maps an array of Result<T> to an array of <T>, if all results are
		* successful. If any results fail, returns failure with a concatenated
		* summary of all failure messages.
		* @param resultsIn The results to be mapped.
		* Aggregates sucessful result values from a collection of {@link Result \| Result<T>}.
		* @param results - The collection of {@link Result \| Result<T>} to be mapped.
		* @returns If all {@link Result \| results} are successful, returns {@link Success} with an
		* array containing all returned values. If any {@link Result \| results} failed, returns
		* {@link Failure} with a concatenated summary of all error messages.
		* @public
		*/
		export declare function mapResults<T>(resultsIn: Iterable<Result<T>>): Result<T[]>;
		export declare function mapResults<T>(results: Iterable<Result<T>>): Result<T[]>;
		/**
		* Maps an array of DetailedResult<T, TD> to an array of <T>, if all results are
		* successful or yield ignorable errors. If any results fail with an error that
		* cannot be ignored, returns failure with a concatenated summary of all failure messages.
		* @param resultsIn The results to be mapped.
		* @param ignore Error detail values that should be ignored
		* Aggregates sucessful results from a collection of {@link DetailedResult \| DetailedResult<T, TD>},
		* optionally ignoring certain error details.
		* @param results - The collection of {@link DetailedResult \| DetailedResult<T, TD>} to be mapped.
		* @param ignore - An array of error detail values (of type `<TD>`) that should be ignored.
		* @returns {@link Success} with an array containing all successful results if all results either
		* suceeded or returned error details listed in `ignore`. If any results failed with details
		* that cannot be ignored, returns {@link Failure} with an concatenated summary of all non-ignorable
		* error mesasges.
		* @public
		*/
		export declare function mapDetailedResults<T, TD>(resultsIn: Iterable<DetailedResult<T, TD>>, ignore: TD[]): Result<T[]>;
		export declare function mapDetailedResults<T, TD>(results: Iterable<DetailedResult<T, TD>>, ignore: TD[]): Result<T[]>;
		/**
		* Maps an array of Result<T> to an array of <T>, omitting any error
		* results. If no results were successful, returns failure with a
		* concatenated summary of all failure messages.
		* Aggregates successful results from a a collection of {@link Result \| Result<T>}.
		* @param results - An `Iterable` of {@link Result \| Result<T>} from which success
		* results are to be aggregated.
		* @returns {@link Success} with an array of `<T>` if any results were successful. If
		* all {@link Result \| results} failed, returns {@link Failure} with a concatenated
		* summary of all error messages.
		* @public
		*/
		export declare function mapSuccess<T>(resultsIn: Iterable<Result<T>>): Result<T[]>;
		export declare function mapSuccess<T>(results: Iterable<Result<T>>): Result<T[]>;
		/**
		* Maps an array of Result<T> to an array of strings consisting of all
		* error messages returned by results in the source array. Ignores
		* success results and returns an empty array if there were no errors.
		* @param resultsIn results to be reported
		* Aggregates error messages from a collection of {@link Result \| Result<T>}.
		* @param results - An interable collection of {@link Result \| Result<T>} for which
		* error messages are aggregated.
		* @returns An array of strings consisting of all error messages returned by
		* {@link Result \| results} in the source collection. Ignores {@link Success}
		* results and returns an empty array if there were no errors.
		* @public
		*/
		export declare function mapFailures<T>(resultsIn: Iterable<Result<T>>): string[];
		export declare function mapFailures<T>(results: Iterable<Result<T>>): string[];
		/**
		* Returns success with true if all results are successful. If any are unsuccessful,
		* returns failure with a concatenated summary of all failure messages.
		* @param results The results to be tested.
		* Determines if an iterable collection of {@link Result \| Result<T>} were all successful.
		* @param results - The collection of {@link Result \| Result<T>} to be tested.
		* @returns Returns {@link Success} with `true` if all {@link Result \| results} are successful.
		* If any are unsuccessful, returns {@link Failure} with a concatenated summary the error
		* messages from all failed elements.
		* @public
		*/
		export declare function allSucceed<T>(results: Iterable<Result<unknown>>, successValue: T): Result<T>;
		/**
		* String-keyed record of initialization functions to be passed to {@link populateObject}.
		* @public
		*/
		export declare type FieldInitializers<T> = {
		@@ -126,8 +478,10 @@ [key in keyof T]: (state: Partial<T>) => Result<T[key]>;
		/**
		* Populates an an object based on a prototype full of field initializers that return Result<T[key]>.
		* Returns success with the populated object if all initializers succeed, or failure with a
		* concatenated list of all failure messages.
		* @param initializers An object with the shape of the target but with initializer functions for
		* Populates an an object based on a prototype full of field initializers that return {@link Result \| Result<T[key]>}.
		* Returns {@link Success} with the populated object if all initializers succeed, or {@link Failure} with a
		* concatenated list of all error messages.
		* @param initializers - An object with the shape of the target but with initializer functions for
		* each property.
		* @public
		*/
		export declare function populateObject<T>(initializers: FieldInitializers<T>, order?: (keyof T)[]): Result<T>;
		//# sourceMappingURL=result.d.ts.map

308

result.js

		@@ -25,18 +25,46 @@ "use strict";
		exports.populateObject = exports.allSucceed = exports.mapFailures = exports.mapSuccess = exports.mapDetailedResults = exports.mapResults = exports.captureResult = exports.propagateWithDetail = exports.failWithDetail = exports.succeedWithDetail = exports.DetailedFailure = exports.DetailedSuccess = exports.fail = exports.succeed = exports.Failure = exports.Success = void 0;
		/**
		* Reports a successful {@link IResult \| result} from some operation and the
		* corresponding value.
		* @public
		*/
		class Success {
		/**
		* Constructs a {@link Success} with the supplied value.
		* @param value - The value to be returned.
		*/
		constructor(value) {
		/**
		* {@inheritdoc IResult.success}
		*/
		this.success = true;
		this._value = value;
		}
		/**
		* The result value returned by the successful operation.
		*/
		get value() {
		return this._value;
		}
		/**
		* {@inheritdoc IResult.isSuccess}
		*/
		isSuccess() {
		return true;
		}
		/**
		* {@inheritdoc IResult.isFailure}
		*/
		isFailure() {
		return false;
		}
		get value() {
		return this._value;
		}
		/**
		* {@inheritdoc IResult.getValueOrThrow}
		*/
		getValueOrThrow(_logger) {
		return this._value;
		}
		/**
		* {@inheritdoc IResult.getValueOrDefault}
		*/
		getValueOrDefault(dflt) {
		@@ -46,11 +74,23 @@ var _a;
		}
		/**
		* {@inheritdoc IResult.onSuccess}
		*/
		onSuccess(cb) {
		return cb(this.value);
		}
		/**
		* {@inheritdoc IResult.onFailure}
		*/
		onFailure(_) {
		return this;
		}
		/**
		* {@inheritdoc IResult.withFailureDetail}
		*/
		withFailureDetail(_detail) {
		return succeedWithDetail(this.value);
		}
		/**
		* {@inheritdoc IResult.withDetail}
		*/
		withDetail(detail, successDetail) {
		@@ -61,15 +101,39 @@ return succeedWithDetail(this.value, successDetail !== null && successDetail !== void 0 ? successDetail : detail);
		exports.Success = Success;
		/**
		* Reports a failed {@link IResult \| result} from some operation, with an error message.
		* @public
		*/
		class Failure {
		/**
		* Constructs a {@link Failure} with the supplied message.
		* @param message - Error message to be reported.
		*/
		constructor(message) {
		/**
		* {@inheritdoc IResult.success}
		*/
		this.success = false;
		this._message = message;
		}
		/**
		* Gets the error message associated with this error.
		*/
		get message() {
		return this._message;
		}
		/**
		* {@inheritdoc IResult.isSuccess}
		*/
		isSuccess() {
		return false;
		}
		/**
		* {@inheritdoc IResult.isFailure}
		*/
		isFailure() {
		return true;
		}
		get message() {
		return this._message;
		}
		/**
		* {@inheritdoc IResult.getValueOrThrow}
		*/
		getValueOrThrow(logger) {
		@@ -81,17 +145,38 @@ if (logger !== undefined) {
		}
		/**
		* {@inheritdoc IResult.getValueOrDefault}
		*/
		getValueOrDefault(dflt) {
		return dflt;
		}
		/**
		* {@inheritdoc IResult.onSuccess}
		*/
		onSuccess(_) {
		return new Failure(this.message);
		}
		/**
		* {@inheritdoc IResult.onFailure}
		*/
		onFailure(cb) {
		return cb(this.message);
		}
		/**
		* {@inheritdoc IResult.withFailureDetail}
		*/
		withFailureDetail(detail) {
		return failWithDetail(this.message, detail);
		}
		/**
		* {@inheritdoc IResult.withDetail}
		*/
		withDetail(detail, _successDetail) {
		return failWithDetail(this.message, detail);
		}
		/**
		* Get a 'friendly' string representation of this object.
		* @remarks
		* The string representation of a {@link Failure} value is the error message.
		* @returns A string representing this object.
		*/
		toString() {
		@@ -103,12 +188,14 @@ return this.message;
		/**
		* Helper function for successful return
		* @param val The value to be returned
		* Returns {@link Success \| Success<T>} with the supplied result value.
		* @param value - The successful result value to be returned
		* @public
		*/
		function succeed(val) {
		return new Success(val);
		function succeed(value) {
		return new Success(value);
		}
		exports.succeed = succeed;
		/**
		* Helper function for error return
		* @param message Error message to be returned
		* Returns {@link Failure \| Failure<T>} with the supplied error message.
		* @param message - Error message to be returned.
		* @public
		*/
		@@ -119,3 +206,15 @@ function fail(message) {
		exports.fail = fail;
		/**
		* A {@link DetailedSuccess} extends {@link Success} to report optional success details in
		* addition to the error message.
		* @public
		*/
		class DetailedSuccess extends Success {
		/**
		* Constructs a new {@link DetailedSuccess \| DetailedSuccess<T, TD>} with the supplied
		* value and detail.
		* @param value - The value to be returned.
		* @param detail - An optional successful detail to be returned. If omitted, detail
		* will be `undefined`.
		*/
		constructor(value, detail) {
		@@ -125,11 +224,39 @@ super(value);
		}
		/**
		* The success detail associated with this {@link DetailedSuccess}, or `undefined` if
		* no detail was supplied.
		*/
		get detail() {
		return this._detail;
		}
		/**
		* Reports that this {@link DetailedSuccess} is a success.
		* @remarks
		* Always true for {@link DetailedSuccess} but can be used as type guard
		* to discriminate {@link DetailedSuccess} from {@link DetailedFailure} in
		* a {@link DetailedResult}.
		* @returns `true`
		*/
		isSuccess() {
		return true;
		}
		/**
		* Invokes the supplied {@link DetailedSuccessContinuation \| success callback} and propagates
		* its returned {@link DetailedResult \| DetailedResult<TN, TD>}.
		* @remarks
		* The success callback mutates the return type from `<T>` to `<TN>`.
		* @param cb - The {@link DetailedSuccessContinuation \| success callback} to be invoked.
		* @returns The {@link DetailedResult \| DetailedResult<T, TD>} returned by the success callback.
		*/
		onSuccess(cb) {
		return cb(this.value, this._detail);
		}
		/**
		* Propagates this {@link DetailedSuccess}.
		* @remarks
		* Failure does not mutate return type so we can return this event directly.
		* @param _cb - {@link DetailedFailureContinuation \| Failure callback} to be called
		* on a {@link DetailedResult} in case of failure (ignored).
		* @returns `this`
		*/
		onFailure(_cb) {
		@@ -141,6 +268,13 @@ return this;
		/**
		* A DetailedFailure reports optional failure details in addition
		* to the standard failure message.
		* A {@link DetailedFailure} extends {@link Failure} to report optional failure details in
		* addition to the error message.
		* @public
		*/
		class DetailedFailure extends Failure {
		/**
		* Constructs a new {@link DetailedFailure \| DetailedFailure<T, TD>} with the supplied
		* message and detail.
		* @param message - The message to be returned.
		* @param detail - The error detail to be returned.
		*/
		constructor(message, detail) {
		@@ -150,11 +284,38 @@ super(message);
		}
		/**
		* The error detail associated with this {@link DetailedFailure}.
		*/
		get detail() {
		return this._detail;
		}
		/**
		* Reports that this {@link DetailedFailure} is a failure.
		* @remarks
		* Always true for {@link DetailedFailure} but can be used as type guard
		* to discriminate {@link DetailedSuccess} from {@link DetailedFailure} in
		* a {@link DetailedResult}.
		* @returns `true`
		*/
		isFailure() {
		return true;
		}
		/**
		* Propagates the error message and detail from this result.
		* @remarks
		* Mutates the success type as the success callback would have, but does not
		* call the success callback.
		* @param _cb - {@link DetailedSuccessContinuation \| Success callback} to be called
		* on a {@link DetailedResult} in case of success (ignored).
		* @returns A new {@link DetailedFailure \| DetailedFailure<TN, TD>} which contains
		* the error message and detail from this one.
		*/
		onSuccess(_cb) {
		return new DetailedFailure(this.message, this._detail);
		}
		/**
		* Invokes the supplied {@link DetailedFailureContinuation \| failure callback} and propagates
		* its returned {@link DetailedResult \| DetailedResult<T, TD>}.
		* @param cb - The {@link DetailedFailureContinuation \| failure callback} to be invoked.
		* @returns The {@link DetailedResult \| DetailedResult<T, TD>} returned by the failure callback.
		*/
		onFailure(cb) {
		@@ -165,2 +326,11 @@ return cb(this.message, this._detail);
		exports.DetailedFailure = DetailedFailure;
		/**
		* Returns {@link DetailedSuccess \| DetailedSuccess<T, TD>} with a supplied value and optional
		* detail.
		* @param value - The value of type `<T>` to be returned.
		* @param detail - An optional detail of type `<TD>` to be returned.
		* @returns A {@link DetailedSuccess \| DetailedSuccess<T, TD>} with the supplied value
		* and detail, if supplied.
		* @public
		*/
		function succeedWithDetail(value, detail) {
		@@ -170,2 +340,10 @@ return new DetailedSuccess(value, detail);
		exports.succeedWithDetail = succeedWithDetail;
		/**
		* Returns {@link DetailedFailure \| DetailedFailure<T, TD>} with a supplied error message and detail.
		* @param message - The error message to be returned.
		* @param detail - The event detail to be returned.
		* @returns An {@link DetailedFailure \| DetailedFailure<T, TD>} with the supplied error
		* message and detail.
		* @public
		*/
		function failWithDetail(message, detail) {
		@@ -175,2 +353,13 @@ return new DetailedFailure(message, detail);
		exports.failWithDetail = failWithDetail;
		/**
		* Propagates a {@link Success} or {@link Failure} {@link Result}, adding supplied
		* event details as appropriate.
		* @param result - The {@link Result} to be propagated.
		* @param detail - The event detail (type `<TD>`) to be added to the {@link Result \| result}.
		* @param successDetail - An optional distinct event detail to be added to {@link Success} results. If `successDetail`
		* is omitted or `undefined`, then `detail` will be applied to {@link Success} results.
		* @returns A new {@link DetailedResult \| DetailedResult<T, TD>} with the success value or error
		* message from the original `result` but with the specified detail added.
		* @public
		*/
		function propagateWithDetail(result, detail, successDetail) {
		@@ -183,5 +372,9 @@ return result.isSuccess()
		/**
		* Wraps a function which returns a value of type <T> or throws
		* to produce Success<T> or Failure<T>
		* @param func The method to be captured
		* Wraps a function which might throw to convert exception results
		* to {@link Failure}.
		* @param func - The function to be captured.
		* @returns Returns {@link Success} with a value of type `<T>` on
		* success , or {@link Failure} with the thrown error message if
		* `func` throws an `Error`.
		* @public
		*/
		@@ -198,11 +391,13 @@ function captureResult(func) {
		/**
		* Maps an array of Result<T> to an array of <T>, if all results are
		* successful. If any results fail, returns failure with a concatenated
		* summary of all failure messages.
		* @param resultsIn The results to be mapped.
		* Aggregates sucessful result values from a collection of {@link Result \| Result<T>}.
		* @param results - The collection of {@link Result \| Result<T>} to be mapped.
		* @returns If all {@link Result \| results} are successful, returns {@link Success} with an
		* array containing all returned values. If any {@link Result \| results} failed, returns
		* {@link Failure} with a concatenated summary of all error messages.
		* @public
		*/
		function mapResults(resultsIn) {
		function mapResults(results) {
		const errors = [];
		const elements = [];
		for (const result of resultsIn) {
		for (const result of results) {
		if (result.isSuccess()) {
		@@ -222,12 +417,16 @@ elements.push(result.value);
		/**
		* Maps an array of DetailedResult<T, TD> to an array of <T>, if all results are
		* successful or yield ignorable errors. If any results fail with an error that
		* cannot be ignored, returns failure with a concatenated summary of all failure messages.
		* @param resultsIn The results to be mapped.
		* @param ignore Error detail values that should be ignored
		* Aggregates sucessful results from a collection of {@link DetailedResult \| DetailedResult<T, TD>},
		* optionally ignoring certain error details.
		* @param results - The collection of {@link DetailedResult \| DetailedResult<T, TD>} to be mapped.
		* @param ignore - An array of error detail values (of type `<TD>`) that should be ignored.
		* @returns {@link Success} with an array containing all successful results if all results either
		* suceeded or returned error details listed in `ignore`. If any results failed with details
		* that cannot be ignored, returns {@link Failure} with an concatenated summary of all non-ignorable
		* error mesasges.
		* @public
		*/
		function mapDetailedResults(resultsIn, ignore) {
		function mapDetailedResults(results, ignore) {
		const errors = [];
		const elements = [];
		for (const result of resultsIn) {
		for (const result of results) {
		if (result.isSuccess()) {
		@@ -247,10 +446,14 @@ elements.push(result.value);
		/**
		* Maps an array of Result<T> to an array of <T>, omitting any error
		* results. If no results were successful, returns failure with a
		* concatenated summary of all failure messages.
		* Aggregates successful results from a a collection of {@link Result \| Result<T>}.
		* @param results - An `Iterable` of {@link Result \| Result<T>} from which success
		* results are to be aggregated.
		* @returns {@link Success} with an array of `<T>` if any results were successful. If
		* all {@link Result \| results} failed, returns {@link Failure} with a concatenated
		* summary of all error messages.
		* @public
		*/
		function mapSuccess(resultsIn) {
		function mapSuccess(results) {
		const errors = [];
		const elements = [];
		for (const result of resultsIn) {
		for (const result of results) {
		if (result.isSuccess()) {
		@@ -270,10 +473,13 @@ elements.push(result.value);
		/**
		* Maps an array of Result<T> to an array of strings consisting of all
		* error messages returned by results in the source array. Ignores
		* success results and returns an empty array if there were no errors.
		* @param resultsIn results to be reported
		* Aggregates error messages from a collection of {@link Result \| Result<T>}.
		* @param results - An interable collection of {@link Result \| Result<T>} for which
		* error messages are aggregated.
		* @returns An array of strings consisting of all error messages returned by
		* {@link Result \| results} in the source collection. Ignores {@link Success}
		* results and returns an empty array if there were no errors.
		* @public
		*/
		function mapFailures(resultsIn) {
		function mapFailures(results) {
		const errors = [];
		for (const result of resultsIn) {
		for (const result of results) {
		if (result.isFailure()) {
		@@ -287,5 +493,8 @@ errors.push(result.message);
		/**
		* Returns success with true if all results are successful. If any are unsuccessful,
		* returns failure with a concatenated summary of all failure messages.
		* @param results The results to be tested.
		* Determines if an iterable collection of {@link Result \| Result<T>} were all successful.
		* @param results - The collection of {@link Result \| Result<T>} to be tested.
		* @returns Returns {@link Success} with `true` if all {@link Result \| results} are successful.
		* If any are unsuccessful, returns {@link Failure} with a concatenated summary the error
		* messages from all failed elements.
		* @public
		*/
		@@ -309,7 +518,8 @@ function allSucceed(results, successValue) {
		/**
		* Populates an an object based on a prototype full of field initializers that return Result<T[key]>.
		* Returns success with the populated object if all initializers succeed, or failure with a
		* concatenated list of all failure messages.
		* @param initializers An object with the shape of the target but with initializer functions for
		* Populates an an object based on a prototype full of field initializers that return {@link Result \| Result<T[key]>}.
		* Returns {@link Success} with the populated object if all initializers succeed, or {@link Failure} with a
		* concatenated list of all error messages.
		* @param initializers - An object with the shape of the target but with initializer functions for
		* each property.
		* @public
		*/
		@@ -348,2 +558,2 @@ function populateObject(initializers, order) {
		exports.populateObject = populateObject;
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"result.js","sourceRoot":"","sources":["../src/result.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2020 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/* eslint-disable no-use-before-define */\nexport type Result<T> = Success<T> | Failure<T>;\nexport type SuccessContinuation<T, TN> = (value: T) => Result<TN>;\nexport type FailureContinuation<T> = (message: string) => Result<T>;\nexport type ResultValueType<T> = T extends Result<infer TV> ? TV : never;\n\nexport interface IResultLogger {\n    error(message: string): void;\n}\n\nexport interface IResult<T> {\n    isSuccess(): this is Success<T>;\n    isFailure(): this is Failure<T>;\n    getValueOrThrow(logger?: IResultLogger): T;\n    getValueOrDefault(dflt?: T): T|undefined;\n    onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN>;\n    onFailure(cb: FailureContinuation<T>): Result<T>;\n    withFailureDetail<TD>(detail: TD): DetailedResult<T, TD>;\n    withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;\n}\n\nexport class Success<T> implements IResult<T> {\n    private readonly _value: T;\n\n    constructor(value: T) {\n        this._value = value;\n    }\n\n    public isSuccess(): this is Success<T> {\n        return true;\n    }\n\n    public isFailure(): this is Failure<T> {\n        return false;\n    }\n\n    public get value(): T {\n        return this._value;\n    }\n\n    public getValueOrThrow(_logger?: IResultLogger): T {\n        return this._value;\n    }\n\n    public getValueOrDefault(dflt?: T): T|undefined {\n        return this._value ?? dflt;\n    }\n\n    public onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN> {\n        return cb(this.value);\n    }\n\n    public onFailure(_: FailureContinuation<T>): Result<T> {\n        return this;\n    }\n\n    public withFailureDetail<TD>(_detail: TD): DetailedResult<T, TD> {\n        return succeedWithDetail(this.value);\n    }\n\n    public withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD> {\n        return succeedWithDetail(this.value, successDetail ?? detail);\n    }\n}\n\nexport class Failure<T> implements IResult<T> {\n    private readonly _message: string;\n\n    constructor(message: string) {\n        this._message = message;\n    }\n\n    public isSuccess(): this is Success<T> {\n        return false;\n    }\n\n    public isFailure(): this is Failure<T> {\n        return true;\n    }\n\n    public get message(): string {\n        return this._message;\n    }\n\n    public getValueOrThrow(logger?: IResultLogger): never {\n        if (logger !== undefined) {\n            logger.error(this._message);\n        }\n        throw new Error(this._message);\n    }\n\n    public getValueOrDefault(dflt?: T): T|undefined {\n        return dflt;\n    }\n\n    public onSuccess<TN>(_: SuccessContinuation<T, TN>): Result<TN> {\n        return new Failure(this.message);\n    }\n\n    public onFailure(cb: FailureContinuation<T>): Result<T> {\n        return cb(this.message);\n    }\n\n    public withFailureDetail<TD>(detail: TD): DetailedResult<T, TD> {\n        return failWithDetail(this.message, detail);\n    }\n\n    public withDetail<TD>(detail: TD, _successDetail?: TD): DetailedResult<T, TD> {\n        return failWithDetail(this.message, detail);\n    }\n\n    public toString(): string {\n        return this.message;\n    }\n}\n\n/**\n * Helper function for successful return\n * @param val The value to be returned\n */\nexport function succeed<T>(val: T): Success<T> {\n    return new Success<T>(val);\n}\n\n/**\n * Helper function for error return\n * @param message Error message to be returned\n */\nexport function fail<T>(message: string): Failure<T> {\n    return new Failure<T>(message);\n}\n\nexport type DetailedSuccessContinuation<T, TD, TN> = (value: T, detail?: TD) => DetailedResult<TN, TD>;\nexport type DetailedFailureContinuation<T, TD> = (message: string, detail: TD) => DetailedResult<T, TD>;\n\nexport class DetailedSuccess<T, TD> extends Success<T> {\n    protected _detail?: TD;\n\n    public constructor(value: T, detail?: TD) {\n        super(value);\n        this._detail = detail;\n    }\n\n    public get detail(): TD|undefined {\n        return this._detail;\n    }\n\n    public isSuccess(): this is DetailedSuccess<T, TD> {\n        return true;\n    }\n\n    public onSuccess<TN>(cb: DetailedSuccessContinuation<T, TD, TN>): DetailedResult<TN, TD> {\n        return cb(this.value, this._detail);\n    }\n\n    public onFailure(_cb: DetailedFailureContinuation<T, TD>): DetailedResult<T, TD> {\n        return this;\n    }\n}\n\n/**\n * A DetailedFailure reports optional failure details in addition\n * to the standard failure message.\n */\nexport class DetailedFailure<T, TD> extends Failure<T> {\n    protected _detail: TD;\n\n    public constructor(message: string, detail: TD) {\n        super(message);\n        this._detail = detail;\n    }\n\n    public get detail(): TD {\n        return this._detail;\n    }\n\n    public isFailure(): this is DetailedFailure<T, TD> {\n        return true;\n    }\n\n    public onSuccess<TN>(_cb: DetailedSuccessContinuation<T, TD, TN>): DetailedResult<TN, TD> {\n        return new DetailedFailure<TN, TD>(this.message, this._detail);\n    }\n\n    public onFailure(cb: DetailedFailureContinuation<T, TD>): DetailedResult<T, TD> {\n        return cb(this.message, this._detail);\n    }\n}\n\nexport type DetailedResult<T, TD> = DetailedSuccess<T, TD>|DetailedFailure<T, TD>;\nexport type ResultDetailType<T> = T extends DetailedResult<unknown, infer TD> ? TD : never;\n\nexport function succeedWithDetail<T, TD>(value: T, detail?: TD): DetailedSuccess<T, TD> {\n    return new DetailedSuccess<T, TD>(value, detail);\n}\n\nexport function failWithDetail<T, TD>(message: string, detail: TD): DetailedFailure<T, TD> {\n    return new DetailedFailure<T, TD>(message, detail);\n}\n\nexport function propagateWithDetail<T, TD>(result: Result<T>, detail: TD, successDetail?: TD): DetailedResult<T, TD> {\n    return result.isSuccess()\n        ? succeedWithDetail(result.value, successDetail ?? detail)\n        : failWithDetail(result.message, detail);\n}\n\n/**\n * Wraps a function which returns a value of type <T> or throws\n * to produce Success<T> or Failure<T>\n * @param func The method to be captured\n */\nexport function captureResult<T>(func: () => T): Result<T> {\n    try {\n        return succeed(func());\n    }\n    catch (err) {\n        return fail((err as Error).message);\n    }\n}\n\n/**\n * Maps an array of Result<T> to an array of <T>, if all results are\n * successful.  If any results fail, returns failure with a concatenated\n * summary of all failure messages.\n * @param resultsIn The results to be mapped.\n */\nexport function mapResults<T>(resultsIn: Iterable<Result<T>>): Result<T[]> {\n    const errors: string[] = [];\n    const elements: T[] = [];\n\n    for (const result of resultsIn) {\n        if (result.isSuccess()) {\n            elements.push(result.value);\n        }\n        else {\n            errors.push(result.message);\n        }\n    }\n\n    if (errors.length > 0) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(elements);\n}\n\n/**\n * Maps an array of DetailedResult<T, TD> to an array of <T>, if all results are\n * successful or yield ignorable errors.  If any results fail with an error that\n * cannot be ignored, returns failure with a concatenated summary of all failure messages.\n * @param resultsIn The results to be mapped.\n * @param ignore Error detail values that should be ignored\n */\nexport function mapDetailedResults<T, TD>(resultsIn: Iterable<DetailedResult<T, TD>>, ignore: TD[]): Result<T[]> {\n    const errors: string[] = [];\n    const elements: T[] = [];\n\n    for (const result of resultsIn) {\n        if (result.isSuccess()) {\n            elements.push(result.value);\n        }\n        else if (!ignore.includes(result.detail)) {\n            errors.push(result.message);\n        }\n    }\n\n    if (errors.length > 0) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(elements);\n}\n\n/**\n * Maps an array of Result<T> to an array of <T>, omitting any error\n * results.  If no results were successful, returns failure with a\n * concatenated summary of all failure messages.\n */\nexport function mapSuccess<T>(resultsIn: Iterable<Result<T>>): Result<T[]> {\n    const errors: string[] = [];\n    const elements: T[] = [];\n\n    for (const result of resultsIn) {\n        if (result.isSuccess()) {\n            elements.push(result.value);\n        }\n        else {\n            errors.push(result.message);\n        }\n    }\n\n    if ((elements.length === 0) && (errors.length > 0)) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(elements);\n}\n\n/**\n * Maps an array of Result<T> to an array of strings consisting of all\n * error messages returned by results in the source array. Ignores\n * success results and returns an empty array if there were no errors.\n * @param resultsIn results to be reported\n */\nexport function mapFailures<T>(resultsIn: Iterable<Result<T>>): string[] {\n    const errors: string[] = [];\n    for (const result of resultsIn) {\n        if (result.isFailure()) {\n            errors.push(result.message);\n        }\n    }\n    return errors;\n}\n\n/**\n * Returns success with true if all results are successful.  If any are unsuccessful,\n * returns failure with a concatenated summary of all failure messages.\n * @param results The results to be tested.\n */\nexport function allSucceed<T>(results: Iterable<Result<unknown>>, successValue: T): Result<T> {\n    const errors: string[] = [];\n\n    // istanbul ignore else\n    if (results !== undefined) {\n        for (const result of results) {\n            if (result.isFailure()) {\n                errors.push(result.message);\n            }\n        }\n    }\n\n    if (errors.length > 0) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(successValue);\n}\n\nexport type FieldInitializers<T> = { [ key in keyof T ]: (state: Partial<T>) => Result<T[key]> };\n\n/**\n * Populates an an object based on a prototype full of field initializers that return Result<T[key]>.\n * Returns success with the populated object if all initializers succeed, or failure with a\n * concatenated list of all failure messages.\n * @param initializers An object with the shape of the target but with initializer functions for\n * each property.\n */\nexport function populateObject<T>(initializers: FieldInitializers<T>, order?: (keyof T)[]): Result<T> {\n    const state = {} as { [key in keyof T]: T[key] };\n    const errors: string[] = [];\n    const keys: (keyof T)[] = Array.from(order ?? []);\n    const foundKeys = new Set<keyof T>(order);\n\n    // start with the supplied order then append anything else we find\n    for (const key in initializers) {\n        if (!foundKeys.has(key)) {\n            keys.push(key);\n            foundKeys.add(key);\n        }\n    }\n\n    for (const key of keys) {\n        if (initializers[key]) {\n            const result = initializers[key](state);\n            if (result.isSuccess()) {\n                state[key] = result.value;\n            }\n            else {\n                errors.push(result.message);\n            }\n        }\n        else {\n            errors.push(`populateObject: Key ${key} is present but has no initializer`);\n        }\n    }\n\n    if (errors.length > 0) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(state as T);\n}\n"]}
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"result.js","sourceRoot":"","sources":["../src/result.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2020 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/* eslint-disable no-use-before-define */\n/**\n * Represents the {@link IResult | result} of some operation or sequence of operations.\n * @remarks\n * {@link Success | Success<T>} and {@link Failure | Failure<T>} share the common\n * contract {@link IResult}, enabling comingled discriminated usage.\n * @public\n */\nexport type Result<T> = Success<T> | Failure<T>;\n/**\n * Continuation callback to be called in the event that an\n * {@link Result} is successful.\n * @public\n */\nexport type SuccessContinuation<T, TN> = (value: T) => Result<TN>;\n/**\n * Continuation callback to be called in the event that an\n * {@link Result} fails.\n * @public\n */\nexport type FailureContinuation<T> = (message: string) => Result<T>;\n/**\n * Type inference to determine the result type of an {@link Result}.\n * @beta\n */\nexport type ResultValueType<T> = T extends Result<infer TV> ? TV : never;\n\n/**\n * Simple logger interface used by {@link IResult.getValueOrThrow}.\n * @public\n */\nexport interface IResultLogger {\n    /**\n     * Log an error message.\n     * @param message - The message to be logged.\n     */\n    error(message: string): void;\n}\n\n/**\n * Represents the result of some operation of sequence of operations.\n * @remarks\n * This common contract enables comingled discriminated usage of {@link Success | Success<T>}\n * and {@link Failure | Failure<T>}.\n * @public\n */\nexport interface IResult<T> {\n    /**\n     * Indicates whether the operation was successful.\n     */\n    readonly success: boolean;\n\n    /**\n     * Indicates whether this operation was successful.  Functions\n     * as a type guard for {@link Success | Success<T>}.\n     */\n    isSuccess(): this is Success<T>;\n\n    /**\n     * Indicates whether this operation failed.  Functions\n     * as a type guard for {@link Failure | Failure<T>}.\n     */\n    isFailure(): this is Failure<T>;\n\n    /**\n     * Gets the value associated with a successful {@link IResult | result},\n     * or throws the error message if the corresponding operation failed.\n     * @param logger - An optional {@link IResultLogger | logger} to which the\n     * error will also be reported.\n     * @returns The return value, if the operation was successful.\n     * @throws The error message if the operation failed.\n     */\n    getValueOrThrow(logger?: IResultLogger): T;\n\n    /**\n     * Gets the value associated with a successful {@link IResult | result},\n     * or a default value if the corresponding operation failed.\n     * @param dflt - The value to be returned if the operation failed (default is\n     * `undefined`).\n     * @returns The return value, if the operation was successful.  Returns\n     * the supplied default value or `undefined` if no default is supplied.\n     */\n    getValueOrDefault(dflt?: T): T|undefined;\n\n    /**\n     * Calls a supplied {@link SuccessContinuation | success continuation} if\n     * the operation was a success.\n     * @remarks\n     * The {@link SuccessContinuation | success continuation} might return a\n     * different result type than {@link IResult} on which it is invoked. This\n     * enables chaining of operations with heterogenous return types.\n     *\n     * @param cb - The {@link SuccessContinuation | success continuation} to\n     * be called in the event of success.\n     * @returns If this operation was successful, returns the value returned\n     * by the {@link SuccessContinuation | success continuation}.  If this result\n     * failed, propagates the error message from this failure.\n     */\n    onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN>;\n\n    /**\n     * Calls a supplied {@link FailureContinuation | failed continuation} if\n     * the operation failed.\n     * @param cb - The {@link FailureContinuation | failure continuation} to\n     * be called in the event of failure.\n     * @returns If this operation failed, returns the value returned by the\n     * {@link FailureContinuation | failure continuation}.  If this result\n     * was successful, propagates the result value from the successful event.\n     */\n    onFailure(cb: FailureContinuation<T>): Result<T>;\n\n    /**\n     * Converts a {@link IResult | IResult<T>} to a {@link DetailedResult | DetailedResult<T, TD>},\n     * adding a supplied detail if the operation failed.\n     * @param detail - The detail to be added if this operation failed.\n     * @returns A new {@link DetailedResult | DetailedResult<T, TD>} with either\n     * the success result or the error message from this {@link IResult}, with\n     * the supplied detail (if this event failed) or detail `undefined` (if\n     * this result succeeded).\n     */\n    withFailureDetail<TD>(detail: TD): DetailedResult<T, TD>;\n\n    /**\n     * Converts a {@link IResult | IResult<T>} to a {@link DetailedResult | DetailedResult<T, TD>},\n     * adding supplied details.\n     * @param detail - The default detail to be added to the new {@link DetailedResult}.\n     * @param successDetail - An optional detail to be added if this result was successful.\n     * @returns A new {@link DetailedResult | DetailedResult<T, TD>} with either\n     * the success result or the error message from this {@link IResult} and the\n     * appopriate added detail.\n     */\n    withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;\n}\n\n/**\n * Reports a successful {@link IResult | result} from some operation and the\n * corresponding value.\n * @public\n */\nexport class Success<T> implements IResult<T> {\n    /**\n     * {@inheritdoc IResult.success}\n     */\n    public readonly success = true;\n    /**\n     * @internal\n     */\n    private readonly _value: T;\n\n    /**\n     * Constructs a {@link Success} with the supplied value.\n     * @param value - The value to be returned.\n     */\n    constructor(value: T) {\n        this._value = value;\n    }\n\n    /**\n     * The result value returned by the successful operation.\n     */\n    public get value(): T {\n        return this._value;\n    }\n\n    /**\n     * {@inheritdoc IResult.isSuccess}\n     */\n    public isSuccess(): this is Success<T> {\n        return true;\n    }\n\n    /**\n     * {@inheritdoc IResult.isFailure}\n     */\n    public isFailure(): this is Failure<T> {\n        return false;\n    }\n\n    /**\n     * {@inheritdoc IResult.getValueOrThrow}\n     */\n    public getValueOrThrow(_logger?: IResultLogger): T {\n        return this._value;\n    }\n\n    /**\n     * {@inheritdoc IResult.getValueOrDefault}\n     */\n    public getValueOrDefault(dflt?: T): T|undefined {\n        return this._value ?? dflt;\n    }\n\n    /**\n     * {@inheritdoc IResult.onSuccess}\n     */\n    public onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN> {\n        return cb(this.value);\n    }\n\n    /**\n     * {@inheritdoc IResult.onFailure}\n     */\n    public onFailure(_: FailureContinuation<T>): Result<T> {\n        return this;\n    }\n\n    /**\n     * {@inheritdoc IResult.withFailureDetail}\n     */\n    public withFailureDetail<TD>(_detail: TD): DetailedResult<T, TD> {\n        return succeedWithDetail(this.value);\n    }\n\n    /**\n     * {@inheritdoc IResult.withDetail}\n     */\n    public withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD> {\n        return succeedWithDetail(this.value, successDetail ?? detail);\n    }\n}\n\n/**\n * Reports a failed {@link IResult | result} from some operation, with an error message.\n * @public\n */\nexport class Failure<T> implements IResult<T> {\n    /**\n     * {@inheritdoc IResult.success}\n     */\n    public readonly success = false;\n\n    /**\n     * @internal\n     */\n    private readonly _message: string;\n\n    /**\n     * Constructs a {@link Failure} with the supplied message.\n     * @param message - Error message to be reported.\n     */\n    constructor(message: string) {\n        this._message = message;\n    }\n\n    /**\n     * Gets the error message associated with this error.\n     */\n    public get message(): string {\n        return this._message;\n    }\n\n    /**\n     * {@inheritdoc IResult.isSuccess}\n     */\n    public isSuccess(): this is Success<T> {\n        return false;\n    }\n\n    /**\n     * {@inheritdoc IResult.isFailure}\n     */\n    public isFailure(): this is Failure<T> {\n        return true;\n    }\n\n    /**\n     * {@inheritdoc IResult.getValueOrThrow}\n     */\n    public getValueOrThrow(logger?: IResultLogger): never {\n        if (logger !== undefined) {\n            logger.error(this._message);\n        }\n        throw new Error(this._message);\n    }\n\n    /**\n     * {@inheritdoc IResult.getValueOrDefault}\n     */\n    public getValueOrDefault(dflt?: T): T|undefined {\n        return dflt;\n    }\n\n    /**\n     * {@inheritdoc IResult.onSuccess}\n     */\n    public onSuccess<TN>(_: SuccessContinuation<T, TN>): Result<TN> {\n        return new Failure(this.message);\n    }\n\n    /**\n     * {@inheritdoc IResult.onFailure}\n     */\n    public onFailure(cb: FailureContinuation<T>): Result<T> {\n        return cb(this.message);\n    }\n\n    /**\n     * {@inheritdoc IResult.withFailureDetail}\n     */\n    public withFailureDetail<TD>(detail: TD): DetailedResult<T, TD> {\n        return failWithDetail(this.message, detail);\n    }\n\n    /**\n     * {@inheritdoc IResult.withDetail}\n     */\n    public withDetail<TD>(detail: TD, _successDetail?: TD): DetailedResult<T, TD> {\n        return failWithDetail(this.message, detail);\n    }\n\n    /**\n     * Get a 'friendly' string representation of this object.\n     * @remarks\n     * The string representation of a {@link Failure} value is the error message.\n     * @returns A string representing this object.\n     */\n    public toString(): string {\n        return this.message;\n    }\n}\n\n/**\n * Returns {@link Success | Success<T>} with the supplied result value.\n * @param value - The successful result value to be returned\n * @public\n */\nexport function succeed<T>(value: T): Success<T> {\n    return new Success<T>(value);\n}\n\n/**\n * Returns {@link Failure | Failure<T>} with the supplied error message.\n * @param message - Error message to be returned.\n * @public\n */\nexport function fail<T>(message: string): Failure<T> {\n    return new Failure<T>(message);\n}\n\n/**\n * Callback to be called when a {@link DetailedResult} encounters success.\n * @remarks\n * A success callback can return a different result type than it receives, allowing\n * success results to chain through intermediate result types.\n * @public\n */\nexport type DetailedSuccessContinuation<T, TD, TN> = (value: T, detail?: TD) => DetailedResult<TN, TD>;\n\n/**\n * Callback to be called when a {@link DetailedResult} encounters a failure.\n * @remarks\n * A failure callback can change {@link Failure} to {@link Success} (e.g. by returning a default value)\n * or it can change or embellish the error message, but it cannot change the success return type.\n * @public\n */\nexport type DetailedFailureContinuation<T, TD> = (message: string, detail: TD) => DetailedResult<T, TD>;\n\n/**\n * A {@link DetailedSuccess} extends {@link Success} to report optional success details in\n * addition to the error message.\n * @public\n */\nexport class DetailedSuccess<T, TD> extends Success<T> {\n    /**\n     * @internal\n     */\n    protected _detail?: TD;\n\n    /**\n     * Constructs a new {@link DetailedSuccess | DetailedSuccess<T, TD>} with the supplied\n     * value and detail.\n     * @param value - The value to be returned.\n     * @param detail - An optional successful detail to be returned.  If omitted, detail\n     * will be `undefined`.\n     */\n    public constructor(value: T, detail?: TD) {\n        super(value);\n        this._detail = detail;\n    }\n\n    /**\n     * The success detail associated with this {@link DetailedSuccess}, or `undefined` if\n     * no detail was supplied.\n     */\n    public get detail(): TD|undefined {\n        return this._detail;\n    }\n\n    /**\n     * Reports that this {@link DetailedSuccess} is a success.\n     * @remarks\n     * Always true for {@link DetailedSuccess} but can be used as type guard\n     * to discriminate {@link DetailedSuccess} from {@link DetailedFailure} in\n     * a {@link DetailedResult}.\n     * @returns `true`\n     */\n    public isSuccess(): this is DetailedSuccess<T, TD> {\n        return true;\n    }\n\n    /**\n     * Invokes the supplied {@link DetailedSuccessContinuation | success callback} and propagates\n     * its returned {@link DetailedResult | DetailedResult<TN, TD>}.\n     * @remarks\n     * The success callback mutates the return type from `<T>` to `<TN>`.\n     * @param cb - The {@link DetailedSuccessContinuation | success callback} to be invoked.\n     * @returns The {@link DetailedResult | DetailedResult<T, TD>} returned by the success callback.\n     */\n    public onSuccess<TN>(cb: DetailedSuccessContinuation<T, TD, TN>): DetailedResult<TN, TD> {\n        return cb(this.value, this._detail);\n    }\n\n    /**\n     * Propagates this {@link DetailedSuccess}.\n     * @remarks\n     * Failure does not mutate return type so we can return this event directly.\n     * @param _cb - {@link DetailedFailureContinuation | Failure callback} to be called\n     * on a {@link DetailedResult} in case of failure (ignored).\n     * @returns `this`\n     */\n    public onFailure(_cb: DetailedFailureContinuation<T, TD>): DetailedResult<T, TD> {\n        return this;\n    }\n}\n\n/**\n * A {@link DetailedFailure} extends {@link Failure} to report optional failure details in\n * addition to the error message.\n * @public\n */\nexport class DetailedFailure<T, TD> extends Failure<T> {\n    /**\n     * @internal\n     */\n    protected _detail: TD;\n\n    /**\n     * Constructs a new {@link DetailedFailure | DetailedFailure<T, TD>} with the supplied\n     * message and detail.\n     * @param message - The message to be returned.\n     * @param detail - The error detail to be returned.\n     */\n    public constructor(message: string, detail: TD) {\n        super(message);\n        this._detail = detail;\n    }\n\n    /**\n     * The error detail associated with this {@link DetailedFailure}.\n     */\n    public get detail(): TD {\n        return this._detail;\n    }\n\n    /**\n     * Reports that this {@link DetailedFailure} is a failure.\n     * @remarks\n     * Always true for {@link DetailedFailure} but can be used as type guard\n     * to discriminate {@link DetailedSuccess} from {@link DetailedFailure} in\n     * a {@link DetailedResult}.\n     * @returns `true`\n     */\n    public isFailure(): this is DetailedFailure<T, TD> {\n        return true;\n    }\n\n    /**\n     * Propagates the error message and detail from this result.\n     * @remarks\n     * Mutates the success type as the success callback would have, but does not\n     * call the success callback.\n     * @param _cb - {@link DetailedSuccessContinuation | Success callback} to be called\n     * on a {@link DetailedResult} in case of success (ignored).\n     * @returns A new {@link DetailedFailure | DetailedFailure<TN, TD>} which contains\n     * the error message and detail from this one.\n     */\n    public onSuccess<TN>(_cb: DetailedSuccessContinuation<T, TD, TN>): DetailedResult<TN, TD> {\n        return new DetailedFailure<TN, TD>(this.message, this._detail);\n    }\n\n    /**\n     * Invokes the supplied {@link DetailedFailureContinuation | failure callback} and propagates\n     * its returned {@link DetailedResult | DetailedResult<T, TD>}.\n     * @param cb - The {@link DetailedFailureContinuation | failure callback} to be invoked.\n     * @returns The {@link DetailedResult | DetailedResult<T, TD>} returned by the failure callback.\n     */\n    public onFailure(cb: DetailedFailureContinuation<T, TD>): DetailedResult<T, TD> {\n        return cb(this.message, this._detail);\n    }\n}\n\n/**\n * Type inference to determine the result type `T` of a {@link DetailedResult | DetailedResult<T, TD>}.\n * @beta\n */\nexport type DetailedResult<T, TD> = DetailedSuccess<T, TD>|DetailedFailure<T, TD>;\n\n/**\n * Type inference to determine the detail type `TD` of a {@link DetailedResult | DetailedResult<T, TD>}.\n * @beta\n */\nexport type ResultDetailType<T> = T extends DetailedResult<unknown, infer TD> ? TD : never;\n\n/**\n * Returns {@link DetailedSuccess | DetailedSuccess<T, TD>} with a supplied value and optional\n * detail.\n * @param value - The value of type `<T>` to be returned.\n * @param detail - An optional detail of type `<TD>` to be returned.\n * @returns A {@link DetailedSuccess | DetailedSuccess<T, TD>} with the supplied value\n * and detail, if supplied.\n * @public\n */\nexport function succeedWithDetail<T, TD>(value: T, detail?: TD): DetailedSuccess<T, TD> {\n    return new DetailedSuccess<T, TD>(value, detail);\n}\n\n/**\n * Returns {@link DetailedFailure | DetailedFailure<T, TD>} with a supplied error message and detail.\n * @param message - The error message to be returned.\n * @param detail - The event detail to be returned.\n * @returns An {@link DetailedFailure | DetailedFailure<T, TD>} with the supplied error\n * message and detail.\n * @public\n */\nexport function failWithDetail<T, TD>(message: string, detail: TD): DetailedFailure<T, TD> {\n    return new DetailedFailure<T, TD>(message, detail);\n}\n\n/**\n * Propagates a {@link Success} or {@link Failure} {@link Result}, adding supplied\n * event details as appropriate.\n * @param result - The {@link Result} to be propagated.\n * @param detail - The event detail (type `<TD>`) to be added to the {@link Result | result}.\n * @param successDetail - An optional distinct event detail to be added to {@link Success} results.  If `successDetail`\n * is omitted or `undefined`, then `detail` will be applied to {@link Success} results.\n * @returns A new {@link DetailedResult | DetailedResult<T, TD>} with the success value or error\n * message from the original `result` but with the specified detail added.\n * @public\n */\nexport function propagateWithDetail<T, TD>(result: Result<T>, detail: TD, successDetail?: TD): DetailedResult<T, TD> {\n    return result.isSuccess()\n        ? succeedWithDetail(result.value, successDetail ?? detail)\n        : failWithDetail(result.message, detail);\n}\n\n/**\n * Wraps a function which might throw to convert exception results\n * to {@link Failure}.\n * @param func - The function to be captured.\n * @returns Returns {@link Success} with a value of type `<T>` on\n * success , or {@link Failure} with the thrown error message if\n * `func` throws an `Error`.\n * @public\n */\nexport function captureResult<T>(func: () => T): Result<T> {\n    try {\n        return succeed(func());\n    }\n    catch (err) {\n        return fail((err as Error).message);\n    }\n}\n\n/**\n * Aggregates sucessful result values from a collection of {@link Result | Result<T>}.\n * @param results - The collection of {@link Result | Result<T>} to be mapped.\n * @returns  If all {@link Result | results} are successful, returns {@link Success} with an\n * array containing all returned values.  If any {@link Result | results} failed, returns\n * {@link Failure} with a concatenated summary of all error messages.\n * @public\n */\nexport function mapResults<T>(results: Iterable<Result<T>>): Result<T[]> {\n    const errors: string[] = [];\n    const elements: T[] = [];\n\n    for (const result of results) {\n        if (result.isSuccess()) {\n            elements.push(result.value);\n        }\n        else {\n            errors.push(result.message);\n        }\n    }\n\n    if (errors.length > 0) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(elements);\n}\n\n/**\n * Aggregates sucessful results from a collection of {@link DetailedResult | DetailedResult<T, TD>},\n * optionally ignoring certain error details.\n * @param results - The collection of {@link DetailedResult | DetailedResult<T, TD>} to be mapped.\n * @param ignore - An array of error detail values (of type `<TD>`) that should be ignored.\n * @returns {@link Success} with an array containing all successful results if all results either\n * suceeded or returned error details listed in `ignore`.  If any results failed with details\n * that cannot be ignored, returns {@link Failure} with an concatenated summary of all non-ignorable\n * error mesasges.\n * @public\n */\nexport function mapDetailedResults<T, TD>(results: Iterable<DetailedResult<T, TD>>, ignore: TD[]): Result<T[]> {\n    const errors: string[] = [];\n    const elements: T[] = [];\n\n    for (const result of results) {\n        if (result.isSuccess()) {\n            elements.push(result.value);\n        }\n        else if (!ignore.includes(result.detail)) {\n            errors.push(result.message);\n        }\n    }\n\n    if (errors.length > 0) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(elements);\n}\n\n/**\n * Aggregates successful results from a a collection of {@link Result | Result<T>}.\n * @param results - An `Iterable` of {@link Result | Result<T>} from which success\n * results are to be aggregated.\n * @returns {@link Success} with an array of `<T>` if any results were successful. If\n * all {@link Result | results} failed, returns {@link Failure} with a concatenated\n * summary of all error messages.\n * @public\n */\nexport function mapSuccess<T>(results: Iterable<Result<T>>): Result<T[]> {\n    const errors: string[] = [];\n    const elements: T[] = [];\n\n    for (const result of results) {\n        if (result.isSuccess()) {\n            elements.push(result.value);\n        }\n        else {\n            errors.push(result.message);\n        }\n    }\n\n    if ((elements.length === 0) && (errors.length > 0)) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(elements);\n}\n\n/**\n * Aggregates error messages from a collection of {@link Result | Result<T>}.\n * @param results - An interable collection of {@link Result | Result<T>} for which\n * error messages are aggregated.\n * @returns An array of strings consisting of all error messages returned by\n * {@link Result | results} in the source collection. Ignores {@link Success}\n * results and returns an empty array if there were no errors.\n * @public\n */\nexport function mapFailures<T>(results: Iterable<Result<T>>): string[] {\n    const errors: string[] = [];\n    for (const result of results) {\n        if (result.isFailure()) {\n            errors.push(result.message);\n        }\n    }\n    return errors;\n}\n\n/**\n * Determines if an iterable collection of {@link Result | Result<T>} were all successful.\n * @param results - The collection of {@link Result | Result<T>} to be tested.\n * @returns Returns {@link Success} with `true` if all {@link Result | results} are successful.\n * If any are unsuccessful, returns {@link Failure} with a concatenated summary the error\n * messages from all failed elements.\n * @public\n */\nexport function allSucceed<T>(results: Iterable<Result<unknown>>, successValue: T): Result<T> {\n    const errors: string[] = [];\n\n    // istanbul ignore else\n    if (results !== undefined) {\n        for (const result of results) {\n            if (result.isFailure()) {\n                errors.push(result.message);\n            }\n        }\n    }\n\n    if (errors.length > 0) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(successValue);\n}\n\n/**\n * String-keyed record of initialization functions to be passed to {@link populateObject}.\n * @public\n */\nexport type FieldInitializers<T> = { [ key in keyof T ]: (state: Partial<T>) => Result<T[key]> };\n\n/**\n * Populates an an object based on a prototype full of field initializers that return {@link Result | Result<T[key]>}.\n * Returns {@link Success} with the populated object if all initializers succeed, or {@link Failure} with a\n * concatenated list of all error messages.\n * @param initializers - An object with the shape of the target but with initializer functions for\n * each property.\n * @public\n */\nexport function populateObject<T>(initializers: FieldInitializers<T>, order?: (keyof T)[]): Result<T> {\n    const state = {} as { [key in keyof T]: T[key] };\n    const errors: string[] = [];\n    const keys: (keyof T)[] = Array.from(order ?? []);\n    const foundKeys = new Set<keyof T>(order);\n\n    // start with the supplied order then append anything else we find\n    for (const key in initializers) {\n        if (!foundKeys.has(key)) {\n            keys.push(key);\n            foundKeys.add(key);\n        }\n    }\n\n    for (const key of keys) {\n        if (initializers[key]) {\n            const result = initializers[key](state);\n            if (result.isSuccess()) {\n                state[key] = result.value;\n            }\n            else {\n                errors.push(result.message);\n            }\n        }\n        else {\n            errors.push(`populateObject: Key ${key} is present but has no initializer`);\n        }\n    }\n\n    if (errors.length > 0) {\n        return fail(errors.join('\\n'));\n    }\n    return succeed(state as T);\n}\n"]}

utils.d.ts

		import { Result } from './result';
		/**
		* Helper type-guard function to report whether a specified key is present in
		* a supplied object.
		* @param key - The key to be tested.
		* @param item - The object to be tested.
		* @returns Returns `true` if the key is present, `false` otherwise.
		* @public
		*/
		export declare function isKeyOf<T extends object>(key: string \| number \| symbol, item: T): key is keyof T;
		/**
		* Type for factory methods which convert a key-value pair to a new unique value.
		* @public
		*/
		declare type KeyedThingFactory<TS, TD, TK extends string = string> = (key: TK, thing: TS) => Result<TD>;
		/**
		* Applies a factory method to convert a Record<TK, TS> into a Map<TK, TD>
		* @param src The Record object to be converted
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting map, or Failure if an error occurs
		* Applies a factory method to convert a `Record<TK, TS>` into a `Map<TK, TD>`.
		* @param src - The `Record` to be converted.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting map on success, or {@link Failure} with a
		* message if an error occurs.
		* @public
		*/
		export declare function recordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>>;
		/**
		* Applies a factory method to convert an optional Record<TK, TS> into a Map<TK, TD> or undefined
		* @param src The Record object to be converted or undefined
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting map if conversion succeeds, or success with undefined if src is undefined. Returns Failure with
		* a message if an error occurs.
		* Applies a factory method to convert an optional `Record<TK, TS>` into a `Map<TK, TD>`, or `undefined`.
		* @param src - The `Record` to be converted, or undefined.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting map if conversion succeeds, or {@link Success} with `undefined`
		* if `src` is `undefined`. Returns {@link Failure} with a message if an error occurs.
		* @public
		*/
		export declare function optionalRecordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS> \| undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD> \| undefined>;
		/**
		* Applies a factory method to convert an optional Record<TK, TS> into a Map<TK, TD>
		* @param src The Record object to be converted or undefined
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting map (empty if src is undefined) if conversion succeeds. Returns Failure with
		* a message if an error occurs.
		* Applies a factory method to convert an optional `Record<TK, TS>` into a `Map<TK, TD>`
		* @param src - The `Record` to be converted, or `undefined`.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting map (empty if `src` is `undefined`) if conversion succeeds.
		* Returns {@link Failure} with a message if an error occurs.
		* @public
		*/
		export declare function optionalRecordToPossiblyEmptyMap<TS, TD, TK extends string = string>(src: Record<TK, TS> \| undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>>;
		/**
		* Applies a factory method to convert a Map<TK, TS> into a Record<TK, TD>
		* @param src The Map object to be converted
		* @param factory The factory method used to convert elements
		* Applies a factory method to convert a `Map<TK, TS>` into a `Record<TK, TD>`.
		* @param src - The `Map` object to be converted.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting `Record<TK, TD>` if conversion succeeds, or
		* {@link Failure} with an error message if an error occurs.
		* @public
		*/
		export declare function mapToRecord<TS, TD, TK extends string = string>(src: Map<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>>;
		/**
		* Applies a factory method to convert an optional Map<string, TS> into a Record<string, TD> or undefined
		* @param src The Map object to be converted or undefined
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting record if conversion succeeds, or success with undefined if src is undefined. Returns Failure with
		* a message if an error occurs.
		* Applies a factory method to convert an optional `Map<string, TS>` into a `Record<string, TD>` or `undefined`.
		* @param src - The `Map` object to be converted, or `undefined`.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting record if conversion succeeds, or {@link Success} with `undefined` if
		* `src` is `undefined`. Returns {@link Failure} with a message if an error occurs.
		* @public
		*/
		export declare function optionalMapToRecord<TS, TD, TK extends string = string>(src: Map<TK, TS> \| undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD> \| undefined>;
		/**
		* Applies a factory method to convert an optional Map<string, TS> into a Record<string, TD>
		* @param src The Map object to be converted or undefined
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting record (empty if src is undefined) if conversion succeeds. Returns Failure with
		* a message if an error occurs.
		* Applies a factory method to convert an optional `Map<string, TS>` into a `Record<string, TD>`
		* @param src - The `Map` object to be converted, or `undefined`.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting record (empty if `src` is `undefined`) if conversion succeeds.
		* Returns {@link Failure} with a message if an error occurs.
		* @public
		*/
		export declare function optionalMapToPossiblyEmptyRecord<TS, TD, TK extends string = string>(src: Map<TK, TS> \| undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>>;
		export {};
		//# sourceMappingURL=utils.d.ts.map

utils.js

		@@ -26,2 +26,10 @@ "use strict";
		const result_1 = require("./result");
		/**
		* Helper type-guard function to report whether a specified key is present in
		* a supplied object.
		* @param key - The key to be tested.
		* @param item - The object to be tested.
		* @returns Returns `true` if the key is present, `false` otherwise.
		* @public
		*/
		// eslint-disable-next-line @typescript-eslint/ban-types
		@@ -33,6 +41,8 @@ function isKeyOf(key, item) {
		/**
		* Applies a factory method to convert a Record<TK, TS> into a Map<TK, TD>
		* @param src The Record object to be converted
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting map, or Failure if an error occurs
		* Applies a factory method to convert a `Record<TK, TS>` into a `Map<TK, TD>`.
		* @param src - The `Record` to be converted.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting map on success, or {@link Failure} with a
		* message if an error occurs.
		* @public
		*/
		@@ -56,7 +66,8 @@ function recordToMap(src, factory) {
		/**
		* Applies a factory method to convert an optional Record<TK, TS> into a Map<TK, TD> or undefined
		* @param src The Record object to be converted or undefined
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting map if conversion succeeds, or success with undefined if src is undefined. Returns Failure with
		* a message if an error occurs.
		* Applies a factory method to convert an optional `Record<TK, TS>` into a `Map<TK, TD>`, or `undefined`.
		* @param src - The `Record` to be converted, or undefined.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting map if conversion succeeds, or {@link Success} with `undefined`
		* if `src` is `undefined`. Returns {@link Failure} with a message if an error occurs.
		* @public
		*/
		@@ -68,7 +79,8 @@ function optionalRecordToMap(src, factory) {
		/**
		* Applies a factory method to convert an optional Record<TK, TS> into a Map<TK, TD>
		* @param src The Record object to be converted or undefined
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting map (empty if src is undefined) if conversion succeeds. Returns Failure with
		* a message if an error occurs.
		* Applies a factory method to convert an optional `Record<TK, TS>` into a `Map<TK, TD>`
		* @param src - The `Record` to be converted, or `undefined`.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting map (empty if `src` is `undefined`) if conversion succeeds.
		* Returns {@link Failure} with a message if an error occurs.
		* @public
		*/
		@@ -80,5 +92,8 @@ function optionalRecordToPossiblyEmptyMap(src, factory) {
		/**
		* Applies a factory method to convert a Map<TK, TS> into a Record<TK, TD>
		* @param src The Map object to be converted
		* @param factory The factory method used to convert elements
		* Applies a factory method to convert a `Map<TK, TS>` into a `Record<TK, TD>`.
		* @param src - The `Map` object to be converted.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting `Record<TK, TD>` if conversion succeeds, or
		* {@link Failure} with an error message if an error occurs.
		* @public
		*/
		@@ -102,7 +117,8 @@ function mapToRecord(src, factory) {
		/**
		* Applies a factory method to convert an optional Map<string, TS> into a Record<string, TD> or undefined
		* @param src The Map object to be converted or undefined
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting record if conversion succeeds, or success with undefined if src is undefined. Returns Failure with
		* a message if an error occurs.
		* Applies a factory method to convert an optional `Map<string, TS>` into a `Record<string, TD>` or `undefined`.
		* @param src - The `Map` object to be converted, or `undefined`.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting record if conversion succeeds, or {@link Success} with `undefined` if
		* `src` is `undefined`. Returns {@link Failure} with a message if an error occurs.
		* @public
		*/
		@@ -114,7 +130,8 @@ function optionalMapToRecord(src, factory) {
		/**
		* Applies a factory method to convert an optional Map<string, TS> into a Record<string, TD>
		* @param src The Map object to be converted or undefined
		* @param factory The factory method used to convert elements
		* @returns Success with the resulting record (empty if src is undefined) if conversion succeeds. Returns Failure with
		* a message if an error occurs.
		* Applies a factory method to convert an optional `Map<string, TS>` into a `Record<string, TD>`
		* @param src - The `Map` object to be converted, or `undefined`.
		* @param factory - The factory method used to convert elements.
		* @returns {@link Success} with the resulting record (empty if `src` is `undefined`) if conversion succeeds.
		* Returns {@link Failure} with a message if an error occurs.
		* @public
		*/
		@@ -125,2 +142,2 @@ function optionalMapToPossiblyEmptyRecord(src, factory) {
		exports.optionalMapToPossiblyEmptyRecord = optionalMapToPossiblyEmptyRecord;
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * Copyright (c) 2020 Erik Fortune\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\n\r\nimport { Result, fail, succeed } from './result';\r\n\r\n// eslint-disable-next-line @typescript-eslint/ban-types\r\nexport function isKeyOf<T extends object>(key: string|number|symbol, item: T): key is keyof T {\r\n    return item.hasOwnProperty(key);\r\n}\r\n\r\ntype KeyedThingFactory<TS, TD, TK extends string = string> = (key: TK, thing: TS) => Result<TD>;\r\n\r\n/**\r\n * Applies a factory method to convert a Record<TK, TS> into a Map<TK, TD>\r\n * @param src The Record object to be converted\r\n * @param factory The factory method used to convert elements\r\n * @returns Success with the resulting map, or Failure if an error occurs\r\n */\r\nexport function recordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>> {\r\n    const map = new Map<TK, TD>();\r\n    for (const key in src) {\r\n        if (src[key] !== undefined) {\r\n            const itemResult = factory(key, src[key]);\r\n            if (itemResult.isSuccess()) {\r\n                map.set(key, itemResult.value);\r\n            }\r\n            else {\r\n                return fail(`${key}: ${itemResult.message}`);\r\n            }\r\n        }\r\n    }\r\n    return succeed(map);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert an optional Record<TK, TS> into a Map<TK, TD> or undefined\r\n * @param src The Record object to be converted or undefined\r\n * @param factory The factory method used to convert elements\r\n * @returns Success with the resulting map if conversion succeeds, or success with undefined if src is undefined. Returns Failure with\r\n * a message if an error occurs.\r\n */\r\nexport function optionalRecordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>|undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>|undefined> {\r\n    return (src === undefined) ? succeed(undefined) : recordToMap(src, factory);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert an optional Record<TK, TS> into a Map<TK, TD>\r\n * @param src The Record object to be converted or undefined\r\n * @param factory The factory method used to convert elements\r\n * @returns Success with the resulting map (empty if src is undefined) if conversion succeeds. Returns Failure with\r\n * a message if an error occurs.\r\n */\r\nexport function optionalRecordToPossiblyEmptyMap<TS, TD, TK extends string = string>(src: Record<TK, TS>|undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>> {\r\n    return (src === undefined) ? succeed(new Map<TK, TD>()) : recordToMap(src, factory);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert a Map<TK, TS> into a Record<TK, TD>\r\n * @param src The Map object to be converted\r\n * @param factory The factory method used to convert elements\r\n */\r\nexport function mapToRecord<TS, TD, TK extends string = string>(src: Map<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>> {\r\n    const record: Record<TK, TD> = {} as Record<TK, TD>;\r\n    for (const kvp of src) {\r\n        if (kvp[1] !== undefined) {\r\n            const itemResult = factory(kvp[0], kvp[1]);\r\n            if (itemResult.isSuccess()) {\r\n                record[kvp[0]] = itemResult.value;\r\n            }\r\n            else {\r\n                return fail(`${kvp[0]}: ${itemResult.message}`);\r\n            }\r\n        }\r\n    }\r\n    return succeed(record);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert an optional Map<string, TS> into a Record<string, TD> or undefined\r\n * @param src The Map object to be converted or undefined\r\n * @param factory The factory method used to convert elements\r\n * @returns Success with the resulting record if conversion succeeds, or success with undefined if src is undefined. Returns Failure with\r\n * a message if an error occurs.\r\n */\r\nexport function optionalMapToRecord<TS, TD, TK extends string = string>(src: Map<TK, TS>|undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>|undefined> {\r\n    return (src === undefined) ? succeed(undefined) : mapToRecord(src, factory);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert an optional Map<string, TS> into a Record<string, TD>\r\n * @param src The Map object to be converted or undefined\r\n * @param factory The factory method used to convert elements\r\n * @returns Success with the resulting record (empty if src is undefined) if conversion succeeds. Returns Failure with\r\n * a message if an error occurs.\r\n */\r\nexport function optionalMapToPossiblyEmptyRecord<TS, TD, TK extends string = string>(src: Map<TK, TS>|undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>> {\r\n    return (src === undefined) ? succeed({} as Record<TK, TD>) : mapToRecord(src, factory);\r\n}\r\n"]}
		//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,qCAAiD;AAEjD;;;;;;;GAOG;AACH,wDAAwD;AACxD,SAAgB,OAAO,CAAmB,GAAyB,EAAE,IAAO;IACxE,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;AACpC,CAAC;AAFD,0BAEC;AAQD;;;;;;;GAOG;AACH,SAAgB,WAAW,CAAqC,GAAmB,EAAE,OAAsC;IACvH,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,KAAK,MAAM,GAAG,IAAI,GAAG,EAAE;QACnB,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;YACxB,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;YAC1C,IAAI,UAAU,CAAC,SAAS,EAAE,EAAE;gBACxB,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;aAClC;iBACI;gBACD,OAAO,IAAA,aAAI,EAAC,GAAG,GAAG,KAAK,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;aAChD;SACJ;KACJ;IACD,OAAO,IAAA,gBAAO,EAAC,GAAG,CAAC,CAAC;AACxB,CAAC;AAdD,kCAcC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAqC,GAA6B,EAAE,OAAsC;IACzI,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,IAAA,gBAAO,EAAC,SAAS,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AAChF,CAAC;AAFD,kDAEC;AAED;;;;;;;GAOG;AACH,SAAgB,gCAAgC,CAAqC,GAA6B,EAAE,OAAsC;IACtJ,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,IAAA,gBAAO,EAAC,IAAI,GAAG,EAAU,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AACxF,CAAC;AAFD,4EAEC;AAED;;;;;;;GAOG;AACH,SAAgB,WAAW,CAAqC,GAAgB,EAAE,OAAsC;IACpH,MAAM,MAAM,GAAmB,EAAoB,CAAC;IACpD,KAAK,MAAM,GAAG,IAAI,GAAG,EAAE;QACnB,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE;YACtB,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3C,IAAI,UAAU,CAAC,SAAS,EAAE,EAAE;gBACxB,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC;aACrC;iBACI;gBACD,OAAO,IAAA,aAAI,EAAC,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;aACnD;SACJ;KACJ;IACD,OAAO,IAAA,gBAAO,EAAC,MAAM,CAAC,CAAC;AAC3B,CAAC;AAdD,kCAcC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAqC,GAA0B,EAAE,OAAsC;IACtI,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,IAAA,gBAAO,EAAC,SAAS,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AAChF,CAAC;AAFD,kDAEC;AAED;;;;;;;GAOG;AACH,SAAgB,gCAAgC,CAAqC,GAA0B,EAAE,OAAsC;IACnJ,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,IAAA,gBAAO,EAAC,EAAoB,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AAC3F,CAAC;AAFD,4EAEC","sourcesContent":["/*\r\n * Copyright (c) 2020 Erik Fortune\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\n\r\nimport { Result, fail, succeed } from './result';\r\n\r\n/**\r\n * Helper type-guard function to report whether a specified key is present in\r\n * a supplied object.\r\n * @param key - The key to be tested.\r\n * @param item - The object to be tested.\r\n * @returns Returns `true` if the key is present, `false` otherwise.\r\n * @public\r\n */\r\n// eslint-disable-next-line @typescript-eslint/ban-types\r\nexport function isKeyOf<T extends object>(key: string|number|symbol, item: T): key is keyof T {\r\n    return item.hasOwnProperty(key);\r\n}\r\n\r\n/**\r\n * Type for factory methods which convert a key-value pair to a new unique value.\r\n * @public\r\n */\r\ntype KeyedThingFactory<TS, TD, TK extends string = string> = (key: TK, thing: TS) => Result<TD>;\r\n\r\n/**\r\n * Applies a factory method to convert a `Record<TK, TS>` into a `Map<TK, TD>`.\r\n * @param src - The `Record` to be converted.\r\n * @param factory - The factory method used to convert elements.\r\n * @returns {@link Success} with the resulting map on success, or {@link Failure} with a\r\n * message if an error occurs.\r\n * @public\r\n */\r\nexport function recordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>> {\r\n    const map = new Map<TK, TD>();\r\n    for (const key in src) {\r\n        if (src[key] !== undefined) {\r\n            const itemResult = factory(key, src[key]);\r\n            if (itemResult.isSuccess()) {\r\n                map.set(key, itemResult.value);\r\n            }\r\n            else {\r\n                return fail(`${key}: ${itemResult.message}`);\r\n            }\r\n        }\r\n    }\r\n    return succeed(map);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert an optional `Record<TK, TS>` into a `Map<TK, TD>`, or `undefined`.\r\n * @param src - The `Record` to be converted, or undefined.\r\n * @param factory - The factory method used to convert elements.\r\n * @returns {@link Success} with the resulting map if conversion succeeds, or {@link Success} with `undefined`\r\n * if `src` is `undefined`. Returns {@link Failure} with a message if an error occurs.\r\n * @public\r\n */\r\nexport function optionalRecordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>|undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>|undefined> {\r\n    return (src === undefined) ? succeed(undefined) : recordToMap(src, factory);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert an optional `Record<TK, TS>` into a `Map<TK, TD>`\r\n * @param src - The `Record` to be converted, or `undefined`.\r\n * @param factory - The factory method used to convert elements.\r\n * @returns {@link Success} with the resulting map (empty if `src` is `undefined`) if conversion succeeds.\r\n * Returns {@link Failure} with a message if an error occurs.\r\n * @public\r\n */\r\nexport function optionalRecordToPossiblyEmptyMap<TS, TD, TK extends string = string>(src: Record<TK, TS>|undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>> {\r\n    return (src === undefined) ? succeed(new Map<TK, TD>()) : recordToMap(src, factory);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert a `Map<TK, TS>` into a `Record<TK, TD>`.\r\n * @param src - The `Map` object to be converted.\r\n * @param factory - The factory method used to convert elements.\r\n * @returns {@link Success} with the resulting `Record<TK, TD>` if conversion succeeds, or\r\n * {@link Failure} with an error message if an error occurs.\r\n * @public\r\n */\r\nexport function mapToRecord<TS, TD, TK extends string = string>(src: Map<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>> {\r\n    const record: Record<TK, TD> = {} as Record<TK, TD>;\r\n    for (const kvp of src) {\r\n        if (kvp[1] !== undefined) {\r\n            const itemResult = factory(kvp[0], kvp[1]);\r\n            if (itemResult.isSuccess()) {\r\n                record[kvp[0]] = itemResult.value;\r\n            }\r\n            else {\r\n                return fail(`${kvp[0]}: ${itemResult.message}`);\r\n            }\r\n        }\r\n    }\r\n    return succeed(record);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert an optional `Map<string, TS>` into a `Record<string, TD>` or `undefined`.\r\n * @param src - The `Map` object to be converted, or `undefined`.\r\n * @param factory - The factory method used to convert elements.\r\n * @returns {@link Success} with the resulting record if conversion succeeds, or {@link Success} with `undefined` if\r\n * `src` is `undefined`. Returns {@link Failure} with a message if an error occurs.\r\n * @public\r\n */\r\nexport function optionalMapToRecord<TS, TD, TK extends string = string>(src: Map<TK, TS>|undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>|undefined> {\r\n    return (src === undefined) ? succeed(undefined) : mapToRecord(src, factory);\r\n}\r\n\r\n/**\r\n * Applies a factory method to convert an optional `Map<string, TS>` into a `Record<string, TD>`\r\n * @param src - The `Map` object to be converted, or `undefined`.\r\n * @param factory - The factory method used to convert elements.\r\n * @returns {@link Success} with the resulting record (empty if `src` is `undefined`) if conversion succeeds.\r\n * Returns {@link Failure} with a message if an error occurs.\r\n * @public\r\n */\r\nexport function optionalMapToPossiblyEmptyRecord<TS, TD, TK extends string = string>(src: Map<TK, TS>|undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>> {\r\n    return (src === undefined) ? succeed({} as Record<TK, TD>) : mapToRecord(src, factory);\r\n}\r\n"]}

converters.js

Sorry, the diff of this file is too big to display

@fgv/ts-utils - npm Package Compare versions

New alerts

Improved metrics

Worsened metrics