iso-price 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Uladzimir Kasacheuski
+
+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/dist/contract/index.d.ts

@@ -0,0 +1,25 @@
+export { IsoCurrency } from '../domain.objects/IsoCurrency';
+export type { IsoPrice } from '../domain.objects/IsoPrice';
+export { IsoPriceExponent } from '../domain.objects/IsoPriceExponent';
+export type { IsoPriceHuman } from '../domain.objects/IsoPriceHuman';
+export { IsoPriceRoundMode } from '../domain.objects/IsoPriceRoundMode';
+export type { IsoPriceShape } from '../domain.objects/IsoPriceShape';
+export type { IsoPriceWords } from '../domain.objects/IsoPriceWords';
+export { allocatePrice, priceAllocate, } from '../domain.operations/arithmetic/allocatePrice';
+export { dividePrice, priceDivide, } from '../domain.operations/arithmetic/dividePrice';
+export { multiplyPrice, priceMultiply, } from '../domain.operations/arithmetic/multiplyPrice';
+export { priceSub, subPrices, } from '../domain.operations/arithmetic/subPrices';
+export { addPrices, priceAdd, priceSum, sumPrices, } from '../domain.operations/arithmetic/sumPrices';
+export { asIsoPrice } from '../domain.operations/cast/asIsoPrice';
+export { asIsoPriceHuman } from '../domain.operations/cast/asIsoPriceHuman';
+export { asIsoPriceShape } from '../domain.operations/cast/asIsoPriceShape';
+export { asIsoPriceWords } from '../domain.operations/cast/asIsoPriceWords';
+export { isIsoPrice } from '../domain.operations/guard/isIsoPrice';
+export { isIsoPriceHuman } from '../domain.operations/guard/isIsoPriceHuman';
+export { isIsoPriceShape } from '../domain.operations/guard/isIsoPriceShape';
+export { isIsoPriceWords } from '../domain.operations/guard/isIsoPriceWords';
+export { getIsoPriceExponentByCurrency } from '../domain.operations/precision/getIsoPriceExponentByCurrency';
+export { roundPrice } from '../domain.operations/precision/roundPrice';
+export { setPricePrecision } from '../domain.operations/precision/setPricePrecision';
+export { calcPriceAvg } from '../domain.operations/statistics/calcPriceAvg';
+export { calcPriceStdev } from '../domain.operations/statistics/calcPriceStdev';

package/dist/contract/index.js

