@satorio/machinery 0.2.1

package/dist/money/amount.d.ts

@@ -0,0 +1,60 @@
+import { type Dinero } from 'dinero.js/bigint';
+import { Either } from 'effect';
+import type { Currency } from './currency.js';
+import { NotAnAmountError } from './failures.js';
+/**
+ * An exact amount of one currency. The value is the money library's own
+ * immutable amount, so every function that library ships works on it
+ * unchanged, and this mechanism adds only what the library leaves to the
+ * business: which currency codes exist, how a rounding is decided, and
+ * what an amount looks like on the wire.
+ */
+export type Money = Dinero<bigint>;
+/**
+ * An amount counted in the currency's own smallest unit: 4055 minor
+ * units of a currency counted in cents is 40.55.
+ */
+export declare const money: (currency: Currency, minorUnits: bigint) => Money;
+/**
+ * An amount held at a scale finer than the currency's own, so a calculation
+ * drops no digit.
+ *
+ * An amount at a scale finer than the currency's own, for a figure a
+ * calculation still holds in full: 400455 units at a scale of four is 40.0455.
+ * Nothing rounds until you say so.
+ */
+export declare const moneyAtScale: (currency: Currency, units: bigint, scale: bigint) => Money;
+/**
+ * Nothing at all, in one currency. This is the empty value a sum folds
+ * from, so a sum of no amounts still says which currency it is in.
+ */
+export declare const zeroMoney: (currency: Currency) => Money;
+/**
+ * The currency an amount is counted in.
+ */
+export declare const currencyOfMoney: (amount: Money) => Currency;
+/**
+ * The scale an amount is currently held at: how many decimals its own
+ * units are counted in, which grows as a calculation keeps precision.
+ */
+export declare const scaleOfMoney: (amount: Money) => bigint;
+/**
+ * Reads an amount somebody wrote: `40.0455`, `-25`, `0.10`. Every
+ * decimal written is kept, so the reader never drops a digit and never
+ * has to guess how fine the sender meant to be. A text of any other
+ * shape comes back as a refusal.
+ */
+export declare const moneyFromDecimalForm: (currency: Currency, text: string) => Either.Either<Money, NotAnAmountError>;
+/**
+ * Writes an amount for the wire and for a person: `40.0455`, `-25.00`.
+ * It never writes fewer decimals than the currency itself counts in, so
+ * a whole number of a currency counted in cents still reads `25.00`.
+ */
+export declare const moneyInDecimalForm: (amount: Money) => string;
+/**
+ * The amount counted in the currency's own smallest unit, rounded to it
+ * by the one policy this mechanism keeps. This is the number a payment
+ * request carries, and the point where a fraction of a cent stops
+ * existing.
+ */
+export declare const minorUnitsOf: (amount: Money) => bigint;

package/dist/money/amount.js

