@yipe/dice 0.5.0 → 0.6.0

package/dist/{pmf-D5VRghZI.d.cts → pmf/query.d.ts}

@@ -1,85 +1,5 @@
-/**
- * Simple LRU cache implementation
- */
-declare class LRUCache<K, V> {
-    private readonly maxSize;
-    private cache;
-    constructor(maxSize?: number);
-    get(key: K): V | undefined;
-    delete(key: K): void;
-    set(key: K, value: V): this;
-    clear(): void;
-    get size(): number;
-    has(key: K): boolean;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-}
-
-/** Mapping from outcome label to probability mass or damage attribution. */
-type OutcomeLabelMap = Partial<Record<string, number>>;
-/** Computational epsilon for pruning negligible probabilities. */
-declare const EPS = 1e-12;
-/** A probability bin for a specific damage value. */
-interface Bin {
-    /** Total probability mass at this damage value. */
-    p: number;
-    /** Per-outcome probability mass contributions at this damage. */
-    count: OutcomeLabelMap;
-    /** Optional per-outcome damage attribution at this damage. */
-    attr?: OutcomeLabelMap;
-}
-interface CritConfig {
-    critThreshold: number;
-}
-/** Simple mapping from damage value to probability. */
-type DamageDistribution = Record<number, number>;
-/** Canonical outcome labels supported by the query helpers. */
-type OutcomeType = "crit" | "hit" | "missNone" | "missDamage" | "saveHalf" | "saveFail" | "pc";
-type Rounding = "none" | "floor" | "round" | "ceil";
-/** How a d20 attack roll resolves: single die, keep-highest of 2/3, or keep-lowest of 2. */
-type RollType = "flat" | "advantage" | "disadvantage" | "elven accuracy";
-/**
- * P(critical hit) for the given crit window and d20 {@link RollType}.
- *
- * `critRange` is the number of top faces that crit (1 for a natural 20, 2 for
- * 19–20, …), so a single die crits with probability `critRange / 20`. Advantage
- * rolls two d20s / elven accuracy three, keeping the best; disadvantage keeps
- * the worst of two.
- */
-declare function critProbability(critRange: number, rollType?: RollType): number;
-/**
- * The canonical "clean miss" outcome — a point of zero damage with no rider.
- * This is the {@link OutcomeType} that attribution charts and outcome stats key
- * on, and is distinct from the builder's attack-resolution `miss` weight label.
- */
-declare const MISS_NONE_OUTCOME: OutcomeType;
-/**
- * All outcome types in canonical severity order — clean miss → crit. This is
- * also the natural stacking order for attribution charts (least- to
- * most-impactful, bottom → top). Enumerates every {@link OutcomeType} exactly
- * once; use it instead of hand-maintained per-consumer outcome tables.
- */
-declare const ALL_OUTCOME_TYPES: OutcomeType[];
-/**
- * Outcome types in display order for stats / breakdown rows — most prominent
- * first (crit, hit, …) down to the clean miss.
- */
-declare const OUTCOME_DISPLAY_ORDER: OutcomeType[];
-/**
- * Sort outcome labels by a canonical order (defaults to {@link ALL_OUTCOME_TYPES}).
- * Labels not present in `order` sort after known ones, alphabetically — so
- * ad-hoc/test labels outside the {@link OutcomeType} union stay stable.
- */
-declare function sortOutcomes<T extends string>(outcomes: Iterable<T>, order?: readonly string[]): T[];
-declare const onAnyHit: OutcomeType[];
-declare const onCritOnly: OutcomeType[];
-declare const onHitOnly: OutcomeType[];
-declare const onMissOnly: OutcomeType[];
-declare const onMissDamageOnly: OutcomeType[];
-declare const onSaveHalfOnly: OutcomeType[];
-declare const onSaveFailOnly: OutcomeType[];
-declare const onPotentCantripOnly: OutcomeType[];
-
+import type { OutcomeType } from "../common/types.js";
+import { PMF } from "./pmf.js";
 /**
  * Query interface for analyzing dice roll probability distributions.
  *
@@ -90,7 +10,7 @@ declare const onPotentCantripOnly: OutcomeType[];
  * - Data export (charts, tables, visualizations)
  *
  */