@@ -0,0 +1,60 @@
+"use strict";
+// iso-price public contract
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcPriceStdev = exports.calcPriceAvg = exports.setPricePrecision = exports.roundPrice = exports.getIsoPriceExponentByCurrency = exports.isIsoPriceWords = exports.isIsoPriceShape = exports.isIsoPriceHuman = exports.isIsoPrice = exports.asIsoPriceWords = exports.asIsoPriceShape = exports.asIsoPriceHuman = exports.asIsoPrice = exports.sumPrices = exports.priceSum = exports.priceAdd = exports.addPrices = exports.subPrices = exports.priceSub = exports.priceMultiply = exports.multiplyPrice = exports.priceDivide = exports.dividePrice = exports.priceAllocate = exports.allocatePrice = exports.IsoPriceRoundMode = exports.IsoPriceExponent = exports.IsoCurrency = void 0;
+var IsoCurrency_1 = require("../domain.objects/IsoCurrency");
+Object.defineProperty(exports, "IsoCurrency", { enumerable: true, get: function () { return IsoCurrency_1.IsoCurrency; } });
+// enums
+var IsoPriceExponent_1 = require("../domain.objects/IsoPriceExponent");
+Object.defineProperty(exports, "IsoPriceExponent", { enumerable: true, get: function () { return IsoPriceExponent_1.IsoPriceExponent; } });
+var IsoPriceRoundMode_1 = require("../domain.objects/IsoPriceRoundMode");
+Object.defineProperty(exports, "IsoPriceRoundMode", { enumerable: true, get: function () { return IsoPriceRoundMode_1.IsoPriceRoundMode; } });
+var allocatePrice_1 = require("../domain.operations/arithmetic/allocatePrice");
+Object.defineProperty(exports, "allocatePrice", { enumerable: true, get: function () { return allocatePrice_1.allocatePrice; } });
+Object.defineProperty(exports, "priceAllocate", { enumerable: true, get: function () { return allocatePrice_1.priceAllocate; } });
+var dividePrice_1 = require("../domain.operations/arithmetic/dividePrice");
+Object.defineProperty(exports, "dividePrice", { enumerable: true, get: function () { return dividePrice_1.dividePrice; } });
+Object.defineProperty(exports, "priceDivide", { enumerable: true, get: function () { return dividePrice_1.priceDivide; } });
+var multiplyPrice_1 = require("../domain.operations/arithmetic/multiplyPrice");
+Object.defineProperty(exports, "multiplyPrice", { enumerable: true, get: function () { return multiplyPrice_1.multiplyPrice; } });
+Object.defineProperty(exports, "priceMultiply", { enumerable: true, get: function () { return multiplyPrice_1.priceMultiply; } });
+var subPrices_1 = require("../domain.operations/arithmetic/subPrices");
+Object.defineProperty(exports, "priceSub", { enumerable: true, get: function () { return subPrices_1.priceSub; } });
+Object.defineProperty(exports, "subPrices", { enumerable: true, get: function () { return subPrices_1.subPrices; } });
+// arithmetic operations
+var sumPrices_1 = require("../domain.operations/arithmetic/sumPrices");
+Object.defineProperty(exports, "addPrices", { enumerable: true, get: function () { return sumPrices_1.addPrices; } });
+Object.defineProperty(exports, "priceAdd", { enumerable: true, get: function () { return sumPrices_1.priceAdd; } });
+Object.defineProperty(exports, "priceSum", { enumerable: true, get: function () { return sumPrices_1.priceSum; } });
+Object.defineProperty(exports, "sumPrices", { enumerable: true, get: function () { return sumPrices_1.sumPrices; } });
+// cast functions
+var asIsoPrice_1 = require("../domain.operations/cast/asIsoPrice");
+Object.defineProperty(exports, "asIsoPrice", { enumerable: true, get: function () { return asIsoPrice_1.asIsoPrice; } });
+var asIsoPriceHuman_1 = require("../domain.operations/cast/asIsoPriceHuman");
+Object.defineProperty(exports, "asIsoPriceHuman", { enumerable: true, get: function () { return asIsoPriceHuman_1.asIsoPriceHuman; } });
+var asIsoPriceShape_1 = require("../domain.operations/cast/asIsoPriceShape");
+Object.defineProperty(exports, "asIsoPriceShape", { enumerable: true, get: function () { return asIsoPriceShape_1.asIsoPriceShape; } });
+var asIsoPriceWords_1 = require("../domain.operations/cast/asIsoPriceWords");
+Object.defineProperty(exports, "asIsoPriceWords", { enumerable: true, get: function () { return asIsoPriceWords_1.asIsoPriceWords; } });
+var isIsoPrice_1 = require("../domain.operations/guard/isIsoPrice");
+Object.defineProperty(exports, "isIsoPrice", { enumerable: true, get: function () { return isIsoPrice_1.isIsoPrice; } });
+var isIsoPriceHuman_1 = require("../domain.operations/guard/isIsoPriceHuman");
+Object.defineProperty(exports, "isIsoPriceHuman", { enumerable: true, get: function () { return isIsoPriceHuman_1.isIsoPriceHuman; } });
+var isIsoPriceShape_1 = require("../domain.operations/guard/isIsoPriceShape");
+Object.defineProperty(exports, "isIsoPriceShape", { enumerable: true, get: function () { return isIsoPriceShape_1.isIsoPriceShape; } });
+// type guards
+var isIsoPriceWords_1 = require("../domain.operations/guard/isIsoPriceWords");
+Object.defineProperty(exports, "isIsoPriceWords", { enumerable: true, get: function () { return isIsoPriceWords_1.isIsoPriceWords; } });
+// precision operations
+var getIsoPriceExponentByCurrency_1 = require("../domain.operations/precision/getIsoPriceExponentByCurrency");
+Object.defineProperty(exports, "getIsoPriceExponentByCurrency", { enumerable: true, get: function () { return getIsoPriceExponentByCurrency_1.getIsoPriceExponentByCurrency; } });
+var roundPrice_1 = require("../domain.operations/precision/roundPrice");
+Object.defineProperty(exports, "roundPrice", { enumerable: true, get: function () { return roundPrice_1.roundPrice; } });
+var setPricePrecision_1 = require("../domain.operations/precision/setPricePrecision");
+Object.defineProperty(exports, "setPricePrecision", { enumerable: true, get: function () { return setPricePrecision_1.setPricePrecision; } });
+// statistics operations
+var calcPriceAvg_1 = require("../domain.operations/statistics/calcPriceAvg");
+Object.defineProperty(exports, "calcPriceAvg", { enumerable: true, get: function () { return calcPriceAvg_1.calcPriceAvg; } });
+var calcPriceStdev_1 = require("../domain.operations/statistics/calcPriceStdev");
+Object.defineProperty(exports, "calcPriceStdev", { enumerable: true, get: function () { return calcPriceStdev_1.calcPriceStdev; } });
+//# sourceMappingURL=index.js.map