@@ -0,0 +1,67 @@
+import { dinero, halfAwayFromZero, toDecimal, toSnapshot, transformScale, } from 'dinero.js/bigint';
+import { Either } from 'effect';
+import { exactDecimalOf } from './decimal.js';
+import { NotAnAmountError } from './failures.js';
+/**
+ * An amount counted in the currency's own smallest unit: 4055 minor
+ * units of a currency counted in cents is 40.55.
+ */
+export const money = (currency, minorUnits) => dinero({ amount: minorUnits, currency });
+/**
+ * An amount held at a scale finer than the currency's own, so a calculation
+ * drops no digit.
+ *
+ * An amount at a scale finer than the currency's own, for a figure a
+ * calculation still holds in full: 400455 units at a scale of four is 40.0455.
+ * Nothing rounds until you say so.
+ */
+export const moneyAtScale = (currency, units, scale) => dinero({ amount: units, currency, scale });
+/**
+ * Nothing at all, in one currency. This is the empty value a sum folds
+ * from, so a sum of no amounts still says which currency it is in.
+ */
+export const zeroMoney = (currency) => money(currency, 0n);
+/**
+ * The currency an amount is counted in.
+ */
+export const currencyOfMoney = (amount) => toSnapshot(amount).currency;
+/**
+ * The scale an amount is currently held at: how many decimals its own
+ * units are counted in, which grows as a calculation keeps precision.
+ */
+export const scaleOfMoney = (amount) => toSnapshot(amount).scale;
+/**
+ * Reads an amount somebody wrote: `40.0455`, `-25`, `0.10`. Every
+ * decimal written is kept, so the reader never drops a digit and never
+ * has to guess how fine the sender meant to be. A text of any other
+ * shape comes back as a refusal.
+ */
+export const moneyFromDecimalForm = (currency, text) => {
+    const read = exactDecimalOf(text);
+    return read === null
+        ? Either.left(new NotAnAmountError({ text }))
+        : Either.right(moneyAtScale(currency, read.units, read.scale));
+};
+const atLeastTheCurrencyScale = (amount) => {
+    const snapshot = toSnapshot(amount);
+    const currencyScale = snapshot.currency.exponent;
+    return snapshot.scale >= currencyScale
+        ? amount
+        : transformScale(amount, currencyScale, halfAwayFromZero);
+};
+/**
+ * Writes an amount for the wire and for a person: `40.0455`, `-25.00`.
+ * It never writes fewer decimals than the currency itself counts in, so
+ * a whole number of a currency counted in cents still reads `25.00`.
+ */
+export const moneyInDecimalForm = (amount) => toDecimal(atLeastTheCurrencyScale(amount));
+/**
+ * The amount counted in the currency's own smallest unit, rounded to it
+ * by the one policy this mechanism keeps. This is the number a payment
+ * request carries, and the point where a fraction of a cent stops
+ * existing.
+ */
+export const minorUnitsOf = (amount) => {
+    const toTheCent = transformScale(amount, currencyOfMoney(amount).exponent, halfAwayFromZero);
+    return toSnapshot(toTheCent).amount;
+};

package/dist/money/arithmetic.d.ts

@@ -0,0 +1,60 @@
+import { Either } from 'effect';
+import { type Money } from './amount.js';
+import type { Currency } from './currency.js';
+import { CurrenciesDoNotMeetError, ProportionsDoNotSplitError } from './failures.js';
+import type { Percent } from './percent.js';
+/**
+ * Rounds an amount to the currency's own smallest unit, half away from
+ * zero. This is the one rounding policy this package keeps: a half cent
+ * goes up when the amount is positive and down when it is negative, so a
+ * credit note mirrors the invoice it reverses exactly. Round once, at
+ * the end of a calculation — a figure rounded twice through a finer
+ * scale moves by a cent nobody can account for.
+ */
+export declare const roundedToTheCent: (amount: Money) => Money;
+/**
+ * Adds two amounts of one currency. Two currencies come back as a
+ * refusal rather than a throw, so the caller reads the failure in the
+ * same channel every other value in this package travels.
+ */
+export declare const addMoney: (left: Money, right: Money) => Either.Either<Money, CurrenciesDoNotMeetError>;
+/**
+ * Adds up any number of amounts, starting from nothing in the currency
+ * you name. Nothing plus an amount is that amount, and the order the
+ * amounts arrive in never changes the total: those two laws are what
+ * makes a journal safe to fold in any order, and a property test holds
+ * them.
+ */
+export declare const sumOfMoney: (currency: Currency, amounts: readonly Money[]) => Either.Either<Money, CurrenciesDoNotMeetError>;
+/**
+ * Turns an amount around: what was owed becomes what is owed back.
+ */
+export declare const negatedMoney: (amount: Money) => Money;
+/**
+ * Puts two amounts of one currency in order.
+ *
+ * Puts two amounts of one currency in order: below zero when the first stands
+ * lower, zero when they are the same amount, above zero when the first stands
+ * higher. Two currencies come back as a refusal.
+ */
+export declare const compareMoney: (left: Money, right: Money) => Either.Either<number, CurrenciesDoNotMeetError>;
+/**
+ * Whether two amounts are the same amount. Amounts in two currencies are
+ * simply not the same amount, which is an answer rather than a refusal.
+ */
+export declare const sameMoney: (left: Money, right: Money) => boolean;
+/**
+ * Takes a share of an amount and keeps every digit of the product. It
+ * rounds nothing on purpose: pass the result through `roundedToTheCent`
+ * once, when the calculation is over, so no figure is rounded twice.
+ */
+export declare const percentOf: (amount: Money, percent: Percent) => Money;
+/**
+ * Splits an amount into shares that add back up to exactly what went in.
+ *
+ * Splits an amount into shares by proportion, and the shares add back up to
+ * exactly what went in — the remainder is handed out one smallest unit at a
+ * time rather than left behind. Proportions that cannot split anything come
+ * back as a refusal.
+ */
+export declare const sharesOf: (amount: Money, proportions: readonly bigint[]) => Either.Either<readonly Money[], ProportionsDoNotSplitError>;

