mixradix 0.1.0 → 0.2.0

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import { type BaseLike } from "./core.js";
+import { type BaseLike } from "./core/index.js";
 /** A number for the convenience functions: text in `base`, or an integer. */
 export type NumberInput = string | number | bigint;
 export interface CalculateOptions {

package/dist/api.js

@@ -1,4 +1,4 @@
-import { MixedRadix } from "./core.js";
+import { MixedRadix } from "./core/index.js";
 /**
  * Adds numbers written in `base` and returns the sum as text in `to`.
  *

package/dist/cli.js

@@ -1,7 +1,8 @@
 import { readFileSync } from "node:fs";
 import { parseArgs } from "node:util";
-import { MixedRadix } from "./core.js";
-import { MixedRadixError } from "./errors.js";
+import { MixedRadix } from "./core/index.js";
+import { MixedRadixError } from "./errors/index.js";
+import { UsageError } from "./usage-error.js";
 const processIo = {
     stdout: (text) => process.stdout.write(text),
     stderr: (text) => process.stderr.write(text),
@@ -120,15 +121,6 @@ function protectNegativeNumbers(argv) {
     }
     return result;
 }
-class UsageError extends Error {
-    usage;
-    prog;
-    constructor(usage, prog, message) {
-        super(message);
-        this.usage = usage;
-        this.prog = prog;
-    }
-}
 /** Runs the CLI with `argv` (without the node and script paths) and returns the exit code. */
 export function main(argv = process.argv.slice(2), io = processIo) {
     try {

package/dist/core/common.d.ts

@@ -0,0 +1,18 @@
+/** What is left of the leftmost radix: see the README. */
+export type Overflow = "extend" | "wrap" | "repeat";
+export declare const SEPARATOR = ":";
+export declare const OVERFLOW_SEPARATOR = "/";
+export declare const DIGIT_CHARS = "0123456789abcdefghijklmnopqrstuvwxyz";
+export declare const MAX_COMPACT_RADIX: bigint;
+export declare const BASE_SYNTAX = "expected radices of 2 or more separated by ':', like 16 or 24:60:60";
+export declare const DIGIT_SYNTAX = "expected decimal digits separated by ':'";
+export declare const isDecimal: (text: string) => boolean;
+export declare const defaultOverflow: (radixCount: number) => Overflow;
+export declare const listLabel: (values: readonly unknown[]) => string;
+export declare function checkOverflow(base: string, overflow: string): Overflow;
+/** A safe integer or bigint as a bigint, or undefined for anything else. */
+export declare function asInteger(value: unknown): bigint | undefined;
+export declare function toInteger(value: number | bigint): bigint;
+export declare const abs: (value: bigint) => bigint;
+/** Remainder that is never negative, for wrapping values into [0, modulus). */
+export declare const mod: (value: bigint, modulus: bigint) => bigint;

package/dist/core/common.js

@@ -0,0 +1,37 @@
+/** Notation and integer helpers shared by MixedRadix and MixedRadixNumber. */
+import { InvalidBaseError } from "../errors/index.js";
+const OVERFLOWS = ["extend", "wrap", "repeat"];
+export const SEPARATOR = ":";
+export const OVERFLOW_SEPARATOR = "/";
+export const DIGIT_CHARS = "0123456789abcdefghijklmnopqrstuvwxyz";
+export const MAX_COMPACT_RADIX = BigInt(DIGIT_CHARS.length);
+export const BASE_SYNTAX = "expected radices of 2 or more separated by ':', like 16 or 24:60:60";
+export const DIGIT_SYNTAX = "expected decimal digits separated by ':'";
+export const isDecimal = (text) => /^[0-9]+$/.test(text);
+export const defaultOverflow = (radixCount) => radixCount === 1 ? "repeat" : "extend";
+export const listLabel = (values) => `[${values.map(String).join(", ")}]`;
+export function checkOverflow(base, overflow) {
+    const known = OVERFLOWS.find((o) => o === overflow);
+    if (known === undefined) {
+        throw new InvalidBaseError(base, `unknown overflow '${overflow}' (expected extend, wrap or repeat)`);
+    }
+    return known;
+}
+/** A safe integer or bigint as a bigint, or undefined for anything else. */
+export function asInteger(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number" && Number.isSafeInteger(value))
+        return BigInt(value);
+    return undefined;
+}
+export function toInteger(value) {
+    const integer = asInteger(value);
+    if (integer === undefined) {
+        throw new TypeError(`expected a safe integer or a bigint, got ${String(value)}`);
+    }
+    return integer;
+}
+export const abs = (value) => (value < 0n ? -value : value);
+/** Remainder that is never negative, for wrapping values into [0, modulus). */
+export const mod = (value, modulus) => ((value % modulus) + modulus) % modulus;

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export type { Overflow } from "./common.js";
+export { type BaseLike, type BaseOptions, MixedRadix } from "./mixed-radix.js";
+export { MixedRadixNumber, type NumberLike } from "./mixed-radix-number.js";

package/dist/core/index.js

@@ -0,0 +1,2 @@
+export { MixedRadix } from "./mixed-radix.js";
+export { MixedRadixNumber } from "./mixed-radix-number.js";

package/dist/core/mixed-radix-number.d.ts

@@ -0,0 +1,34 @@
+import { type BaseLike, MixedRadix } from "./mixed-radix.js";
+/** An operand for arithmetic: a number, an integer, or text in the left operand's base. */
+export type NumberLike = MixedRadixNumber | string | number | bigint;
+/**
+ * A signed integer of any size, written in a MixedRadix.
+ *
+ * Arithmetic is on values, so operands may be in different bases, integers,
+ * or text in this number's base. Results use the left operand's base.
+ *
+ * ```ts
+ * new MixedRadixNumber("23:59:59", "24:60:60").add(1).toString(); // "1:0:0:0"
+ * ```
+ */
+export declare class MixedRadixNumber {
+    readonly value: bigint;
+    readonly base: MixedRadix;
+    constructor(number: string | number | bigint, base?: BaseLike);
+    get isNegative(): boolean;
+    /** Digit values of the absolute value, most significant first. */
+    get digits(): readonly bigint[];
+    /** The same value written in another base. */
+    to(base: BaseLike): MixedRadixNumber;
+    add(other: NumberLike): MixedRadixNumber;
+    sub(other: NumberLike): MixedRadixNumber;
+    neg(): MixedRadixNumber;
+    abs(): MixedRadixNumber;
+    /** -1, 0 or 1 as this value is below, equal to or above `other`'s. */
+    compare(other: MixedRadixNumber | number | bigint): -1 | 0 | 1;
+    /** True when the values are equal, whatever the bases. */
+    equals(other: MixedRadixNumber | number | bigint): boolean;
+    toBigInt(): bigint;
+    toString(): string;
+    toJSON(): string;
+}

package/dist/core/mixed-radix-number.js

@@ -0,0 +1,111 @@
+import { abs, DIGIT_CHARS, mod, SEPARATOR, toInteger } from "./common.js";
+import { MixedRadix } from "./mixed-radix.js";
+/**
+ * A signed integer of any size, written in a MixedRadix.
+ *
+ * Arithmetic is on values, so operands may be in different bases, integers,
+ * or text in this number's base. Results use the left operand's base.
+ *
+ * ```ts
+ * new MixedRadixNumber("23:59:59", "24:60:60").add(1).toString(); // "1:0:0:0"
+ * ```
+ */
+export class MixedRadixNumber {
+    value;
+    base;
+    constructor(number, base = 10) {
+        const mixedRadix = MixedRadix.of(base);
+        const built = typeof number === "string" ? mixedRadix.parse(number) : mixedRadix.fromInt(number);
+        this.value = built.value;
+        this.base = mixedRadix;
+        Object.freeze(this);
+    }
+    /** @internal Makes a number from a value, wrapping it for `wrap` bases. */
+    static create(value, base) {
+        const modulus = base.modulus;
+        const number = Object.create(MixedRadixNumber.prototype);
+        Object.assign(number, { value: modulus === null ? value : mod(value, modulus), base });
+        return Object.freeze(number);
+    }
+    get isNegative() {
+        return this.value < 0n;
+    }
+    /** Digit values of the absolute value, most significant first. */
+    get digits() {
+        let remaining = abs(this.value);
+        const digits = []; // least significant first while building
+        if (this.base.overflow === "wrap") {
+            for (let i = this.base.radices.length - 1; i >= 0; i--) {
+                const radix = this.base.radices[i];
+                digits.push(remaining % radix);
+                remaining /= radix;
+            }
+        }
+        else {
+            for (let position = 0;; position++) {
+                const radix = this.base.radixAt(position);
+                if (radix === null) {
+                    digits.push(remaining);
+                    break;
+                }
+                digits.push(remaining % radix);
+                remaining /= radix;
+                if (remaining === 0n)
+                    break;
+            }
+        }
+        return Object.freeze(digits.reverse());
+    }
+    /** The same value written in another base. */
+    to(base) {
+        return MixedRadixNumber.create(this.value, MixedRadix.of(base));
+    }
+    // -- Arithmetic --------------------------------------------------------------
+    add(other) {
+        return MixedRadixNumber.create(this.value + operandValue(this, other), this.base);
+    }
+    sub(other) {
+        return MixedRadixNumber.create(this.value - operandValue(this, other), this.base);
+    }
+    neg() {
+        return MixedRadixNumber.create(-this.value, this.base);
+    }
+    abs() {
+        return MixedRadixNumber.create(abs(this.value), this.base);
+    }
+    // -- Comparison (by value) -----------------------------------------------------
+    /** -1, 0 or 1 as this value is below, equal to or above `other`'s. */
+    compare(other) {
+        const value = other instanceof MixedRadixNumber ? other.value : toInteger(other);
+        return this.value < value ? -1 : this.value > value ? 1 : 0;
+    }
+    /** True when the values are equal, whatever the bases. */
+    equals(other) {
+        return this.compare(other) === 0;
+    }
+    // -- Conversion ------------------------------------------------------------------
+    toBigInt() {
+        return this.value;
+    }
+    toString() {
+        const sign = this.value < 0n ? "-" : "";
+        const digits = this.digits;
+        if (this.base.isUniform)
+            return sign + digits.map((d) => DIGIT_CHARS[Number(d)]).join("");
+        return sign + digits.join(SEPARATOR);
+    }
+    toJSON() {
+        return this.toString();
+    }
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return `MixedRadixNumber('${this}', base='${this.base}')`;
+    }
+}
+/** The value of an arithmetic operand; text is parsed in the left operand's base. */
+function operandValue(left, other) {
+    if (other instanceof MixedRadixNumber)
+        return other.value;
+    if (typeof other === "string")
+        return left.base.parse(other).value;
+    return toInteger(other);
+}

package/dist/{core.d.ts → core/mixed-radix.d.ts}

@@ -1,9 +1,7 @@
-/** What is left of the leftmost radix: see the README. */
-export type Overflow = "extend" | "wrap" | "repeat";
+import { type Overflow } from "./common.js";
+import { MixedRadixNumber } from "./mixed-radix-number.js";
 /** Anything that can be turned into a base: `"24:60:60"`, `16`, `[24, 60, 60]`. */
 export type BaseLike = MixedRadix | string | number | bigint | readonly (number | bigint)[];
-/** An operand for arithmetic: a number, an integer, or text in the left operand's base. */
-export type NumberLike = MixedRadixNumber | string | number | bigint;
 export interface BaseOptions {
     overflow?: Overflow;
 }
@@ -60,34 +58,3 @@ export declare class MixedRadix {
     toString(): string;
     toJSON(): string;
 }
-/**
- * A signed integer of any size, written in a MixedRadix.
- *
- * Arithmetic is on values, so operands may be in different bases, integers,
- * or text in this number's base. Results use the left operand's base.
- *
- * ```ts
- * new MixedRadixNumber("23:59:59", "24:60:60").add(1).toString(); // "1:0:0:0"
- * ```
- */
-export declare class MixedRadixNumber {
-    readonly value: bigint;
-    readonly base: MixedRadix;
-    constructor(number: string | number | bigint, base?: BaseLike);
-    get isNegative(): boolean;
-    /** Digit values of the absolute value, most significant first. */
-    get digits(): readonly bigint[];
-    /** The same value written in another base. */
-    to(base: BaseLike): MixedRadixNumber;
-    add(other: NumberLike): MixedRadixNumber;
-    sub(other: NumberLike): MixedRadixNumber;
-    neg(): MixedRadixNumber;
-    abs(): MixedRadixNumber;
-    /** -1, 0 or 1 as this value is below, equal to or above `other`'s. */
-    compare(other: MixedRadixNumber | number | bigint): -1 | 0 | 1;
-    /** True when the values are equal, whatever the bases. */
-    equals(other: MixedRadixNumber | number | bigint): boolean;
-    toBigInt(): bigint;
-    toString(): string;
-    toJSON(): string;
-}

package/dist/{core.js → core/mixed-radix.js}

@@ -1,39 +1,6 @@
-import { DigitOutOfRangeError, InvalidBaseError, InvalidNumberError } from "./errors.js";
-const OVERFLOWS = ["extend", "wrap", "repeat"];
-const SEPARATOR = ":";
-const OVERFLOW_SEPARATOR = "/";
-const DIGIT_CHARS = "0123456789abcdefghijklmnopqrstuvwxyz";
-const MAX_COMPACT_RADIX = BigInt(DIGIT_CHARS.length);
-const BASE_SYNTAX = "expected radices of 2 or more separated by ':', like 16 or 24:60:60";
-const DIGIT_SYNTAX = "expected decimal digits separated by ':'";
-const isDecimal = (text) => /^[0-9]+$/.test(text);
-const defaultOverflow = (radixCount) => (radixCount === 1 ? "repeat" : "extend");
-const listLabel = (values) => `[${values.map(String).join(", ")}]`;
-function checkOverflow(base, overflow) {
-    const known = OVERFLOWS.find((o) => o === overflow);
-    if (known === undefined) {
-        throw new InvalidBaseError(base, `unknown overflow '${overflow}' (expected extend, wrap or repeat)`);
-    }
-    return known;
-}
-/** A safe integer or bigint as a bigint, or undefined for anything else. */
-function asInteger(value) {
-    if (typeof value === "bigint")
-        return value;
-    if (typeof value === "number" && Number.isSafeInteger(value))
-        return BigInt(value);
-    return undefined;
-}
-function toInteger(value) {
-    const integer = asInteger(value);
-    if (integer === undefined) {
-        throw new TypeError(`expected a safe integer or a bigint, got ${String(value)}`);
-    }
-    return integer;
-}
-const abs = (value) => (value < 0n ? -value : value);
-/** Remainder that is never negative, for wrapping values into [0, modulus). */
-const mod = (value, modulus) => ((value % modulus) + modulus) % modulus;
+import { DigitOutOfRangeError, InvalidBaseError, InvalidNumberError } from "../errors/index.js";
+import { asInteger, BASE_SYNTAX, checkOverflow, DIGIT_CHARS, DIGIT_SYNTAX, defaultOverflow, isDecimal, listLabel, MAX_COMPACT_RADIX, OVERFLOW_SEPARATOR, SEPARATOR, toInteger, } from "./common.js";
+import { MixedRadixNumber } from "./mixed-radix-number.js";
 /**
  * A base with one radix per digit position, most significant first.
  *
@@ -254,112 +221,3 @@ export class MixedRadix {
         return `MixedRadix('${this}')`;
     }
 }
-/**
- * A signed integer of any size, written in a MixedRadix.
- *
- * Arithmetic is on values, so operands may be in different bases, integers,
- * or text in this number's base. Results use the left operand's base.
- *
- * ```ts
- * new MixedRadixNumber("23:59:59", "24:60:60").add(1).toString(); // "1:0:0:0"
- * ```
- */
-export class MixedRadixNumber {
-    value;
-    base;
-    constructor(number, base = 10) {
-        const mixedRadix = MixedRadix.of(base);
-        const built = typeof number === "string" ? mixedRadix.parse(number) : mixedRadix.fromInt(number);
-        this.value = built.value;
-        this.base = mixedRadix;
-        Object.freeze(this);
-    }
-    /** @internal Makes a number from a value, wrapping it for `wrap` bases. */
-    static create(value, base) {
-        const modulus = base.modulus;
-        const number = Object.create(MixedRadixNumber.prototype);
-        Object.assign(number, { value: modulus === null ? value : mod(value, modulus), base });
-        return Object.freeze(number);
-    }
-    get isNegative() {
-        return this.value < 0n;
-    }
-    /** Digit values of the absolute value, most significant first. */
-    get digits() {
-        let remaining = abs(this.value);
-        const digits = []; // least significant first while building
-        if (this.base.overflow === "wrap") {
-            for (let i = this.base.radices.length - 1; i >= 0; i--) {
-                const radix = this.base.radices[i];
-                digits.push(remaining % radix);
-                remaining /= radix;
-            }
-        }
-        else {
-            for (let position = 0;; position++) {
-                const radix = this.base.radixAt(position);
-                if (radix === null) {
-                    digits.push(remaining);
-                    break;
-                }
-                digits.push(remaining % radix);
-                remaining /= radix;
-                if (remaining === 0n)
-                    break;
-            }
-        }
-        return Object.freeze(digits.reverse());
-    }
-    /** The same value written in another base. */
-    to(base) {
-        return MixedRadixNumber.create(this.value, MixedRadix.of(base));
-    }
-    // -- Arithmetic --------------------------------------------------------------
-    add(other) {
-        return MixedRadixNumber.create(this.value + operandValue(this, other), this.base);
-    }
-    sub(other) {
-        return MixedRadixNumber.create(this.value - operandValue(this, other), this.base);
-    }
-    neg() {
-        return MixedRadixNumber.create(-this.value, this.base);
-    }
-    abs() {
-        return MixedRadixNumber.create(abs(this.value), this.base);
-    }
-    // -- Comparison (by value) -----------------------------------------------------
-    /** -1, 0 or 1 as this value is below, equal to or above `other`'s. */
-    compare(other) {
-        const value = other instanceof MixedRadixNumber ? other.value : toInteger(other);
-        return this.value < value ? -1 : this.value > value ? 1 : 0;
-    }
-    /** True when the values are equal, whatever the bases. */
-    equals(other) {
-        return this.compare(other) === 0;
-    }
-    // -- Conversion ------------------------------------------------------------------
-    toBigInt() {
-        return this.value;
-    }
-    toString() {
-        const sign = this.value < 0n ? "-" : "";
-        const digits = this.digits;
-        if (this.base.isUniform)
-            return sign + digits.map((d) => DIGIT_CHARS[Number(d)]).join("");
-        return sign + digits.join(SEPARATOR);
-    }
-    toJSON() {
-        return this.toString();
-    }
-    [Symbol.for("nodejs.util.inspect.custom")]() {
-        return `MixedRadixNumber('${this}', base='${this.base}')`;
-    }
-}
-/** The value of an arithmetic operand; text is parsed in the left operand's base. */
-function operandValue(left, other) {
-    if (other instanceof MixedRadixNumber)
-        return other.value;
-    if (typeof other === "string")
-        return left.base.parse(other).value;
-    return toInteger(other);
-}

package/dist/errors/digit-out-of-range-error.d.ts

@@ -0,0 +1,8 @@
+import { InvalidNumberError } from "./invalid-number-error.js";
+/** A digit is not below the radix of its position. */
+export declare class DigitOutOfRangeError extends InvalidNumberError {
+    readonly digit: bigint;
+    readonly radix: bigint;
+    name: string;
+    constructor(number: string, digit: bigint, radix: bigint, char?: string);
+}

package/dist/errors/digit-out-of-range-error.js

@@ -0,0 +1,13 @@
+import { InvalidNumberError } from "./invalid-number-error.js";
+/** A digit is not below the radix of its position. */
+export class DigitOutOfRangeError extends InvalidNumberError {
+    digit;
+    radix;
+    name = "DigitOutOfRangeError";
+    constructor(number, digit, radix, char) {
+        const shown = char !== undefined && !/^[0-9]$/.test(char) ? `'${char}' (${digit})` : `${digit}`;
+        super(number, `digit ${shown} is out of range for radix ${radix}`);
+        this.digit = digit;
+        this.radix = radix;
+    }
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,4 @@
+export { DigitOutOfRangeError } from "./digit-out-of-range-error.js";
+export { InvalidBaseError } from "./invalid-base-error.js";
+export { InvalidNumberError } from "./invalid-number-error.js";
+export { MixedRadixError } from "./mixed-radix-error.js";

package/dist/errors/index.js

@@ -0,0 +1,4 @@
+export { DigitOutOfRangeError } from "./digit-out-of-range-error.js";
+export { InvalidBaseError } from "./invalid-base-error.js";
+export { InvalidNumberError } from "./invalid-number-error.js";
+export { MixedRadixError } from "./mixed-radix-error.js";

package/dist/errors/invalid-base-error.d.ts

@@ -0,0 +1,8 @@
+import { MixedRadixError } from "./mixed-radix-error.js";
+/** A base could not be parsed or built. */
+export declare class InvalidBaseError extends MixedRadixError {
+    readonly base: string;
+    readonly reason: string;
+    name: string;
+    constructor(base: string, reason: string);
+}

package/dist/errors/invalid-base-error.js

@@ -0,0 +1,12 @@
+import { MixedRadixError } from "./mixed-radix-error.js";
+/** A base could not be parsed or built. */
+export class InvalidBaseError extends MixedRadixError {
+    base;
+    reason;
+    name = "InvalidBaseError";
+    constructor(base, reason) {
+        super(`invalid base ${base}: ${reason}`);
+        this.base = base;
+        this.reason = reason;
+    }
+}

package/dist/errors/invalid-number-error.d.ts

@@ -0,0 +1,8 @@
+import { MixedRadixError } from "./mixed-radix-error.js";
+/** A number could not be parsed or built in its base. */
+export declare class InvalidNumberError extends MixedRadixError {
+    readonly number: string;
+    readonly reason: string;
+    name: string;
+    constructor(number: string, reason: string);
+}

package/dist/errors/invalid-number-error.js

@@ -0,0 +1,12 @@
+import { MixedRadixError } from "./mixed-radix-error.js";
+/** A number could not be parsed or built in its base. */
+export class InvalidNumberError extends MixedRadixError {
+    number;
+    reason;
+    name = "InvalidNumberError";
+    constructor(number, reason) {
+        super(`invalid number ${number}: ${reason}`);
+        this.number = number;
+        this.reason = reason;
+    }
+}

package/dist/errors/mixed-radix-error.d.ts

@@ -0,0 +1,4 @@
+/** Base class for every error thrown by mixradix. */
+export declare class MixedRadixError extends Error {
+    name: string;
+}

package/dist/errors/mixed-radix-error.js

@@ -0,0 +1,4 @@
+/** Base class for every error thrown by mixradix. */
+export class MixedRadixError extends Error {
+    name = "MixedRadixError";
+}

package/dist/index.d.ts

@@ -5,5 +5,5 @@
  * @module
  */
 export { add, type CalculateOptions, type ConvertOptions, convert, type NumberInput, sub, } from "./api.js";
-export { type BaseLike, type BaseOptions, MixedRadix, MixedRadixNumber, type NumberLike, type Overflow, } from "./core.js";
-export { DigitOutOfRangeError, InvalidBaseError, InvalidNumberError, MixedRadixError, } from "./errors.js";
+export { type BaseLike, type BaseOptions, MixedRadix, MixedRadixNumber, type NumberLike, type Overflow, } from "./core/index.js";
+export { DigitOutOfRangeError, InvalidBaseError, InvalidNumberError, MixedRadixError, } from "./errors/index.js";

package/dist/index.js

@@ -5,5 +5,5 @@
  * @module
  */
 export { add, convert, sub, } from "./api.js";
-export { MixedRadix, MixedRadixNumber, } from "./core.js";
-export { DigitOutOfRangeError, InvalidBaseError, InvalidNumberError, MixedRadixError, } from "./errors.js";
+export { MixedRadix, MixedRadixNumber, } from "./core/index.js";
+export { DigitOutOfRangeError, InvalidBaseError, InvalidNumberError, MixedRadixError, } from "./errors/index.js";

package/dist/usage-error.d.ts

@@ -0,0 +1,6 @@
+/** A bad command line: printed with the usage text, exit code 2. */
+export declare class UsageError extends Error {
+    readonly usage: string;
+    readonly prog: string;
+    constructor(usage: string, prog: string, message: string);
+}

package/dist/usage-error.js

@@ -0,0 +1,10 @@
+/** A bad command line: printed with the usage text, exit code 2. */
+export class UsageError extends Error {
+    usage;
+    prog;
+    constructor(usage, prog, message) {
+        super(message);
+        this.usage = usage;
+        this.prog = prog;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixradix",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Add, subtract and convert integers of any size in mixed radix bases (like 24:60:60), with a CLI",
   "keywords": [
     "mixed-radix",

package/dist/errors.d.ts

@@ -1,25 +0,0 @@
-/** Base class for every error thrown by mixradix. */
-export declare class MixedRadixError extends Error {
-    name: string;
-}
-/** A base could not be parsed or built. */
-export declare class InvalidBaseError extends MixedRadixError {
-    readonly base: string;
-    readonly reason: string;
-    name: string;
-    constructor(base: string, reason: string);
-}
-/** A number could not be parsed or built in its base. */
-export declare class InvalidNumberError extends MixedRadixError {
-    readonly number: string;
-    readonly reason: string;
-    name: string;
-    constructor(number: string, reason: string);
-}
-/** A digit is not below the radix of its position. */
-export declare class DigitOutOfRangeError extends InvalidNumberError {
-    readonly digit: bigint;
-    readonly radix: bigint;
-    name: string;
-    constructor(number: string, digit: bigint, radix: bigint, char?: string);
-}

package/dist/errors.js

@@ -1,38 +0,0 @@
-/** Base class for every error thrown by mixradix. */
-export class MixedRadixError extends Error {
-    name = "MixedRadixError";
-}
-/** A base could not be parsed or built. */
-export class InvalidBaseError extends MixedRadixError {
-    base;
-    reason;
-    name = "InvalidBaseError";
-    constructor(base, reason) {
-        super(`invalid base ${base}: ${reason}`);
-        this.base = base;
-        this.reason = reason;
-    }
-}
-/** A number could not be parsed or built in its base. */
-export class InvalidNumberError extends MixedRadixError {
-    number;
-    reason;
-    name = "InvalidNumberError";
-    constructor(number, reason) {
-        super(`invalid number ${number}: ${reason}`);
-        this.number = number;
-        this.reason = reason;
-    }
-}
-/** A digit is not below the radix of its position. */
-export class DigitOutOfRangeError extends InvalidNumberError {
-    digit;
-    radix;
-    name = "DigitOutOfRangeError";
-    constructor(number, digit, radix, char) {
-        const shown = char !== undefined && !/^[0-9]$/.test(char) ? `'${char}' (${digit})` : `${digit}`;
-        super(number, `digit ${shown} is out of range for radix ${radix}`);
-        this.digit = digit;
-        this.radix = radix;
-    }
-}