package/dist/contract/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":";AAAA,4BAA4B;;;AAE5B,6DAA4D;AAAnD,0GAAA,WAAW,OAAA;AAEpB,QAAQ;AACR,uEAAsE;AAA7D,oHAAA,gBAAgB,OAAA;AAEzB,yEAAwE;AAA/D,sHAAA,iBAAiB,OAAA;AAI1B,+EAGuD;AAFrD,8GAAA,aAAa,OAAA;AACb,8GAAA,aAAa,OAAA;AAEf,2EAGqD;AAFnD,0GAAA,WAAW,OAAA;AACX,0GAAA,WAAW,OAAA;AAEb,+EAGuD;AAFrD,8GAAA,aAAa,OAAA;AACb,8GAAA,aAAa,OAAA;AAEf,uEAGmD;AAFjD,qGAAA,QAAQ,OAAA;AACR,sGAAA,SAAS,OAAA;AAEX,wBAAwB;AACxB,uEAKmD;AAJjD,sGAAA,SAAS,OAAA;AACT,qGAAA,QAAQ,OAAA;AACR,qGAAA,QAAQ,OAAA;AACR,sGAAA,SAAS,OAAA;AAEX,iBAAiB;AACjB,mEAAkE;AAAzD,wGAAA,UAAU,OAAA;AACnB,6EAA4E;AAAnE,kHAAA,eAAe,OAAA;AACxB,6EAA4E;AAAnE,kHAAA,eAAe,OAAA;AACxB,6EAA4E;AAAnE,kHAAA,eAAe,OAAA;AACxB,oEAAmE;AAA1D,wGAAA,UAAU,OAAA;AACnB,8EAA6E;AAApE,kHAAA,eAAe,OAAA;AACxB,8EAA6E;AAApE,kHAAA,eAAe,OAAA;AACxB,cAAc;AACd,8EAA6E;AAApE,kHAAA,eAAe,OAAA;AACxB,uBAAuB;AACvB,8GAA6G;AAApG,8IAAA,6BAA6B,OAAA;AACtC,wEAAuE;AAA9D,wGAAA,UAAU,OAAA;AACnB,sFAAqF;AAA5E,sHAAA,iBAAiB,OAAA;AAC1B,wBAAwB;AACxB,6EAA4E;AAAnE,4GAAA,YAAY,OAAA;AACrB,iFAAgF;AAAvE,gHAAA,cAAc,OAAA"}

package/dist/domain.objects/IsoCurrency.d.ts

@@ -0,0 +1,63 @@
+/**
+ * .what = enum of iso 4217 currency codes for type-safe price operations
+ * .why = provides compile-time safety for the most common currencies
+ *
+ * includes:
+ * - top 21 currencies by forex trade volume (~$7 trillion daily)
+ * - 4 currencies with 3-decimal exponent (BHD, KWD, OMR, TND)
+ *
+ * note: custom currencies (BTC, ETH, etc) are supported via string generics
+ * this enum is for convenience, not restriction
+ */
+export declare enum IsoCurrency {
+    /** US Dollar — ~90% of forex transactions */
+    USD = "USD",
+    /** Euro — 20 eurozone countries */
+    EUR = "EUR",
+    /** Japanese Yen — major reserve currency, 0-decimal */
+    JPY = "JPY",
+    /** British Pound — London as global finance hub */
+    GBP = "GBP",
+    /** Chinese Yuan — rapid growth in trade share */
+    CNY = "CNY",
+    /** Australian Dollar — commodity-linked */
+    AUD = "AUD",
+    /** Canadian Dollar — oil price correlation */
+    CAD = "CAD",
+    /** Swiss Franc — safe-haven currency */
+    CHF = "CHF",
+    /** Hong Kong Dollar — pegged to USD */
+    HKD = "HKD",
+    /** New Zealand Dollar — commodity-linked */
+    NZD = "NZD",
+    /** Swedish Krona — nordic economy */
+    SEK = "SEK",
+    /** South Korean Won — tech export economy, 0-decimal */
+    KRW = "KRW",
+    /** Singapore Dollar — asian finance hub */
+    SGD = "SGD",
+    /** Norwegian Krone — oil-linked */
+    NOK = "NOK",
+    /** Mexican Peso — growth market */
+    MXN = "MXN",
+    /** Indian Rupee — large population economy */
+    INR = "INR",
+    /** South African Rand — commodity-linked */
+    ZAR = "ZAR",
+    /** Brazilian Real — growth market */
+    BRL = "BRL",
+    /** Danish Krone — pegged to EUR */
+    DKK = "DKK",
+    /** Polish Zloty — EU non-eurozone */
+    PLN = "PLN",
+    /** Thai Baht — southeast asian economy */
+    THB = "THB",
+    /** Bahraini Dinar — 3-decimal, fils */
+    BHD = "BHD",
+    /** Kuwaiti Dinar — 3-decimal, fils */
+    KWD = "KWD",
+    /** Omani Rial — 3-decimal, baisa */
+    OMR = "OMR",
+    /** Tunisian Dinar — 3-decimal, millimes */
+    TND = "TND"
+}

