@fgv/ts-utils 1.2.1 → 1.3.0

package/csvHelpers.d.ts

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

package/csvHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csvHelpers.d.ts","sourceRoot":"","sources":["../src/csvHelpers.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,MAAM,EAAiB,MAAM,UAAU,CAAC;AAGjD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAOhE"}

package/csvHelpers.js

@@ -22,7 +22,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -48,6 +52,12 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const result_1 = require("./result");
 const sync_1 = __importDefault(require("csv-parse/lib/sync"));
+/**
+ * Reads a CSV file from a supplied path.
+ * @param srcPath - Source path from which the file is read.
+ * @returns The contents of the file.
+ * @beta
+ */
 function readCsvFileSync(srcPath) {
     return (0, result_1.captureResult)(() => {
         const fullPath = path.resolve(srcPath);
@@ -57,4 +67,4 @@ function readCsvFileSync(srcPath) {
     });
 }
 exports.readCsvFileSync = readCsvFileSync;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/extendedArray.d.ts

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

package/extendedArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extendedArray.d.ts","sourceRoot":"","sources":["../src/extendedArray.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,MAAM,EAAiB,MAAM,UAAU,CAAC;AAEjD;;;;GAIG;AACH,qBAAa,aAAa,CAAC,CAAC,CAAE,SAAQ,KAAK,CAAC,CAAC,CAAC;IAC1C,SAAgB,eAAe,EAAE,MAAM,CAAC;IAExC;;;;OAIG;gBACgB,eAAe,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC,EAAE;IAKzD;;;;;;OAMG;WACW,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;IAIhE;;;;;;;OAOG;IACI,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC;IAW1D;;;;;;OAMG;IACI,KAAK,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;IAO7C;;;;;;;OAOG;IACI,UAAU,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC;IAOpD;;;;OAIG;IACI,GAAG,IAAI,CAAC,EAAE;CAGpB"}

package/extendedArray.js

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

package/formatter.d.ts

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

package/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../src/formatter.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,MAAM,EAAsC,MAAM,UAAU,CAAC;AAKtE;;;GAGG;AACH,oBAAY,aAAa,GAAG,MAAM,GAAC,UAAU,GAAC,OAAO,CAAC;AAEtD;;;GAGG;AACH,MAAM,WAAW,WAAW;IACxB;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;CAC1C;AAED;;;GAGG;AACH,qBAAa,eAAe;IACxB;;;;;;OAMG;IACH,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAC,SAAS,GAAG,IAAI;IAO/F;;OAEG;IACI,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;CAGlD;AAED;;;;GAIG;AACH,oBAAY,SAAS,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC;AAEvE;;;;GAIG;AACH,oBAAY,0BAA0B,CAAC,GAAG,SAAS,aAAa,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AACjG;;;;GAIG;AACH,oBAAY,kBAAkB,CAAC,CAAC,IAAI,0BAA0B,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;AAEjF;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAOrG"}

package/formatter.js

@@ -28,18 +28,41 @@ exports.formatList = exports.FormattableBase = void 0;
 const result_1 = require("./result");
 const mustache_1 = __importDefault(require("mustache"));
 mustache_1.default.escape = (s) => s;
+/**
+ * Base class which adds common formatting.
+ * @beta
+ */
 class FormattableBase {
+    /**
+     * Helper enables derived classes to add named details to a formatted presentation.
+     * @param details - An array of detail description strings.
+     * @param label - Label to use for the new detail.
+     * @param value - Value to use for the new detail.
+     * @internal
+     */
     static _tryAddDetail(details, label, value) {
         if (value !== undefined) {
             const padded = `  ${label}:`.padEnd(20, ' ');
             details.push(`${padded} ${value}`);
         }
     }
+    /**
+     * {@inheritdoc Formattable.format}
+     */
     format(template) {
         return (0, result_1.captureResult)(() => mustache_1.default.render(template, this));
     }
 }
 exports.FormattableBase = FormattableBase;
+/**
+ * Formats a list of items using the supplied template and formatter, one result
+ * per output line.
+ * @param format - A mustache template used to format each item.
+ * @param items - The items to be formatted.
+ * @param itemFormatter - The {@link Formatter | Formatter<T>} used to format each item.
+ * @returns The resulting string.
+ * @beta
+ */
 function formatList(format, items, itemFormatter) {
     return (0, result_1.mapResults)(items.map((item) => {
         return itemFormatter(format, item);
@@ -49,4 +72,4 @@ function formatList(format, items, itemFormatter) {
     });
 }
 exports.formatList = formatList;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybWF0dGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Zvcm1hdHRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBb0JHOzs7Ozs7QUFFSCxxQ0FBc0U7QUFDdEUsd0RBQWdDO0FBRWhDLGtCQUFRLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBUyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFRbkMsTUFBYSxlQUFlO0lBQ2QsTUFBTSxDQUFDLGFBQWEsQ0FBQyxPQUFpQixFQUFFLEtBQWEsRUFBRSxLQUF1QjtRQUNwRixJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUU7WUFDckIsTUFBTSxNQUFNLEdBQUcsS0FBSyxLQUFLLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFLEdBQUcsQ0FBQyxDQUFDO1lBQzdDLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FBRyxNQUFNLElBQUksS0FBSyxFQUFFLENBQUMsQ0FBQztTQUN0QztJQUNMLENBQUM7SUFFTSxNQUFNLENBQUMsUUFBZ0I7UUFDMUIsT0FBTyxJQUFBLHNCQUFhLEVBQUMsR0FBRyxFQUFFLENBQUMsa0JBQVEsQ0FBQyxNQUFNLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDaEUsQ0FBQztDQUNKO0FBWEQsMENBV0M7QUFNRCxTQUFnQixVQUFVLENBQUksTUFBYyxFQUFFLEtBQVUsRUFBRSxhQUEyQjtJQUNqRixPQUFPLElBQUEsbUJBQVUsRUFBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7UUFDakMsT0FBTyxhQUFhLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ3ZDLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsT0FBaUIsRUFBRSxFQUFFO1FBQ2hDLE1BQU0sUUFBUSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDbkQsT0FBTyxJQUFBLGdCQUFPLEVBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ3hDLENBQUMsQ0FBQyxDQUFDO0FBQ1AsQ0FBQztBQVBELGdDQU9DIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAyMCBFcmlrIEZvcnR1bmVcbiAqXG4gKiBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5XG4gKiBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSBcIlNvZnR3YXJlXCIpLCB0byBkZWFsXG4gKiBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzXG4gKiB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsXG4gKiBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXNcbiAqIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6XG4gKlxuICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4gYWxsXG4gKiBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLlxuICpcbiAqIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1JcbiAqIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLFxuICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFXG4gKiBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSXG4gKiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLFxuICogT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTiBUSEVcbiAqIFNPRlRXQVJFLlxuICovXG5cbmltcG9ydCB7IFJlc3VsdCwgY2FwdHVyZVJlc3VsdCwgbWFwUmVzdWx0cywgc3VjY2VlZCB9IGZyb20gJy4vcmVzdWx0JztcbmltcG9ydCBNdXN0YWNoZSBmcm9tICdtdXN0YWNoZSc7XG5cbk11c3RhY2hlLmVzY2FwZSA9IChzOiBzdHJpbmcpID0+IHM7XG5cbmV4cG9ydCB0eXBlIEZvcm1hdFRhcmdldHMgPSAndGV4dCd8J21hcmtkb3duJ3wnZW1iZWQnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEZvcm1hdHRhYmxlIHtcbiAgICBmb3JtYXQoZm9ybWF0OiBzdHJpbmcpOiBSZXN1bHQ8c3RyaW5nPjtcbn1cblxuZXhwb3J0IGNsYXNzIEZvcm1hdHRhYmxlQmFzZSB7XG4gICAgcHJvdGVjdGVkIHN0YXRpYyBfdHJ5QWRkRGV0YWlsKGRldGFpbHM6IHN0cmluZ1tdLCBsYWJlbDogc3RyaW5nLCB2YWx1ZTogc3RyaW5nfHVuZGVmaW5lZCk6IHZvaWQge1xuICAgICAgICBpZiAodmFsdWUgIT09IHVuZGVmaW5lZCkge1xuICAgICAgICAgICAgY29uc3QgcGFkZGVkID0gYCAgJHtsYWJlbH06YC5wYWRFbmQoMjAsICcgJyk7XG4gICAgICAgICAgICBkZXRhaWxzLnB1c2goYCR7cGFkZGVkfSAke3ZhbHVlfWApO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgcHVibGljIGZvcm1hdCh0ZW1wbGF0ZTogc3RyaW5nKTogUmVzdWx0PHN0cmluZz4ge1xuICAgICAgICByZXR1cm4gY2FwdHVyZVJlc3VsdCgoKSA9PiBNdXN0YWNoZS5yZW5kZXIodGVtcGxhdGUsIHRoaXMpKTtcbiAgICB9XG59XG5cbmV4cG9ydCB0eXBlIEZvcm1hdHRlcjxUPiA9IChmb3JtYXQ6IHN0cmluZywgaXRlbTogVCkgPT4gUmVzdWx0PHN0cmluZz47XG5leHBvcnQgdHlwZSBGb3JtYXR0ZXJzQnlFeHRlbmRlZFRhcmdldDxURlQgZXh0ZW5kcyBGb3JtYXRUYXJnZXRzLCBUPiA9IFJlY29yZDxURlQsIEZvcm1hdHRlcjxUPj47XG5leHBvcnQgdHlwZSBGb3JtYXR0ZXJzQnlUYXJnZXQ8VD4gPSBGb3JtYXR0ZXJzQnlFeHRlbmRlZFRhcmdldDxGb3JtYXRUYXJnZXRzLCBUPjtcblxuZXhwb3J0IGZ1bmN0aW9uIGZvcm1hdExpc3Q8VD4oZm9ybWF0OiBzdHJpbmcsIGl0ZW1zOiBUW10sIGl0ZW1Gb3JtYXR0ZXI6IEZvcm1hdHRlcjxUPik6IFJlc3VsdDxzdHJpbmc+IHtcbiAgICByZXR1cm4gbWFwUmVzdWx0cyhpdGVtcy5tYXAoKGl0ZW0pID0+IHtcbiAgICAgICAgcmV0dXJuIGl0ZW1Gb3JtYXR0ZXIoZm9ybWF0LCBpdGVtKTtcbiAgICB9KSkub25TdWNjZXNzKChyZXN1bHRzOiBzdHJpbmdbXSkgPT4ge1xuICAgICAgICBjb25zdCBmaWx0ZXJlZCA9IHJlc3VsdHMuZmlsdGVyKChzKSA9PiAocyAhPT0gJycpKTtcbiAgICAgICAgcmV0dXJuIHN1Y2NlZWQoZmlsdGVyZWQuam9pbignXFxuJykpO1xuICAgIH0pO1xufVxuXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/hash.d.ts

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

package/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,MAAM,EAA4C,MAAM,UAAU,CAAC;AAE5E;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAEnD;AAED;;;GAGG;AACH,qBAAa,UAAU;IACnB;;;;;;;;;OASG;IACI,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC;IA8BjD;;;;;;;OAOG;IACH,SAAS,CAAC,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,MAAM;IAexD;;;;;;;OAOG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;IAIxF;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,OAAO,GAAC,MAAM,GAAC,SAAS,GAAC,IAAI,GAAC,MAAM,GAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC;CAwBpH"}

package/hash.js

@@ -22,7 +22,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -45,13 +49,18 @@ const crypto = __importStar(require("crypto"));
 const result_1 = require("./result");
 /**
  * Computes an md5 hash from an array of strings. Not secure and not intended to be secure.
- * @param parts The strings to be hashed
+ * @param parts - The strings to be hashed
  * @returns An md5 hash of the parts
+ * @public
  */
 function computeHash(parts) {
     return crypto.createHash('md5').update(parts.join('|'), 'utf8').digest('hex');
 }
 exports.computeHash = computeHash;
+/**
+ * Computes a normalized hash for an arbitrary javascript value.
+ * @public
+ */
 class Normalizer {
     /**
      * Computes a normalized md5 hash from an arbitrary supplied object.  Not secure and not
@@ -60,8 +69,8 @@ class Normalizer {
      * Normalization just sorts Maps, Sets and object keys by hash so that differences in order
      * do not affect the hash.
      *
-     * @param from The arbitrary unknown to be hashed
-     * @returns An md5 hash
+     * @param from - The arbitrary `unknown` to be hashed.
+     * @returns A normalized md5 hash for the supplied value.
      */
     computeHash(from) {
         switch (typeof from) {
@@ -92,6 +101,14 @@ class Normalizer {
         }
         return (0, result_1.fail)(`computeHash: Unexpected type - cannot hash '${typeof from}'`);
     }
+    /**
+     * Compares two property names from some object being normalized.
+     * @param k1 - First key to be compared.
+     * @param k2 - Second key to be compared.
+     * @returns `1` if `k1` is greater, `-1` if `k2` is greater and
+     * `0` if they are equal.
+     * @internal
+     */
     _compareKeys(k1, k2) {
         const cs1 = String(k1);
         const cs2 = String(k2);
@@ -105,9 +122,23 @@ class Normalizer {
         // istanbul ignore next
         return 0;
     }
+    /**
+     * Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).
+     * @remarks
+     * Converts property names (entry key) to string and then sorts as string.
+     * @param entries - The entries to be normalized.
+     * @returns A normalized sorted array of entries.
+     * @internal
+     */
     _normalizeEntries(entries) {
         return Array.from(entries).sort((e1, e2) => this._compareKeys(e1[0], e2[0]));
     }
+    /**
+     * Constructs a normalized string representation of some literal value.
+     * @param from - The literal value to be normalized.
+     * @returns A normalized string representation of the literal.
+     * @internal
+     */
     _normalizeLiteral(from) {
         switch (typeof from) {
             case 'string':
@@ -134,4 +165,4 @@ class Normalizer {
     }
 }
 exports.Normalizer = Normalizer;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hash.js","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2021 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as crypto from 'crypto';\nimport { Result, captureResult, fail, mapResults, succeed } from './result';\n\n/**\n * Computes an md5 hash from an array of strings. Not secure and not intended to be secure.\n * @param parts The strings to be hashed\n * @returns An md5 hash of the parts\n */\nexport function computeHash(parts: string[]): string {\n    return crypto.createHash('md5').update(parts.join('|'), 'utf8').digest('hex');\n}\n\nexport class Normalizer {\n    /**\n     * Computes a normalized md5 hash from an arbitrary supplied object.  Not secure and not\n     * intended to be secure.  Also not fast and not intended to be fast.\n     *\n     * Normalization just sorts Maps, Sets and object keys by hash so that differences in order\n     * do not affect the hash.\n     *\n     * @param from The arbitrary unknown to be hashed\n     * @returns An md5 hash\n     */\n    public computeHash(from: unknown): Result<string> {\n        switch (typeof from) {\n            case 'string':\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return this._normalizeLiteral(from).onSuccess((v) => {\n                    return captureResult(() => computeHash([v]));\n                });\n            case 'object':\n                if ((from === null) || (from instanceof Date) || (from instanceof RegExp)) {\n                    return this._normalizeLiteral(from).onSuccess((v) => {\n                        return captureResult(() => computeHash([v]));\n                    });\n                }\n                else if (Array.isArray(from)) {\n                    return mapResults(from.map((e) => this.computeHash(e))).onSuccess((a) => {\n                        return captureResult(() => computeHash(a));\n                    });\n                }\n                else if ((from instanceof Map) || (from instanceof Set)) {\n                    return this.computeHash(this._normalizeEntries(from.entries()));\n                }\n                return this.computeHash(this._normalizeEntries(Object.entries(from)));\n        }\n        return fail(`computeHash: Unexpected type - cannot hash '${typeof from}'`);\n    }\n\n    protected _compareKeys(k1: unknown, k2: unknown): number {\n        const cs1 = String(k1);\n        const cs2 = String(k2);\n        if (cs1 > cs2) {\n            return 1;\n        }\n        // istanbul ignore else\n        if (cs2 > cs1) {\n            return -1;\n        }\n\n        // istanbul ignore next\n        return 0;\n    }\n\n    protected _normalizeEntries(entries: Iterable<[unknown, unknown]>): [unknown, unknown][] {\n        return Array.from(entries).sort((e1, e2) => this._compareKeys(e1[0], e2[0]));\n    }\n\n    protected _normalizeLiteral(from: string|number|bigint|boolean|symbol|undefined|Date|RegExp|null): Result<string> {\n        switch (typeof from) {\n            case 'string':\n                return succeed(from);\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return succeed(`${typeof from}:[[[${String(from)}]]]`);\n        }\n        if (from === null) {\n            return succeed('object:[[[null]]');\n        }\n        if (from instanceof Date) {\n            return succeed(`Date:[[[${String(from.valueOf())}]]]`);\n        }\n        // istanbul ignore else\n        if (from instanceof RegExp) {\n            return succeed(`RegExp:[[[${from.toString()}]]]`);\n        }\n        // istanbul ignore next\n        return fail(`cannot normalize ${JSON.stringify(from)}`);\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hash.js","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,+CAAiC;AACjC,qCAA4E;AAE5E;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,KAAe;IACvC,OAAO,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAClF,CAAC;AAFD,kCAEC;AAED;;;GAGG;AACH,MAAa,UAAU;IACnB;;;;;;;;;OASG;IACI,WAAW,CAAC,IAAa;QAC5B,QAAQ,OAAO,IAAI,EAAE;YACjB,KAAK,QAAQ,CAAC;YACd,KAAK,QAAQ,CAAC;YACd,KAAK,SAAS,CAAC;YACf,KAAK,QAAQ,CAAC;YACd,KAAK,QAAQ,CAAC;YACd,KAAK,WAAW;gBACZ,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;oBAChD,OAAO,IAAA,sBAAa,EAAC,GAAG,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACjD,CAAC,CAAC,CAAC;YACP,KAAK,QAAQ;gBACT,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,YAAY,IAAI,CAAC,IAAI,CAAC,IAAI,YAAY,MAAM,CAAC,EAAE;oBACvE,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;wBAChD,OAAO,IAAA,sBAAa,EAAC,GAAG,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBACjD,CAAC,CAAC,CAAC;iBACN;qBACI,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;oBAC1B,OAAO,IAAA,mBAAU,EAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;wBACpE,OAAO,IAAA,sBAAa,EAAC,GAAG,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC/C,CAAC,CAAC,CAAC;iBACN;qBACI,IAAI,CAAC,IAAI,YAAY,GAAG,CAAC,IAAI,CAAC,IAAI,YAAY,GAAG,CAAC,EAAE;oBACrD,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;iBACnE;gBACD,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SAC7E;QACD,OAAO,IAAA,aAAI,EAAC,+CAA+C,OAAO,IAAI,GAAG,CAAC,CAAC;IAC/E,CAAC;IAED;;;;;;;OAOG;IACO,YAAY,CAAC,EAAW,EAAE,EAAW;QAC3C,MAAM,GAAG,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACvB,MAAM,GAAG,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACvB,IAAI,GAAG,GAAG,GAAG,EAAE;YACX,OAAO,CAAC,CAAC;SACZ;QACD,uBAAuB;QACvB,IAAI,GAAG,GAAG,GAAG,EAAE;YACX,OAAO,CAAC,CAAC,CAAC;SACb;QAED,uBAAuB;QACvB,OAAO,CAAC,CAAC;IACb,CAAC;IAED;;;;;;;OAOG;IACO,iBAAiB,CAAC,OAAqC;QAC7D,OAAO,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjF,CAAC;IAED;;;;;OAKG;IACO,iBAAiB,CAAC,IAAoE;QAC5F,QAAQ,OAAO,IAAI,EAAE;YACjB,KAAK,QAAQ;gBACT,OAAO,IAAA,gBAAO,EAAC,IAAI,CAAC,CAAC;YACzB,KAAK,QAAQ,CAAC;YACd,KAAK,SAAS,CAAC;YACf,KAAK,QAAQ,CAAC;YACd,KAAK,QAAQ,CAAC;YACd,KAAK,WAAW;gBACZ,OAAO,IAAA,gBAAO,EAAC,GAAG,OAAO,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAC9D;QACD,IAAI,IAAI,KAAK,IAAI,EAAE;YACf,OAAO,IAAA,gBAAO,EAAC,kBAAkB,CAAC,CAAC;SACtC;QACD,IAAI,IAAI,YAAY,IAAI,EAAE;YACtB,OAAO,IAAA,gBAAO,EAAC,WAAW,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;SAC1D;QACD,uBAAuB;QACvB,IAAI,IAAI,YAAY,MAAM,EAAE;YACxB,OAAO,IAAA,gBAAO,EAAC,aAAa,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;SACrD;QACD,uBAAuB;QACvB,OAAO,IAAA,aAAI,EAAC,oBAAoB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5D,CAAC;CACJ;AA1GD,gCA0GC","sourcesContent":["/*\n * Copyright (c) 2021 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as crypto from 'crypto';\nimport { Result, captureResult, fail, mapResults, succeed } from './result';\n\n/**\n * Computes an md5 hash from an array of strings. Not secure and not intended to be secure.\n * @param parts - The strings to be hashed\n * @returns An md5 hash of the parts\n * @public\n */\nexport function computeHash(parts: string[]): string {\n    return crypto.createHash('md5').update(parts.join('|'), 'utf8').digest('hex');\n}\n\n/**\n * Computes a normalized hash for an arbitrary javascript value.\n * @public\n */\nexport class Normalizer {\n    /**\n     * Computes a normalized md5 hash from an arbitrary supplied object.  Not secure and not\n     * intended to be secure.  Also not fast and not intended to be fast.\n     *\n     * Normalization just sorts Maps, Sets and object keys by hash so that differences in order\n     * do not affect the hash.\n     *\n     * @param from - The arbitrary `unknown` to be hashed.\n     * @returns A normalized md5 hash for the supplied value.\n     */\n    public computeHash(from: unknown): Result<string> {\n        switch (typeof from) {\n            case 'string':\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return this._normalizeLiteral(from).onSuccess((v) => {\n                    return captureResult(() => computeHash([v]));\n                });\n            case 'object':\n                if ((from === null) || (from instanceof Date) || (from instanceof RegExp)) {\n                    return this._normalizeLiteral(from).onSuccess((v) => {\n                        return captureResult(() => computeHash([v]));\n                    });\n                }\n                else if (Array.isArray(from)) {\n                    return mapResults(from.map((e) => this.computeHash(e))).onSuccess((a) => {\n                        return captureResult(() => computeHash(a));\n                    });\n                }\n                else if ((from instanceof Map) || (from instanceof Set)) {\n                    return this.computeHash(this._normalizeEntries(from.entries()));\n                }\n                return this.computeHash(this._normalizeEntries(Object.entries(from)));\n        }\n        return fail(`computeHash: Unexpected type - cannot hash '${typeof from}'`);\n    }\n\n    /**\n     * Compares two property names from some object being normalized.\n     * @param k1 - First key to be compared.\n     * @param k2 - Second key to be compared.\n     * @returns `1` if `k1` is greater, `-1` if `k2` is greater and\n     * `0` if they are equal.\n     * @internal\n     */\n    protected _compareKeys(k1: unknown, k2: unknown): number {\n        const cs1 = String(k1);\n        const cs2 = String(k2);\n        if (cs1 > cs2) {\n            return 1;\n        }\n        // istanbul ignore else\n        if (cs2 > cs1) {\n            return -1;\n        }\n\n        // istanbul ignore next\n        return 0;\n    }\n\n    /**\n     * Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).\n     * @remarks\n     * Converts property names (entry key) to string and then sorts as string.\n     * @param entries - The entries to be normalized.\n     * @returns A normalized sorted array of entries.\n     * @internal\n     */\n    protected _normalizeEntries(entries: Iterable<[unknown, unknown]>): [unknown, unknown][] {\n        return Array.from(entries).sort((e1, e2) => this._compareKeys(e1[0], e2[0]));\n    }\n\n    /**\n     * Constructs a normalized string representation of some literal value.\n     * @param from - The literal value to be normalized.\n     * @returns A normalized string representation of the literal.\n     * @internal\n     */\n    protected _normalizeLiteral(from: string|number|bigint|boolean|symbol|undefined|Date|RegExp|null): Result<string> {\n        switch (typeof from) {\n            case 'string':\n                return succeed(from);\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return succeed(`${typeof from}:[[[${String(from)}]]]`);\n        }\n        if (from === null) {\n            return succeed('object:[[[null]]');\n        }\n        if (from instanceof Date) {\n            return succeed(`Date:[[[${String(from.valueOf())}]]]`);\n        }\n        // istanbul ignore else\n        if (from instanceof RegExp) {\n            return succeed(`RegExp:[[[${from.toString()}]]]`);\n        }\n        // istanbul ignore next\n        return fail(`cannot normalize ${JSON.stringify(from)}`);\n    }\n}\n"]}

package/index.d.ts

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

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqBA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AAExB,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,GAAG,MAAM,cAAc,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC"}