package/dist/money/arithmetic.js

@@ -0,0 +1,73 @@
+import { add, allocate, compare, equal, halfAwayFromZero, haveSameCurrency, multiply, transformScale, } from 'dinero.js/bigint';
+import { Either } from 'effect';
+import { currencyOfMoney, zeroMoney } from './amount.js';
+import { currencyCodeOf } from './currency.js';
+import { CurrenciesDoNotMeetError, ProportionsDoNotSplitError, } from './failures.js';
+const meetOrRefuse = (left, right) => haveSameCurrency([left, right])
+    ? Either.void
+    : Either.left(new CurrenciesDoNotMeetError({
+        left: currencyCodeOf(currencyOfMoney(left)),
+        right: currencyCodeOf(currencyOfMoney(right)),
+    }));
+/**
+ * Rounds an amount to the currency's own smallest unit, half away from
+ * zero. This is the one rounding policy this package keeps: a half cent
+ * goes up when the amount is positive and down when it is negative, so a
+ * credit note mirrors the invoice it reverses exactly. Round once, at
+ * the end of a calculation — a figure rounded twice through a finer
+ * scale moves by a cent nobody can account for.
+ */
+export const roundedToTheCent = (amount) => transformScale(amount, currencyOfMoney(amount).exponent, halfAwayFromZero);
+/**
+ * Adds two amounts of one currency. Two currencies come back as a
+ * refusal rather than a throw, so the caller reads the failure in the
+ * same channel every other value in this package travels.
+ */
+export const addMoney = (left, right) => Either.map(meetOrRefuse(left, right), () => add(left, right));
+/**
+ * Adds up any number of amounts, starting from nothing in the currency
+ * you name. Nothing plus an amount is that amount, and the order the
+ * amounts arrive in never changes the total: those two laws are what
+ * makes a journal safe to fold in any order, and a property test holds
+ * them.
+ */
+export const sumOfMoney = (currency, amounts) => amounts.reduce((total, amount) => Either.flatMap(total, (running) => addMoney(running, amount)), Either.right(zeroMoney(currency)));
+/**
+ * Turns an amount around: what was owed becomes what is owed back.
+ */
+export const negatedMoney = (amount) => multiply(amount, { amount: -1n, scale: 0n });
+/**
+ * Puts two amounts of one currency in order.
+ *
+ * Puts two amounts of one currency in order: below zero when the first stands
+ * lower, zero when they are the same amount, above zero when the first stands
+ * higher. Two currencies come back as a refusal.
+ */
+export const compareMoney = (left, right) => Either.map(meetOrRefuse(left, right), () => compare(left, right));
+/**
+ * Whether two amounts are the same amount. Amounts in two currencies are
+ * simply not the same amount, which is an answer rather than a refusal.
+ */
+export const sameMoney = (left, right) => haveSameCurrency([left, right]) && equal(left, right);
+/**
+ * Takes a share of an amount and keeps every digit of the product. It
+ * rounds nothing on purpose: pass the result through `roundedToTheCent`
+ * once, when the calculation is over, so no figure is rounded twice.
+ */
+export const percentOf = (amount, percent) => multiply(amount, percent);
+/**
+ * Splits an amount into shares that add back up to exactly what went in.
+ *
+ * Splits an amount into shares by proportion, and the shares add back up to
+ * exactly what went in — the remainder is handed out one smallest unit at a
+ * time rather than left behind. Proportions that cannot split anything come
+ * back as a refusal.
+ */
+export const sharesOf = (amount, proportions) => {
+    const splits = proportions.length > 0 &&
+        proportions.every((proportion) => proportion >= 0n) &&
+        proportions.some((proportion) => proportion > 0n);
+    return splits
+        ? Either.right(allocate(amount, proportions))
+        : Either.left(new ProportionsDoNotSplitError({ proportions }));
+};