package/dist/domain.objects/IsoCurrency.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsoCurrency = void 0;
+/**
+ * .what = enum of iso 4217 currency codes for type-safe price operations
+ * .why = provides compile-time safety for the most common currencies
+ *
+ * includes:
+ * - top 21 currencies by forex trade volume (~$7 trillion daily)
+ * - 4 currencies with 3-decimal exponent (BHD, KWD, OMR, TND)
+ *
+ * note: custom currencies (BTC, ETH, etc) are supported via string generics
+ * this enum is for convenience, not restriction
+ */
+var IsoCurrency;
+(function (IsoCurrency) {
+    // top 21 by forex trade volume
+    /** US Dollar — ~90% of forex transactions */
+    IsoCurrency["USD"] = "USD";
+    /** Euro — 20 eurozone countries */
+    IsoCurrency["EUR"] = "EUR";
+    /** Japanese Yen — major reserve currency, 0-decimal */
+    IsoCurrency["JPY"] = "JPY";
+    /** British Pound — London as global finance hub */
+    IsoCurrency["GBP"] = "GBP";
+    /** Chinese Yuan — rapid growth in trade share */
+    IsoCurrency["CNY"] = "CNY";
+    /** Australian Dollar — commodity-linked */
+    IsoCurrency["AUD"] = "AUD";
+    /** Canadian Dollar — oil price correlation */
+    IsoCurrency["CAD"] = "CAD";
+    /** Swiss Franc — safe-haven currency */
+    IsoCurrency["CHF"] = "CHF";
+    /** Hong Kong Dollar — pegged to USD */
+    IsoCurrency["HKD"] = "HKD";
+    /** New Zealand Dollar — commodity-linked */
+    IsoCurrency["NZD"] = "NZD";
+    /** Swedish Krona — nordic economy */
+    IsoCurrency["SEK"] = "SEK";
+    /** South Korean Won — tech export economy, 0-decimal */
+    IsoCurrency["KRW"] = "KRW";
+    /** Singapore Dollar — asian finance hub */
+    IsoCurrency["SGD"] = "SGD";
+    /** Norwegian Krone — oil-linked */
+    IsoCurrency["NOK"] = "NOK";
+    /** Mexican Peso — growth market */
+    IsoCurrency["MXN"] = "MXN";
+    /** Indian Rupee — large population economy */
+    IsoCurrency["INR"] = "INR";
+    /** South African Rand — commodity-linked */
+    IsoCurrency["ZAR"] = "ZAR";
+    /** Brazilian Real — growth market */
+    IsoCurrency["BRL"] = "BRL";
+    /** Danish Krone — pegged to EUR */
+    IsoCurrency["DKK"] = "DKK";
+    /** Polish Zloty — EU non-eurozone */
+    IsoCurrency["PLN"] = "PLN";
+    /** Thai Baht — southeast asian economy */
+    IsoCurrency["THB"] = "THB";
+    // 3-decimal exponent currencies (milli.x10^-3)
+    /** Bahraini Dinar — 3-decimal, fils */
+    IsoCurrency["BHD"] = "BHD";
+    /** Kuwaiti Dinar — 3-decimal, fils */
+    IsoCurrency["KWD"] = "KWD";
+    /** Omani Rial — 3-decimal, baisa */
+    IsoCurrency["OMR"] = "OMR";
+    /** Tunisian Dinar — 3-decimal, millimes */
+    IsoCurrency["TND"] = "TND";
+})(IsoCurrency || (exports.IsoCurrency = IsoCurrency = {}));
+//# sourceMappingURL=IsoCurrency.js.map

