@fgv/ts-utils 1.2.0 → 1.3.1

package/converters.js

@@ -33,36 +33,50 @@ const extendedArray_1 = require("./extendedArray");
 const mustache_1 = __importDefault(require("mustache"));
 const utils_1 = require("./utils");
 /**
- * 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
  */
 class StringConverter extends converter_1.BaseConverter {
     /**
-     * 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, traits, converter = StringConverter._convert) {
         super(converter, defaultContext, traits);
     }
+    /**
+     * @internal
+     */
     static _convert(from) {
         return typeof from === 'string'
-            ? result_1.succeed(from)
-            : result_1.fail(`Not a string: ${JSON.stringify(from)}`);
+            ? (0, result_1.succeed)(from)
+            : (0, result_1.fail)(`Not a string: ${JSON.stringify(from)}`);
     }
+    /**
+     * @internal
+     */
     static _wrap(wrapped, converter, traits) {
         return new StringConverter(undefined, undefined, (from) => {
             return wrapped.convert(from).onSuccess(converter);
         })._with(wrapped._traits(traits));
     }
+    /**
+     * Concrete implementation of {@link Converters.StringConverter.(matching#string) | StringConverter.matching(string)},
+     * {@link Converters.StringConverter.(matching#array) | StringConverter.matching(string[])},
+     * {@link Converters.StringConverter.(matching#set) | StringConverter.matching(Set<string>)}, and
+     * {@link Converters.StringConverter.(matching#regexp) | StringConverter.matching(RegExp)}.
+     * @internal
+     */
     matching(match, options) {
         const message = options === null || options === void 0 ? void 0 : options.message;
         if (typeof match === 'string') {
             return StringConverter._wrap(this, (from) => {
                 return (match === from)
-                    ? result_1.succeed(from)
-                    : result_1.fail(message
+                    ? (0, result_1.succeed)(from)
+                    : (0, result_1.fail)(message
                         ? `"${from}": ${message}`
                         : `"${from}": does not match "${match}"`);
             });
@@ -70,8 +84,8 @@ class StringConverter extends converter_1.BaseConverter {
         else if (match instanceof RegExp) {
             return StringConverter._wrap(this, (from) => {
                 return (match.test(from))
-                    ? result_1.succeed(from)
-                    : result_1.fail(message
+                    ? (0, result_1.succeed)(from)
+                    : (0, result_1.fail)(message
                         ? `"${from}": ${message}`
                         : `"${from}": does not match "${match}"`);
             });
@@ -79,8 +93,8 @@ class StringConverter extends converter_1.BaseConverter {
         else if (match instanceof Set) {
             return StringConverter._wrap(this, (from) => {
                 return (match.has(from))
-                    ? result_1.succeed(from)
-                    : result_1.fail(message
+                    ? (0, result_1.succeed)(from)
+                    : (0, result_1.fail)(message
                         ? `"${from}": ${message}`
                         : `"${from}": not found in set`);
             });
@@ -88,8 +102,8 @@ class StringConverter extends converter_1.BaseConverter {
         else {
             return StringConverter._wrap(this, (from) => {
                 return (match.includes(from))
-                    ? result_1.succeed(from)
-                    : result_1.fail(message
+                    ? (0, result_1.succeed)(from)
+                    : (0, result_1.fail)(message
                         ? `"${from}": ${message}`
                         : `"${from}": not found in [${match.join(',')}]`);
             });
@@ -100,113 +114,138 @@ exports.StringConverter = StringConverter;
 /**
  * A converter to convert unknown to string. Values of type
  * string succeed.  Anything else fails.
+ * @public
  */
 exports.string = new StringConverter();
 /**
- * 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
  */
 function templateString(defaultContext) {
     return new StringConverter(defaultContext, undefined, (from, _self, context) => {
         if (typeof from !== 'string') {
-            return result_1.fail(`Not a string: ${JSON.stringify(from)}`);
+            return (0, result_1.fail)(`Not a string: ${JSON.stringify(from)}`);
         }
-        return result_1.captureResult(() => mustache_1.default.render(from, context));
+        return (0, result_1.captureResult)(() => mustache_1.default.render(from, context));
     });
 }
 exports.templateString = templateString;
 /**
- * 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
  */
 function enumeratedValue(values) {
     return new converter_1.BaseConverter((from, _self, context) => {
         const v = context !== null && context !== void 0 ? context : values;
         const index = v.indexOf(from);
-        return (index >= 0 ? result_1.succeed(v[index]) : result_1.fail(`Invalid enumerated value ${JSON.stringify(from)}`));
+        return (index >= 0 ? (0, result_1.succeed)(v[index]) : (0, result_1.fail)(`Invalid enumerated value ${JSON.stringify(from)}`));
     });
 }
 exports.enumeratedValue = enumeratedValue;
 /**
- * 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
  */
 function mappedEnumeratedValue(map, message) {
     return new converter_1.BaseConverter((from, _self, _context) => {
         for (const item of map) {
             if (item[1].includes(from)) {
-                return result_1.succeed(item[0]);
+                return (0, result_1.succeed)(item[0]);
             }
         }
-        return result_1.fail(message ? `${JSON.stringify(from)}: ${message}` : `Cannot map '${JSON.stringify(from)}' to a supported value`);
+        return (0, result_1.fail)(message ? `${JSON.stringify(from)}: ${message}` : `Cannot map '${JSON.stringify(from)}' to a supported value`);
     });
 }
 exports.mappedEnumeratedValue = mappedEnumeratedValue;
 /**
- * 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
  */
 function literal(value) {
     return new converter_1.BaseConverter((from, _self, _context) => {
-        return (from === value) ? result_1.succeed(value) : result_1.fail(`${JSON.stringify(from)}: does not match ${JSON.stringify(value)}`);
+        return (from === value) ? (0, result_1.succeed)(value) : (0, result_1.fail)(`${JSON.stringify(from)}: does not match ${JSON.stringify(value)}`);
     });
 }
 exports.literal = literal;
 /**
  * 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
  */
 exports.value = 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
  */
 exports.number = new converter_1.BaseConverter((from) => {
     if (typeof from !== 'number') {
         const num = (typeof from === 'string' ? Number(from) : NaN);
         return isNaN(num)
-            ? result_1.fail(`Not a number: ${JSON.stringify(from)}`)
-            : result_1.succeed(num);
+            ? (0, result_1.fail)(`Not a number: ${JSON.stringify(from)}`)
+            : (0, result_1.succeed)(num);
     }
-    return result_1.succeed(from);
+    return (0, result_1.succeed)(from);
 });
 /**
- * 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
  */
 exports.boolean = new converter_1.BaseConverter((from) => {
     if (typeof from === 'boolean') {
-        return result_1.succeed(from);
+        return (0, result_1.succeed)(from);
     }
     else if (typeof from === 'string') {
         switch (from.toLowerCase()) {
-            case 'true': return result_1.succeed(true);
-            case 'false': return result_1.succeed(false);
+            case 'true': return (0, result_1.succeed)(true);
+            case 'false': return (0, result_1.succeed)(false);
         }
     }
-    return result_1.fail(`Not a boolean: ${JSON.stringify(from)}`);
+    return (0, result_1.fail)(`Not a boolean: ${JSON.stringify(from)}`);
 });
 /**
- * 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
  */
 exports.optionalString = exports.string.optional();
 /**
- * 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
  */
 function delimitedString(delimiter, options = 'filtered') {
     return new converter_1.BaseConverter((from, _self, context) => {
@@ -216,55 +255,65 @@ function delimitedString(delimiter, options = 'filtered') {
             if (options !== 'all') {
                 strings = strings.filter((s) => (s.trim().length > 0));
             }
-            return result_1.succeed(strings);
+            return (0, result_1.succeed)(strings);
         }
-        return result_1.fail(result.message);
+        return (0, result_1.fail)(result.message);
     });
 }
 exports.delimitedString = delimitedString;
 /**
- * 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
  */
 exports.isoDate = new converter_1.BaseConverter((from) => {
     if (typeof from === 'string') {
         const dt = luxon_1.DateTime.fromISO(from);
         if (dt.isValid) {
-            return result_1.succeed(dt.toJSDate());
+            return (0, result_1.succeed)(dt.toJSDate());
         }
-        return result_1.fail(`Invalid date: ${dt.invalidExplanation}`);
+        return (0, result_1.fail)(`Invalid date: ${dt.invalidExplanation}`);
     }
     else if (typeof from === 'number') {
-        return result_1.succeed(new Date(from));
+        return (0, result_1.succeed)(new Date(from));
     }
     else if (from instanceof Date) {
-        return result_1.succeed(from);
+        return (0, result_1.succeed)(from);
     }
-    return result_1.fail(`Cannot convert ${JSON.stringify(from)} to Date`);
+    return (0, result_1.fail)(`Cannot convert ${JSON.stringify(from)} to Date`);
 });
 /**
- * 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
  */
 exports.optionalNumber = exports.number.optional();
 /**
- * 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
  */
 exports.optionalBoolean = exports.boolean.optional();
 /**
- * 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
  */
 function oneOf(converters, onError = 'ignoreErrors') {
     return new converter_1.BaseConverter((from, _self, context) => {
@@ -281,21 +330,24 @@ function oneOf(converters, onError = 'ignoreErrors') {
                 errors.push(result.message);
             }
         }
-        return result_1.fail(`No matching converter for ${JSON.stringify(from)}: ${errors.join('\n')}`);
+        return (0, result_1.fail)(`No matching converter for ${JSON.stringify(from)}: ${errors.join('\n')}`);
     });
 }
 exports.oneOf = oneOf;
 /**
- * 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
  */
 function arrayOf(converter, onError = 'failOnError') {
     return new converter_1.BaseConverter((from, _self, context) => {
         if (!Array.isArray(from)) {
-            return result_1.fail(`Not an array: ${JSON.stringify(from)}`);
+            return (0, result_1.fail)(`Not an array: ${JSON.stringify(from)}`);
         }
         const successes = [];
         const errors = [];
@@ -309,190 +361,228 @@ function arrayOf(converter, onError = 'failOnError') {
             }
         }
         return (errors.length === 0) || (onError === 'ignoreErrors')
-            ? result_1.succeed(successes)
-            : result_1.fail(errors.join('\n'));
+            ? (0, result_1.succeed)(successes)
+            : (0, result_1.fail)(errors.join('\n'));
     });
 }
 exports.arrayOf = arrayOf;
 /**
- * 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
  */
 function extendedArrayOf(label, converter, onError = 'failOnError') {
     return arrayOf(converter, onError).map((items) => {
-        return result_1.captureResult(() => new extendedArray_1.ExtendedArray(label, ...items));
+        return (0, result_1.captureResult)(() => new extendedArray_1.ExtendedArray(label, ...items));
     });
 }
 exports.extendedArrayOf = extendedArrayOf;
 /**
- * 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
  */
 exports.stringArray = arrayOf(exports.string);
 /**
- * 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
  */
 exports.numberArray = arrayOf(exports.number);
+/**
+ * Concrete implementation of {@link Converters.(recordOf:default) | Converters.recordOf(Converter<T>)},
+ * {@link Converters.(recordOf:withOnError) | Converters.recordOf(Converter<T>, 'fail'|'ignore')}, and
+ * {@link Converters.(recordOf:withOptions) | Converters.recordOf(Converter<T>, KeyedConverterOptions)}.
+ * @internal
+ */
 function recordOf(converter, option = 'fail') {
     const options = (typeof option === 'string') ? { onError: option } : { onError: 'fail', ...option };
     return new converter_1.BaseConverter((from, _self, context) => {
         var _a, _b;
         if ((typeof from !== 'object') || (from === null) || Array.isArray(from)) {
-            return result_1.fail(`Not a string-keyed object: ${JSON.stringify(from)}`);
+            return (0, result_1.fail)(`Not a string-keyed object: ${JSON.stringify(from)}`);
         }
         const record = {};
         const errors = [];
         for (const key in from) {
-            if (utils_1.isKeyOf(key, from)) {
-                const writeKeyResult = (_b = (_a = options.keyConverter) === null || _a === void 0 ? void 0 : _a.convert(key, context)) !== null && _b !== void 0 ? _b : result_1.succeed(key);
+            if ((0, utils_1.isKeyOf)(key, from)) {
+                const writeKeyResult = (_b = (_a = options.keyConverter) === null || _a === void 0 ? void 0 : _a.convert(key, context)) !== null && _b !== void 0 ? _b : (0, result_1.succeed)(key);
                 writeKeyResult.onSuccess((writeKey) => {
                     return converter.convert(from[key], context).onSuccess((value) => {
                         record[writeKey] = value;
-                        return result_1.succeed(true);
+                        return (0, result_1.succeed)(true);
                     });
                 }).onFailure((message) => {
                     errors.push(message);
-                    return result_1.fail(message);
+                    return (0, result_1.fail)(message);
                 });
             }
         }
         return (errors.length === 0) || (options.onError === 'ignore')
-            ? result_1.succeed(record)
-            : result_1.fail(errors.join('\n'));
+            ? (0, result_1.succeed)(record)
+            : (0, result_1.fail)(errors.join('\n'));
     });
 }
 exports.recordOf = recordOf;
+/**
+ * Concrete implementation of {@link Converters.(mapOf:default) | Converters.mapOf(Converter<T>)},
+ * {@link Converters.(mapOf:withOnError) | Converters.mapOf(Converter<T>, 'fail'|'ignore')}, and
+ * {@link Converters.(mapOf:withOptions) | Converters.mapOf(Converter<T>, KeyedConverterOptions)}.
+ * @internal
+ */
 function mapOf(converter, option = 'fail') {
     const options = (typeof option === 'string') ? { onError: option } : { onError: 'fail', ...option };
     return new converter_1.BaseConverter((from, _self, context) => {
         var _a, _b;
         if ((typeof from !== 'object') || (from === null) || Array.isArray(from)) {
-            return result_1.fail(`Not a string-keyed object: ${JSON.stringify(from)}`);
+            return (0, result_1.fail)(`Not a string-keyed object: ${JSON.stringify(from)}`);
         }
         const map = new Map();
         const errors = [];
         for (const key in from) {
-            if (utils_1.isKeyOf(key, from)) {
-                const writeKeyResult = (_b = (_a = options.keyConverter) === null || _a === void 0 ? void 0 : _a.convert(key, context)) !== null && _b !== void 0 ? _b : result_1.succeed(key);
+            if ((0, utils_1.isKeyOf)(key, from)) {
+                const writeKeyResult = (_b = (_a = options.keyConverter) === null || _a === void 0 ? void 0 : _a.convert(key, context)) !== null && _b !== void 0 ? _b : (0, result_1.succeed)(key);
                 writeKeyResult.onSuccess((writeKey) => {
                     return converter.convert(from[key], context).onSuccess((value) => {
                         map.set(writeKey, value);
-                        return result_1.succeed(true);
+                        return (0, result_1.succeed)(true);
                     });
                 }).onFailure((message) => {
                     errors.push(message);
-                    return result_1.fail(message);
+                    return (0, result_1.fail)(message);
                 });
             }
         }
         return (errors.length === 0) || (options.onError === 'ignore')
-            ? result_1.succeed(map)
-            : result_1.fail(errors.join('\n'));
+            ? (0, result_1.succeed)(map)
+            : (0, result_1.fail)(errors.join('\n'));
     });
 }
 exports.mapOf = mapOf;
 /**
- * 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
  */
 function validateWith(validator, description) {
     return new converter_1.BaseConverter((from, _self, _context) => {
         if (validator(from)) {
-            return result_1.succeed(from);
+            return (0, result_1.succeed)(from);
         }
-        return result_1.fail(`${JSON.stringify(from)}: invalid ${description !== null && description !== void 0 ? description : 'value'}`);
+        return (0, result_1.fail)(`${JSON.stringify(from)}: invalid ${description !== null && description !== void 0 ? description : 'value'}`);
     });
 }
 exports.validateWith = validateWith;
 /**
- * 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
  */
 function element(index, converter) {
     return new converter_1.BaseConverter((from, _self, context) => {
         if (index < 0) {
-            return result_1.fail(`${index}: cannot convert for a negative element index`);
+            return (0, result_1.fail)(`${index}: cannot convert for a negative element index`);
         }
         else if (!Array.isArray(from)) {
-            return result_1.fail('element converter: source is not an array');
+            return (0, result_1.fail)('element converter: source is not an array');
         }
         else if (index >= from.length) {
-            return result_1.fail(`${index}: element converter index out of range (0..${from.length - 1})`);
+            return (0, result_1.fail)(`${index}: element converter index out of range (0..${from.length - 1})`);
         }
         return converter.convert(from[index], context);
     });
 }
 exports.element = element;
 /**
- * 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
  */
 function optionalElement(index, converter) {
     return new converter_1.BaseConverter((from, _self, context) => {
         if (index < 0) {
-            return result_1.fail(`${index}: cannot convert for a negative element index`);
+            return (0, result_1.fail)(`${index}: cannot convert for a negative element index`);
         }
         else if (!Array.isArray(from)) {
-            return result_1.fail('element converter: source is not an array');
+            return (0, result_1.fail)('element converter: source is not an array');
         }
         else if (index >= from.length) {
-            return result_1.succeed(undefined);
+            return (0, result_1.succeed)(undefined);
         }
         return converter.convert(from[index], context);
     });
 }
 exports.optionalElement = optionalElement;
 /**
- * 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
  */
 function field(name, converter) {
     return new converter_1.BaseConverter((from, _self, context) => {
         if (typeof from === 'object' && (!Array.isArray(from)) && from !== null) {
-            if (utils_1.isKeyOf(name, from)) {
+            if ((0, utils_1.isKeyOf)(name, from)) {
                 return converter.convert(from[name], context).onFailure((message) => {
-                    return result_1.fail(`Field ${name}: ${message}`);
+                    return (0, result_1.fail)(`Field ${name}: ${message}`);
                 });
             }
-            return result_1.fail(`Field ${name} not found in: ${JSON.stringify(from)}`);
+            return (0, result_1.fail)(`Field ${name} not found in: ${JSON.stringify(from)}`);
         }
-        return result_1.fail(`Cannot convert field "${name}" from non-object ${JSON.stringify(from)}`);
+        return (0, result_1.fail)(`Cannot convert field "${name}" from non-object ${JSON.stringify(from)}`);
     });
 }
 exports.field = field;
 /**
- * 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
  */
 function optionalField(name, converter) {
     return new converter_1.BaseConverter((from, _self, context) => {
         if (typeof from === 'object' && (!Array.isArray(from)) && from !== null) {
-            if (utils_1.isKeyOf(name, from)) {
+            if ((0, utils_1.isKeyOf)(name, from)) {
                 const result = converter.convert(from[name], context).onFailure((message) => {
-                    return result_1.fail(`${name}: ${message}`);
+                    return (0, result_1.fail)(`${name}: ${message}`);
                 });
                 // if conversion was successful or input was undefined we
                 // succeed with 'undefined', but we propagate actual
@@ -501,19 +591,28 @@ function optionalField(name, converter) {
                     return result;
                 }
             }
-            return result_1.succeed(undefined);
+            return (0, result_1.succeed)(undefined);
         }
-        return result_1.fail(`Cannot convert field "${name}" from non-object ${JSON.stringify(from)}`);
+        return (0, result_1.fail)(`Cannot convert field "${name}" from non-object ${JSON.stringify(from)}`);
     }, undefined, { isOptional: true });
 }
 exports.optionalField = optionalField;
 /**
- * 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
  */
 class ObjectConverter extends converter_1.BaseConverter {
+    /**
+     * Concrete implementation of {@link Converters.ObjectConverter.(constructor:withOptions)}
+     * and {@link Converters.ObjectConverter.(constructor:withKeys)}.
+     * @internal
+     */
     constructor(fields, opt) {
         super((from, _self, context) => {
             var _a, _b;
@@ -538,7 +637,7 @@ class ObjectConverter extends converter_1.BaseConverter {
             if (this.options.strict === true) {
                 if ((typeof from === 'object') && (!Array.isArray(from))) {
                     for (const key in from) {
-                        if (from.hasOwnProperty(key) && (!utils_1.isKeyOf(key, fields) || (fields[key] === undefined))) {
+                        if (from.hasOwnProperty(key) && (!(0, utils_1.isKeyOf)(key, fields) || (fields[key] === undefined))) {
                             errors.push(`${key}: unexpected property in source object`);
                         }
                     }
@@ -547,7 +646,7 @@ class ObjectConverter extends converter_1.BaseConverter {
                     errors.push('source is not an object');
                 }
             }
-            return (errors.length === 0) ? result_1.succeed(converted) : result_1.fail(errors.join('\n'));
+            return (errors.length === 0) ? (0, result_1.succeed)(converted) : (0, result_1.fail)(errors.join('\n'));
         });
         this.fields = fields;
         if (Array.isArray(opt)) {
@@ -557,106 +656,110 @@ class ObjectConverter extends converter_1.BaseConverter {
             this.options = opt !== null && opt !== void 0 ? opt : {};
         }
     }
+    /**
+     * Concrete implementation of
+     * {@link Converters.ObjectConverter.(partial:withOptions) | ObjectConverter.partial(ObjectConverterOptions)} and
+     * {@link Converters.ObjectConverter.(partial:withKeys) | ObjectConverter.partial((keyof T)[]}.
+     * @internal
+     */
     partial(opt) {
         return new ObjectConverter(this.fields, opt)._with(this._traits());
     }
-    addPartial(addOptionalFields) {
+    /**
+     * 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) {
         var _a;
-        return this.partial([...(_a = this.options.optionalFields) !== null && _a !== void 0 ? _a : [], ...addOptionalFields])._with(this._traits());
+        return this.partial([...(_a = this.options.optionalFields) !== null && _a !== void 0 ? _a : [], ...addOptionalProperties])._with(this._traits());
     }
 }
 exports.ObjectConverter = ObjectConverter;
 /**
- * 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.
- *
- * 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.
+ * Concrete implementation of {@link Converters.(object:withOptions) | Converters.object(fields, options)}
+ * and {@link Converters.(object:withKeys) | Converters.objects(fields, optionalKeys)}.
+ * @internal
  */
-function object(fields, opt) {
-    return new ObjectConverter(fields, opt);
+function object(properties, options) {
+    return new ObjectConverter(properties, options);
 }
 exports.object = object;
 /**
- * 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.
- *
- * 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.
+ * Concrete implementation for {@link Converters.(strictObject:withOptions) | Converters.strictObject(fields, options)}
+ * and {@link Converters.(strictObject:withKeys) | Converters.strictObject(fields, optional)}.
+ * @internal
  */
-function strictObject(fields, opt) {
+function strictObject(properties, opt) {
     const options = (opt && Array.isArray(opt))
         ? { strict: true, optionalFields: opt }
         : { ...(opt !== null && opt !== void 0 ? opt : {}), strict: true };
-    return new ObjectConverter(fields, options);
+    return new ObjectConverter(properties, options);
 }
 exports.strictObject = strictObject;
 /**
- * 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
  */
 function discriminatedObject(discriminatorProp, converters) {
     return new converter_1.BaseConverter((from) => {
         if ((typeof from !== 'object') || Array.isArray(from) || from === null) {
-            return result_1.fail(`Not a discriminated object: "${JSON.stringify(from)}"`);
+            return (0, result_1.fail)(`Not a discriminated object: "${JSON.stringify(from)}"`);
         }
-        if ((!utils_1.isKeyOf(discriminatorProp, from)) || (!from[discriminatorProp])) {
-            return result_1.fail(`Discriminator property ${discriminatorProp} not present in "${JSON.stringify(from)}"`);
+        if ((!(0, utils_1.isKeyOf)(discriminatorProp, from)) || (!from[discriminatorProp])) {
+            return (0, result_1.fail)(`Discriminator property ${discriminatorProp} not present in "${JSON.stringify(from)}"`);
         }
         const discriminatorValue = from[discriminatorProp];
         const converter = converters[discriminatorValue];
         if (converter === undefined) {
-            return result_1.fail(`No converter for discriminator ${discriminatorProp}="${discriminatorValue}"`);
+            return (0, result_1.fail)(`No converter for discriminator ${discriminatorProp}="${discriminatorValue}"`);
         }
         return converter.convert(from);
     });
 }
 exports.discriminatedObject = discriminatedObject;
 /**
- * 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.
  *
  * Fields that succeed but convert to undefined are omitted from the result object but do not
  * fail the conversion.
  *
- * @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
  */
-function transform(fields) {
+function transform(properties) {
     return new converter_1.BaseConverter((from, _self, context) => {
         // eslint bug thinks key is used before defined
         // eslint-disable-next-line no-use-before-define
         const converted = {};
         const errors = [];
-        for (const key in fields) {
-            if (fields[key]) {
-                const result = fields[key].convert(from, context);
+        for (const key in properties) {
+            if (properties[key]) {
+                const result = properties[key].convert(from, context);
                 if (result.isSuccess() && (result.value !== undefined)) {
                     converted[key] = result.value;
                 }
@@ -665,30 +768,38 @@ function transform(fields) {
                 }
             }
         }
-        return (errors.length === 0) ? result_1.succeed(converted) : result_1.fail(errors.join('\n'));
+        return (errors.length === 0) ? (0, result_1.succeed)(converted) : (0, result_1.fail)(errors.join('\n'));
     });
 }
 exports.transform = transform;
 /**
- * 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
  */
 function rangeTypeOf(converter, constructor) {
     return new converter_1.BaseConverter((from, _self, context) => {
         const result = object({
             min: converter,
             max: converter,
-        }, ['min', 'max']).convert(from, context);
+        }, { optionalFields: ['min', 'max'] }).convert(from, context);
         if (result.isSuccess()) {
             return constructor({ min: result.value.min, max: result.value.max });
         }
-        return result_1.fail(result.message);
+        return (0, result_1.fail)(result.message);
     });
 }
 exports.rangeTypeOf = rangeTypeOf;
+/**
+ * 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
+ */
 function rangeOf(converter) {
     return rangeTypeOf(converter, rangeOf_1.RangeOf.createRange);
 }
 exports.rangeOf = rangeOf;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"converters.js","sourceRoot":"","sources":["../src/converters.ts"],"names":[],"mappings":"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","sourcesContent":["\n/*\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 { BaseConverter, Converter, ConverterTraits } from './converter';\nimport { RangeOf, RangeOfProperties } from './rangeOf';\nimport { Result, captureResult, fail, succeed } from './result';\n\nimport { DateTime } from 'luxon';\nimport { ExtendedArray } from './extendedArray';\nimport Mustache from 'mustache';\nimport { isKeyOf } from './utils';\n\ntype OnError = 'failOnError' | 'ignoreErrors';\n\n/**\n * Options for @see StringConverter maching method\n */\nexport interface StringMatchOptions {\n    /**\n     * An optional message to be displayed if a non-matching string\n     * is encountered.\n     */\n    message?: string;\n}\n\n/**\n * The @see StringConverter class extends @see BaseConverter to provide string-specific helper\n * functions.\n */\nexport class StringConverter<T extends string = string, TC = unknown> extends BaseConverter<T, TC> {\n    /**\n     * Construct a new @see StringConverter\n     * @param defaultContext Optional context used by the conversion\n     * @param traits Optional traits to be applied to the conversion\n     * @param converter Optional converter to be used for the conversion\n     */\n    public constructor(\n        defaultContext?: TC,\n        traits?: ConverterTraits,\n        converter: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T> = StringConverter._convert,\n    ) {\n        super(converter, defaultContext, traits);\n    }\n\n    protected static _convert<T extends string>(from: unknown): Result<T> {\n        return typeof from === 'string'\n            ? succeed(from as T)\n            : fail(`Not a string: ${JSON.stringify(from)}`);\n    }\n\n    protected static _wrap<T extends string, TC>(\n        wrapped: StringConverter<T, TC>,\n        converter: (from: T) => Result<T>,\n        traits?: ConverterTraits\n    ): StringConverter<T, TC> {\n        return new StringConverter<T, TC>(undefined, undefined, (from: unknown) => {\n            return wrapped.convert(from).onSuccess(converter);\n        })._with(wrapped._traits(traits));\n    }\n\n    /**\n     * Returns a @see StringConverter which constrains the result to match a supplied\n     * string.\n     * @param match The string to be matched\n     * @param options Optional @see StringMatchOptions for this conversion\n     * @returns @see Success with a matching string or @see Failure with an informative\n     * error if the string does not match.\n     */\n    public matching(match: string, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;\n\n    /**\n     * Returns a @see StringConverter which constrains the result to match one of a supplied\n     * array of strings.\n     * @param match The array to be searched\n     * @param options Optional @see StringMatchOptions for this conversion\n     * @returns @see Success with a matching string or @see Failure with an informative\n     * error if the string does not match.\n     */\n    public matching(match: string[], options?: Partial<StringMatchOptions>): StringConverter<T, TC>;\n\n    /**\n     * Returns a @see StringConverter which constrains the result to match one of a supplied\n     * Set of strings.\n     * @param match The Set to be tested\n     * @param options Optional @see StringMatchOptions for this conversion\n     * @returns @see Success with a matching string or @see Failure with an informative\n     * error if the string does not match.\n     */\n    public matching(match: Set<T>, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;\n\n    /**\n     * Returns a @see StringConverter which constrains the result to match a supplied regular\n     * expression.\n     * @param match The @see RegExp to be tested\n     * @param options Optional @see StringMatchOptions for this conversion\n     * @returns @see Success with a matching string or @see Failure with an informative\n     * error if the string does not match.\n     */\n    public matching(match: RegExp, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;\n    public matching(match: string | string[] | Set<T> | RegExp, options?: Partial<StringMatchOptions>): StringConverter<T, TC> {\n        const message = options?.message;\n        if (typeof match === 'string') {\n            return StringConverter._wrap<T, TC>(this, (from: T) => {\n                return (match === from)\n                    ? succeed(from as T)\n                    : fail(message\n                        ? `\"${from}\": ${message}`\n                        : `\"${from}\": does not match \"${match}\"`);\n            });\n        }\n        else if (match instanceof RegExp) {\n            return StringConverter._wrap<T, TC>(this, (from: T) => {\n                return (match.test(from))\n                    ? succeed(from as T)\n                    : fail(message\n                        ? `\"${from}\": ${message}`\n                        : `\"${from}\": does not match \"${match}\"`);\n            });\n        }\n        else if (match instanceof Set) {\n            return StringConverter._wrap<T, TC>(this, (from: T) => {\n                return (match.has(from))\n                    ? succeed(from as T)\n                    : fail(message\n                        ? `\"${from}\": ${message}`\n                        : `\"${from}\": not found in set`);\n            });\n        }\n        else {\n            return StringConverter._wrap<T, TC>(this, (from: T) => {\n                return (match.includes(from))\n                    ? succeed(from as T)\n                    : fail(message\n                        ? `\"${from}\": ${message}`\n                        : `\"${from}\": not found in [${match.join(',')}]`);\n            });\n        }\n    }\n}\n\n/**\n * A converter to convert unknown to string. Values of type\n * string succeed.  Anything else fails.\n */\nexport const string = new StringConverter();\n\n/**\n * Helper function to create a converter which converts unknown to string, applying\n * template conversions supplied at construction time or at runtime as context.\n * @param defaultContext optional default context to use for template values\n */\nexport function templateString(defaultContext?: unknown): StringConverter<string, unknown> {\n    return new StringConverter<string, unknown>(defaultContext, undefined, (from: unknown, _self: Converter<string, unknown>, context?: unknown) => {\n        if (typeof from !== 'string') {\n            return fail(`Not a string: ${JSON.stringify(from)}`);\n        }\n        return captureResult(() => Mustache.render(from, context));\n    });\n}\n\n/**\n * A converter to convert unknown to one of a set of supplied enumerated values. Anything else fails.\n * Allowed enumerated values can also be supplied as context at conversion time.\n * @param values Array of allowed values\n */\nexport function enumeratedValue<T>(values: T[]): Converter<T, T[]> {\n    return new BaseConverter((from: unknown, _self: Converter<T, T[]>, context?: T[]): Result<T> => {\n        const v = context ?? values;\n        const index = v.indexOf(from as T);\n        return (index >= 0 ? succeed(v[index]) : fail(`Invalid enumerated value ${JSON.stringify(from)}`));\n    });\n}\n\n/**\n * Converts unknown to one of a set of supplied enumerated values, mapping any of multiple supplied\n * values to the enumeration. Enables mapping of multiple input values to a consistent internal\n * representation (so e.g. 'y', 'yes', 'true' and true can all map to boolean true)\n * @param map An array of tuples describing the mapping. The first element of each tuple is the result\n * value, the second is the set of values that map to the result.  Tuples are evaluated in the order\n * supplied and are not checked for duplicates.\n * @param message an optional error message\n * @returns The mapped value\n */\nexport function mappedEnumeratedValue<T>(map: [T, unknown[]][], message?: string): Converter<T, undefined> {\n    return new BaseConverter((from: unknown, _self: Converter<T, undefined>, _context?: unknown) => {\n        for (const item of map) {\n            if (item[1].includes(from)) {\n                return succeed(item[0]);\n            }\n        }\n        return fail(message ? `${JSON.stringify(from)}: ${message}` : `Cannot map '${JSON.stringify(from)}' to a supported value`);\n    });\n}\n\n/**\n * A converter to convert unknown to some value. Succeeds with the supplied value if an identity\n * comparison succeeds, fails otherwise.\n * @param value The value to be compared\n */\nexport function literal<T>(value: T): Converter<T, unknown> {\n    return new BaseConverter<T, unknown>((from: unknown, _self: Converter<T, unknown>, _context?: unknown): Result<T> => {\n        return (from === value) ? succeed(value) : fail(`${JSON.stringify(from)}: does not match ${JSON.stringify(value)}`);\n    });\n}\n\n/**\n * Deprecated alias for @see literal\n * @param value The value to be compared\n * @deprecated use literal instead\n */\nexport const value = literal;\n\n/**\n * A converter to convert unknown to a number.  Numbers and strings\n * with a numeric format succeed.  Anything else fails.\n */\nexport const number = new BaseConverter<number>((from: unknown) => {\n    if (typeof from !== 'number') {\n        const num: number = (typeof from === 'string' ? Number(from) : NaN);\n        return isNaN(num)\n            ? fail(`Not a number: ${JSON.stringify(from)}`)\n            : succeed(num);\n    }\n    return succeed(from);\n});\n\n/**\n * A converter to convert unknown to boolean. Boolean values or the\n * case-insensitive strings 'true' and 'false' succeed.  Anything\n * else fails.\n */\nexport const boolean = new BaseConverter<boolean>((from: unknown) => {\n    if (typeof from === 'boolean') {\n        return succeed(from as boolean);\n    }\n    else if (typeof from === 'string') {\n        switch (from.toLowerCase()) {\n            case 'true': return succeed(true);\n            case 'false': return succeed(false);\n        }\n    }\n    return fail(`Not a boolean: ${JSON.stringify(from)}`);\n});\n\n/**\n * A converter to convert an optional string value. Values of type string\n * are returned.  Anything else returns success with an undefined value.\n */\nexport const optionalString = string.optional();\n\n/**\n * Creates a converter which converts any string into an array of strings\n * by separating at a supplied delimiter. Delimeter may also be supplied\n * as context at conversion time.\n * @param delimiter The delimiter at which to split.\n */\nexport function delimitedString(delimiter: string, options: 'filtered'|'all' = 'filtered'): Converter<string[], string> {\n    return new BaseConverter<string[], string>((from: unknown, _self: Converter<string[], string>, context?: string) => {\n        const result = string.convert(from);\n        if (result.isSuccess()) {\n            let strings = result.value.split(context ?? delimiter);\n            if (options !== 'all') {\n                strings = strings.filter((s) => (s.trim().length > 0));\n            }\n            return succeed(strings);\n        }\n        return fail(result.message);\n    });\n}\n\n/**\n * A converter to convert an iso formatted string, a number or a Date object to a Date object\n */\nexport const isoDate = new BaseConverter<Date>((from: unknown) => {\n    if (typeof from === 'string') {\n        const dt = DateTime.fromISO(from);\n        if (dt.isValid) {\n            return succeed(dt.toJSDate());\n        }\n        return fail(`Invalid date: ${dt.invalidExplanation}`);\n    }\n    else if (typeof from === 'number') {\n        return succeed(new Date(from));\n    }\n    else if (from instanceof Date) {\n        return succeed(from);\n    }\n    return fail(`Cannot convert ${JSON.stringify(from)} to Date`);\n});\n\n/**\n * A converter to convert an optional number value. Values of type number\n * or numeric strings are converted and returned. Anything else returns\n * success with an undefined value.\n */\nexport const optionalNumber = number.optional();\n\n/**\n * A converter to convert an optional boolean value. Values of type boolean\n * or strings that match (case-insensitive) 'true' or 'false' are converted\n * and returned.  Anything else returns success with an undefined value.\n */\nexport const optionalBoolean = boolean.optional();\n\n/**\n * A helper wrapper for polymorphic fields. Invokes the wrapped converters\n * in sequence, returning the first successful result.  Returns an error\n * if none of the supplied converters can convert the value.\n *\n * If onError is 'ignoreErrors' (default), then errors from any of the\n * converters are ignored provided that some converter succeeds.  If\n * onError is 'failOnError', then an error from any converter fails the entire\n * conversion.\n *\n * @param converters An ordered list of converters to be considered\n * @param onError Specifies treatment of unconvertable elements\n */\nexport function oneOf<T, TC=unknown>(converters: Array<Converter<T, TC>>, onError: OnError = 'ignoreErrors'): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self, context?: TC) => {\n        const errors: string[] = [];\n        for (const converter of converters) {\n            const result = converter.convert(from, context);\n            if (result.isSuccess() && (result.value !== undefined)) {\n                return result;\n            }\n\n            if (result.isFailure()) {\n                if (onError === 'failOnError') {\n                    return result;\n                }\n                errors.push(result.message);\n            }\n        }\n        return fail(`No matching converter for ${JSON.stringify(from)}: ${errors.join('\\n')}`);\n    });\n}\n\n/**\n * A helper wrapper for converting an array of <T>.  If onError is 'failOnError' (default),\n * then the entire conversion fails if any element cannot be converted.  If onError\n * is 'ignoreErrors', failing elements are silently ignored.\n * @param converter Converter used to convert each item in the array\n * @param ignoreErrors Specifies treatment of unconvertable elements\n */\nexport function arrayOf<T, TC=undefined>(converter: Converter<T, TC>, onError: OnError = 'failOnError'): Converter<T[], TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T[], TC>, context?: TC) => {\n        if (!Array.isArray(from)) {\n            return fail(`Not an array: ${JSON.stringify(from)}`);\n        }\n\n        const successes: T[] = [];\n        const errors: string[] = [];\n        for (const item of from) {\n            const result = converter.convert(item, context);\n            if (result.isSuccess() && result.value !== undefined) {\n                successes.push(result.value);\n            }\n            else if (result.isFailure()) {\n                errors.push(result.message);\n            }\n        }\n\n        return (errors.length === 0) || (onError === 'ignoreErrors')\n            ? succeed(successes)\n            : fail(errors.join('\\n'));\n    });\n}\n\n/**\n * A helper wrapper for converting to Itemrray<T>.  If onError is 'failOnError' (default),\n * then the entire conversion fails if any element cannot be converted.  If onError\n * is 'ignoreErrors', failing elements are silently ignored.\n * @param converter Converter used to convert each item in the array\n * @param ignoreErrors Specifies treatment of unconvertable elements\n */\nexport function extendedArrayOf<T, TC=undefined>(label: string, converter: Converter<T, TC>, onError: OnError = 'failOnError'): Converter<ExtendedArray<T>, TC> {\n    return arrayOf(converter, onError).map((items: T[]) => {\n        return captureResult(() => new ExtendedArray(label, ...items));\n    });\n}\n\n/**\n * Converter to convert an unknown to an array of strings. Conversion succeeds\n * and returns the supplied value if it as an array of strings, fails otherwise.\n */\nexport const stringArray = arrayOf(string);\n\n/**\n * Converter to convert an unknown to an array of numbers. Conversion succeeds\n * and returns the supplied value if it as an array of numbers, fails otherwise.\n */\nexport const numberArray = arrayOf(number);\n\n/**\n * Options for 'recordOf' and 'mapOf' converters\n */\nexport interface KeyedConverterOptions<T extends string = string, TC=undefined> {\n    onError?: 'fail'|'ignore';\n    keyConverter?: Converter<T, TC>;\n}\n\n/**\n * A helper wrapper to convert the string-keyed properties of an object to a Record of T.\n * Conversion fails if any element cannot be converted.  If onError is 'ignore' failing\n * elements are silently ignored.\n * @param converter Converter used to convert each item in the record\n */\nexport function recordOf<T, TC=undefined, TK extends string=string>(converter: Converter<T, TC>): Converter<Record<TK, T>, TC>;\n\n/**\n * A helper wrapper to convert the string-keyed properties of an object to a Record of T.\n * If onError is 'fail' (default),  then the entire conversion fails if any element\n * cannot be converted.  If onError is 'ignore' failing elements are silently ignored.\n * @param converter Converter used to convert each item in the record\n * @param onError Specifies treatment of unconvertable elements\n */\nexport function recordOf<T, TC=undefined, TK extends string=string>(\n    converter: Converter<T, TC>,\n    onError: 'fail'|'ignore'\n): Converter<Record<TK, T>, TC>;\n\n/**\n * A helper wrapper to convert the string-keyed properties of an object to a Record of T.\n * If options specify a key converter it will be applied to each key.\n * If onError is 'fail' (default),  then the entire conversion fails if any key or element\n * cannot be converted.  If onError is 'ignore' failing elements are silently ignored.\n * @param converter Converter used to convert each item in the record\n * @param options Optional @see KeyedConverterOptions\n */\nexport function recordOf<T, TC=undefined, TK extends string=string>(\n    converter: Converter<T, TC>,\n    options: KeyedConverterOptions<TK, TC>\n): Converter<Record<TK, T>, TC>;\n\nexport function recordOf<T, TC=undefined, TK extends string=string>(\n    converter: Converter<T, TC>,\n    option: 'fail'|'ignore'|KeyedConverterOptions<TK, TC> = 'fail'\n): Converter<Record<TK, T>, TC> {\n    const options: KeyedConverterOptions<TK, TC> = (typeof option === 'string') ? { onError: option } : { onError: 'fail', ...option };\n    return new BaseConverter((from: unknown, _self: Converter<Record<TK, T>, TC>, context?: TC) => {\n        if ((typeof from !== 'object') || (from === null) || Array.isArray(from)) {\n            return fail(`Not a string-keyed object: ${JSON.stringify(from)}`);\n        }\n\n        const record: Record<string, T> = {};\n        const errors: string[] = [];\n\n        for (const key in from) {\n            if (isKeyOf(key, from)) {\n                const writeKeyResult = options.keyConverter?.convert(key, context) ?? succeed(key);\n\n                writeKeyResult.onSuccess((writeKey) => {\n                    return converter.convert(from[key] as unknown, context).onSuccess((value) => {\n                        record[writeKey] = value;\n                        return succeed(true);\n                    });\n                }).onFailure((message) => {\n                    errors.push(message);\n                    return fail(message);\n                });\n            }\n        }\n\n        return (errors.length === 0) || (options.onError === 'ignore')\n            ? succeed(record)\n            : fail(errors.join('\\n'));\n    });\n}\n\n/**\n * A helper wrapper to convert the string-keyed properties of an object to a Map of T.\n * Conversion fails if any element cannot be converted.\n * @param converter Converter used to convert each item in the map\n */\nexport function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>): Converter<Map<TK, T>, TC>;\n\n/**\n * A helper wrapper to convert the string-keyed properties of an object to a Map of T.\n * If onError is 'fail' (default),  then the entire conversion fails if any element\n * cannot be converted.  If onError is 'ignore' failing elements are silently ignored.\n * @param converter Converter used to convert each item in the map\n * @param onError Specifies treatment of unconvertable elements\n */\nexport function mapOf<T, TC = undefined, TK extends string = string>(\n    converter: Converter<T, TC>,\n    onError: 'fail' | 'ignore'\n): Converter<Map<TK, T>, TC>;\n\n/**\n * A helper wrapper to convert the string-keyed properties of an object to a Map of T.\n * If options specify a key converter it will be applied to each key.\n * If onError is 'fail' (default),  then the entire conversion fails if any key or element\n * cannot be converted.  If onError is 'ignore' failing elements are silently ignored.\n * @param converter Converter used to convert each item in the map\n * @param options Optional @see KeyedConverterOptions\n */\nexport function mapOf<T, TC = undefined, TK extends string = string>(\n    converter: Converter<T, TC>,\n    options: KeyedConverterOptions<TK, TC>\n): Converter<Map<TK, T>, TC>;\n\nexport function mapOf<T, TC = undefined, TK extends string = string>(\n    converter: Converter<T, TC>,\n    option: 'fail' | 'ignore' | KeyedConverterOptions<TK, TC> = 'fail'\n): Converter<Map<TK, T>, TC> {\n    const options = (typeof option === 'string') ? { onError: option } : { onError: 'fail', ...option };\n    return new BaseConverter((from: unknown, _self: Converter<Map<TK, T>, TC>, context?: TC) => {\n        if ((typeof from !== 'object') || (from === null) || Array.isArray(from)) {\n            return fail(`Not a string-keyed object: ${JSON.stringify(from)}`);\n        }\n\n        const map = new Map<TK, T>();\n        const errors: string[] = [];\n\n        for (const key in from) {\n            if (isKeyOf(key, from)) {\n                const writeKeyResult = options.keyConverter?.convert(key, context) ?? succeed(key);\n\n                writeKeyResult.onSuccess((writeKey) => {\n                    return converter.convert(from[key] as unknown, context).onSuccess((value) => {\n                        map.set(writeKey, value);\n                        return succeed(true);\n                    });\n                }).onFailure((message) => {\n                    errors.push(message);\n                    return fail(message);\n                });\n            }\n        }\n\n        return (errors.length === 0) || (options.onError === 'ignore')\n            ? succeed(map)\n            : fail(errors.join('\\n'));\n    });\n}\n\n/**\n * Gets a converter which validates that a supplied value is of a type validated by\n * a supplied validator and returns it.\n * @param validator A validator function to determine if the converted value is valid\n * @param description A description of the validate type for use in error messages\n * @returns If validator returns true, suceeds with from coerced to T.  Fails with an error\n * message otherwise.\n */\nexport function validateWith<T, TC=undefined>(validator: (from: unknown) => from is T, description?: string): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T, TC>, _context?: TC) => {\n        if (validator(from)) {\n            return succeed(from);\n        }\n        return fail(`${JSON.stringify(from)}: invalid ${description ?? 'value'}`);\n    });\n}\n\n/**\n * A helper function to extract and convert an element from an array. Succeeds and returns\n * the converted value if the element exists in the supplied parameter and can be converted.\n * Fails otherwise.\n * @param index The index of the field to be extracted.\n * @param converter Converter used to convert the extracted element.\n */\nexport function element<T, TC=undefined>(index: number, converter: Converter<T, TC>): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T, TC>, context?: TC) => {\n        if (index < 0) {\n            return fail(`${index}: cannot convert for a negative element index`);\n        }\n        else if (!Array.isArray(from)) {\n            return fail('element converter: source is not an array');\n        }\n        else if (index >= from.length) {\n            return fail(`${index}: element converter index out of range (0..${from.length - 1})`);\n        }\n        return converter.convert(from[index], context);\n    });\n}\n\n/**\n * A helper function to extract and convert an optional element from an array. Succeeds\n * and returns the converted value if the element exists in the supplied parameter and can\n * be converted. Succeeds with undefined if the parameter is an array but the index is too\n * large. Fails if the supplied parameter is not an array, if the requested index is negative,\n * or if the element cannot be converted.\n * @param name The name of the field to be extracted.\n * @param converter Converter used to convert the extracted field.\n */\nexport function optionalElement<T, TC=undefined>(index: number, converter: Converter<T, TC>): Converter<T|undefined, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T|undefined, TC>, context?: TC) => {\n        if (index < 0) {\n            return fail(`${index}: cannot convert for a negative element index`);\n        }\n        else if (!Array.isArray(from)) {\n            return fail('element converter: source is not an array');\n        }\n        else if (index >= from.length) {\n            return succeed(undefined);\n        }\n        return converter.convert(from[index], context);\n    });\n}\n\n/**\n * A helper function to extract and convert a field from an object. Succeeds and returns\n * the converted value if the field exists in the supplied parameter and can be converted.\n * Fails otherwise.\n * @param name The name of the field to be extracted.\n * @param converter Converter used to convert the extracted field.\n */\nexport function field<T, TC=undefined>(name: string, converter: Converter<T, TC>): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T, TC>, context?: TC) => {\n        if (typeof from === 'object' && (!Array.isArray(from)) && from !== null) {\n            if (isKeyOf(name, from)) {\n                return converter.convert(from[name], context).onFailure((message) => {\n                    return fail(`Field ${name}: ${message}`);\n                });\n            }\n            return fail(`Field ${name} not found in: ${JSON.stringify(from)}`);\n        }\n        return fail(`Cannot convert field \"${name}\" from non-object ${JSON.stringify(from)}`);\n    });\n}\n\n/**\n * A helper function to extract and convert an optional field from an object. Succeeds\n * and returns the converted value if the field exists in the supplied parameter and can\n * be converted. Succeeds with undefined if the parameter is an object but the named field\n * is not present. Fails if the supplied parameter is not an object.\n * @param name The name of the field to be extracted.\n * @param converter Converter used to convert the extracted field.\n */\nexport function optionalField<T, TC=undefined>(name: string, converter: Converter<T, TC>): Converter<T|undefined, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T|undefined, TC>, context?: TC) => {\n        if (typeof from === 'object' && (!Array.isArray(from)) && from !== null) {\n            if (isKeyOf(name, from)) {\n                const result = converter.convert(from[name], context).onFailure((message) => {\n                    return fail(`${name}: ${message}`);\n                });\n\n                // if conversion was successful or input was undefined we\n                // succeed with 'undefined', but we propagate actual\n                // failures.\n                if (result.isSuccess() || (from[name] !== undefined)) {\n                    return result;\n                }\n            }\n            return succeed(undefined);\n        }\n        return fail(`Cannot convert field \"${name}\" from non-object ${JSON.stringify(from)}`);\n    }, undefined, { isOptional: true });\n}\n\n/**\n * Options for an @see ObjectConverter.\n */\nexport interface ObjectConverterOptions<T> {\n    /**\n     * If present, lists optional fields. Missing non-optional fields cause an error.\n     */\n    optionalFields?: (keyof T)[];\n    /**\n     * If true, unrecognized fields yield an error.  If false or undefined (default),\n     * unrecognized fields are ignored.\n     */\n    strict?: boolean;\n}\n\n/**\n * Per-property converters for each of the properties in type T.\n */\nexport type FieldConverters<T, TC=unknown> = { [ key in keyof T ]: Converter<T[key], TC> };\n\n/**\n * Converter to convert an object of type T without changing shape, given a @see FieldConverters<T>.\n * If all of the required fields exist and can be converted, returns a new object with the converted\n * values under the original key names.  If any required fields do not exist or cannot be converted,\n * the entire conversion fails.  See @see ObjectConverterOptions for other conversion options.\n */\nexport class ObjectConverter<T, TC=unknown> extends BaseConverter<T, TC> {\n    public readonly fields: FieldConverters<T>;\n    public readonly options: ObjectConverterOptions<T>;\n\n    /**\n     * Constructs a new @see ObjectConverter<T> using options supplied in an\n     * optional @see ObjectConverterOptions<T>.\n     * @param fields A @see FieldConverters<T> containing converters for each field\n     * @param options An optional @see ObjectConverterOptions to configure the conversion\n     */\n    public constructor(fields: FieldConverters<T, TC>, options?: ObjectConverterOptions<T>)\n\n    /**\n     * Constructs a new @see ObjectConverter<T> using optional fields supplied in an\n     * optional array of keyof T.\n     * @param fields A @see FieldConverters<T> containing converters for each field\n     * @param optional An optional array of keyof T listing fields that are not required.\n     */\n    public constructor(fields: FieldConverters<T, TC>, optional?: (keyof T)[]);\n    public constructor(fields: FieldConverters<T, TC>, opt?: ObjectConverterOptions<T>|(keyof T)[]) {\n        super((from: unknown, _self, context?: TC) => {\n            // eslint bug thinks key is used before defined\n            // eslint-disable-next-line no-use-before-define\n            const converted = {} as { [key in keyof T]: T[key] };\n            const errors: string[] = [];\n            for (const key in fields) {\n                if (fields[key]) {\n                    const isOptional = (fields[key].isOptional || this.options.optionalFields?.includes(key)) ?? false;\n                    const result = isOptional\n                        ? optionalField(key, fields[key]).convert(from, context)\n                        : field(key, fields[key]).convert(from, context);\n                    if (result.isSuccess() && (result.value !== undefined)) {\n                        converted[key] = result.value;\n                    }\n                    else if (result.isFailure()) {\n                        errors.push(result.message);\n                    }\n                }\n            }\n\n            if (this.options.strict === true) {\n                if ((typeof from === 'object') && (!Array.isArray(from))) {\n                    for (const key in from) {\n                        if (from.hasOwnProperty(key) && (!isKeyOf(key, fields) || (fields[key] === undefined))) {\n                            errors.push(`${key}: unexpected property in source object`);\n                        }\n                    }\n                }\n                else {\n                    errors.push('source is not an object');\n                }\n            }\n            return (errors.length === 0) ? succeed(converted) : fail(errors.join('\\n'));\n        });\n\n        this.fields = fields;\n        if (Array.isArray(opt)) {\n            this.options = { optionalFields: opt };\n        }\n        else {\n            this.options = opt ?? {};\n        }\n    }\n\n    public partial(options: ObjectConverterOptions<T>): ObjectConverter<Partial<T>, TC>;\n    public partial(optional?: (keyof T)[]): ObjectConverter<Partial<T>, TC>;\n    public partial(opt?: ObjectConverterOptions<T>|(keyof T)[]): ObjectConverter<Partial<T>, TC> {\n        return new ObjectConverter<Partial<T>, TC>(this.fields as FieldConverters<Partial<T>, TC>, opt as ObjectConverterOptions<Partial<T>>)._with(this._traits());\n    }\n\n    public addPartial(addOptionalFields: (keyof T)[]): ObjectConverter<Partial<T>, TC> {\n        return this.partial([...this.options.optionalFields ?? [], ...addOptionalFields])._with(this._traits());\n    }\n}\n\n/**\n * Helper to convert an object without changing shape. The source parameter is an object with\n * key names that correspond to the target object and the appropriate corresponding converter\n * as the property value. If all of the requested fields exist and can be converted, returns a\n * new object with the converted values under the original key names.  If any fields do not exist\n * or cannot be converted, the entire conversion fails.\n *\n * Fields that succeed but convert to undefined are omitted from the result object but do not\n * fail the conversion.\n * @param fields An object containing defining the shape and converters to be applied.\n * @param opt An @see ObjectConverterOptions<T> containing options for the object converter, or\n * an array of (keyof T) containing optional keys.\n */\nexport function object<T>(fields: FieldConverters<T>, opt?: (keyof T)[]|ObjectConverterOptions<T>): ObjectConverter<T> {\n    return new ObjectConverter(fields, opt as ObjectConverterOptions<T>);\n}\n\n/**\n * Helper to convert an object without changing shape. The source parameter is an object with\n * key names that correspond to the target object and the appropriate corresponding converter\n * as the property value. If all of the requested fields exist and can be converted, returns a\n * new object with the converted values under the original key names.  If any fields do not exist\n * or cannot be converted, the entire conversion fails.\n *\n * Fields that succeed but convert to undefined are omitted from the result object but do not\n * fail the conversion.\n *\n * The conversion fails if any unexpected fields are encountered.\n *\n * @param fields An object containing defining the shape and converters to be applied.\n * @param opt - An @see ObjectConverterOptions<T> containing options for the object converter, or\n * an array of (keyof T) containing optional keys.\n */\nexport function strictObject<T>(\n    fields: FieldConverters<T>,\n    opt?: (keyof T)[]|Omit<ObjectConverterOptions<T>, 'strict'>,\n): ObjectConverter<T> {\n    const options: ObjectConverterOptions<T> = (opt && Array.isArray(opt))\n        ? { strict: true, optionalFields: opt }\n        : { ...(opt ?? {}), strict: true };\n    return new ObjectConverter(fields, options);\n}\n\nexport type DiscriminatedObjectConverters<T, TD extends string = string, TC=unknown> = Record<TD, Converter<T, TC>>;\n\n/**\n * Helper to convert a discriminated property without changing shape.  Takes the name of the\n * discriminator property and a string-keyed record of object converters, and invokes the\n * converter that corresponds to the value of the discriminator property in the source object.\n * Fails if the source is not an object or if the discriminator property is missing or has\n * a value not present in the converters.\n * @param discriminatorProp Name of the property used to discriminate types\n * @param converters String-keyed record of converters to invoke, where key corresponds to a value of the\n * discriminator property.\n */\nexport function discriminatedObject<T, TD extends string = string, TC=unknown>(discriminatorProp: string, converters: DiscriminatedObjectConverters<T, TD>): Converter<T, TC> {\n    return new BaseConverter((from: unknown) => {\n        if ((typeof from !== 'object') || Array.isArray(from) || from === null) {\n            return fail(`Not a discriminated object: \"${JSON.stringify(from)}\"`);\n        }\n        if ((!isKeyOf(discriminatorProp, from)) || (!from[discriminatorProp])) {\n            return fail(`Discriminator property ${discriminatorProp} not present in \"${JSON.stringify(from)}\"`);\n        }\n\n        const discriminatorValue = from[discriminatorProp] as TD;\n        const converter = converters[discriminatorValue];\n        if (converter === undefined) {\n            return fail(`No converter for discriminator ${discriminatorProp}=\"${discriminatorValue}\"`);\n        }\n        return converter.convert(from);\n    });\n}\n\n/**\n * Helper to convert an object to a new object with a different shape. The source parameter is\n * an object with key names that correspond to the target object, and an approriate _field_\n * converter that will extract and convert a single field from the source object.\n *\n * If all of the extracted fields exist and can be converted, returns a new object with the\n * converted values under the original key names.  If any fields to be extracted do not exist\n * or cannot be converted, the entire conversion fails.\n *\n * Fields that succeed but convert to undefined are omitted from the result object but do not\n * fail the conversion.\n *\n * @param fields An object defining the shape of the target object and the field converters\n * to be used to construct it.\n */\nexport function transform<T, TC=unknown>(fields: FieldConverters<T, TC>): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self, context?: TC) => {\n        // eslint bug thinks key is used before defined\n        // eslint-disable-next-line no-use-before-define\n        const converted = {} as { [ key in keyof T]: T[key] };\n        const errors: string[] = [];\n\n        for (const key in fields) {\n            if (fields[key]) {\n                const result = fields[key].convert(from, context);\n                if (result.isSuccess() && (result.value !== undefined)) {\n                    converted[key] = result.value;\n                }\n                else if (result.isFailure()) {\n                    errors.push(result.message);\n                }\n            }\n        }\n\n        return (errors.length === 0) ? succeed(converted) : fail(errors.join('\\n'));\n    });\n}\n\n/**\n * A helper wrapper to convert a range of some other comparable type\n * @param converter Converter used to convert min and max extent of the raid\n * @param constructor Optional static constructor to instantiate the object\n */\nexport function rangeTypeOf<T, RT extends RangeOf<T>, TC=unknown>(converter: Converter<T, TC>, constructor: (init: RangeOfProperties<T>) => Result<RT>): Converter<RT, TC> {\n    return new BaseConverter((from: unknown, _self, context?: TC) => {\n        const result = object({\n            min: converter,\n            max: converter,\n        }, ['min', 'max']).convert(from, context);\n        if (result.isSuccess()) {\n            return constructor({ min: result.value.min, max: result.value.max });\n        }\n        return fail(result.message);\n    });\n}\n\nexport function rangeOf<T, TC=unknown>(converter: Converter<T, TC>): Converter<RangeOf<T>, TC> {\n    return rangeTypeOf<T, RangeOf<T>, TC>(converter, RangeOf.createRange);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"converters.js","sourceRoot":"","sources":["../src/converters.ts"],"names":[],"mappings":"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","sourcesContent":["\n/*\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 { BaseConverter, Converter, ConverterTraits } from './converter';\nimport { RangeOf, RangeOfProperties } from './rangeOf';\nimport { Result, captureResult, fail, succeed } from './result';\n\nimport { DateTime } from 'luxon';\nimport { ExtendedArray } from './extendedArray';\nimport Mustache from 'mustache';\nimport { isKeyOf } from './utils';\n\ntype OnError = 'failOnError' | 'ignoreErrors';\n\n/**\n * Options for {@link Converters.StringConverter | StringConverter}\n * matching method\n * @public\n */\nexport interface StringMatchOptions {\n    /**\n     * An optional message to be displayed if a non-matching string\n     * is encountered.\n     */\n    message?: string;\n}\n\n/**\n * The {@link Converters.StringConverter | StringConverter} class extends {@link BaseConverter}\n * to provide string-specific helper methods.\n * @public\n */\nexport class StringConverter<T extends string = string, TC = unknown> extends BaseConverter<T, TC> {\n    /**\n     * Construct a new {@link Converters.StringConverter | StringConverter}.\n     * @param defaultContext - Optional context used by the conversion.\n     * @param traits - Optional traits to be applied to the conversion.\n     * @param converter - Optional conversion function to be used for the conversion.\n     */\n    public constructor(\n        defaultContext?: TC,\n        traits?: ConverterTraits,\n        converter: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T> = StringConverter._convert,\n    ) {\n        super(converter, defaultContext, traits);\n    }\n\n    /**\n     * @internal\n     */\n    protected static _convert<T extends string>(from: unknown): Result<T> {\n        return typeof from === 'string'\n            ? succeed(from as T)\n            : fail(`Not a string: ${JSON.stringify(from)}`);\n    }\n\n    /**\n     * @internal\n     */\n    protected static _wrap<T extends string, TC>(\n        wrapped: StringConverter<T, TC>,\n        converter: (from: T) => Result<T>,\n        traits?: ConverterTraits\n    ): StringConverter<T, TC> {\n        return new StringConverter<T, TC>(undefined, undefined, (from: unknown) => {\n            return wrapped.convert(from).onSuccess(converter);\n        })._with(wrapped._traits(traits));\n    }\n\n    /**\n     * Returns a {@link Converters.StringConverter | StringConverter} which constrains the result to match\n     * a supplied string.\n     * @param match - The string to be matched\n     * @param options - Optional {@link Converters.StringMatchOptions} for this conversion.\n     * @returns {@link Success} with a matching string or {@link Failure} with an informative\n     * error if the string does not match.\n     * {@label string}\n     */\n    public matching(match: string, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;\n\n    /**\n     * Returns a {@link Converters.StringConverter | StringConverter} which constrains the result to match\n     * one of a supplied array of strings.\n     * @param match - The array of allowed strings.\n     * @param options - Optional {@link Converters.StringMatchOptions} for this conversion.\n     * @returns {@link Success} with a matching string or {@link Failure} with an informative\n     * error if the string does not match.\n     * {@label array}\n     */\n    public matching(match: string[], options?: Partial<StringMatchOptions>): StringConverter<T, TC>;\n\n    /**\n     * Returns a {@link Converters.StringConverter | StringConverter} which constrains the result to match\n     * one of a supplied `Set` of strings.\n     * @param match - The `Set` of allowed strings.\n     * @param options - Optional {@link Converters.StringMatchOptions} for this conversion.\n     * @returns {@link Success} with a matching string or {@link Failure} with an informative\n     * error if the string does not match.\n     * {@label set}\n     */\n    public matching(match: Set<T>, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;\n\n    /**\n     * Returns a {@link Converters.StringConverter | StringConverter} which constrains the result to match\n     * a supplied regular expression.\n     * @param match - The regular expression to be used as a constraint.\n     * @param options - Optional {@link Converters.StringMatchOptions} for this conversion\n     * @returns {@link Success} with a matching string or {@link Failure} with an informative\n     * error if the string does not match.\n     * {@label regexp}\n     */\n    public matching(match: RegExp, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;\n    /**\n     * Concrete implementation of {@link Converters.StringConverter.(matching#string) | StringConverter.matching(string)},\n     * {@link Converters.StringConverter.(matching#array) | StringConverter.matching(string[])},\n     * {@link Converters.StringConverter.(matching#set) | StringConverter.matching(Set<string>)}, and\n     * {@link Converters.StringConverter.(matching#regexp) | StringConverter.matching(RegExp)}.\n     * @internal\n     */\n    public matching(match: string | string[] | Set<T> | RegExp, options?: Partial<StringMatchOptions>): StringConverter<T, TC> {\n        const message = options?.message;\n        if (typeof match === 'string') {\n            return StringConverter._wrap<T, TC>(this, (from: T) => {\n                return (match === from)\n                    ? succeed(from as T)\n                    : fail(message\n                        ? `\"${from}\": ${message}`\n                        : `\"${from}\": does not match \"${match}\"`);\n            });\n        }\n        else if (match instanceof RegExp) {\n            return StringConverter._wrap<T, TC>(this, (from: T) => {\n                return (match.test(from))\n                    ? succeed(from as T)\n                    : fail(message\n                        ? `\"${from}\": ${message}`\n                        : `\"${from}\": does not match \"${match}\"`);\n            });\n        }\n        else if (match instanceof Set) {\n            return StringConverter._wrap<T, TC>(this, (from: T) => {\n                return (match.has(from))\n                    ? succeed(from as T)\n                    : fail(message\n                        ? `\"${from}\": ${message}`\n                        : `\"${from}\": not found in set`);\n            });\n        }\n        else {\n            return StringConverter._wrap<T, TC>(this, (from: T) => {\n                return (match.includes(from))\n                    ? succeed(from as T)\n                    : fail(message\n                        ? `\"${from}\": ${message}`\n                        : `\"${from}\": not found in [${match.join(',')}]`);\n            });\n        }\n    }\n}\n\n/**\n * A converter to convert unknown to string. Values of type\n * string succeed.  Anything else fails.\n * @public\n */\nexport const string = new StringConverter();\n\n/**\n * Helper function to create a {@link Converters.StringConverter | StringConverter} which converts\n * `unknown` to `string`, applying template conversions supplied at construction time or at\n * runtime as context.\n * @remarks\n * Template conversions are applied using `mustache` syntax.\n * @param defaultContext - Optional default context to use for template values.\n * @returns A new {@link Converter} returning `string`.\n * @public\n */\nexport function templateString(defaultContext?: unknown): StringConverter<string, unknown> {\n    return new StringConverter<string, unknown>(defaultContext, undefined, (from: unknown, _self: Converter<string, unknown>, context?: unknown) => {\n        if (typeof from !== 'string') {\n            return fail(`Not a string: ${JSON.stringify(from)}`);\n        }\n        return captureResult(() => Mustache.render(from, context));\n    });\n}\n\n/**\n * Helper function to create a {@link Converter} which converts `unknown` to one of a set of supplied\n * enumerated values. Anything else fails.\n *\n * @remarks\n * Allowed enumerated values can also be supplied as context at conversion time.\n * @param values - Array of allowed values.\n * @returns A new {@link Converter} returning `<T>`.\n * @public\n */\nexport function enumeratedValue<T>(values: T[]): Converter<T, T[]> {\n    return new BaseConverter((from: unknown, _self: Converter<T, T[]>, context?: T[]): Result<T> => {\n        const v = context ?? values;\n        const index = v.indexOf(from as T);\n        return (index >= 0 ? succeed(v[index]) : fail(`Invalid enumerated value ${JSON.stringify(from)}`));\n    });\n}\n\n/**\n * Helper function to create a {@link Converter} which converts `unknown` to one of a set of supplied enumerated\n * values, mapping any of multiple supplied values to the enumeration.\n * @remarks\n * Enables mapping of multiple input values to a consistent internal representation (so e.g. `'y'`, `'yes'`,\n * `'true'`, `1` and `true` can all map to boolean `true`)\n * @param map - An array of tuples describing the mapping. The first element of each tuple is the result\n * value, the second is the set of values that map to the result.  Tuples are evaluated in the order\n * supplied and are not checked for duplicates.\n * @param message - An optional error message.\n * @returns A {@link Converter} which applies the mapping and yields `<T>` on success.\n * @public\n */\nexport function mappedEnumeratedValue<T>(map: [T, unknown[]][], message?: string): Converter<T, undefined> {\n    return new BaseConverter((from: unknown, _self: Converter<T, undefined>, _context?: unknown) => {\n        for (const item of map) {\n            if (item[1].includes(from)) {\n                return succeed(item[0]);\n            }\n        }\n        return fail(message ? `${JSON.stringify(from)}: ${message}` : `Cannot map '${JSON.stringify(from)}' to a supported value`);\n    });\n}\n\n/**\n * Helper function to create a {@link Converter} which converts `unknown` to some supplied literal value. Succeeds with\n * the supplied value if an identity comparison succeeds, fails otherwise.\n * @param value - The value to be compared.\n * @returns A {@link Converter} which returns the supplied value on success.\n * @public\n */\nexport function literal<T>(value: T): Converter<T, unknown> {\n    return new BaseConverter<T, unknown>((from: unknown, _self: Converter<T, unknown>, _context?: unknown): Result<T> => {\n        return (from === value) ? succeed(value) : fail(`${JSON.stringify(from)}: does not match ${JSON.stringify(value)}`);\n    });\n}\n\n/**\n * Deprecated alias for @see literal\n * @param value - The value to be compared.\n * @deprecated Use {@link Converters.literal} instead.\n * @internal\n */\nexport const value = literal;\n\n/**\n * A {@link Converter} which converts `unknown` to a `number`.\n * @remarks\n * Numbers and strings with a numeric format succeed. Anything else fails.\n * @public\n */\nexport const number = new BaseConverter<number>((from: unknown) => {\n    if (typeof from !== 'number') {\n        const num: number = (typeof from === 'string' ? Number(from) : NaN);\n        return isNaN(num)\n            ? fail(`Not a number: ${JSON.stringify(from)}`)\n            : succeed(num);\n    }\n    return succeed(from);\n});\n\n/**\n * A {@link Converter} which converts `unknown` to `boolean`.\n * @remarks\n * Boolean values or the case-insensitive strings `'true'` and `'false'` succeed.\n * Anything else fails.\n * @public\n */\nexport const boolean = new BaseConverter<boolean>((from: unknown) => {\n    if (typeof from === 'boolean') {\n        return succeed(from as boolean);\n    }\n    else if (typeof from === 'string') {\n        switch (from.toLowerCase()) {\n            case 'true': return succeed(true);\n            case 'false': return succeed(false);\n        }\n    }\n    return fail(`Not a boolean: ${JSON.stringify(from)}`);\n});\n\n/**\n * A {@link Converter} which converts an optional `string` value. Values of type\n * `string` are returned.  Anything else returns {@link Success} with value `undefined`.\n * @public\n */\nexport const optionalString = string.optional();\n\n/**\n * Helper function to create a {@link Converter} which converts any `string` into an\n * array of `string`, by separating at a supplied delimiter.\n * @remarks\n * Delimeter may also be supplied as context at conversion time.\n * @param delimiter - The delimiter at which to split.\n * @returns A new {@link Converter} returning `string[]`.\n * @public\n */\nexport function delimitedString(delimiter: string, options: 'filtered'|'all' = 'filtered'): Converter<string[], string> {\n    return new BaseConverter<string[], string>((from: unknown, _self: Converter<string[], string>, context?: string) => {\n        const result = string.convert(from);\n        if (result.isSuccess()) {\n            let strings = result.value.split(context ?? delimiter);\n            if (options !== 'all') {\n                strings = strings.filter((s) => (s.trim().length > 0));\n            }\n            return succeed(strings);\n        }\n        return fail(result.message);\n    });\n}\n\n/**\n * A {@link Converter} which converts an iso formatted string, a number or a `Date` object to\n * a `Date` object.\n * @public\n */\nexport const isoDate = new BaseConverter<Date>((from: unknown) => {\n    if (typeof from === 'string') {\n        const dt = DateTime.fromISO(from);\n        if (dt.isValid) {\n            return succeed(dt.toJSDate());\n        }\n        return fail(`Invalid date: ${dt.invalidExplanation}`);\n    }\n    else if (typeof from === 'number') {\n        return succeed(new Date(from));\n    }\n    else if (from instanceof Date) {\n        return succeed(from);\n    }\n    return fail(`Cannot convert ${JSON.stringify(from)} to Date`);\n});\n\n/**\n * A {@link Converter} which converts an optional `number` value.\n * @remarks\n * Values of type `number` or numeric strings are converted and returned.\n * Anything else returns {@link Success} with value `undefined`.\n * @public\n */\nexport const optionalNumber = number.optional();\n\n/**\n * A {@link Converter} to convert an optional `boolean` value.\n * @remarks\n * Values of type `boolean` or strings that match (case-insensitive) `'true'`\n * or `'false'` are converted and returned.  Anything else returns {@link Success}\n * with value `undefined`.\n * @public\n */\nexport const optionalBoolean = boolean.optional();\n\n/**\n * A helper function to create a {@link Converter} for polymorphic values.  Returns a\n * converter which Invokes the wrapped converters in sequence, returning the first successful\n * result.  Returns an error if none of the supplied converters can convert the value.\n * @remarks\n * If `onError` is `ignoreErrors` (default), then errors from any of the\n * converters are ignored provided that some converter succeeds.  If\n * onError is `failOnError`, then an error from any converter fails the entire\n * conversion.\n *\n * @param converters - An ordered list of {@link Converter | converters} to be considered.\n * @param onError - Specifies treatment of unconvertable elements.\n * @returns A new {@link Converter} which yields a value from the union of the types returned\n * by the wrapped converters.\n * @public\n */\nexport function oneOf<T, TC=unknown>(converters: Array<Converter<T, TC>>, onError: OnError = 'ignoreErrors'): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self, context?: TC) => {\n        const errors: string[] = [];\n        for (const converter of converters) {\n            const result = converter.convert(from, context);\n            if (result.isSuccess() && (result.value !== undefined)) {\n                return result;\n            }\n\n            if (result.isFailure()) {\n                if (onError === 'failOnError') {\n                    return result;\n                }\n                errors.push(result.message);\n            }\n        }\n        return fail(`No matching converter for ${JSON.stringify(from)}: ${errors.join('\\n')}`);\n    });\n}\n\n/**\n * A helper function to create a {@link Converter} which converts `unknown` to an array of `<T>`.\n * @remarks\n * If `onError` is `'failOnError'` (default), then the entire conversion fails if any element cannot\n * be converted.  If `onError` is `'ignoreErrors'`, then failing elements are silently ignored.\n * @param converter - {@link Converter} used to convert each item in the array.\n * @param ignoreErrors - Specifies treatment of unconvertable elements.\n * @returns A {@link Converter} which returns an array of `<T>`.\n * @public\n */\nexport function arrayOf<T, TC=undefined>(converter: Converter<T, TC>, onError: OnError = 'failOnError'): Converter<T[], TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T[], TC>, context?: TC) => {\n        if (!Array.isArray(from)) {\n            return fail(`Not an array: ${JSON.stringify(from)}`);\n        }\n\n        const successes: T[] = [];\n        const errors: string[] = [];\n        for (const item of from) {\n            const result = converter.convert(item, context);\n            if (result.isSuccess() && result.value !== undefined) {\n                successes.push(result.value);\n            }\n            else if (result.isFailure()) {\n                errors.push(result.message);\n            }\n        }\n\n        return (errors.length === 0) || (onError === 'ignoreErrors')\n            ? succeed(successes)\n            : fail(errors.join('\\n'));\n    });\n}\n\n/**\n * A helper function to create a {@link Converter} which converts `unknown` to {@link ExtendedArray | ExtendedArray<T>}.\n * @remarks\n * If `onError` is `'failOnError'` (default), then the entire conversion fails if any element cannot\n * be converted.  If `onError` is `'ignoreErrors'`, then failing elements are silently ignored.\n * @param converter - {@link Converter} used to convert each item in the array\n * @param ignoreErrors - Specifies treatment of unconvertable elements\n * @beta\n */\nexport function extendedArrayOf<T, TC=undefined>(label: string, converter: Converter<T, TC>, onError: OnError = 'failOnError'): Converter<ExtendedArray<T>, TC> {\n    return arrayOf(converter, onError).map((items: T[]) => {\n        return captureResult(() => new ExtendedArray(label, ...items));\n    });\n}\n\n/**\n * {@link Converter} to convert an `unknown` to an array of `string`.\n * @remarks\n * Returns {@link Success} with the the supplied value if it as an array\n * of strings, returns {@link Failure} with an error message otherwise.\n * @public\n */\nexport const stringArray = arrayOf(string);\n\n/**\n * {@link Converter} to convert an `unknown` to an array of `number`.\n * @remarks\n * Returns {@link Success} with the the supplied value if it as an array\n * of numbers, returns {@link Failure} with an error message otherwise.\n * @public\n */\nexport const numberArray = arrayOf(number);\n\n/**\n * Options for {@link Converters.(recordOf:withOptions)} and {@link Converters.(mapOf:withOptions)}\n * helper functions.\n * @public\n */\nexport interface KeyedConverterOptions<T extends string = string, TC=undefined> {\n    /**\n     * if `onError` is `'fail'` (default), then the entire conversion fails if any key or element\n     * cannot be converted.  If `onError` is `'ignore'`, failing elements are silently ignored.\n     */\n    onError?: 'fail'|'ignore';\n    /**\n     * If present, `keyConverter` is used to convert the source object property names to\n     * keys in the resulting map or record.\n     * @remarks\n     * Can be used to coerce key names to supported values and/or strong types.\n     */\n    keyConverter?: Converter<T, TC>;\n}\n\n/**\n * A helper function to create a {@link Converter} which converts the `string`-keyed properties\n * using a supplied {@link Converter | Converter<T>} to produce a `Record<string, T>`.\n * @remarks\n * The resulting converter fails conversion if any element cannot be converted.\n * @param converter - {@link Converter} used to convert each item in the source object.\n * @returns A {@link Converter} which returns `Record<string, T>`.\n * {@label default}\n * @public\n */\nexport function recordOf<T, TC=undefined, TK extends string=string>(converter: Converter<T, TC>): Converter<Record<TK, T>, TC>;\n\n/**\n * A helper function to create a {@link Converter} which converts the `string`-keyed properties\n * using a supplied {@link Converter | Converter<T>} to produce a `Record<string, T>` and optionally\n * specified handling of elements that cannot be converted.\n * @remarks\n * if `onError` is `'fail'` (default), then the entire conversion fails if any key or element\n * cannot be converted.  If `onError` is `'ignore'`, failing elements are silently ignored.\n * @param converter - {@link Converter} used to convert each item in the source object.\n * @returns A {@link Converter} which returns `Record<string, T>`.\n * {@label withOnError}\n * @public\n */\nexport function recordOf<T, TC=undefined, TK extends string=string>(\n    converter: Converter<T, TC>,\n    onError: 'fail'|'ignore'\n): Converter<Record<TK, T>, TC>;\n\n/**\n * A helper function to create a {@link Converter} which converts the `string`-keyed properties\n * using a supplied {@link Converter | Converter<T>} to produce a `Record<TK, T>`.\n * @remarks\n * If present, the supplied {@link Converters.KeyedConverterOptions | options} can provide a strongly-typed\n * converter for keys and/or control the handling of elements that fail conversion.\n * @param converter - {@link Converter} used to convert each item in the source object.\n * @param options - Optional {@link Converters.KeyedConverterOptions | KeyedConverterOptions<TK, TC>} which\n * supplies a key converter and/or error-handling options.\n * @returns A {@link Converter} which returns `Record<TK, T>`.\n * {@label withOptions}\n * @public\n */\nexport function recordOf<T, TC=undefined, TK extends string=string>(\n    converter: Converter<T, TC>,\n    options: KeyedConverterOptions<TK, TC>\n): Converter<Record<TK, T>, TC>;\n\n/**\n * Concrete implementation of {@link Converters.(recordOf:default) | Converters.recordOf(Converter<T>)},\n * {@link Converters.(recordOf:withOnError) | Converters.recordOf(Converter<T>, 'fail'|'ignore')}, and\n * {@link Converters.(recordOf:withOptions) | Converters.recordOf(Converter<T>, KeyedConverterOptions)}.\n * @internal\n */\nexport function recordOf<T, TC=undefined, TK extends string=string>(\n    converter: Converter<T, TC>,\n    option: 'fail'|'ignore'|KeyedConverterOptions<TK, TC> = 'fail'\n): Converter<Record<TK, T>, TC> {\n    const options: KeyedConverterOptions<TK, TC> = (typeof option === 'string') ? { onError: option } : { onError: 'fail', ...option };\n    return new BaseConverter((from: unknown, _self: Converter<Record<TK, T>, TC>, context?: TC) => {\n        if ((typeof from !== 'object') || (from === null) || Array.isArray(from)) {\n            return fail(`Not a string-keyed object: ${JSON.stringify(from)}`);\n        }\n\n        const record: Record<string, T> = {};\n        const errors: string[] = [];\n\n        for (const key in from) {\n            if (isKeyOf(key, from)) {\n                const writeKeyResult = options.keyConverter?.convert(key, context) ?? succeed(key);\n\n                writeKeyResult.onSuccess((writeKey) => {\n                    return converter.convert(from[key] as unknown, context).onSuccess((value) => {\n                        record[writeKey] = value;\n                        return succeed(true);\n                    });\n                }).onFailure((message) => {\n                    errors.push(message);\n                    return fail(message);\n                });\n            }\n        }\n\n        return (errors.length === 0) || (options.onError === 'ignore')\n            ? succeed(record)\n            : fail(errors.join('\\n'));\n    });\n}\n\n/**\n * A helper function to create a {@link Converter} which converts the `string`-keyed properties\n * using a supplied {@link Converter | Converter<T>} to produce a `Map<string, T>`.\n * @remarks\n * The resulting converter fails conversion if any element cannot be converted.\n * @param converter - {@link Converter} used to convert each item in the source object.\n * @returns A {@link Converter} which returns `Map<string, T>`.\n * {@label default}\n * @public\n */\nexport function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>): Converter<Map<TK, T>, TC>;\n\n/**\n * A helper function to create a {@link Converter} which converts the `string`-keyed properties\n * using a supplied {@link Converter | Converter<T>} to produce a `Map<string, T>` and optionally\n * specified handling of elements that cannot be converted.\n * @remarks\n * if `onError` is `'fail'` (default), then the entire conversion fails if any key or element\n * cannot be converted.  If `onError` is `'ignore'`, failing elements are silently ignored.\n * @param converter - {@link Converter} used to convert each item in the source object.\n * @returns A {@link Converter} which returns `Map<string, T>`.\n * {@label withOnError}\n * @public\n */\nexport function mapOf<T, TC = undefined, TK extends string = string>(\n    converter: Converter<T, TC>,\n    onError: 'fail' | 'ignore'\n): Converter<Map<TK, T>, TC>;\n\n/**\n * A helper function to create a {@link Converter} which converts the `string`-keyed properties\n * using a supplied {@link Converter | Converter<T>} to produce a `Map<TK, T>`.\n * @remarks\n * If present, the supplied {@link Converters.KeyedConverterOptions | options} can provide a strongly-typed\n * converter for keys and/or control the handling of elements that fail conversion.\n * @param converter - {@link Converter} used to convert each item in the source object.\n * @param options - Optional {@link Converters.KeyedConverterOptions | KeyedConverterOptions<TK, TC>} which\n * supplies a key converter and/or error-handling options.\n * @returns A {@link Converter} which returns `Map<TK, T>`.\n * {@label withOptions}\n * @public\n */\nexport function mapOf<T, TC = undefined, TK extends string = string>(\n    converter: Converter<T, TC>,\n    options: KeyedConverterOptions<TK, TC>\n): Converter<Map<TK, T>, TC>;\n\n/**\n * Concrete implementation of {@link Converters.(mapOf:default) | Converters.mapOf(Converter<T>)},\n * {@link Converters.(mapOf:withOnError) | Converters.mapOf(Converter<T>, 'fail'|'ignore')}, and\n * {@link Converters.(mapOf:withOptions) | Converters.mapOf(Converter<T>, KeyedConverterOptions)}.\n * @internal\n */\nexport function mapOf<T, TC = undefined, TK extends string = string>(\n    converter: Converter<T, TC>,\n    option: 'fail' | 'ignore' | KeyedConverterOptions<TK, TC> = 'fail'\n): Converter<Map<TK, T>, TC> {\n    const options = (typeof option === 'string') ? { onError: option } : { onError: 'fail', ...option };\n    return new BaseConverter((from: unknown, _self: Converter<Map<TK, T>, TC>, context?: TC) => {\n        if ((typeof from !== 'object') || (from === null) || Array.isArray(from)) {\n            return fail(`Not a string-keyed object: ${JSON.stringify(from)}`);\n        }\n\n        const map = new Map<TK, T>();\n        const errors: string[] = [];\n\n        for (const key in from) {\n            if (isKeyOf(key, from)) {\n                const writeKeyResult = options.keyConverter?.convert(key, context) ?? succeed(key);\n\n                writeKeyResult.onSuccess((writeKey) => {\n                    return converter.convert(from[key] as unknown, context).onSuccess((value) => {\n                        map.set(writeKey, value);\n                        return succeed(true);\n                    });\n                }).onFailure((message) => {\n                    errors.push(message);\n                    return fail(message);\n                });\n            }\n        }\n\n        return (errors.length === 0) || (options.onError === 'ignore')\n            ? succeed(map)\n            : fail(errors.join('\\n'));\n    });\n}\n\n/**\n * Helper function to create  a {@link Converter} which validates that a supplied value is\n * of a type validated by a supplied validator function and returns it.\n * @remarks\n * If `validator` succeeds, this {@link Converter} returns {@link Success} with the supplied\n * value of `from` coerced to type `<T>`.  Returns a {@link Failure} with additional\n * information otherwise.\n * @param validator - A validator function to determine if the converted value is valid.\n * @param description - A description of the validated type for use in error messages.\n * @returns A new {@link Converter | Converter<T>} which applies the supplied validation.\n * @public\n */\nexport function validateWith<T, TC=undefined>(validator: (from: unknown) => from is T, description?: string): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T, TC>, _context?: TC) => {\n        if (validator(from)) {\n            return succeed(from);\n        }\n        return fail(`${JSON.stringify(from)}: invalid ${description ?? 'value'}`);\n    });\n}\n\n/**\n * A helper function to create a {@link Converter} which extracts and converts an element from an array.\n * @remarks\n * The returned {@link Converter} returns {@link Success} with the converted value if the element exists\n * in the supplied array and can be converted. Returns {@link Failure} with an error message otherwise.\n * @param index - The index of the element to be extracted.\n * @param converter - A {@link Converter} used to convert the extracted element.\n * @returns A {@link Converter | Converter<T>} which extracts the specified element from an array.\n * @public\n */\nexport function element<T, TC=undefined>(index: number, converter: Converter<T, TC>): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T, TC>, context?: TC) => {\n        if (index < 0) {\n            return fail(`${index}: cannot convert for a negative element index`);\n        }\n        else if (!Array.isArray(from)) {\n            return fail('element converter: source is not an array');\n        }\n        else if (index >= from.length) {\n            return fail(`${index}: element converter index out of range (0..${from.length - 1})`);\n        }\n        return converter.convert(from[index], context);\n    });\n}\n\n/**\n * A helper function to create a {@link Converter} which extracts and converts an optional element from an array.\n * @remarks\n * The resulting {@link Converter} returns {@link Success} with the converted value if the element exsist\n * in the supplied array and can be converted. Returns {@link Success} with value `undefined` if the parameter\n * is an array but the index is out of range. Returns {@link Failure} with a message if the supplied parameter\n * is not an array, if the requested index is negative, or if the element cannot be converted.\n * @param index - The index of the element to be extracted.\n * @param converter - A {@link Converter} used to convert the extracted element.\n * @returns A {@link Converter | Converter<T>} which extracts the specified element from an array.\n * @public\n */\nexport function optionalElement<T, TC=undefined>(index: number, converter: Converter<T, TC>): Converter<T|undefined, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T|undefined, TC>, context?: TC) => {\n        if (index < 0) {\n            return fail(`${index}: cannot convert for a negative element index`);\n        }\n        else if (!Array.isArray(from)) {\n            return fail('element converter: source is not an array');\n        }\n        else if (index >= from.length) {\n            return succeed(undefined);\n        }\n        return converter.convert(from[index], context);\n    });\n}\n\n/**\n * A helper function to create a {@link Converter} which extracts and convert a property specified\n * by name from an object.\n * @remarks\n * The resulting {@link Converter} returns {@link Success} with the converted value of the correpsonding\n * object property if the field exists and can be converted. Returns {@link Failure} with an error message\n * otherwise.\n * @param name - The name of the field to be extracted.\n * @param converter - {@link Converter} used to convert the extracted field.\n * @public\n */\nexport function field<T, TC=undefined>(name: string, converter: Converter<T, TC>): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T, TC>, context?: TC) => {\n        if (typeof from === 'object' && (!Array.isArray(from)) && from !== null) {\n            if (isKeyOf(name, from)) {\n                return converter.convert(from[name], context).onFailure((message) => {\n                    return fail(`Field ${name}: ${message}`);\n                });\n            }\n            return fail(`Field ${name} not found in: ${JSON.stringify(from)}`);\n        }\n        return fail(`Cannot convert field \"${name}\" from non-object ${JSON.stringify(from)}`);\n    });\n}\n\n/**\n * A helper function to create a {@link Converter} which extracts and convert a property specified\n * by name from an object.\n * @remarks\n * The resulting {@link Converter} returns {@link Success} with the converted value of the correpsonding\n * object property if the field exists and can be converted. Returns {@link Success} with value `undefined`\n * if the supplied parametr is an object but the named field is not present.  Returns {@link Failure} with\n * an error message otherwise.\n * @param name - The name of the field to be extracted.\n * @param converter - {@link Converter} used to convert the extracted field.\n * @public\n */\nexport function optionalField<T, TC=undefined>(name: string, converter: Converter<T, TC>): Converter<T|undefined, TC> {\n    return new BaseConverter((from: unknown, _self: Converter<T|undefined, TC>, context?: TC) => {\n        if (typeof from === 'object' && (!Array.isArray(from)) && from !== null) {\n            if (isKeyOf(name, from)) {\n                const result = converter.convert(from[name], context).onFailure((message) => {\n                    return fail(`${name}: ${message}`);\n                });\n\n                // if conversion was successful or input was undefined we\n                // succeed with 'undefined', but we propagate actual\n                // failures.\n                if (result.isSuccess() || (from[name] !== undefined)) {\n                    return result;\n                }\n            }\n            return succeed(undefined);\n        }\n        return fail(`Cannot convert field \"${name}\" from non-object ${JSON.stringify(from)}`);\n    }, undefined, { isOptional: true });\n}\n\n/**\n * Options for an {@link Converters.ObjectConverter | ObjectConverter}.\n * @public\n */\nexport interface ObjectConverterOptions<T> {\n    /**\n     * If present, lists optional fields. Missing non-optional fields cause an error.\n     */\n    optionalFields?: (keyof T)[];\n    /**\n     * If true, unrecognized fields yield an error.  If false or undefined (default),\n     * unrecognized fields are ignored.\n     */\n    strict?: boolean;\n}\n\n/**\n * Per-property converters for each of the properties in type T.\n * @remarks\n * Used to construct a {@link Converters.ObjectConverter | ObjectConverter}\n * @public\n */\nexport type FieldConverters<T, TC=unknown> = { [ key in keyof T ]: Converter<T[key], TC> };\n\n/**\n * A {@link Converter} which converts an object of type `<T>` without changing shape, given\n * a {@link Converters.FieldConverters | FieldConverters<T>} for the fields in the object.\n * @remarks\n * By default, if all of the required fields exist and can be converted, returns a new object with\n * the converted values under the original key names.  If any required fields do not exist or cannot\n * be converted, the entire conversion fails. See {@link Converters.ObjectConverterOptions | ObjectConverterOptions}\n * for other conversion options.\n * @public\n */\nexport class ObjectConverter<T, TC=unknown> extends BaseConverter<T, TC> {\n    /**\n     * Fields converted by this {@link Converters.ObjectConverter | ObjectConverter}.\n     */\n    public readonly fields: FieldConverters<T>;\n    /**\n     * Options used to initialize this {@link Converters.ObjectConverter | ObjectConverter}.\n     */\n    public readonly options: ObjectConverterOptions<T>;\n\n    /**\n     * Constructs a new {@link Converters.ObjectConverter | ObjectConverter<T>} using options\n     * supplied in a {@link Converters.ObjectConverterOptions | ObjectConverterOptions<T>}.\n     * @param fields - A {@link Converters.FieldConverters | FieldConverters<T>} containing\n     * a {@link Converter} for each field\n     * @param options - An optional @see ObjectConverterOptions to configure the conversion\n     * {@label withOptions}\n     */\n    public constructor(fields: FieldConverters<T, TC>, options?: ObjectConverterOptions<T>)\n\n    /**\n     * Constructs a new {@link Converters.ObjectConverter | ObjectConverter<T>} with optional\n     * properties specified as an array of `keyof T`.\n     * @param fields - A {@link Converters.FieldConverters | FieldConverters<T>} containing\n     * a {@link Converter} for each field.\n     * @param optional - An array of `keyof T` listing fields that are not required.\n     * {@label withKeys}\n     */\n    public constructor(fields: FieldConverters<T, TC>, optional?: (keyof T)[]);\n    /**\n     * Concrete implementation of {@link Converters.ObjectConverter.(constructor:withOptions)}\n     * and {@link Converters.ObjectConverter.(constructor:withKeys)}.\n     * @internal\n     */\n    public constructor(fields: FieldConverters<T, TC>, opt?: ObjectConverterOptions<T>|(keyof T)[]) {\n        super((from: unknown, _self, context?: TC) => {\n            // eslint bug thinks key is used before defined\n            // eslint-disable-next-line no-use-before-define\n            const converted = {} as { [key in keyof T]: T[key] };\n            const errors: string[] = [];\n            for (const key in fields) {\n                if (fields[key]) {\n                    const isOptional = (fields[key].isOptional || this.options.optionalFields?.includes(key)) ?? false;\n                    const result = isOptional\n                        ? optionalField(key, fields[key]).convert(from, context)\n                        : field(key, fields[key]).convert(from, context);\n                    if (result.isSuccess() && (result.value !== undefined)) {\n                        converted[key] = result.value;\n                    }\n                    else if (result.isFailure()) {\n                        errors.push(result.message);\n                    }\n                }\n            }\n\n            if (this.options.strict === true) {\n                if ((typeof from === 'object') && (!Array.isArray(from))) {\n                    for (const key in from) {\n                        if (from.hasOwnProperty(key) && (!isKeyOf(key, fields) || (fields[key] === undefined))) {\n                            errors.push(`${key}: unexpected property in source object`);\n                        }\n                    }\n                }\n                else {\n                    errors.push('source is not an object');\n                }\n            }\n            return (errors.length === 0) ? succeed(converted) : fail(errors.join('\\n'));\n        });\n\n        this.fields = fields;\n        if (Array.isArray(opt)) {\n            this.options = { optionalFields: opt };\n        }\n        else {\n            this.options = opt ?? {};\n        }\n    }\n\n    /**\n     * Creates a new {@link Converters.ObjectConverter | ObjectConverter} derived from this one but with\n     * new optional properties as specified by a supplied {@link Converters.ObjectConverterOptions | ObjectConverterOptions<T>}.\n     * @param options - The {@link Converters.ObjectConverterOptions | options} to be applied to the new\n     * converter.\n     * @returns A new {@link Converters.ObjectConverter | ObjectConverter} with the additional optional source properties.\n     * {@label withOptions}\n     */\n    public partial(options: ObjectConverterOptions<T>): ObjectConverter<Partial<T>, TC>;\n\n    /**\n     * Creates a new {@link Converters.ObjectConverter | ObjectConverter} derived from this one but with\n     * new optional properties as specified by a supplied array of `keyof T`.\n     * @param optional - The keys of the source object properties to be made optional.\n     * @returns A new {@link Converters.ObjectConverter | ObjectConverter} with the additional optional source\n     * properties.\n     * {@label withKeys}\n     */\n    public partial(optional?: (keyof T)[]): ObjectConverter<Partial<T>, TC>;\n    /**\n     * Concrete implementation of\n     * {@link Converters.ObjectConverter.(partial:withOptions) | ObjectConverter.partial(ObjectConverterOptions)} and\n     * {@link Converters.ObjectConverter.(partial:withKeys) | ObjectConverter.partial((keyof T)[]}.\n     * @internal\n     */\n    public partial(opt?: ObjectConverterOptions<T>|(keyof T)[]): ObjectConverter<Partial<T>, TC> {\n        return new ObjectConverter<Partial<T>, TC>(this.fields as FieldConverters<Partial<T>, TC>, opt as ObjectConverterOptions<Partial<T>>)._with(this._traits());\n    }\n\n    /**\n     * Creates a new {@link Converters.ObjectConverter | ObjectConverter} derived from this one but with\n     * new optional properties as specified by a supplied array of `keyof T`.\n     * @param addOptionalProperties - The keys to be made optional.\n     * @returns A new {@link Converters.ObjectConverter | ObjectConverter} with the additional optional source\n     * properties.\n     */\n    public addPartial(addOptionalProperties: (keyof T)[]): ObjectConverter<Partial<T>, TC> {\n        return this.partial([...this.options.optionalFields ?? [], ...addOptionalProperties])._with(this._traits());\n    }\n}\n\n/**\n * Helper function to create a {@link Converters.ObjectConverter | ObjectConverter<T>} which converts an object\n * without changing shape, given a {@link Converters.FieldConverters | FieldConverters<T>} and an optional\n * {@link Converters.ObjectConverterOptions | ObjectConverterOptions<T>} to further refine conversion beavior.\n * @remarks\n * By default, if all of the requested fields exist and can be converted, returns {@link Success}\n * with a new object that contains the converted values under the original key names.  If any requried properties\n * do not exist or cannot be converted, the entire conversion fails, returning {@link Failure} with additional\n * error information.\n *\n * Fields that succeed but convert to undefined are omitted from the result object but do not\n * fail the conversion.\n * @param properties - An {@link Converters.FieldConverters | FieldConverters<T>} defining the shape of the\n * source object and {@link Converter | converters} to be applied to each properties.\n * @param options - An {@link Converters.ObjectConverterOptions | ObjectConverterOptions<T>} containing options\n * for the object converter.\n * @returns A new {@link Converters.ObjectConverter | ObjectConverter} which applies the specified conversions.\n * {@label withOptions}\n * @public\n */\nexport function object<T>(properties: FieldConverters<T>, options?: ObjectConverterOptions<T>): ObjectConverter<T>;\n\n/**\n * Helper function to create a {@link Converters.ObjectConverter | ObjectConverter<T>} which converts an object\n * without changing shape, given a {@link Converters.FieldConverters | FieldConverters<T>} and a set of\n * optional properties.\n * @remarks\n * By default, if all of the requested fields exist and can be converted, returns {@link Success}\n * with a new object that contains the converted values under the original key names.  If any requried properties\n * do not exist or cannot be converted, the entire conversion fails, returning {@link Failure} with additional\n * error information.\n *\n * Fields that succeed but convert to undefined are omitted from the result object but do not\n * fail the conversion.\n * @param properties - An {@link Converters.FieldConverters | FieldConverters<T>} defining the shape of the\n * source object and {@link Converter | converters} to be applied to each properties.\n * @param optional - An array of `(keyof T)` listing the keys to be considered optional.\n * {@label withKeys}\n * @returns A new {@link Converters.ObjectConverter | ObjectConverter} which applies the specified conversions.\n * @public\n * @deprecated Use {@link Converters.(object:withOptions) | Converters.object(fields, options)} instead.\n */\n\nexport function object<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;\n/**\n * Concrete implementation of {@link Converters.(object:withOptions) | Converters.object(fields, options)}\n * and {@link Converters.(object:withKeys) | Converters.objects(fields, optionalKeys)}.\n * @internal\n */\nexport function object<T>(properties: FieldConverters<T>, options?: (keyof T)[]|ObjectConverterOptions<T>): ObjectConverter<T> {\n    return new ObjectConverter(properties, options as ObjectConverterOptions<T>);\n}\n\n/**\n * Options for the {@link Converters.(strictObject:withOptions)} helper function.\n * @public\n */\nexport type StrictObjectConverterOptions<T> = Omit<ObjectConverterOptions<T>, 'strict'>;\n\n/**\n * Helper function to create a {@link Converters.ObjectConverter | ObjectConverter} which converts an object\n * without changing shape, a {@link Converters.FieldConverters | FieldConverters<T>} and an optional\n * {@link Converters.StrictObjectConverterOptions | StrictObjectConverterOptions<T>} to further refine\n * conversion behavior.\n *\n * @remarks\n * Fields that succeed but convert to undefined are omitted from the result object but do not\n * fail the conversion.\n *\n * The conversion fails if any unexpected fields are encountered.\n *\n * @param properties - An object containing defining the shape and converters to be applied.\n * @param options - An optional @see StrictObjectConverterOptions<T> containing options for the object converter.\n * @returns A new {@link Converters.ObjectConverter | ObjectConverter} which applies the specified conversions.\n * {@label withOptions}\n * @public\n */\nexport function strictObject<T>(properties: FieldConverters<T>, options?: StrictObjectConverterOptions<T>): ObjectConverter<T>;\n\n/**\n * Helper function to create a {@link Converters.ObjectConverter | ObjectConverter} which converts an object\n * without changing shape, a {@link Converters.FieldConverters | FieldConverters<T>} and an optional\n * {@link Converters.StrictObjectConverterOptions | StrictObjectConverterOptions<T>} to further refine\n * conversion behavior.\n *\n * @remarks\n * Fields that succeed but convert to undefined are omitted from the result object but do not\n * fail the conversion.\n *\n * The conversion fails if any unexpected fields are encountered.\n *\n * @param properties - An object containing defining the shape and converters to be applied.\n * @param optional - An array of `keyof T` containing keys to be considered optional.\n * @returns A new {@link Converters.ObjectConverter | ObjectConverter} which applies the specified conversions.\n * {@label withKeys}\n * @deprecated Use {@link Converters.(strictObject:withOptions) | Converters.strictObject(options)} instead.\n * @public\n */\nexport function strictObject<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;\n/**\n * Concrete implementation for {@link Converters.(strictObject:withOptions) | Converters.strictObject(fields, options)}\n * and {@link Converters.(strictObject:withKeys) | Converters.strictObject(fields, optional)}.\n * @internal\n */\nexport function strictObject<T>(\n    properties: FieldConverters<T>,\n    opt?: (keyof T)[]|StrictObjectConverterOptions<T>,\n): ObjectConverter<T> {\n    const options: ObjectConverterOptions<T> = (opt && Array.isArray(opt))\n        ? { strict: true, optionalFields: opt }\n        : { ...(opt ?? {}), strict: true };\n    return new ObjectConverter(properties, options);\n}\n\n/**\n * A string-keyed `Record<string, Converter>` which maps specific {@link Converter | converters} to the\n * value of a discriminator property.\n * @public\n */\nexport type DiscriminatedObjectConverters<T, TD extends string = string, TC=unknown> = Record<TD, Converter<T, TC>>;\n\n/**\n * Helper to create a {@link Converter} whhich converts a discriminated object without changing shape.\n * @remarks\n * Takes the name of the discriminator property and a\n * {@link Converters.DiscriminatedObjectConverters | string-keyed Record of converters}. During conversion,\n * the resulting {@link Converter} invokes the converter from `converters` that corresponds to the value of\n * the discriminator property in the source object.\n *\n * If the source is not an object, the discriminator property is missing, or the discriminator has\n * a value not present in the converters, conversion fails and returns {@link Failure} with more information.\n * @param discriminatorProp - Name of the property used to discriminate types.\n * @param converters - {@link Converters.DiscriminatedObjectConverters | String-keyed record of converters} to\n * invoke, where each key corresponds to a value of the discriminator property.\n * @returns A {@link Converter} which converts the corresponding discriminated object.\n * @public\n */\nexport function discriminatedObject<T, TD extends string = string, TC=unknown>(discriminatorProp: string, converters: DiscriminatedObjectConverters<T, TD>): Converter<T, TC> {\n    return new BaseConverter((from: unknown) => {\n        if ((typeof from !== 'object') || Array.isArray(from) || from === null) {\n            return fail(`Not a discriminated object: \"${JSON.stringify(from)}\"`);\n        }\n        if ((!isKeyOf(discriminatorProp, from)) || (!from[discriminatorProp])) {\n            return fail(`Discriminator property ${discriminatorProp} not present in \"${JSON.stringify(from)}\"`);\n        }\n\n        const discriminatorValue = from[discriminatorProp] as TD;\n        const converter = converters[discriminatorValue];\n        if (converter === undefined) {\n            return fail(`No converter for discriminator ${discriminatorProp}=\"${discriminatorValue}\"`);\n        }\n        return converter.convert(from);\n    });\n}\n\n/**\n * Helper to create a {@link Converter} which converts a source object to a new object with a\n * different shape.\n *\n * @remarks\n * On successful conversion, the resulting {@link Converter} returns {@link Success} with a new\n * object, which contains the converted values under the key names specified at initialization time.\n * It returns {@link Failure} with an error message if any fields to be extracted do not exist\n * or cannot be converted.\n *\n * Fields that succeed but convert to undefined are omitted from the result object but do not\n * fail the conversion.\n *\n * @param properties - An object with key names that correspond to the target object and an\n * appropriate {@link Converters.FieldConverters | FieldConverter} which extracts and converts\n * a single filed from the source object.\n * @returns A {@link Converter} with the specified conversion behavior.\n * @public\n */\nexport function transform<T, TC=unknown>(properties: FieldConverters<T, TC>): Converter<T, TC> {\n    return new BaseConverter((from: unknown, _self, context?: TC) => {\n        // eslint bug thinks key is used before defined\n        // eslint-disable-next-line no-use-before-define\n        const converted = {} as { [ key in keyof T]: T[key] };\n        const errors: string[] = [];\n\n        for (const key in properties) {\n            if (properties[key]) {\n                const result = properties[key].convert(from, context);\n                if (result.isSuccess() && (result.value !== undefined)) {\n                    converted[key] = result.value;\n                }\n                else if (result.isFailure()) {\n                    errors.push(result.message);\n                }\n            }\n        }\n\n        return (errors.length === 0) ? succeed(converted) : fail(errors.join('\\n'));\n    });\n}\n\n/**\n * A helper wrapper to construct a {@link Converter} which converts to an arbitrary strongly-typed\n * range of some comparable type.\n * @param converter - {@link Converter} used to convert `min` and `max` extent of the range.\n * @param constructor - Static constructor to instantiate the object.\n * @public\n */\nexport function rangeTypeOf<T, RT extends RangeOf<T>, TC=unknown>(converter: Converter<T, TC>, constructor: (init: RangeOfProperties<T>) => Result<RT>): Converter<RT, TC> {\n    return new BaseConverter((from: unknown, _self, context?: TC) => {\n        const result = object({\n            min: converter,\n            max: converter,\n        }, { optionalFields: ['min', 'max'] }).convert(from, context);\n        if (result.isSuccess()) {\n            return constructor({ min: result.value.min, max: result.value.max });\n        }\n        return fail(result.message);\n    });\n}\n\n/**\n * A helper wrapper to construct a {@link Converter} which converts to {@link RangeOf | RangeOf<T>}\n * where `<T>` is some comparable type.\n * @param converter - {@link Converter} used to convert `min` and `max` extent of the range.\n * @public\n */\nexport function rangeOf<T, TC=unknown>(converter: Converter<T, TC>): Converter<RangeOf<T>, TC> {\n    return rangeTypeOf<T, RangeOf<T>, TC>(converter, RangeOf.createRange);\n}\n"]}