package/dist/money/currency.d.ts

@@ -0,0 +1,25 @@
+import type { DineroCurrency } from 'dinero.js/bigint';
+import { Either } from 'effect';
+import { NotACurrencyCodeError } from './failures.js';
+/**
+ * One currency of the ISO 4217 table: its code, the base it counts in,
+ * and how many decimals one unit holds. Every currency here comes from
+ * the money library's own table, so nothing in this package keeps a
+ * second list of how many decimals a currency has.
+ */
+export type Currency = DineroCurrency<bigint>;
+/**
+ * Reads a currency code somebody wrote: `USD`, `EUR`, `UAH`. A code the
+ * ISO 4217 table does not hold comes back as a refusal rather than a
+ * currency nobody can count decimals in.
+ */
+export declare const currencyOf: (code: string) => Either.Either<Currency, NotACurrencyCodeError>;
+/**
+ * Writes a currency back as the three letters ISO 4217 gives it.
+ */
+export declare const currencyCodeOf: (currency: Currency) => string;
+/**
+ * How many decimals one unit of this currency holds: two for a currency
+ * counted in cents, zero for one counted in whole units.
+ */
+export declare const decimalsOf: (currency: Currency) => number;

package/dist/money/currency.js

@@ -0,0 +1,24 @@
+import * as isoCurrencies from 'dinero.js/bigint/currencies';
+import { Either } from 'effect';
+import { NotACurrencyCodeError } from './failures.js';
+const BY_CODE = new Map(Object.values(isoCurrencies).map((currency) => [currency.code, currency]));
+/**
+ * Reads a currency code somebody wrote: `USD`, `EUR`, `UAH`. A code the
+ * ISO 4217 table does not hold comes back as a refusal rather than a
+ * currency nobody can count decimals in.
+ */
+export const currencyOf = (code) => {
+    const known = BY_CODE.get(code);
+    return known === undefined
+        ? Either.left(new NotACurrencyCodeError({ text: code }))
+        : Either.right(known);
+};
+/**
+ * Writes a currency back as the three letters ISO 4217 gives it.
+ */
+export const currencyCodeOf = (currency) => currency.code;
+/**
+ * How many decimals one unit of this currency holds: two for a currency
+ * counted in cents, zero for one counted in whole units.
+ */
+export const decimalsOf = (currency) => Number(currency.exponent);

package/dist/money/decimal.d.ts