package/dist/domain.objects/IsoCurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsoCurrency.js","sourceRoot":"","sources":["../../src/domain.objects/IsoCurrency.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACH,IAAY,WAwDX;AAxDD,WAAY,WAAW;IACrB,+BAA+B;IAE/B,6CAA6C;IAC7C,0BAAW,CAAA;IACX,mCAAmC;IACnC,0BAAW,CAAA;IACX,uDAAuD;IACvD,0BAAW,CAAA;IACX,mDAAmD;IACnD,0BAAW,CAAA;IACX,iDAAiD;IACjD,0BAAW,CAAA;IACX,2CAA2C;IAC3C,0BAAW,CAAA;IACX,8CAA8C;IAC9C,0BAAW,CAAA;IACX,wCAAwC;IACxC,0BAAW,CAAA;IACX,uCAAuC;IACvC,0BAAW,CAAA;IACX,4CAA4C;IAC5C,0BAAW,CAAA;IACX,qCAAqC;IACrC,0BAAW,CAAA;IACX,wDAAwD;IACxD,0BAAW,CAAA;IACX,2CAA2C;IAC3C,0BAAW,CAAA;IACX,mCAAmC;IACnC,0BAAW,CAAA;IACX,mCAAmC;IACnC,0BAAW,CAAA;IACX,8CAA8C;IAC9C,0BAAW,CAAA;IACX,4CAA4C;IAC5C,0BAAW,CAAA;IACX,qCAAqC;IACrC,0BAAW,CAAA;IACX,mCAAmC;IACnC,0BAAW,CAAA;IACX,qCAAqC;IACrC,0BAAW,CAAA;IACX,0CAA0C;IAC1C,0BAAW,CAAA;IAEX,+CAA+C;IAE/C,uCAAuC;IACvC,0BAAW,CAAA;IACX,sCAAsC;IACtC,0BAAW,CAAA;IACX,oCAAoC;IACpC,0BAAW,CAAA;IACX,2CAA2C;IAC3C,0BAAW,CAAA;AACb,CAAC,EAxDW,WAAW,2BAAX,WAAW,QAwDtB"}

package/dist/domain.objects/IsoPrice.d.ts

@@ -0,0 +1,16 @@
+import type { IsoPriceExponent } from './IsoPriceExponent';
+import type { IsoPriceHuman } from './IsoPriceHuman';
+import type { IsoPriceShape } from './IsoPriceShape';
+import type { IsoPriceWords } from './IsoPriceWords';
+/**
+ * .what = union type that accepts any iso-price format
+ * .why = enables functions to accept prices in any format for convenience
+ *
+ * three formats:
+ * - `IsoPriceWords` — code-prefixed string: 'USD 50.37' (recommended for storage)
+ * - `IsoPriceShape` — structured object: { amount: 5037n, currency: 'USD' }
+ * - `IsoPriceHuman` — symbol-prefixed string: '$50.37' (for display and quick input)
+ *
+ * @template TCurrency - the currency code type (defaults to `string`)
+ */
+export type IsoPrice<TCurrency extends string = string> = IsoPriceWords<TCurrency> | IsoPriceShape<TCurrency, IsoPriceExponent | `${IsoPriceExponent}`> | IsoPriceHuman;

package/dist/domain.objects/IsoPrice.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IsoPrice.js.map

package/dist/domain.objects/IsoPrice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsoPrice.js","sourceRoot":"","sources":["../../src/domain.objects/IsoPrice.ts"],"names":[],"mappings":""}

package/dist/domain.objects/IsoPriceExponent.d.ts

