@ncfour-us/stats 0.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Tim Hahn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# replace this

package/lib/components/normal-sample-set.d.ts

@@ -0,0 +1,36 @@
+import { ILogger } from '@ncfour-us/logging';
+import { SampleSet } from './sample-set.js';
+/**
+ * The options for instantiating a Normal distribution SampleSet.
+ */
+export interface NormalSampleSetOptions {
+    /**
+     * number of smaples to generate, default 1000
+     */
+    numSamples?: number;
+    /**
+     * optional mean value, default 0
+     */
+    mean?: number;
+    /**
+     * optional standard deviation value, default 1
+     */
+    stddev?: number;
+    /**
+     * optional logger to use.
+     */
+    logger?: ILogger;
+}
+/**
+ * Class to create a Normal distribution SampleSet
+ * with values in the range (-infinity,infinity),
+ * with default mean 0 and default standard deviation 1.
+ */
+export declare class NormalSampleSet extends SampleSet {
+    /**
+     * Create a new NormalSampleSet instance.
+     *
+     * @param options See {@link NormalSampleSetOptions}
+     */
+    constructor(options: NormalSampleSetOptions);
+}

package/lib/components/normal-sample-set.js

@@ -0,0 +1,43 @@
+// Copyright (c) 2026 Tim Hahn
+import { SampleSet } from './sample-set.js';
+import { UniformSampleSet } from './uniform-sample-set.js';
+;
+/**
+ * Class to create a Normal distribution SampleSet
+ * with values in the range (-infinity,infinity),
+ * with default mean 0 and default standard deviation 1.
+ */
+export class NormalSampleSet extends SampleSet {
+    /**
+     * Create a new NormalSampleSet instance.
+     *
+     * @param options See {@link NormalSampleSetOptions}
+     */
+    constructor(options) {
+        super({
+            logger: options.logger,
+        });
+        // Create a Normal distribution using the Box-Muller transform method.
+        //
+        // For information on this method, refer to: https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
+        const U1 = new UniformSampleSet({
+            numSamples: options.numSamples ?? 1000,
+        });
+        const U2 = new UniformSampleSet({
+            numSamples: options.numSamples ?? 1000,
+        });
+        const u1 = U1.getValues();
+        const u2 = U2.getValues();
+        const z0 = u1.map((u1Value, index) => {
+            return Math.sqrt(-2.0 * Math.log(u1Value)) * Math.cos(2.0 * Math.PI * u2[index]);
+        });
+        // const z1 = u1.map( (u1Value, index) => {
+        //   return Math.sqrt(-2.0*Math.log(u1Value))*Math.sin(2.0*Math.PI*u2[index])
+        // });
+        const mean = options.mean ?? 0;
+        const stddev = options.stddev ?? 1;
+        this.addValues(z0.map((value) => mean + (value) * (stddev)));
+        this.logger?.trace(`NormalSampleSet.constructor: numSamples: ${this.getNumSamples()}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/normal-set.d.ts

@@ -0,0 +1,11 @@
+import { ILogger } from '@ncfour-us/logging';
+import { SampleSet } from './sample-set.js';
+export interface NormalSetOptions {
+    numSamples?: number;
+    min?: number;
+    max?: number;
+    logger?: ILogger;
+}
+export declare class NormalSet extends SampleSet {
+    constructor(options: NormalSetOptions);
+}

package/lib/components/normal-set.js

@@ -0,0 +1,18 @@
+// Copyright (c) 2026 Tim Hahn
+import { SampleSet } from './sample-set.js';
+;
+export class NormalSet extends SampleSet {
+    constructor(options) {
+        super({
+            logger: options.logger,
+        });
+        this.addValues(Array.from({ length: options.numSamples ?? 1000 }, (_element, _index) => {
+            const min = options.min ?? 0;
+            const max = options.max ?? 1;
+            const newVal = min + (max - min) * Math.random();
+            return newVal;
+        }));
+        this.logger?.trace(`NormalSet.constructor: numSamples: ${this.getNumSamples()}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/sample-set.d.ts

@@ -0,0 +1,172 @@
+import { ILogger } from '@ncfour-us/logging';
+/**
+ * SampleBucket is used to represent the calculated
+ * distribution for the SampleSet.
+ */
+export declare class SampleBucket {
+    min: number;
+    max: number;
+    midPoint: number;
+    count: number;
+    constructor(min: number, max: number, count: number);
+}
+/**
+ * The type of values stored in the SampleSet
+ */
+export type SampleSetValue = number | string;
+/**
+ * SampleSetPercentiles represents the calculated percentiles
+ * for the values in the SampleSet.
+ */
+export interface SampleSetPercentiles {
+    0: SampleSetValue;
+    25: SampleSetValue;
+    50: SampleSetValue;
+    75: SampleSetValue;
+    100: SampleSetValue;
+}
+/**
+ * The options for instantiating the SampleSet.
+ */
+export interface SampleSetOptions {
+    /**
+     * optional initial set of values to put into the SampleSet
+     */
+    initialValues?: SampleSetValue[];
+    /**
+     * optional logger to use.
+     */
+    logger?: ILogger;
+}
+/**
+ * Base class to represent samples of a random variable
+ * in the stats package.
+ *
+ * Other calculated distributions are based on this base
+ * class.  However, instances of the base class can be
+ * created as well, if a set of random values exists to
+ * initialize the SampleSet.
+ */
+export declare class SampleSet {
+    protected logger?: ILogger;
+    private valuesNumeric;
+    private values;
+    private dictionary;
+    private recalculate;
+    private mean;
+    private median;
+    private mode;
+    private variance;
+    private stddev;
+    private max;
+    private min;
+    private percentile25;
+    private percentile75;
+    private distribution;
+    /**
+     * Create a new SampleSet instance.
+     *
+     * @param options See {@link SampleSetOptions}
+     */
+    constructor(options: SampleSetOptions);
+    /**
+     * get the array of values held in the SampleSet.
+     *
+     * @returns SampleSetValue[] - array of SampleSetValue
+     */
+    getValues(): SampleSetValue[];
+    /**
+     * get a specific value, by index, held in the SampleSet.
+     *
+     * @returns SampleSetValue
+     */
+    getValue(index: number): SampleSetValue | undefined;
+    /**
+     * Replace the set of values held in the SampleSet
+     */
+    setValues(values: SampleSetValue[]): void;
+    /**
+     * Add values to the SampleSet
+     *
+     * @param values values to add to the SampleSet
+     */
+    addValues(values: SampleSetValue[]): void;
+    /**
+     * Add a single value to the SampleSet
+     *
+     * @param value value to add to the SampleSet
+     */
+    addValue(value: SampleSetValue): void;
+    /**
+     * Get the mean value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - mean value of the SampleSet
+     */
+    getMean(): SampleSetValue;
+    /**
+     * Get the median value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - median value of the SampleSet
+     */
+    getMedian(): SampleSetValue;
+    /**
+     * Get the mode value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - mode value of the SampleSet
+     */
+    getMode(): SampleSetValue;
+    /**
+     * Get the minimum value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - minimum value of the SampleSet
+     */
+    getMin(): SampleSetValue;
+    /**
+     * Get the maximum value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - maximum value of the SampleSet
+     */
+    getMax(): SampleSetValue;
+    /**
+     * Get the variance value of the SampleSet.  For string
+     * values, this is the variance across the size of the SampleSet [0,sampleSet.getNumSamples()-1].
+     *
+     * @returns number - Calculated variance of the SampleSet
+     */
+    getVariance(): number;
+    /**
+     * Get the percentiles values for the SampleSet.
+     *
+     * @returns sampleSetPercentiles - the 0, 25, 50, 75, and 100th percential values for the SampleSet.
+     */
+    getPercentiles(): SampleSetPercentiles;
+    /**
+     * Get the standard deviation value of the SampleSet.  For string
+     * values, this is the standard deviation across the size of the
+     * SampleSet [0,sampleSet.getNumSamples()-1].
+     *
+     * @returns number - Calculated standard deviation of the SampleSet
+     */
+    getStddev(): number;
+    /**
+     * Get the type of values in the SampleSet
+     *
+     * @returns true if numeric values, false if string values
+     */
+    isNumeric(): boolean;
+    /**
+     * Get the number of values in the SampleSet
+     *
+     * @returns number of samples in the SampleSet
+     */
+    getNumSamples(): number;
+    private recalculateStats;
+    private calcMean;
+    private calcVariance;
+    private calcFromSortedValues;
+}

package/lib/components/sample-set.js

@@ -0,0 +1,429 @@
+// Copyright (c) 2026 Tim Hahn
+/**
+ * SampleBucket is used to represent the calculated
+ * distribution for the SampleSet.
+ */
+export class SampleBucket {
+    min;
+    max;
+    midPoint;
+    count;
+    constructor(min, max, count) {
+        this.min = min;
+        this.max = max;
+        this.midPoint = this.min + (this.max - this.min) / 2;
+        this.count = count;
+    }
+}
+;
+/**
+ * Base class to represent samples of a random variable
+ * in the stats package.
+ *
+ * Other calculated distributions are based on this base
+ * class.  However, instances of the base class can be
+ * created as well, if a set of random values exists to
+ * initialize the SampleSet.
+ */
+export class SampleSet {
+    // dependencies
+    logger;
+    // sample data
+    valuesNumeric;
+    values;
+    dictionary;
+    // calculated items
+    recalculate; // sets whether or not re-calculation is needed
+    mean;
+    median;
+    mode;
+    variance;
+    stddev;
+    max;
+    min;
+    percentile25;
+    percentile75;
+    distribution;
+    /**
+     * Create a new SampleSet instance.
+     *
+     * @param options See {@link SampleSetOptions}
+     */
+    constructor(options) {
+        // dependencies
+        this.logger = options.logger;
+        // intialize information
+        this.recalculate = true;
+        this.mean = 0;
+        this.median = 0;
+        this.mode = 0;
+        this.variance = 0;
+        this.stddev = 0;
+        this.min = 0;
+        this.max = 0;
+        this.percentile25 = 0;
+        this.percentile75 = 0;
+        this.distribution = [];
+        // initialize values
+        this.valuesNumeric = true;
+        this.values = [];
+        this.dictionary = [];
+        if (options.initialValues) {
+            this.setValues(options.initialValues);
+        }
+        this.logger?.trace(`SampleSet.constructor: numSamples: ${this.values.length}`);
+    }
+    /**
+     * get the array of values held in the SampleSet.
+     *
+     * @returns SampleSetValue[] - array of SampleSetValue
+     */
+    getValues() {
+        let retVals;
+        if (this.valuesNumeric) {
+            retVals = this.values.map((value) => value);
+        }
+        else {
+            retVals = this.values.map((value) => this.dictionary[value]);
+        }
+        return retVals;
+    }
+    /**
+     * get a specific value, by index, held in the SampleSet.
+     *
+     * @returns SampleSetValue
+     */
+    getValue(index) {
+        let retVal;
+        if (index < 0 || index >= this.values.length) {
+            return undefined;
+        }
+        if (this.valuesNumeric) {
+            retVal = this.values[index];
+        }
+        else {
+            retVal = this.dictionary[this.values[index]];
+        }
+        return retVal;
+    }
+    /**
+     * Replace the set of values held in the SampleSet
+     */
+    setValues(values) {
+        this.values = [];
+        this.dictionary = [];
+        this.logger?.trace(`SampleSet.setValues: typeof value: ${typeof values[0]}`);
+        if (values.length > 0 && typeof values[0] === 'string') {
+            this.valuesNumeric = false;
+        }
+        else {
+            this.valuesNumeric = true;
+        }
+        this.addValues(values);
+        this.recalculate = true;
+    }
+    /**
+     * Add values to the SampleSet
+     *
+     * @param values values to add to the SampleSet
+     */
+    addValues(values) {
+        if (this.values.length > 0 &&
+            (typeof values[0] === 'string' && this.valuesNumeric) ||
+            (typeof values[0] === 'number' && !this.valuesNumeric)) {
+            // type mismatch on values being added - quietly IGNORE
+            this.logger?.error(`SampleSet.addValues: type mismatch on values added, valuesNumeric: ${this.valuesNumeric}, values type: ${typeof values[0]}`);
+            return;
+        }
+        if (values.length > 0 && typeof values[0] === 'string') {
+            this.valuesNumeric = false;
+            values.forEach((value) => {
+                const existingItemIndex = this.dictionary.findIndex((dictItem) => dictItem === value);
+                if (existingItemIndex >= 0) {
+                    // item found in dictionary
+                    this.values.push(existingItemIndex);
+                }
+                else {
+                    // add to dictionary
+                    this.dictionary.push(value);
+                    this.values.push(this.dictionary.length - 1);
+                }
+            });
+            this.logger?.trace(`SampleSet.addValues: resulting dictionary: ${this.dictionary}`);
+        }
+        else {
+            // number values
+            this.valuesNumeric = true;
+            this.values = values.map((value) => value);
+        }
+        this.logger?.trace(`SampleSet.addValues: new numSamples: ${this.values.length}`);
+        this.recalculate = true;
+    }
+    /**
+     * Add a single value to the SampleSet
+     *
+     * @param value value to add to the SampleSet
+     */
+    addValue(value) {
+        if (this.values.length > 0 &&
+            (typeof value === 'string' && this.valuesNumeric) ||
+            (typeof value === 'number' && !this.valuesNumeric)) {
+            // type mismatch on values being added - quietly IGNORE
+            this.logger?.error(`SampleSet.addValue: type mismatch on value added, valuesNumeric: ${this.valuesNumeric}, values type: ${typeof value}`);
+            return;
+        }
+        if (typeof value === 'string') {
+            const existingItemIndex = this.dictionary.findIndex((dictItem) => dictItem === value);
+            if (existingItemIndex > 0) {
+                // item found in dictionary
+                this.values.push(existingItemIndex);
+            }
+            else {
+                // add to dictionary
+                this.dictionary.push(value);
+                this.values.push(this.dictionary.length - 1);
+            }
+        }
+        else {
+            this.values.push(value);
+        }
+        this.recalculate = true;
+    }
+    /**
+     * Get the mean value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - mean value of the SampleSet
+     */
+    getMean() {
+        if (this.recalculate) {
+            this.recalculateStats();
+        }
+        return this.valuesNumeric ? this.mean : this.dictionary[this.mean];
+    }
+    /**
+     * Get the median value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - median value of the SampleSet
+     */
+    getMedian() {
+        if (this.recalculate) {
+            this.recalculateStats();
+        }
+        return this.valuesNumeric ? this.median : this.dictionary[this.median];
+    }
+    /**
+     * Get the mode value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - mode value of the SampleSet
+     */
+    getMode() {
+        if (this.recalculate) {
+            this.recalculateStats();
+        }
+        return this.valuesNumeric ? this.mode : this.dictionary[this.mode];
+    }
+    /**
+     * Get the minimum value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - minimum value of the SampleSet
+     */
+    getMin() {
+        if (this.recalculate) {
+            this.recalculateStats();
+        }
+        return this.valuesNumeric ? this.min : this.dictionary[this.min];
+    }
+    /**
+     * Get the maximum value of the SampleSet.  For string
+     * values, this is ordered by string sorting rules.
+     *
+     * @returns SampleSetValue - maximum value of the SampleSet
+     */
+    getMax() {
+        if (this.recalculate) {
+            this.recalculateStats();
+        }
+        return this.valuesNumeric ? this.max : this.dictionary[this.max];
+    }
+    /**
+     * Get the variance value of the SampleSet.  For string
+     * values, this is the variance across the size of the SampleSet [0,sampleSet.getNumSamples()-1].
+     *
+     * @returns number - Calculated variance of the SampleSet
+     */
+    getVariance() {
+        if (this.recalculate) {
+            this.recalculateStats();
+        }
+        return this.variance;
+    }
+    /**
+     * Get the percentiles values for the SampleSet.
+     *
+     * @returns sampleSetPercentiles - the 0, 25, 50, 75, and 100th percential values for the SampleSet.
+     */
+    getPercentiles() {
+        if (this.recalculate) {
+            this.recalculateStats();
+        }
+        return {
+            0: this.valuesNumeric ? this.min : this.dictionary[this.min],
+            25: this.valuesNumeric ? this.percentile25 : this.dictionary[this.percentile25],
+            50: this.valuesNumeric ? this.median : this.dictionary[this.median],
+            75: this.valuesNumeric ? this.percentile75 : this.dictionary[this.percentile75],
+            100: this.valuesNumeric ? this.max : this.dictionary[this.max],
+        };
+    }
+    /**
+     * Get the standard deviation value of the SampleSet.  For string
+     * values, this is the standard deviation across the size of the
+     * SampleSet [0,sampleSet.getNumSamples()-1].
+     *
+     * @returns number - Calculated standard deviation of the SampleSet
+     */
+    getStddev() {
+        if (this.recalculate) {
+            this.recalculateStats();
+        }
+        return this.stddev;
+    }
+    /**
+     * Get the type of values in the SampleSet
+     *
+     * @returns true if numeric values, false if string values
+     */
+    isNumeric() {
+        return this.valuesNumeric;
+    }
+    /**
+     * Get the number of values in the SampleSet
+     *
+     * @returns number of samples in the SampleSet
+     */
+    getNumSamples() {
+        return this.values.length;
+    }
+    recalculateStats() {
+        this.calcMean();
+        this.calcVariance();
+        this.calcFromSortedValues();
+        this.recalculate = false;
+    }
+    calcMean() {
+        this.mean = this.values.reduce((sum, value) => sum + value, 0) / this.values.length;
+        this.mean = this.valuesNumeric ? this.mean : Math.round(this.mean);
+    }
+    // Calculates the variance and standard deviation
+    // NOTE - this function ASSUMES that the mean has already been recalculated
+    calcVariance() {
+        this.variance = this.values.reduce((sum, value) => sum + ((value - this.mean) * (value - this.mean)), 0) / this.values.length;
+        this.stddev = Math.sqrt(this.variance);
+    }
+    // Calculates median, mode, and distribution
+    calcFromSortedValues() {
+        // sort the values
+        let sortedValues;
+        if (this.valuesNumeric) {
+            // the default sort function is appropriate
+            sortedValues = this.values.toSorted((a, b) => a < b ?
+                -1 :
+                a > b ?
+                    1 :
+                    0);
+            this.logger?.trace(`SampleSet.calcFromSortedValues: sortedValues: ${sortedValues}`);
+        }
+        else {
+            // need to sort based on dictionary lookup
+            sortedValues = this.values.toSorted((a, b) => this.dictionary[a] < this.dictionary[b] ?
+                -1 :
+                (this.dictionary[a] > this.dictionary[b] ?
+                    1 :
+                    0));
+            this.logger?.trace(`SampleSet.calcFromSortedValues: sortedValues: ${sortedValues.map((value) => this.dictionary[value])}`);
+        }
+        // get the median
+        const midPointIndex = Math.trunc((this.values.length - 1) / 2);
+        this.median = sortedValues[midPointIndex];
+        this.logger?.trace(`SampleSet.calcFromSortedValues: midPointIndex: ${midPointIndex}`);
+        // get the min and max values
+        this.min = sortedValues[0];
+        this.max = sortedValues[sortedValues.length - 1];
+        // get the percentile25 and percentile50 values
+        let percentileIndex = Math.trunc((this.values.length - 1) / 4);
+        this.percentile25 = sortedValues[percentileIndex];
+        percentileIndex = Math.trunc((this.values.length - 1) * (3 / 4));
+        this.percentile75 = sortedValues[percentileIndex];
+        // create the distribution histogram/table
+        this.distribution = [];
+        if (this.valuesNumeric) {
+            // in this case, create buckets of equal size which span the range [min, max)
+            // and count the number of values in each range
+            // Use the sqrt(numSamples) rule of thumb for calculating the number of buckets
+            const numBuckets = Math.trunc(Math.sqrt(this.values.length) + 1);
+            const bucketSize = (this.max - this.min) / numBuckets;
+            let currentMin = sortedValues[0];
+            let currentMax = currentMin + bucketSize;
+            if (currentMax === this.max) {
+                // VERY unlikely - but just in case, add a very small amount so as not to have a
+                // bucket of one with only the max value at the end.
+                currentMax += 1e-10;
+            }
+            let count = 0;
+            for (let i = 0; i < sortedValues.length; i++) {
+                if (sortedValues[i] >= currentMin && sortedValues[i] < currentMax) {
+                    count++;
+                }
+                else {
+                    this.distribution.push(new SampleBucket(currentMin, currentMax, count));
+                    currentMin += bucketSize;
+                    currentMax = currentMin + bucketSize;
+                    if (currentMax === this.max) {
+                        // VERY unlikely - but just in case, add a very small amount so as not to have a
+                        // bucket of one with only the max value at the end.
+                        currentMax += 1e-10;
+                    }
+                    count = 1;
+                }
+            }
+            this.distribution.push(new SampleBucket(currentMin, currentMax, count));
+            // numBuckets and distribution.length should match
+            this.logger?.trace(`SampleSet.calcFromSortedValues: numeric data, numBuckets: ${numBuckets}, distribution.length: ${this.distribution.length}`);
+        }
+        else {
+            // in this case, the number of buckets matches the number of strings in the SampleSet
+            // which is the size of the dictionary
+            let currentValue = sortedValues[0];
+            let count = 0;
+            for (let i = 0; i < sortedValues.length; i++) {
+                if (sortedValues[i] === currentValue) {
+                    count++;
+                }
+                else {
+                    this.distribution.push(new SampleBucket(currentValue, currentValue, count));
+                    currentValue = sortedValues[i];
+                    count = 1;
+                }
+            }
+            this.distribution.push(new SampleBucket(currentValue, currentValue, count));
+            // dictionary.length and distribution.length should match
+            this.logger?.trace(`SampleSet.calcFromSortedValues: string data, dictionary.length: ${this.dictionary.length}, distribution.length: ${this.distribution.length}`);
+            this.logger?.trace(`SampleSet.calcFromSortedValues: dictionary: ${this.dictionary}`);
+        }
+        this.logger?.trace(`SampleSet.calcFromSortedValues: numeric: ${this.valuesNumeric}, distribution details: ${JSON.stringify(this.distribution, null, 2)}`);
+        // calculate the mode
+        const maxDistributionBucketIndex = this.distribution.reduce((curMaxIndex, bucket, index) => bucket.count > this.distribution[curMaxIndex].count ? index : curMaxIndex, 0);
+        if (this.valuesNumeric) {
+            this.mode = this.distribution[maxDistributionBucketIndex].min +
+                (this.distribution[maxDistributionBucketIndex].max - this.distribution[maxDistributionBucketIndex].min) / 2;
+        }
+        else {
+            this.mode = this.distribution[maxDistributionBucketIndex].min;
+        }
+        this.logger?.trace(`SampleSet.calcFromSortedValues: mode: ${this.mode}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sample-set.js","sourceRoot":"","sources":["../../src/components/sample-set.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) 2026 Tim Hahn\n\nimport { ILogger } from '@ncfour-us/logging';\n\n/**\n * SampleBucket is used to represent the calculated\n * distribution for the SampleSet.\n */\nexport class SampleBucket {\n  public min: number;\n  public max: number;\n  public midPoint: number;\n  public count: number;\n\n  constructor(min: number, max: number, count: number) {\n    this.min = min;\n    this.max = max;\n    this.midPoint = this.min + (this.max-this.min)/2;\n    this.count = count;\n  }\n}\n\n/**\n * The type of values stored in the SampleSet\n */\nexport type SampleSetValue = number | string;\n\n/**\n * SampleSetPercentiles represents the calculated percentiles\n * for the values in the SampleSet.\n */\nexport interface SampleSetPercentiles {\n  0: SampleSetValue;\n  25: SampleSetValue;\n  50: SampleSetValue;\n  75: SampleSetValue;\n  100: SampleSetValue;\n}\n\n/**\n * The options for instantiating the SampleSet.\n */\nexport interface SampleSetOptions {\n\n  /**\n   * optional initial set of values to put into the SampleSet\n   */\n  initialValues?: SampleSetValue[];\n\n  // dependencies\n  /**\n   * optional logger to use.\n   */\n  logger?: ILogger;\n};\n\n/**\n * Base class to represent samples of a random variable\n * in the stats package.\n *\n * Other calculated distributions are based on this base\n * class.  However, instances of the base class can be\n * created as well, if a set of random values exists to\n * initialize the SampleSet.\n */\nexport class SampleSet {\n  // dependencies\n  protected logger?: ILogger;\n\n  // sample data\n  private valuesNumeric: boolean;\n  private values: number[];\n  private dictionary: string[];\n\n  // calculated items\n  private recalculate: boolean; // sets whether or not re-calculation is needed\n  private mean: number;\n  private median: number;\n  private mode: number;\n  private variance: number;\n  private stddev: number;\n  private max: number;\n  private min: number;\n  private percentile25: number;\n  private percentile75: number;\n  private distribution: SampleBucket[];\n\n  /**\n   * Create a new SampleSet instance.\n   *\n   * @param options See {@link SampleSetOptions}\n   */\n  constructor(options: SampleSetOptions) {\n    // dependencies\n    this.logger = options.logger;\n\n    // intialize information\n    this.recalculate = true;\n    this.mean = 0;\n    this.median = 0;\n    this.mode = 0;\n    this.variance = 0;\n    this.stddev = 0;\n    this.min = 0;\n    this.max = 0;\n    this.percentile25 = 0;\n    this.percentile75 = 0;\n    this.distribution = [];\n\n    // initialize values\n    this.valuesNumeric = true;\n    this.values = ([] as number[]);\n    this.dictionary = ([] as string[]);\n    if (options.initialValues) {\n      this.setValues(options.initialValues);\n    }\n\n    this.logger?.trace(`SampleSet.constructor: numSamples: ${this.values.length}`);\n\n  }\n\n  /**\n   * get the array of values held in the SampleSet.\n   *\n   * @returns SampleSetValue[] - array of SampleSetValue\n   */\n  public getValues(): SampleSetValue[] {\n    let retVals: SampleSetValue[];\n    if (this.valuesNumeric) {\n      retVals = this.values.map((value) => value);\n    } else {\n      retVals = this.values.map((value) => this.dictionary[value]);\n    }\n\n    return retVals;\n  }\n\n  /**\n   * get a specific value, by index, held in the SampleSet.\n   *\n   * @returns SampleSetValue\n   */\n  public getValue(index: number): SampleSetValue | undefined {\n    let retVal: SampleSetValue;\n\n    if (index < 0 || index >= this.values.length) {\n      return undefined;\n    }\n\n    if (this.valuesNumeric) {\n      retVal = this.values[index];\n    } else {\n      retVal = this.dictionary[this.values[index]];\n    }\n\n    return retVal;\n  }\n\n  /**\n   * Replace the set of values held in the SampleSet\n   */\n  public setValues(values: SampleSetValue[]): void {\n    this.values = [] as number[];\n    this.dictionary = [] as string[];\n\n    this.logger?.trace(`SampleSet.setValues: typeof value: ${typeof values[0]}`);\n\n    if (values.length > 0 && typeof values[0] === 'string') {\n      this.valuesNumeric = false;\n    } else {\n      this.valuesNumeric = true;\n    }\n\n    this.addValues(values);\n\n    this.recalculate = true;\n  }\n\n  /**\n   * Add values to the SampleSet\n   *\n   * @param values values to add to the SampleSet\n   */\n  public addValues(values: SampleSetValue[] ): void {\n    if ( this.values.length > 0 &&\n        ( typeof values[0] === 'string' && this.valuesNumeric ) ||\n        ( typeof values[0] === 'number' && !this.valuesNumeric ) ) {\n      // type mismatch on values being added - quietly IGNORE\n      this.logger?.error(`SampleSet.addValues: type mismatch on values added, valuesNumeric: ${this.valuesNumeric}, values type: ${typeof values[0]}`);\n      return;\n    }\n\n    if (values.length > 0 && typeof values[0] === 'string') {\n      this.valuesNumeric = false;\n\n      (values as string[]).forEach((value) => {\n        const existingItemIndex = this.dictionary.findIndex((dictItem) => dictItem === value);\n        if (existingItemIndex >= 0) {\n          // item found in dictionary\n          this.values.push(existingItemIndex);\n        } else {\n          // add to dictionary\n          this.dictionary.push(value);\n          this.values.push(this.dictionary.length-1);\n        }\n      });\n\n      this.logger?.trace(`SampleSet.addValues: resulting dictionary: ${this.dictionary}`);\n    } else {\n      // number values\n      this.valuesNumeric = true;\n      this.values = (values as number[]).map((value) => value) as number[];\n    }\n\n    this.logger?.trace(`SampleSet.addValues: new numSamples: ${this.values.length}`);\n\n    this.recalculate = true;\n  }\n\n  /**\n   * Add a single value to the SampleSet\n   *\n   * @param value value to add to the SampleSet\n   */\n  public addValue(value: SampleSetValue) {\n    if ( this.values.length > 0 &&\n        ( typeof value === 'string' && this.valuesNumeric ) ||\n        ( typeof value === 'number' && !this.valuesNumeric ) ) {\n      // type mismatch on values being added - quietly IGNORE\n      this.logger?.error(`SampleSet.addValue: type mismatch on value added, valuesNumeric: ${this.valuesNumeric}, values type: ${typeof value}`);\n      return;\n    }\n\n    if (typeof value === 'string') {\n      const existingItemIndex = this.dictionary.findIndex((dictItem) => dictItem === value);\n      if (existingItemIndex > 0) {\n        // item found in dictionary\n        this.values.push(existingItemIndex);\n      } else {\n        // add to dictionary\n        this.dictionary.push(value);\n        this.values.push(this.dictionary.length-1);\n      }\n    } else {\n      this.values.push(value);\n    }\n\n    this.recalculate = true;\n  }\n\n  /**\n   * Get the mean value of the SampleSet.  For string\n   * values, this is ordered by string sorting rules.\n   *\n   * @returns SampleSetValue - mean value of the SampleSet\n   */\n  public getMean(): SampleSetValue {\n    if (this.recalculate) {\n      this.recalculateStats();\n    }\n    return this.valuesNumeric ? this.mean : this.dictionary[this.mean];\n  }\n\n  /**\n   * Get the median value of the SampleSet.  For string\n   * values, this is ordered by string sorting rules.\n   *\n   * @returns SampleSetValue - median value of the SampleSet\n   */\n  public getMedian(): SampleSetValue {\n    if (this.recalculate) {\n      this.recalculateStats();\n    }\n    return this.valuesNumeric ? this.median : this.dictionary[this.median];\n  }\n\n  /**\n   * Get the mode value of the SampleSet.  For string\n   * values, this is ordered by string sorting rules.\n   *\n   * @returns SampleSetValue - mode value of the SampleSet\n   */\n  public getMode(): SampleSetValue {\n    if (this.recalculate) {\n      this.recalculateStats();\n    }\n    return this.valuesNumeric ? this.mode : this.dictionary[this.mode];\n  }\n\n  /**\n   * Get the minimum value of the SampleSet.  For string\n   * values, this is ordered by string sorting rules.\n   *\n   * @returns SampleSetValue - minimum value of the SampleSet\n   */\n  public getMin(): SampleSetValue {\n    if (this.recalculate) {\n      this.recalculateStats();\n    }\n    return this.valuesNumeric ? this.min : this.dictionary[this.min];\n  }\n\n  /**\n   * Get the maximum value of the SampleSet.  For string\n   * values, this is ordered by string sorting rules.\n   *\n   * @returns SampleSetValue - maximum value of the SampleSet\n   */\n  public getMax(): SampleSetValue {\n    if (this.recalculate) {\n      this.recalculateStats();\n    }\n    return this.valuesNumeric ? this.max : this.dictionary[this.max];\n  }\n\n  /**\n   * Get the variance value of the SampleSet.  For string\n   * values, this is the variance across the size of the SampleSet [0,sampleSet.getNumSamples()-1].\n   *\n   * @returns number - Calculated variance of the SampleSet\n   */\n  public getVariance(): number {\n    if (this.recalculate) {\n      this.recalculateStats();\n    }\n    return this.variance;\n  }\n\n  /**\n   * Get the percentiles values for the SampleSet.\n   *\n   * @returns sampleSetPercentiles - the 0, 25, 50, 75, and 100th percential values for the SampleSet.\n   */\n  public getPercentiles(): SampleSetPercentiles {\n    if (this.recalculate) {\n      this.recalculateStats();\n    }\n    return {\n      0: this.valuesNumeric ? this.min : this.dictionary[this.min],\n      25: this.valuesNumeric ? this.percentile25 : this.dictionary[this.percentile25],\n      50: this.valuesNumeric ? this.median : this.dictionary[this.median],\n      75: this.valuesNumeric ? this.percentile75 : this.dictionary[this.percentile75],\n      100: this.valuesNumeric ? this.max : this.dictionary[this.max],\n    };\n  }\n\n  /**\n   * Get the standard deviation value of the SampleSet.  For string\n   * values, this is the standard deviation across the size of the\n   * SampleSet [0,sampleSet.getNumSamples()-1].\n   *\n   * @returns number - Calculated standard deviation of the SampleSet\n   */\n  public getStddev(): number {\n    if (this.recalculate) {\n      this.recalculateStats();\n    }\n    return this.stddev;\n  }\n\n  /**\n   * Get the type of values in the SampleSet\n   *\n   * @returns true if numeric values, false if string values\n   */\n  public isNumeric(): boolean {\n    return this.valuesNumeric;\n  }\n\n  /**\n   * Get the number of values in the SampleSet\n   *\n   * @returns number of samples in the SampleSet\n   */\n  public getNumSamples(): number {\n    return this.values.length;\n  }\n\n  private recalculateStats() {\n\n    this.calcMean();\n    this.calcVariance();\n    this.calcFromSortedValues();\n\n    this.recalculate = false;\n  }\n\n  private calcMean() {\n    this.mean = this.values.reduce((sum, value) => sum+value, 0) / this.values.length;\n    this.mean = this.valuesNumeric ? this.mean : Math.round(this.mean);\n  }\n\n  // Calculates the variance and standard deviation\n  // NOTE - this function ASSUMES that the mean has already been recalculated\n  private calcVariance() {\n    this.variance = this.values.reduce((sum, value) => sum+((value-this.mean)*(value-this.mean)), 0) / this.values.length;\n    this.stddev = Math.sqrt(this.variance);\n  }\n\n  // Calculates median, mode, and distribution\n  private calcFromSortedValues() {\n    // sort the values\n    let sortedValues: number[];\n\n    if ( this.valuesNumeric ) {\n      // the default sort function is appropriate\n      sortedValues = this.values.toSorted( (a, b) =>\n        a < b ?\n          -1 :\n          a > b ?\n            1 :\n            0,\n      );\n\n      this.logger?.trace(`SampleSet.calcFromSortedValues: sortedValues: ${sortedValues}`);\n    } else {\n      // need to sort based on dictionary lookup\n      sortedValues = this.values.toSorted( (a, b) =>\n        this.dictionary[a] < this.dictionary[b] ?\n          -1 :\n          (this.dictionary[a] > this.dictionary[b] ?\n            1 :\n            0 ),\n      );\n\n      this.logger?.trace(`SampleSet.calcFromSortedValues: sortedValues: ${sortedValues.map((value) => this.dictionary[value])}`);\n    }\n\n\n    // get the median\n    const midPointIndex = Math.trunc((this.values.length-1)/2);\n    this.median = sortedValues[midPointIndex];\n    this.logger?.trace(`SampleSet.calcFromSortedValues: midPointIndex: ${midPointIndex}`);\n\n    // get the min and max values\n    this.min = sortedValues[0];\n    this.max = sortedValues[sortedValues.length-1];\n\n    // get the percentile25 and percentile50 values\n    let percentileIndex = Math.trunc((this.values.length-1)/4);\n    this.percentile25 = sortedValues[percentileIndex];\n    percentileIndex = Math.trunc((this.values.length-1)*(3/4));\n    this.percentile75 = sortedValues[percentileIndex];\n\n    // create the distribution histogram/table\n    this.distribution = [];\n    if ( this.valuesNumeric ) {\n      // in this case, create buckets of equal size which span the range [min, max)\n      // and count the number of values in each range\n\n      // Use the sqrt(numSamples) rule of thumb for calculating the number of buckets\n      const numBuckets: number = Math.trunc(Math.sqrt(this.values.length)+1);\n      const bucketSize: number = (this.max-this.min)/numBuckets;\n\n      let currentMin: number = sortedValues[0];\n      let currentMax: number = currentMin + bucketSize;\n      if (currentMax === this.max) {\n        // VERY unlikely - but just in case, add a very small amount so as not to have a\n        // bucket of one with only the max value at the end.\n        currentMax += 1e-10;\n      }\n      let count: number = 0;\n\n      for (let i=0; i<sortedValues.length; i++) {\n        if (sortedValues[i] >= currentMin && sortedValues[i] < currentMax) {\n          count++;\n        } else {\n          this.distribution.push(new SampleBucket(currentMin, currentMax, count));\n          currentMin += bucketSize;\n          currentMax = currentMin+bucketSize;\n          if (currentMax === this.max) {\n            // VERY unlikely - but just in case, add a very small amount so as not to have a\n            // bucket of one with only the max value at the end.\n            currentMax += 1e-10;\n          }\n          count = 1;\n        }\n\n      }\n      this.distribution.push(new SampleBucket(currentMin, currentMax, count));\n\n      // numBuckets and distribution.length should match\n      this.logger?.trace(`SampleSet.calcFromSortedValues: numeric data, numBuckets: ${numBuckets}, distribution.length: ${this.distribution.length}`);\n    } else {\n      // in this case, the number of buckets matches the number of strings in the SampleSet\n      // which is the size of the dictionary\n\n      let currentValue: number = sortedValues[0];\n      let count: number = 0;\n\n      for (let i=0; i<sortedValues.length; i++) {\n        if (sortedValues[i] === currentValue) {\n          count++;\n        } else {\n          this.distribution.push(new SampleBucket(currentValue, currentValue, count));\n          currentValue = sortedValues[i];\n          count = 1;\n        }\n\n      }\n      this.distribution.push(new SampleBucket(currentValue, currentValue, count));\n\n      // dictionary.length and distribution.length should match\n      this.logger?.trace(`SampleSet.calcFromSortedValues: string data, dictionary.length: ${this.dictionary.length}, distribution.length: ${this.distribution.length}`);\n      this.logger?.trace(`SampleSet.calcFromSortedValues: dictionary: ${this.dictionary}`);\n    }\n\n    this.logger?.trace(`SampleSet.calcFromSortedValues: numeric: ${this.valuesNumeric}, distribution details: ${JSON.stringify(this.distribution, null, 2)}`);\n\n    // calculate the mode\n    const maxDistributionBucketIndex = this.distribution.reduce(\n      (curMaxIndex, bucket, index) => bucket.count > this.distribution[curMaxIndex].count ? index : curMaxIndex,\n      0,\n    );\n    if ( this.valuesNumeric ) {\n      this.mode = this.distribution[maxDistributionBucketIndex].min +\n        (this.distribution[maxDistributionBucketIndex].max - this.distribution[maxDistributionBucketIndex].min)/2;\n    } else {\n      this.mode = this.distribution[maxDistributionBucketIndex].min;\n    }\n\n    this.logger?.trace(`SampleSet.calcFromSortedValues: mode: ${this.mode}`);\n\n  }\n\n}\n"]}

package/lib/components/uniform-sample-set.d.ts

@@ -0,0 +1,35 @@
+import { ILogger } from '@ncfour-us/logging';
+import { SampleSet } from './sample-set.js';
+/**
+ * The options for instantiating a Uniform distribution SampleSet.
+ */
+export interface UniformSampleSetOptions {
+    /**
+     * number of smaples to generate, default 1000
+     */
+    numSamples?: number;
+    /**
+     * optional minimum value, default 0
+     */
+    min?: number;
+    /**
+     * optional maximum value, default 1
+     */
+    max?: number;
+    /**
+     * optional logger to use.
+     */
+    logger?: ILogger;
+}
+/**
+ * Class to create a Uniform distribution SampleSet
+ * with values in the range [0,1).
+ */
+export declare class UniformSampleSet extends SampleSet {
+    /**
+     * Create a new UniformSampleSet instance.
+     *
+     * @param options See {@link UniformSampleSetOptions}
+     */
+    constructor(options: UniformSampleSetOptions);
+}

package/lib/components/uniform-sample-set.js

@@ -0,0 +1,27 @@
+// Copyright (c) 2026 Tim Hahn
+import { SampleSet } from './sample-set.js';
+;
+/**
+ * Class to create a Uniform distribution SampleSet
+ * with values in the range [0,1).
+ */
+export class UniformSampleSet extends SampleSet {
+    /**
+     * Create a new UniformSampleSet instance.
+     *
+     * @param options See {@link UniformSampleSetOptions}
+     */
+    constructor(options) {
+        super({
+            logger: options.logger,
+        });
+        this.addValues(Array.from({ length: options.numSamples ?? 1000 }, (_element, _index) => {
+            const min = options.min ?? 0;
+            const max = options.max ?? 1;
+            const newVal = min + (max - min) * Math.random();
+            return newVal;
+        }));
+        this.logger?.trace(`UniformSampleSet.constructor: numSamples: ${this.getNumSamples()}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+import { NormalSampleSet, NormalSampleSetOptions } from './components/normal-sample-set.js';
+import { SampleBucket, SampleSet, SampleSetValue, SampleSetPercentiles, SampleSetOptions } from './components/sample-set.js';
+import { UniformSampleSet, UniformSampleSetOptions } from './components/uniform-sample-set.js';
+export type { SampleSetValue, SampleSetOptions, SampleSetPercentiles, UniformSampleSetOptions, NormalSampleSetOptions };
+export { SampleBucket, SampleSet, UniformSampleSet, NormalSampleSet };

package/lib/index.js

@@ -0,0 +1,6 @@
+// Copyright (c) 2026 Tim Hahn
+import { NormalSampleSet } from './components/normal-sample-set.js';
+import { SampleBucket, SampleSet } from './components/sample-set.js';
+import { UniformSampleSet } from './components/uniform-sample-set.js';
+export { SampleBucket, SampleSet, UniformSampleSet, NormalSampleSet };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsOEJBQThCO0FBRTlCLE9BQU8sRUFBRSxlQUFlLEVBQTBCLE1BQU0sbUNBQW1DLENBQUM7QUFDNUYsT0FBTyxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQTBELE1BQU0sNEJBQTRCLENBQUM7QUFDN0gsT0FBTyxFQUFFLGdCQUFnQixFQUEyQixNQUFNLG9DQUFvQyxDQUFDO0FBSS9GLE9BQU8sRUFBRSxZQUFZLEVBQUUsU0FBUyxFQUFFLGdCQUFnQixFQUFFLGVBQWUsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChjKSAyMDI2IFRpbSBIYWhuXG5cbmltcG9ydCB7IE5vcm1hbFNhbXBsZVNldCwgTm9ybWFsU2FtcGxlU2V0T3B0aW9ucyB9IGZyb20gJy4vY29tcG9uZW50cy9ub3JtYWwtc2FtcGxlLXNldC5qcyc7XG5pbXBvcnQgeyBTYW1wbGVCdWNrZXQsIFNhbXBsZVNldCwgU2FtcGxlU2V0VmFsdWUsIFNhbXBsZVNldFBlcmNlbnRpbGVzLCBTYW1wbGVTZXRPcHRpb25zIH0gZnJvbSAnLi9jb21wb25lbnRzL3NhbXBsZS1zZXQuanMnO1xuaW1wb3J0IHsgVW5pZm9ybVNhbXBsZVNldCwgVW5pZm9ybVNhbXBsZVNldE9wdGlvbnMgfSBmcm9tICcuL2NvbXBvbmVudHMvdW5pZm9ybS1zYW1wbGUtc2V0LmpzJztcblxuZXhwb3J0IHR5cGUgeyBTYW1wbGVTZXRWYWx1ZSwgU2FtcGxlU2V0T3B0aW9ucywgU2FtcGxlU2V0UGVyY2VudGlsZXMsIFVuaWZvcm1TYW1wbGVTZXRPcHRpb25zLCBOb3JtYWxTYW1wbGVTZXRPcHRpb25zIH07XG5cbmV4cG9ydCB7IFNhbXBsZUJ1Y2tldCwgU2FtcGxlU2V0LCBVbmlmb3JtU2FtcGxlU2V0LCBOb3JtYWxTYW1wbGVTZXQgfTtcbiJdfQ==

package/package.json

@@ -0,0 +1,139 @@
+{
+  "name": "@ncfour-us/stats",
+  "description": "A set of basic statistics classes and utility functions",
+  "author": {
+    "name": "Tim Hahn",
+    "email": "hahntj@gmail.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@eslint/compat": "^2.1.1",
+    "@eslint/eslintrc": "^3.3.7",
+    "@eslint/js": "^9.39.5",
+    "@jest/globals": "^30.5.1",
+    "@ncfour-us/projen-utils": "^0.3.5",
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "commit-and-tag-version": "^12",
+    "constructs": "^10.0.0",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import": "^2.32.0",
+    "globals": "^14.0.0",
+    "jest": "^30.5.1",
+    "jest-junit": "^17",
+    "jiti": "^2.7.0",
+    "prettier": "^3.9.6",
+    "projen": "^0.103.23",
+    "ts-jest": "^29.4.12",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.23.13",
+    "typedoc": "^0.28.20",
+    "typedoc-plugin-markdown": "^4.13.0",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "@ncfour-us/logging": "^0.1.0"
+  },
+  "engines": {
+    "node": ">= 24.0.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": ">=10",
+      "onFail": "ignore"
+    }
+  },
+  "main": "lib/index.js",
+  "license": "MIT",
+  "version": "0.0.0",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.(mt|t|cj|j)s$": [
+        "ts-jest",
+        {
+          "useESM": true,
+          "tsconfig": "test/tsconfig.json"
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    }
+  },
+  "types": "lib/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"pnpm exec projen\".",
+  "scripts": {
+    "build": "projen build",
+    "build:tag": "projen build:tag",
+    "build:tag:env": "projen build:tag:env",
+    "bump": "projen bump",
+    "bump:releasable-commits": "projen bump:releasable-commits",
+    "clobber": "projen clobber",
+    "compile": "projen compile",
+    "compile:examples": "projen compile:examples",
+    "default": "projen default",
+    "eject": "projen eject",
+    "eslint": "projen eslint",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "post-upgrade": "projen post-upgrade",
+    "pre-compile": "projen pre-compile",
+    "publish:git": "projen publish:git",
+    "publish:local": "projen publish:local",
+    "release": "projen release",
+    "test": "projen test",
+    "test:watch": "projen test:watch",
+    "unbump": "projen unbump",
+    "upgrade": "projen upgrade",
+    "watch": "projen watch",
+    "projen": "projen",
+    "build:docs": "pnpm typedoc"
+  }
+}