@@ -0,0 +1,29 @@
+/**
+ * An exact decimal number, held as a whole number of steps and the count
+ * of decimals those steps are counted in. `40.0455` is `400455` units at
+ * a scale of four, so no digit is ever handed to a floating-point number.
+ *
+ * @internal
+ */
+export interface ExactDecimal {
+    readonly units: bigint;
+    readonly scale: bigint;
+}
+/**
+ * Reads a written decimal number, keeping every digit the writer wrote:
+ * nothing here rounds, and nothing here refuses a number for being
+ * finer than expected. A text of any other shape comes back as `null` —
+ * the caller turns that into its own refusal, because only the caller
+ * knows what was being read.
+ *
+ * @internal
+ */
+export declare const exactDecimalOf: (text: string) => ExactDecimal | null;
+/**
+ * Writes an exact decimal back, trimming the trailing zeros a scale
+ * carried but a reader never asked for: thirty percent reads `0.3`, not
+ * `0.300000`.
+ *
+ * @internal
+ */
+export declare const trimmedDecimalOf: (value: ExactDecimal) => string;

package/dist/money/decimal.js

@@ -0,0 +1,39 @@
+const WRITTEN_DECIMAL = /^(-?)(\d+)(?:\.(\d+))?$/;
+/**
+ * Reads a written decimal number, keeping every digit the writer wrote:
+ * nothing here rounds, and nothing here refuses a number for being
+ * finer than expected. A text of any other shape comes back as `null` —
+ * the caller turns that into its own refusal, because only the caller
+ * knows what was being read.
+ *
+ * @internal
+ */
+export const exactDecimalOf = (text) => {
+    const parts = WRITTEN_DECIMAL.exec(text);
+    if (parts === null)
+        return null;
+    const [, sign, whole = '', decimals = ''] = parts;
+    const magnitude = BigInt(`${whole}${decimals}`);
+    return {
+        units: sign === '-' ? -magnitude : magnitude,
+        scale: BigInt(decimals.length),
+    };
+};
+/**
+ * Writes an exact decimal back, trimming the trailing zeros a scale
+ * carried but a reader never asked for: thirty percent reads `0.3`, not
+ * `0.300000`.
+ *
+ * @internal
+ */
+export const trimmedDecimalOf = (value) => {
+    const negative = value.units < 0n;
+    const scale = Number(value.scale);
+    const digits = (negative ? -value.units : value.units)
+        .toString(10)
+        .padStart(scale + 1, '0');
+    const whole = digits.slice(0, digits.length - scale);
+    const decimals = digits.slice(digits.length - scale).replace(/0+$/, '');
+    const body = decimals === '' ? whole : `${whole}.${decimals}`;
+    return negative ? `-${body}` : body;
+};

package/dist/money/exchange-rate.d.ts

@@ -0,0 +1,32 @@
+import { Either } from 'effect';
+import type { Money } from './amount.js';
+import { type Currency } from './currency.js';
+import { NotAnExchangeRateError } from './failures.js';
+/**
+ * How many units of the currency you are going to, one unit of the
+ * currency you are coming from buys. The value is exact: `0.89` is 89
+ * units at a scale of two, and no digit of it reaches a floating-point
+ * number.
+ */
+export interface ExchangeRate {
+    readonly amount: bigint;
+    readonly scale: bigint;
+}
+/**
+ * Reads a rate somebody wrote: `0.89`, `41.57306`. A text of any other
+ * shape, or a rate that is not above zero, comes back as a refusal — a
+ * rate of nothing would turn every amount into nothing, quietly.
+ */
+export declare const exchangeRateFromDecimalForm: (text: string) => Either.Either<ExchangeRate, NotAnExchangeRateError>;
+/**
+ * Writes a rate back, trimmed, the way the source that published it
+ * wrote it: `0.89`.
+ */
+export declare const exchangeRateInDecimalForm: (rate: ExchangeRate) => string;
+/**
+ * Turns an amount into another currency at the rate you name, keeping
+ * every digit of the product. It rounds nothing on purpose: pass the
+ * result through `roundedToTheCent` once, at the end, so a converted
+ * figure is never rounded twice.
+ */
+export declare const atRate: (amount: Money, target: Currency, rate: ExchangeRate) => Money;

package/dist/money/exchange-rate.js