@@ -0,0 +1,28 @@
+/**
+ * .what = enum of supported precision exponents for iso-price
+ * .why = explicit exponent declarations avoid conflation between iso 4217 and scientific notation
+ *
+ * the `.x10^-N` suffix makes the math unambiguous:
+ * - `'centi.x10^-2'` → `amount × 10^-2 = amount / 100`
+ *
+ * the si metric prefix provides human readability:
+ * - `centi` = hundredths (cents)
+ * - `milli` = thousandths (fils)
+ * - `micro` = millionths (llm token costs)
+ * - `nano` = billionths (serverless costs)
+ * - `pico` = trillionths (extreme precision)
+ */
+export declare enum IsoPriceExponent {
+    /** whole units — JPY, KRW, VND, etc */
+    WHOLE = "whole.x10^0",
+    /** standard cents — USD, EUR, GBP, most currencies */
+    CENTI = "centi.x10^-2",
+    /** thousandths — BHD, KWD, OMR, TND (fils/baisa) */
+    MILLI = "milli.x10^-3",
+    /** millionths — llm token costs, api rates */
+    MICRO = "micro.x10^-6",
+    /** billionths — serverless invocation costs */
+    NANO = "nano.x10^-9",
+    /** trillionths — extreme precision, requires bigint */
+    PICO = "pico.x10^-12"
+}

package/dist/domain.objects/IsoPriceExponent.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsoPriceExponent = void 0;
+/**
+ * .what = enum of supported precision exponents for iso-price
+ * .why = explicit exponent declarations avoid conflation between iso 4217 and scientific notation
+ *
+ * the `.x10^-N` suffix makes the math unambiguous:
+ * - `'centi.x10^-2'` → `amount × 10^-2 = amount / 100`
+ *
+ * the si metric prefix provides human readability:
+ * - `centi` = hundredths (cents)
+ * - `milli` = thousandths (fils)
+ * - `micro` = millionths (llm token costs)
+ * - `nano` = billionths (serverless costs)
+ * - `pico` = trillionths (extreme precision)
+ */
+var IsoPriceExponent;
+(function (IsoPriceExponent) {
+    /** whole units — JPY, KRW, VND, etc */
+    IsoPriceExponent["WHOLE"] = "whole.x10^0";
+    /** standard cents — USD, EUR, GBP, most currencies */
+    IsoPriceExponent["CENTI"] = "centi.x10^-2";
+    /** thousandths — BHD, KWD, OMR, TND (fils/baisa) */
+    IsoPriceExponent["MILLI"] = "milli.x10^-3";
+    /** millionths — llm token costs, api rates */
+    IsoPriceExponent["MICRO"] = "micro.x10^-6";
+    /** billionths — serverless invocation costs */
+    IsoPriceExponent["NANO"] = "nano.x10^-9";
+    /** trillionths — extreme precision, requires bigint */
+    IsoPriceExponent["PICO"] = "pico.x10^-12";
+})(IsoPriceExponent || (exports.IsoPriceExponent = IsoPriceExponent = {}));
+//# sourceMappingURL=IsoPriceExponent.js.map

package/dist/domain.objects/IsoPriceExponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsoPriceExponent.js","sourceRoot":"","sources":["../../src/domain.objects/IsoPriceExponent.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;GAaG;AACH,IAAY,gBAaX;AAbD,WAAY,gBAAgB;IAC1B,uCAAuC;IACvC,yCAAqB,CAAA;IACrB,sDAAsD;IACtD,0CAAsB,CAAA;IACtB,oDAAoD;IACpD,0CAAsB,CAAA;IACtB,8CAA8C;IAC9C,0CAAsB,CAAA;IACtB,+CAA+C;IAC/C,wCAAoB,CAAA;IACpB,uDAAuD;IACvD,yCAAqB,CAAA;AACvB,CAAC,EAbW,gBAAgB,gCAAhB,gBAAgB,QAa3B"}

package/dist/domain.objects/IsoPriceHuman.d.ts

@@ -0,0 +1,19 @@
+import type { AsOfGlossary } from 'domain-glossaries';
+/**
+ * .what = branded type for iso-price in human-readable format
+ * .why = ensures type safety for price strings with currency symbols like '$50.37'
+ *
+ * format: `{SYMBOL}{AMOUNT}` or `{AMOUNT} {SYMBOL}` (locale-dependent)
+ * - symbol: currency symbol (e.g., '$', '€', '¥', '£')
+ * - amount: numeric with optional comma separators and decimal point
+ *
+ * examples:
+ * - '$50.37'
+ * - '€1,000,000.00'
+ * - '¥1,000'
+ * - '100 €' (suffix position, some locales)
+ *
+ * note: this is a LOSSY format — symbols are ambiguous ($ could be USD, CAD, AUD, etc)
+ * use IsoPriceWords for unambiguous storage and serialization
+ */
+export type IsoPriceHuman = AsOfGlossary<string, 'iso-price-human'>;

package/dist/domain.objects/IsoPriceHuman.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IsoPriceHuman.js.map