-declare class DiceQuery {
+export declare class DiceQuery {
     readonly singles: PMF[];
     private readonly _eps;
     private readonly _combinedProvided;
@@ -729,7 +649,7 @@ declare class DiceQuery {
      */
     firstSuccessSplit(successOutcome: OutcomeType | OutcomeType[], subsetOutcome: OutcomeType | OutcomeType[], eps?: number): readonly [pSuccess: number, pSubset: number, pAny: number, pNone: number];
 }
-type OutcomeSnapshot = {
+export type OutcomeSnapshot = {
     atLeastOneProbability: number;
     allProbability: number;
     damageRange: {
@@ -738,7 +658,7 @@ type OutcomeSnapshot = {
         max: number;
     };
 };
-type Snapshot = {
+export type Snapshot = {
     averageDPR: number;
     damageChance: number;
     percentiles: {
@@ -748,382 +668,4 @@ type Snapshot = {
     };
     outcomes: Map<OutcomeType, OutcomeSnapshot>;
 };
-
-declare const pmfCache: LRUCache<string, PMF>;
-/**
- * Probability Mass Function for discrete damage distributions.
- */
-declare class PMF {
-    readonly map: Map<number, Bin>;
-    readonly epsilon: number;
-    readonly normalized: boolean;
-    readonly identifier: string;
-    private _preservedProvenance;
-    private static __anonIdCounter;
-    private _support?;
-    private _min?;
-    private _max?;
-    private _totalMass?;
-    private _mean?;
-    private _variance?;
-    private _stdev?;
-    private _fingerprint?;
-    constructor(map?: Map<number, Bin>, epsilon?: number, normalized?: boolean, identifier?: string, _preservedProvenance?: boolean);
-    static empty(epsilon?: number, identifier?: string): PMF;
-    static zero(epsilon?: number): PMF;
-    static delta(value: number, epsilon?: number): PMF;
-    /**
-     * Point mass at damage 0 tagged with the canonical `missNone` outcome.
-     *
-     * Differs from {@link PMF.zero}, which labels its zero bin `miss` — the
-     * builder's attack-resolution vocabulary. This uses the `missNone`
-     * {@link OutcomeType} that the attribution charts and outcome stats key on,
-     * so it is the correct "clean miss / no damage" delta for provenance-aware
-     * mixtures feeding those consumers.
-     */
-    static missNone(epsilon?: number): PMF;
-    static emptyMass(): PMF;
-    [Symbol.iterator](): IterableIterator<[number, Bin]>;
-    static clearCache(): void;
-    /**
-     * Creates a conditional PMF from two branches (success and failure) and a probability.
-     * This is the core logic for modeling any probabilistic event where there are two
-     * distinct outcomes.
-     */
-    static branch(successPMF: PMF, failurePMF: PMF, successProbability: number): PMF;
-    /**
-     * withProbability()
-     *
-     * A convenience wrapper around branch() for the common case where the "failure" branch is always zero().
-     *
-     *  Think of this as a shortcut for:
-     *    pmf.gate(p, PMF.zero())
-     *
-     * Use this to model a *single* Bernoulli event — an outcome that either happens or doesn't,
-     * like an opportunity attack that occurs with probability p, or a single attack that either hits or misses.
-     *
-     * This is **not** for combining multiple independent attacks or mutually exclusive multi-outcome scenarios.
-     * - For multiple independent swings, use DiceQuery with separate PMFs for each attack.
-     * - For modeling "first success" logic across multiple attacks (like Sneak Attack or Smite)
-     *   use query.firstSuccessSplit() to get the exact probabilities.
-     * - For scenarios with several mutually exclusive outcomes (like crit vs hit vs none), use PMF.exclusive().
-     *
-     */
-    static withProbability(successPMF: PMF, probability: number): PMF;
-    /**
-     * gate()
-     *
-     * A conditional wrapper around branch() that applies this PMF with probability `p`,
-     * and applies a provided fallback PMF otherwise.
-     *
-     * This is useful for modeling a binary choice between two outcomes:
-     * - The "success" outcome (this PMF) happens with probability `p`.
-     * - The "failure" outcome (fallback PMF) happens with probability `1 - p`.
-     *
-     * Examples:
-     * - 25% chance to include an opportunity attack, otherwise nothing:
-     *     attackPMF.gate(0.25, PMF.zero())
-     *
-     * - 50% chance to deal fireball damage, otherwise cone of cold damage:
-     *     fireballPMF.gate(0.5, coneOfColdPMF)
-     *
-     * Relationship to other helpers:
-     * - **withProbability()** is a shortcut for the common case where the fallback is `PMF.zero()`.
-     * - **exclusive()** is for three or more mutually exclusive outcomes (e.g., crit vs hit vs none).
-     *
-     * @param p Probability of applying this PMF (between 0 and 1).
-     * @param fallback PMF to apply when this PMF is *not* selected.
-     * @returns A new PMF representing the weighted mixture of this PMF and the fallback.
-     */
-    gate(p: number, fallback: PMF): PMF;
-    /**
-     * PMF.exclusive()
-     *
-     * Builds a single PMF from a set of mutually exclusive weighted outcomes.
-     * Exactly one of the provided options will occur.
-     *
-     * Each option has:
-     *  - A PMF representing its outcome (e.g., damage dice).
-     *  - A weight representing its probability of being selected.
-     *
-     * Notes:
-     *  - If total weight < 1 (within eps), leftover mass is assumed to be PMF.zero()
-     *
-     * @param options Array of `{ pmf, weight }` or `[PMF, number]`.
-     * @param eps Optional tolerance for floating point rounding.
-     */
-    static exclusive(options: Array<{
-        pmf: PMF;
-        weight: number;
-    } | [PMF, number]>, eps?: number): PMF;
-    /**
-     * PMF.mix()
-     *
-     * Builds a PMF as a linear combination of input PMFs with the given weights.
-     * Unlike `exclusive`, this does NOT:
-     *  - enforce that weights sum to 1
-     *  - add leftover probability to δ0 (PMF.zero())
-     *
-     * Use when outcomes are not mutually exclusive, or for interpolation/blending.
-     *
-     * @param options Array of `{ pmf, weight }` or `[PMF, number]`.
-     * @param eps Optional tolerance for skipping tiny weights.
-     */
-    static mix(options: Array<{
-        pmf: PMF;
-        weight: number;
-    } | [PMF, number]>, eps?: number): PMF;
-    /**
-     * Adds damage attribution metadata to this PMF based on existing count metadata.
-     * For each bin, sets attr[outcome] = damage × count[outcome].
-     *
-     * This enables damage attribution charts to work with builder-generated PMFs.
-     * The parser generates attr automatically, but builder PMFs only have count.
-     *
-     * @returns New PMF with attr field populated in each bin
-     */
-    /**
-     * Returns true if this PMF already carries damage attribution metadata.
-     *
-     * Only the first positive-damage bin is inspected (parser-generated PMFs
-     * populate `attr` uniformly), so this is O(1) in practice.
-     */
-    hasAttribution(): boolean;
-    withAttribution(): PMF;
-    /**
-     * General-purpose N-way mixture.
-     * weights: Array of [weight, PMF].
-     *
-     * Example: PMF.mixN([
-     *   [pMiss, zero],
-     *   [pHit, hitPMF],
-     *   [pCrit, critPMF],
-     * ]);
-     */
-    static mixN(weights: [number, PMF][], eps?: number): PMF;
-    private setPreservedProvenance;
-    preservedProvenance(): boolean;
-    private getPowerCacheKey;
-    /**
-     * Efficiently computes this PMF convolved with itself `n` times.
-     * Uses exponentiation by squaring to reduce total convolutions.
-     * n must be a positive integer.
-     * *
-     * * NOTE: This folds multiple independent attacks into a single PMF.
-     * As a result, The power() method causes a loss of data provenance.
-     * This is ONLY SAFE if you are trying to calculate masses.
-     * If you want to query any atLeast probabilities, you should use the DiceQuery class instead without power().
-     */
-    power(n: number, eps?: number): PMF;
-    replicate(n: number): PMF[];
-    mass(): number;
-    outcomeMass(outcome: string): number;
-    faceTotal(): number;
-    normalize(): PMF;
-    /**
-     * Returns a copy with negligible probabilities removed (p < eps).
-     * If keepFinalBin is true, the bin with the largest key is always kept,
-     * even if its probability is below eps. count/attr submaps are still cleaned.
-     */
-    compact(eps?: number, keepFinalBin?: boolean): PMF;
-    support(): number[];
-    min(): number;
-    max(): number;
-    /**
-     * Returns the expected (mean) damage value.
-     * Cached for performance since this requires iterating through all bins.
-     */
-    mean(): number;
-    /**
-     * Returns the variance of the damage distribution.
-     * Cached for performance since this requires mean calculation plus iteration.
-     */
-    variance(): number;
-    /**
-     * Returns the standard deviation of the damage distribution.
-     */
-    stdev(): number;
-    /** Deep-copies a Bin, cloning its count and (optional) attr maps. */
-    private static cloneBin;
-    /** Returns a new Bin with p, count, and attr all multiplied by `factor`. */
-    private static scaleBin;
-    private static mergeInto;
-    add(other: PMF): PMF;
-    /**
-     * Returns a new PMF with a scaled branch added to this one.
-     * The branch PMF is scaled by the given probability before merging
-     * This will be very useful for conditional effects and for being
-     * able to model "I can probably have this opportunity attack 40% of rounds"
-     * Example: `pmf.addScaled(critBranch, 0.05)` → PMF including 5% crit outcomes
-     */
-    addScaled(branch: PMF, probability: number): PMF;
-    /**
-     * Redistributes probability mass to model an effect that only occurs with
-     * probability `frequency` — a conditional attack, an on-hit rider, or a
-     * sub-one AoE target fraction.
-     *
-     * Every hit outcome (damage > 0) is scaled by `frequency` — probability mass,
-     * per-label `count`, AND per-label `attr` — and the freed mass is moved into
-     * the miss bin at damage 0, tagged with the canonical `missNone` outcome.
-     * Total probability mass is preserved.
-     *
-     * Unlike a bare {@link scaleMass} or {@link mapDamage}, this keeps damage
-     * attribution (`attr`) intact, so a frequency-scaled PMF still renders
-     * correctly in the damage-attribution charts.
-     *
-     * `frequency >= 1` (or non-finite) returns this PMF unchanged; `frequency <= 0`
-     * collapses all mass into the miss bin. The miss outcome is assumed to be
-     * encoded at damage value 0.
-     *
-     * @param frequency Probability in [0, 1] that the effect occurs.
-     */
-    applyHitFrequency(frequency: number): PMF;
-    scaleMass(factor: number): PMF;
-    mapDamage(damageTransformFunction: (damageValue: number) => number): PMF;
-    scaleDamage(factor: number, rounding?: "floor" | "round" | "ceil"): PMF;
-    private getPMFCombineCacheKey;
-    /**
-     * A small content fingerprint (mass + bin count + face sum) so convolution
-     * cache keys change if the underlying numbers do. Memoized because a PMF is
-     * immutable once constructed — this avoids re-summing every key on each
-     * convolve() call (including cache hits).
-     */
-    fingerprint(): string;
-    convolve(other: PMF, eps?: number, raw?: boolean): PMF;
-    combineRaw(other: PMF, eps?: number): PMF;
-    private static reduceConvolveLeft;
-    /**
-     * Convolves multiple PMFs using linear convolution with automatic caching.
-     * Uses a left-to-right accumulation approach for maximum cache reuse.
-     * Each convolve() call automatically uses the convolution cache for performance.
-     *
-     * This linear approach provides better cache hits than pairwise because:
-     * - Intermediate results are more predictable and stable
-     * - Similar PMF lists share common prefixes (A+B, (A+B)+C, etc.)
-     * - Order-independent cache keys work better with consistent build patterns
-     */
-    static convolveMany(pmfList: PMF[], eps?: number): PMF;
-    /**
-     * Returns a plain, JSON-serializable representation of this PMF.
-     *
-     * Follows the standard `toJSON` contract, so `JSON.stringify(pmf)` produces
-     * the expected output (no double-encoding). Use {@link PMF.fromJSON} to
-     * reconstruct, or {@link PMF.toJSONString} if you need the string directly.
-     */
-    toJSON(): {
-        bins: Array<[number, Bin]>;
-        normalized: boolean;
-        identifier: string;
-    };
-    /** Serializes this PMF to a JSON string (equivalent to `JSON.stringify(pmf)`). */
-    toJSONString(): string;
-    static fromJSON(jsonData: {
-        bins: Array<[number, Bin]>;
-        normalized?: boolean;
-        identifier?: string;
-    }): PMF;
-    /**
-     * Relative pruning with optional top-K floor.
-     * Keeps bins with p >= epsRel * peak, always keeps min and max damage,
-     * optionally guarantees at least `minBins` survivors by adding top-K.
-     * Returns a new, non-normalized PMF.
-     */
-    prune(epsRel: number, minBins?: number): PMF;
-    /** Probability mass at exactly x. */
-    pAt(x: number): number;
-    /**
-     * P(any damage) — the mass on all non-zero outcomes, i.e. `1 - P(0)`.
-     * Assumes a miss is encoded as the damage-0 bin (the convention used across
-     * attack/save PMFs). The dual of {@link missProbability}.
-     */
-    hitProbability(): number;
-    /** P(no damage) — the mass at damage 0. The dual of {@link hitProbability}. */
-    missProbability(): number;
-    /**
-     * Coarsen the distribution into at most `maxBuckets` contiguous, equal-width
-     * damage buckets, aggregating probability mass (and `count`/`attr`
-     * provenance) into each bucket's start value. Returns this PMF unchanged when
-     * its integer support already fits within `maxBuckets`.
-     *
-     * This is a lossy display/downsampling transform (bucket start replaces the
-     * exact damage value) — use it for charting wide distributions, not for DPR
-     * math.
-     */
-    rebin(maxBuckets: number): PMF;
-    /** Dense integer support from min..max (inclusive).
-     * Useful for showing empty bars in charts.
-     */
-    denseSupport(): number[];
-    /** CDF at x: P(X ≤ x). */
-    cdfAt(x: number): number;
-    /** Quantile / inverse CDF for p in [0,1]. Returns smallest x with CDF ≥ p. */
-    quantile(p: number): number;
-    /** Get outcome probability at specific damage value. */
-    outcomeAt(damage: number, outcome: string): number;
-    /** Get all outcome types present in this PMF. */
-    outcomes(): string[];
-    /** Get total probability of an outcome across all damage values. */
-    outcomeProbability(outcome: string): number;
-    /** Get damage attribution for an outcome at specific damage value. */
-    outcomeAttributionAt(damage: number, outcome: string): number;
-    /** Get all outcome data at specific damage value. */
-    binAt(damage: number): {
-        p: number;
-        count: Record<string, number>;
-        attr?: Record<string, number>;
-    } | null;
-    /** Check if outcome exists in this PMF. */
-    hasOutcome(outcome: string): boolean;
-    /**
-     * Split each damage value's probability mass across outcome labels, returning
-     * per-label maps of `damage value → probability mass attributable to that
-     * label`. Summing over labels at a given value recovers that value's `p`.
-     *
-     * Damage-bearing bins are split by `attr` weight (the share of damage each
-     * outcome contributed); the clean-miss bin at 0 is split by `count` weight
-     * (there is no damage to attribute). Attribution is computed on demand via
-     * {@link withAttribution} when absent, so builder-generated PMFs work too.
-     *
-     * This is the provenance core of the stacked damage-attribution chart — the
-     * caller only maps these series into its rendering format (colors, binning,
-     * axis labels).
-     */
-    attributionByValue(): Map<string, Map<number, number>>;
-    tailProbGE(t: number): number;
-    tailProbGT(t: number): number;
-    /**
-     * Returns a new PMF containing only bins where the specified outcome has non-zero probability.
-     * This creates a marginal distribution for the given outcome type, with probabilities
-     * scaled to represent the unconditional mass attributable to that outcome.
-     */
-    filterOutcome(outcome: string): PMF;
-    /**
-     * Calculates probabilities for first-success outcomes across n independent attempts.
-     *
-     * @param pSuccess - Total probability of any success on a single attempt.
-     * @param pSpecial - Probability of a specific subset of successes (e.g., critical success).
-     * @param n - Number of independent attempts.
-     *
-     * Returns:
-     *  - pSpecificSuccess: Probability that the first success was of the "special" type
-     *  - pGeneralSuccess: Probability that the first success was of the non-special type
-     *  - pNone: Probability that no successes occurred
-     *  - pAny: Probability that at least one success occurred
-     */
-    static firstSuccessWeights(pSuccess: number, pSpecial: number, n: number): {
-        pSpecificSuccess: number;
-        pGeneralSuccess: number;
-        pNone: number;
-        pAny: number;
-    };
-    mapValues(f: (v: number) => number, eps?: number, opts?: {
-        rounding?: Rounding;
-        preserveCounts?: boolean;
-    }): PMF;
-    static fromMap(m: Map<number, number>, eps?: number, { requireIntegerValues }?: {
-        requireIntegerValues?: boolean;
-    }): PMF;
-    query(): DiceQuery;
-}
-
-export { ALL_OUTCOME_TYPES as A, type Bin as B, type CritConfig as C, type DamageDistribution as D, EPS as E, LRUCache as L, MISS_NONE_OUTCOME as M, type OutcomeLabelMap as O, PMF as P, type Rounding as R, type Snapshot as S, type OutcomeType as a, type RollType as b, critProbability as c, OUTCOME_DISPLAY_ORDER as d, onCritOnly as e, onHitOnly as f, onMissOnly as g, onMissDamageOnly as h, onSaveHalfOnly as i, onSaveFailOnly as j, onPotentCantripOnly as k, DiceQuery as l, type OutcomeSnapshot as m, onAnyHit as o, pmfCache as p, sortOutcomes as s };
+//# sourceMappingURL=query.d.ts.map

package/dist/pmf/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/pmf/query.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yipe/dice",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "A high-performance dice probability engine for D&D 5e DPR calculations. Powers dprcalc.com.",
   "keywords": [
     "dnd",
@@ -21,7 +21,7 @@
   "license": "MIT",
   "author": "Michael Margolis <acct@yipe.org>",
   "type": "module",
-  "packageManager": "yarn@4.9.4",
+  "packageManager": "yarn@4.17.1",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -62,11 +62,11 @@
     "./dist/builder/dc.js"
   ],
   "scripts": {
-    "format": "eslint . --fix",
-    "lint": "eslint .",
+    "format": "node -r ./config/eslint-ts6-alias.cjs ./node_modules/eslint/bin/eslint.js . --fix",
+    "lint": "node -r ./config/eslint-ts6-alias.cjs ./node_modules/eslint/bin/eslint.js .",
     "typecheck": "tsc -p config/tsconfig.build.json --noEmit",
-    "build": "tsup --config config/tsup.config.ts",
-    "types": "tsc -p config/tsconfig.build.json --emitDeclarationOnly",
+    "build": "tsup --config config/tsup.config.ts && yarn types",
+    "types": "tsc -p config/tsconfig.build.json --emitDeclarationOnly && node config/postbuild-dts.mjs",
     "test": "vitest run",
     "test:watch": "vitest watch",
     "prepare": "yarn build",
@@ -80,14 +80,15 @@
     "node": ">=18.17"
   },
   "devDependencies": {
-    "@types/node": "^26.0.1",
-    "@typescript-eslint/eslint-plugin": "^8.62.0",
-    "@typescript-eslint/parser": "^8.62.0",
-    "@vitest/coverage-v8": "^4.1.9",
-    "eslint": "^10.6.0",
+    "@types/node": "^26.1.1",
+    "@typescript-eslint/eslint-plugin": "^8.64.0",
+    "@typescript-eslint/parser": "^8.64.0",
+    "@typescript/typescript6": "^6.0.2",
+    "@vitest/coverage-v8": "^4.1.10",
+    "eslint": "^10.7.0",
     "tsup": "^8.5.1",
-    "tsx": "^4.22.4",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.9"
+    "tsx": "^4.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   }
-}
+}

package/.claude/worktrees/amazing-matsumoto-27220c/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Michael Margolis
-
-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.