@@ -0,0 +1,28 @@
+import { convert } from 'dinero.js/bigint';
+import { Either } from 'effect';
+import { currencyCodeOf } from './currency.js';
+import { exactDecimalOf, trimmedDecimalOf } from './decimal.js';
+import { NotAnExchangeRateError } from './failures.js';
+/**
+ * Reads a rate somebody wrote: `0.89`, `41.57306`. A text of any other
+ * shape, or a rate that is not above zero, comes back as a refusal — a
+ * rate of nothing would turn every amount into nothing, quietly.
+ */
+export const exchangeRateFromDecimalForm = (text) => {
+    const read = exactDecimalOf(text);
+    return read === null || read.units <= 0n
+        ? Either.left(new NotAnExchangeRateError({ text }))
+        : Either.right({ amount: read.units, scale: read.scale });
+};
+/**
+ * Writes a rate back, trimmed, the way the source that published it
+ * wrote it: `0.89`.
+ */
+export const exchangeRateInDecimalForm = (rate) => trimmedDecimalOf({ units: rate.amount, scale: rate.scale });
+/**
+ * Turns an amount into another currency at the rate you name, keeping
+ * every digit of the product. It rounds nothing on purpose: pass the
+ * result through `roundedToTheCent` once, at the end, so a converted
+ * figure is never rounded twice.
+ */
+export const atRate = (amount, target, rate) => convert(amount, target, { [currencyCodeOf(target)]: rate });

package/dist/money/failures.d.ts

@@ -0,0 +1,86 @@
+import type { Refusal } from '@satorio/machinery/core';
+declare const NotACurrencyCodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NotACurrencyCodeError";
+} & Readonly<A>;
+/**
+ * The text handed in does not name a currency this mechanism knows. Every
+ * currency here comes from the money library's own ISO 4217 table, so a
+ * code outside it has no exponent and no base to count in.
+ */
+export declare class NotACurrencyCodeError extends NotACurrencyCodeError_base<{
+    readonly text: string;
+}> {
+    get refusal(): Refusal;
+}
+declare const NotAnAmountError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NotAnAmountError";
+} & Readonly<A>;
+/**
+ * The text handed in does not write an amount. The reader keeps every
+ * decimal somebody wrote, so this refusal is about the shape of the
+ * text and never about a digit the reader was unwilling to hold.
+ */
+export declare class NotAnAmountError extends NotAnAmountError_base<{
+    readonly text: string;
+}> {
+    get refusal(): Refusal;
+}
+declare const NotAnExchangeRateError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NotAnExchangeRateError";
+} & Readonly<A>;
+/**
+ * The text handed in does not write an exchange rate. A rate has to
+ * stand above zero: a rate of nothing turns every amount into nothing,
+ * and it does it without a word.
+ */
+export declare class NotAnExchangeRateError extends NotAnExchangeRateError_base<{
+    readonly text: string;
+}> {
+    get refusal(): Refusal;
+}
+declare const NotAPercentError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NotAPercentError";
+} & Readonly<A>;
+/**
+ * The text handed in does not write a percent. `form` names which of the
+ * two written forms was being read, so the refusal quotes the rule the
+ * sender was actually held to.
+ */
+export declare class NotAPercentError extends NotAPercentError_base<{
+    readonly text: string;
+    readonly form: 'percentage' | 'ratio';
+}> {
+    get refusal(): Refusal;
+}
+declare const CurrenciesDoNotMeetError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CurrenciesDoNotMeetError";
+} & Readonly<A>;
+/**
+ * Two amounts in two currencies were asked to meet. Nothing here adds
+ * them, compares them, or folds them together: a rate turns one into the
+ * other first, and the rate is a fact somebody has to supply.
+ */
+export declare class CurrenciesDoNotMeetError extends CurrenciesDoNotMeetError_base<{
+    readonly left: string;
+    readonly right: string;
+}> {
+    get refusal(): Refusal;
+}
+declare const ProportionsDoNotSplitError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ProportionsDoNotSplitError";
+} & Readonly<A>;
+/**
+ * The proportions handed in cannot split an amount. A split needs at
+ * least one proportion, none of them below zero, and at least one above
+ * it, or there is no share for the remainder to land in.
+ */
+export declare class ProportionsDoNotSplitError extends ProportionsDoNotSplitError_base<{
+    readonly proportions: readonly bigint[];
+}> {
+    get refusal(): Refusal;
+}
+/**
+ * Every way this mechanism refuses a value.
+ */
+export type MoneyFailure = NotACurrencyCodeError | NotAnAmountError | NotAnExchangeRateError | NotAPercentError | CurrenciesDoNotMeetError | ProportionsDoNotSplitError;
+export {};