package/dist/domain.objects/IsoPriceHuman.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsoPriceHuman.js","sourceRoot":"","sources":["../../src/domain.objects/IsoPriceHuman.ts"],"names":[],"mappings":""}

package/dist/domain.objects/IsoPriceRoundMode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * .what = enum of supported round modes for iso-price precision operations
+ * .why = explicit round mode selection prevents silent precision loss
+ *
+ * round modes follow IEEE 754-2008 names for mathematical precision:
+ * - `floor` = toward negative infinity
+ * - `ceil` = toward positive infinity
+ * - `half-up` = ties go away from zero (most common expectation)
+ * - `half-down` = ties go toward zero
+ * - `half-even` = ties go to nearest even (banker's round)
+ */
+export declare enum IsoPriceRoundMode {
+    /** round toward negative infinity — 5.5 → 5, -5.5 → -6 */
+    FLOOR = "floor",
+    /** round toward positive infinity — 5.5 → 6, -5.5 → -5 */
+    CEIL = "ceil",
+    /** ties go away from zero — 5.5 → 6, -5.5 → -6 (most common) */
+    HALF_UP = "half-up",
+    /** ties go toward zero — 5.5 → 5, -5.5 → -5 */
+    HALF_DOWN = "half-down",
+    /** ties go to nearest even — 5.5 → 6, 4.5 → 4 (banker's round) */
+    HALF_EVEN = "half-even"
+}

package/dist/domain.objects/IsoPriceRoundMode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsoPriceRoundMode = void 0;
+/**
+ * .what = enum of supported round modes for iso-price precision operations
+ * .why = explicit round mode selection prevents silent precision loss
+ *
+ * round modes follow IEEE 754-2008 names for mathematical precision:
+ * - `floor` = toward negative infinity
+ * - `ceil` = toward positive infinity
+ * - `half-up` = ties go away from zero (most common expectation)
+ * - `half-down` = ties go toward zero
+ * - `half-even` = ties go to nearest even (banker's round)
+ */
+var IsoPriceRoundMode;
+(function (IsoPriceRoundMode) {
+    /** round toward negative infinity — 5.5 → 5, -5.5 → -6 */
+    IsoPriceRoundMode["FLOOR"] = "floor";
+    /** round toward positive infinity — 5.5 → 6, -5.5 → -5 */
+    IsoPriceRoundMode["CEIL"] = "ceil";
+    /** ties go away from zero — 5.5 → 6, -5.5 → -6 (most common) */
+    IsoPriceRoundMode["HALF_UP"] = "half-up";
+    /** ties go toward zero — 5.5 → 5, -5.5 → -5 */
+    IsoPriceRoundMode["HALF_DOWN"] = "half-down";
+    /** ties go to nearest even — 5.5 → 6, 4.5 → 4 (banker's round) */
+    IsoPriceRoundMode["HALF_EVEN"] = "half-even";
+})(IsoPriceRoundMode || (exports.IsoPriceRoundMode = IsoPriceRoundMode = {}));
+//# sourceMappingURL=IsoPriceRoundMode.js.map

package/dist/domain.objects/IsoPriceRoundMode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsoPriceRoundMode.js","sourceRoot":"","sources":["../../src/domain.objects/IsoPriceRoundMode.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACH,IAAY,iBAWX;AAXD,WAAY,iBAAiB;IAC3B,0DAA0D;IAC1D,oCAAe,CAAA;IACf,0DAA0D;IAC1D,kCAAa,CAAA;IACb,gEAAgE;IAChE,wCAAmB,CAAA;IACnB,+CAA+C;IAC/C,4CAAuB,CAAA;IACvB,kEAAkE;IAClE,4CAAuB,CAAA;AACzB,CAAC,EAXW,iBAAiB,iCAAjB,iBAAiB,QAW5B"}

package/dist/domain.objects/IsoPriceShape.d.ts

@@ -0,0 +1,30 @@
+import type { IsoPriceExponent } from './IsoPriceExponent';
+/**
+ * .what = structured domain literal for iso-price with bigint precision
+ * .why = enables lossless arithmetic and explicit precision control
+ *
+ * the shape provides:
+ * - `amount: bigint` — integer representation in minor units (no float precision errors)
+ * - `currency: TCurrency` — iso 4217 code or custom currency string
+ * - `exponent?: TExponent` — explicit precision level (defaults to currency standard)
+ *
+ * example:
+ * ```ts
+ * // $50.37 in cents (default centi.x10^-2 for USD)
+ * { amount: 5037n, currency: 'USD' }
+ *
+ * // $0.000003 in micro-dollars (llm token cost)
+ * { amount: 3n, currency: 'USD', exponent: 'micro.x10^-6' }
+ * ```
+ *
+ * @template TCurrency - the currency code type (defaults to `string`)
+ * @template TExponent - the exponent type (defaults to `IsoPriceExponent`)
+ */
+export interface IsoPriceShape<TCurrency extends string = string, TExponent extends IsoPriceExponent | `${IsoPriceExponent}` = IsoPriceExponent | `${IsoPriceExponent}`> {
+    /** integer amount in minor units — always bigint for precision safety */
+    amount: bigint;
+    /** iso 4217 currency code or custom currency string */
+    currency: TCurrency;
+    /** explicit precision exponent — defaults to currency standard when omitted */
+    exponent?: TExponent;
+}

package/dist/domain.objects/IsoPriceShape.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IsoPriceShape.js.map

package/dist/domain.objects/IsoPriceShape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsoPriceShape.js","sourceRoot":"","sources":["../../src/domain.objects/IsoPriceShape.ts"],"names":[],"mappings":""}

package/dist/domain.objects/IsoPriceWords.d.ts

@@ -0,0 +1,20 @@
+import type { AsOfGlossary } from 'domain-glossaries';
+/**
+ * .what = branded type for iso-price in words format
+ * .why = ensures type safety for price strings like 'USD 50.37'
+ *
+ * format: `{CURRENCY} {AMOUNT}`
+ * - currency: 3-letter iso 4217 code (e.g., 'USD', 'EUR', 'JPY')
+ * - amount: numeric with optional underscore separators and decimal point
+ *
+ * examples:
+ * - 'USD 50.37'
+ * - 'EUR 1_000_000.00'
+ * - 'JPY 1_000'
+ * - 'USD 0.000_003'
+ *
+ * note: commas are NOT valid in words format (use underscore separators)
+ *
+ * @template TCurrency - the currency code (defaults to `string` for any currency)
+ */
+export type IsoPriceWords<TCurrency extends string = string> = AsOfGlossary<`${TCurrency} ${string}`, 'iso-price-words'>;

package/dist/domain.objects/IsoPriceWords.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IsoPriceWords.js.map

package/dist/domain.objects/IsoPriceWords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsoPriceWords.js","sourceRoot":"","sources":["../../src/domain.objects/IsoPriceWords.ts"],"names":[],"mappings":""}

package/dist/domain.operations/arithmetic/allocatePrice.d.ts

@@ -0,0 +1,48 @@
+import type { IsoPrice } from '../../domain.objects/IsoPrice';
+import type { IsoPriceShape } from '../../domain.objects/IsoPriceShape';
+import type { IsoPriceWords } from '../../domain.objects/IsoPriceWords';
+/**
+ * .what = remainder distribution mode
+ * .why = determines where leftover cents go in allocation
+ */
+type AllocationRemainderMode = 'first' | 'last' | 'largest' | 'random';
+/**
+ * .what = allocates a price into equal parts or by ratios
+ * .why = enables fair distribution without loss (sum always equals original)
+ *
+ * @example
+ * allocatePrice({ of: 'USD 10.00', into: { parts: 3 }, remainder: 'first' })
+ * // => ['USD 3.34', 'USD 3.33', 'USD 3.33']
+ *
+ * @example
+ * allocatePrice({ of: 'USD 5.00', into: { ratios: [7, 3] }, remainder: 'first' })
+ * // => ['USD 3.50', 'USD 1.50']
+ */
+export declare function allocatePrice<TCurrency extends string = string>(input: {
+    of: IsoPrice<TCurrency> | string;
+    into: {
+        parts: number;
+    } | {
+        ratios: number[];
+    };
+    remainder: AllocationRemainderMode;
+}, options?: {
+    format?: 'words';
+}): IsoPriceWords<TCurrency>[];
+export declare function allocatePrice<TCurrency extends string = string>(input: {
+    of: IsoPrice<TCurrency> | string;
+    into: {
+        parts: number;
+    } | {
+        ratios: number[];
+    };
+    remainder: AllocationRemainderMode;
+}, options: {
+    format: 'shape';
+}): IsoPriceShape<TCurrency>[];
+/**
+ * .what = alias for allocatePrice
+ * .why = provides price-prefixed variant
+ */
+export declare const priceAllocate: typeof allocatePrice;
+export {};