package/dist/money/failures.js

@@ -0,0 +1,97 @@
+import { Data } from 'effect';
+/**
+ * The text handed in does not name a currency this mechanism knows. Every
+ * currency here comes from the money library's own ISO 4217 table, so a
+ * code outside it has no exponent and no base to count in.
+ */
+export class NotACurrencyCodeError extends Data.TaggedError('NotACurrencyCodeError') {
+    get refusal() {
+        return {
+            what: `${JSON.stringify(this.text)} is not a currency code this mechanism knows.`,
+            why: 'Every currency here comes from the ISO 4217 table, which says how ' +
+                'many decimals the currency counts in; a code outside it has none.',
+            whatToDo: 'Name the currency as three upper-case letters, such as USD or EUR, ' +
+                'then hand it back.',
+        };
+    }
+}
+/**
+ * The text handed in does not write an amount. The reader keeps every
+ * decimal somebody wrote, so this refusal is about the shape of the
+ * text and never about a digit the reader was unwilling to hold.
+ */
+export class NotAnAmountError extends Data.TaggedError('NotAnAmountError') {
+    get refusal() {
+        return {
+            what: `${JSON.stringify(this.text)} is not written as an amount.`,
+            why: 'An amount is a decimal number, and this reader keeps every ' +
+                "decimal of it, because a dropped digit is somebody's money.",
+            whatToDo: 'Write the amount as 40.0455 or as -25, then hand it back.',
+        };
+    }
+}
+/**
+ * The text handed in does not write an exchange rate. A rate has to
+ * stand above zero: a rate of nothing turns every amount into nothing,
+ * and it does it without a word.
+ */
+export class NotAnExchangeRateError extends Data.TaggedError('NotAnExchangeRateError') {
+    get refusal() {
+        return {
+            what: `${JSON.stringify(this.text)} is not written as an exchange rate.`,
+            why: 'A rate is a decimal number above zero, and a rate of nothing ' +
+                'would turn every amount it touches into nothing.',
+            whatToDo: 'Write the rate as 0.89 or as 41.57306, then hand it back.',
+        };
+    }
+}
+/**
+ * The text handed in does not write a percent. `form` names which of the
+ * two written forms was being read, so the refusal quotes the rule the
+ * sender was actually held to.
+ */
+export class NotAPercentError extends Data.TaggedError('NotAPercentError') {
+    get refusal() {
+        return {
+            what: `${JSON.stringify(this.text)} is not written as a percent in ${this.form} form.`,
+            why: 'A percent is one exact decimal number, and this mechanism reads ' +
+                'the form it was asked for rather than guessing which one somebody ' +
+                'meant.',
+            whatToDo: this.form === 'percentage'
+                ? 'Write thirty percent as 30, then hand it back.'
+                : 'Write thirty percent as 0.3, then hand it back.',
+        };
+    }
+}
+/**
+ * Two amounts in two currencies were asked to meet. Nothing here adds
+ * them, compares them, or folds them together: a rate turns one into the
+ * other first, and the rate is a fact somebody has to supply.
+ */
+export class CurrenciesDoNotMeetError extends Data.TaggedError('CurrenciesDoNotMeetError') {
+    get refusal() {
+        return {
+            what: `An amount in ${this.left} met an amount in ${this.right}.`,
+            why: 'Two currencies fold apart, so adding or ordering them would ' +
+                'invent a number nobody can bank.',
+            whatToDo: 'Turn one into the other through a rate you can name, then hand ' +
+                'the two amounts back in one currency.',
+        };
+    }
+}
+/**
+ * The proportions handed in cannot split an amount. A split needs at
+ * least one proportion, none of them below zero, and at least one above
+ * it, or there is no share for the remainder to land in.
+ */
+export class ProportionsDoNotSplitError extends Data.TaggedError('ProportionsDoNotSplitError') {
+    get refusal() {
+        return {
+            what: `These proportions cannot split an amount: [${this.proportions.join(', ')}].`,
+            why: 'A split needs at least one proportion, none below zero, and at ' +
+                'least one above it; otherwise no share can hold the remainder.',
+            whatToDo: 'Hand in one proportion per share, each zero or more, with at ' +
+                'least one above zero.',
+        };
+    }
+}

package/dist/money/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Public entry to the money mechanism, over dinero.js, the optional peer your
+ * service installs: exact amounts of one currency, shares, rates, and
+ * rounding. It gives you an exact amount of one currency over the money
+ * library this package stands on, a share of an amount in both forms a
+ * business writes it, an exchange rate, the one rounding policy every figure
+ * here goes through, and the decimal text an amount travels the wire as.
+ */
+export { currencyOfMoney, type Money, minorUnitsOf, money, moneyAtScale, moneyFromDecimalForm, moneyInDecimalForm, scaleOfMoney, zeroMoney, } from './amount.js';
+export { addMoney, compareMoney, negatedMoney, percentOf, roundedToTheCent, sameMoney, sharesOf, sumOfMoney, } from './arithmetic.js';
+export { type Currency, currencyCodeOf, currencyOf, decimalsOf, } from './currency.js';
+export { atRate, type ExchangeRate, exchangeRateFromDecimalForm, exchangeRateInDecimalForm, } from './exchange-rate.js';
+export { CurrenciesDoNotMeetError, type MoneyFailure, NotACurrencyCodeError, NotAnAmountError, NotAnExchangeRateError, NotAPercentError, ProportionsDoNotSplitError, } from './failures.js';
+export { type Percent, percentFromPercentageForm, percentFromRatioForm, percentInPercentageForm, percentInRatioForm, samePercent, } from './percent.js';
+export { MoneyFromDecimalString, PercentFromPercentageString, PercentFromRatioString, } from './schema.js';

package/dist/money/index.js

@@ -0,0 +1,15 @@
+/**
+ * Public entry to the money mechanism, over dinero.js, the optional peer your
+ * service installs: exact amounts of one currency, shares, rates, and
+ * rounding. It gives you an exact amount of one currency over the money
+ * library this package stands on, a share of an amount in both forms a
+ * business writes it, an exchange rate, the one rounding policy every figure
+ * here goes through, and the decimal text an amount travels the wire as.
+ */
+export { currencyOfMoney, minorUnitsOf, money, moneyAtScale, moneyFromDecimalForm, moneyInDecimalForm, scaleOfMoney, zeroMoney, } from './amount.js';
+export { addMoney, compareMoney, negatedMoney, percentOf, roundedToTheCent, sameMoney, sharesOf, sumOfMoney, } from './arithmetic.js';
+export { currencyCodeOf, currencyOf, decimalsOf, } from './currency.js';
+export { atRate, exchangeRateFromDecimalForm, exchangeRateInDecimalForm, } from './exchange-rate.js';
+export { CurrenciesDoNotMeetError, NotACurrencyCodeError, NotAnAmountError, NotAnExchangeRateError, NotAPercentError, ProportionsDoNotSplitError, } from './failures.js';
+export { percentFromPercentageForm, percentFromRatioForm, percentInPercentageForm, percentInRatioForm, samePercent, } from './percent.js';
+export { MoneyFromDecimalString, PercentFromPercentageString, PercentFromRatioString, } from './schema.js';