@fulcro/types 0.1.0

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsignedInteger = exports.SinglePrecisionFloat = exports.SignedInteger = exports.HalfPrecisionFloat = exports.DoublePrecisionFloat = exports.Decimal = exports.BigInteger = void 0;
+/**
+ * Public entry point of the package, matching the `main` and `types` fields of
+ * `package.json`.
+ *
+ * Listed one by one rather than re-exported wholesale, so that adding an export
+ * to a module below is never enough on its own to put it in front of consumers.
+ * The modules export more than this — `createIntegerType`, the parts and the
+ * rounding of `Decimal` — and none of it is a promise.
+ *
+ * Every type here has a value of the same name beside it. A consumer who wants
+ * only the types imports them with `import type` and takes no code at all.
+ */
+var bigInteger_1 = require("./bigInteger/index.js");
+Object.defineProperty(exports, "BigInteger", { enumerable: true, get: function () { return bigInteger_1.BigInteger; } });
+var decimal_1 = require("./decimal/index.js");
+Object.defineProperty(exports, "Decimal", { enumerable: true, get: function () { return decimal_1.Decimal; } });
+var doublePrecisionFloat_1 = require("./doublePrecisionFloat/index.js");
+Object.defineProperty(exports, "DoublePrecisionFloat", { enumerable: true, get: function () { return doublePrecisionFloat_1.DoublePrecisionFloat; } });
+var halfPrecisionFloat_1 = require("./halfPrecisionFloat/index.js");
+Object.defineProperty(exports, "HalfPrecisionFloat", { enumerable: true, get: function () { return halfPrecisionFloat_1.HalfPrecisionFloat; } });
+var signedInteger_1 = require("./signedInteger/index.js");
+Object.defineProperty(exports, "SignedInteger", { enumerable: true, get: function () { return signedInteger_1.SignedInteger; } });
+var singlePrecisionFloat_1 = require("./singlePrecisionFloat/index.js");
+Object.defineProperty(exports, "SinglePrecisionFloat", { enumerable: true, get: function () { return singlePrecisionFloat_1.SinglePrecisionFloat; } });
+var unsignedInteger_1 = require("./unsignedInteger/index.js");
+Object.defineProperty(exports, "UnsignedInteger", { enumerable: true, get: function () { return unsignedInteger_1.UnsignedInteger; } });

package/dist/integer/index.d.ts

@@ -0,0 +1,163 @@
+import type { BoundedNumericType } from '../numericType/index.js';
+/**
+ * Machinery shared by `SignedInteger` and `UnsignedInteger`.
+ *
+ * The two differ only in where their range starts, so everything else — the
+ * range check, the modular conversion, the checked arithmetic — is written once
+ * here. Nothing in this module is exported by the package except the two types
+ * a signature needs: `IntegerWidth` and `IntegerType`.
+ */
+/** The widths a fixed-width integer comes in, in bits. */
+export type IntegerWidth = 8 | 16 | 32 | 64 | 128;
+/** Size, and alignment, of each width in bytes. */
+interface ByteSizes {
+    readonly 8: 1;
+    readonly 16: 2;
+    readonly 32: 4;
+    readonly 64: 8;
+    readonly 128: 16;
+}
+/**
+ * Size of an integer of a width, in bytes; its alignment is the same number,
+ * as it is for every fixed-width integer on the platforms that define one.
+ *
+ * @template N Width, in bits.
+ */
+export type ByteSize<N extends IntegerWidth> = ByteSizes[N];
+/**
+ * The primitive an integer of a width is carried by.
+ *
+ * Up to 32 bits a `number` holds every value exactly and costs nothing. From 64
+ * bits it cannot — a `number` is exact only up to 2^53 — so the value is a
+ * `bigint`, and a consumer sees that in the type rather than discovering it as
+ * a lost digit.
+ *
+ * @template N Width, in bits.
+ */
+export type IntegerRepresentation<N extends IntegerWidth> = N extends 64 | 128 ? bigint : number;
+/**
+ * Descriptor of a fixed-width integer type.
+ *
+ * Every operation is checked: a result outside the range throws a `RangeError`
+ * naming the operation, the value and the range, as a C# `checked` context
+ * does. `wrap` is the one exception, and the explicit way to ask for the
+ * modular behaviour of an `unchecked` conversion.
+ *
+ * @template T Type of the values this descriptor produces.
+ */
+export interface IntegerType<T> extends BoundedNumericType<T, number | bigint> {
+    /** Width of the type, in bits. */
+    readonly width: IntegerWidth;
+    /** Whether the range includes negative values. */
+    readonly signed: boolean;
+    /**
+     * Converts an integer into this type modulo 2^width, as a two's complement
+     * truncation does. Never throws for an integer, whatever its size.
+     *
+     * ```ts
+     * SignedInteger(8).wrap(200); // -56
+     * UnsignedInteger(8).wrap(-1); // 255
+     * ```
+     *
+     * @param value Integer to convert.
+     * @returns The value congruent to it within the range.
+     * @throws {RangeError} When the value is a `number` that is not an integer.
+     */
+    wrap(value: number | bigint): T;
+    /**
+     * Divides, truncating the quotient towards zero as integer division does in
+     * C#, Java and `BigInt`.
+     *
+     * @param left Dividend.
+     * @param right Divisor.
+     * @returns The truncated quotient.
+     * @throws {RangeError} On a zero divisor, and on the one quotient a signed
+     * type cannot hold: its minimum divided by `-1`.
+     */
+    divide(left: T, right: T): T;
+    /**
+     * The bits set in both, as `&` computes them.
+     *
+     * @param left First operand.
+     * @param right Second operand.
+     * @returns The conjunction of the bits.
+     */
+    bitwiseAnd(left: T, right: T): T;
+    /**
+     * The bits set in either, as `|` computes them.
+     *
+     * @param left First operand.
+     * @param right Second operand.
+     * @returns The disjunction of the bits.
+     */
+    bitwiseOr(left: T, right: T): T;
+    /**
+     * The bits set in exactly one, as `^` computes them.
+     *
+     * @param left First operand.
+     * @param right Second operand.
+     * @returns The exclusive disjunction of the bits.
+     */
+    bitwiseXor(left: T, right: T): T;
+    /**
+     * Every bit of the width flipped, as `~` does.
+     *
+     * @param value Operand.
+     * @returns The complement, within the width.
+     */
+    bitwiseNot(value: T): T;
+    /**
+     * Shifts the bits towards the most significant end, as `<<` does. Bits
+     * shifted past the width are discarded: a shift is a bit operation, never
+     * an overflow.
+     *
+     * @param value Operand.
+     * @param count Places to shift, from 0 to `width - 1`.
+     * @returns The shifted value, within the width.
+     * @throws {RangeError} When the count is outside 0 … `width - 1`.
+     */
+    shiftLeft(value: T, count: T): T;
+    /**
+     * Shifts the bits towards the least significant end, as `>>` does: copying
+     * the sign bit in on a signed type, and zeros on an unsigned one.
+     *
+     * @param value Operand.
+     * @param count Places to shift, from 0 to `width - 1`.
+     * @returns The shifted value.
+     * @throws {RangeError} When the count is outside 0 … `width - 1`.
+     */
+    shiftRight(value: T, count: T): T;
+    /**
+     * Shifts the bits towards the least significant end with zeros coming in,
+     * as `>>>` does — on a signed type, over the bits of its own width, and read
+     * back as signed, as Java's `>>>` does.
+     *
+     * ```ts
+     * const Int32 = SignedInteger(32);
+     *
+     * Int32.shiftRightLogical(Int32.from(-1), Int32.from(28)); // 15
+     * ```
+     *
+     * @param value Operand.
+     * @param count Places to shift, from 0 to `width - 1`.
+     * @returns The shifted value.
+     * @throws {RangeError} When the count is outside 0 … `width - 1`.
+     */
+    shiftRightLogical(value: T, count: T): T;
+}
+/**
+ * Builds the descriptor of one signedness and width.
+ *
+ * Two implementations behind one interface: the widths a `number` holds work in
+ * `number` throughout and never touch a `bigint`, and the wider ones work in
+ * `bigint` throughout. Mixing the two would make every 32-bit addition pay for
+ * a conversion it never needed, which the performance suite counts.
+ *
+ * @param signed Whether the range includes negative values.
+ * @param width Width, in bits.
+ * @param name Name of the type, as it reads in an error message.
+ * @returns The descriptor.
+ * @throws {RangeError} When the width is not one of {@link IntegerWidth}.
+ */
+export declare const createIntegerType: <T>(signed: boolean, width: IntegerWidth, name: string) => IntegerType<T>;
+export {};

package/dist/integer/index.js

@@ -0,0 +1,402 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIntegerType = void 0;
+/** Every width, for validating the argument a descriptor is built from. */
+const INTEGER_WIDTHS = [8, 16, 32, 64, 128];
+/**
+ * Formats a range for an error message.
+ *
+ * @param minimum Smallest value.
+ * @param maximum Largest value.
+ * @returns The range, as `[minimum, maximum]`.
+ */
+const describeRange = (minimum, maximum) => `[${minimum}, ${maximum}]`;
+/**
+ * Describes a value for an error message without letting a stray `-0` read as
+ * `0` or a `bigint` lose its suffix.
+ *
+ * @param value Value being reported.
+ * @returns The value as the caller wrote it.
+ */
+const describeValue = (value) => {
+    if (typeof value === 'bigint')
+        return `${value}n`;
+    if (Object.is(value, -0))
+        return '-0';
+    return String(value);
+};
+/**
+ * Fails a conversion whose input is not a number or a bigint at all.
+ *
+ * @param name Name of the type converting.
+ * @param operation Operation being performed.
+ * @param value Value it was handed.
+ * @returns Never.
+ */
+const rejectKind = (name, operation, value) => {
+    throw new TypeError(`${name}.${operation}: expected a number or a bigint, received ${typeof value}.`);
+};
+/**
+ * Fails a conversion of a number that has a fractional part, or is not finite.
+ *
+ * @param name Name of the type converting.
+ * @param operation Operation being performed.
+ * @param value Value it was handed.
+ * @returns Never.
+ */
+const rejectFraction = (name, operation, value) => {
+    throw new RangeError(`${name}.${operation}: expected an integer, received ${describeValue(value)}.`);
+};
+/**
+ * Fails a power whose exponent is negative, which has no integer result.
+ *
+ * @param name Name of the type.
+ * @param exponent Exponent it was handed.
+ * @returns Never.
+ */
+const rejectNegativeExponent = (name, exponent) => {
+    throw new RangeError(`${name}.power: expected an exponent of zero or more, received ${describeValue(exponent)}.`);
+};
+/**
+ * Fails a shift whose count is outside the width.
+ *
+ * @param name Name of the type.
+ * @param operation Shift being performed.
+ * @param width Width of the type.
+ * @param count Count it was handed.
+ * @returns Never.
+ */
+const rejectCount = (name, operation, width, count) => {
+    throw new RangeError(`${name}.${operation}: expected a count from 0 to ${width - 1}, received ${describeValue(count)}.`);
+};
+/**
+ * Builds the descriptor of one signedness and width.
+ *
+ * Two implementations behind one interface: the widths a `number` holds work in
+ * `number` throughout and never touch a `bigint`, and the wider ones work in
+ * `bigint` throughout. Mixing the two would make every 32-bit addition pay for
+ * a conversion it never needed, which the performance suite counts.
+ *
+ * @param signed Whether the range includes negative values.
+ * @param width Width, in bits.
+ * @param name Name of the type, as it reads in an error message.
+ * @returns The descriptor.
+ * @throws {RangeError} When the width is not one of {@link IntegerWidth}.
+ */
+const createIntegerType = (signed, width, name) => {
+    if (!INTEGER_WIDTHS.includes(width)) {
+        throw new RangeError(`${signed ? 'SignedInteger' : 'UnsignedInteger'}: expected a width of ${INTEGER_WIDTHS.join(', ')} bits, received ${describeValue(width)}.`);
+    }
+    const minimum = signed ? -(1n << BigInt(width - 1)) : 0n;
+    const maximum = signed
+        ? (1n << BigInt(width - 1)) - 1n
+        : (1n << BigInt(width)) - 1n;
+    return width >= 64
+        ? createBigIntegerType(signed, width, name, minimum, maximum)
+        : createNumberIntegerType(signed, width, name, minimum, maximum);
+};
+exports.createIntegerType = createIntegerType;
+/**
+ * Builds the descriptor of a width carried by a `number`.
+ *
+ * @param signed Whether the range includes negative values.
+ * @param width Width, in bits.
+ * @param name Name of the type.
+ * @param minimum Smallest value.
+ * @param maximum Largest value.
+ * @returns The descriptor.
+ */
+const createNumberIntegerType = (signed, width, name, minimum, maximum) => {
+    const low = Number(minimum);
+    const high = Number(maximum);
+    const range = describeRange(minimum, maximum);
+    /**
+     * Accepts a result that fits, normalising `-0` to `0`.
+     *
+     * `-0` fits every range, but an integer has one zero: letting the negative
+     * one through would make `Object.is` tell two equal integers apart.
+     *
+     * @param operation Operation that produced the value.
+     * @param value Exact result of the operation.
+     * @returns The value, as this type.
+     */
+    const accept = (operation, value) => {
+        if (value < low || value > high) {
+            throw new RangeError(`${name}.${operation}: ${describeValue(value)} is outside ${range}.`);
+        }
+        return (value === 0 ? 0 : value);
+    };
+    // Two's complement truncation, done by the engine's own 32-bit conversions:
+    // `| 0` and `>>> 0` reduce any finite integer modulo 2^32 exactly, and the
+    // shifts then sign-extend or mask down to the narrower widths.
+    const truncate = width === 32
+        ? signed
+            ? (value) => value | 0
+            : (value) => value >>> 0
+        : signed
+            ? (value) => (value << (32 - width)) >> (32 - width)
+            : (value) => value & (2 ** width - 1);
+    /**
+     * Refuses a zero divisor.
+     *
+     * @param operation Operation being performed.
+     * @param divisor Divisor it was handed.
+     */
+    const requireDivisor = (operation, divisor) => {
+        if (divisor === 0) {
+            throw new RangeError(`${name}.${operation}: division by zero.`);
+        }
+    };
+    /** The bits of the width, for reading a narrow signed value as unsigned. */
+    const mask = width === 32 ? 0xffff_ffff : 2 ** width - 1;
+    /**
+     * Accepts a shift count within the width.
+     *
+     * @param operation Shift being performed.
+     * @param count Count it was handed.
+     * @returns The count.
+     */
+    const requireCount = (operation, count) => {
+        const places = count;
+        if (places < 0 || places >= width) {
+            return rejectCount(name, operation, width, places);
+        }
+        return places;
+    };
+    return {
+        name,
+        width,
+        signed,
+        minimum: low,
+        maximum: high,
+        from: (value) => {
+            if (typeof value === 'bigint') {
+                if (value < minimum || value > maximum) {
+                    throw new RangeError(`${name}.from: ${describeValue(value)} is outside ${range}.`);
+                }
+                return Number(value);
+            }
+            if (typeof value !== 'number')
+                return rejectKind(name, 'from', value);
+            if (!Number.isInteger(value))
+                return rejectFraction(name, 'from', value);
+            return accept('from', value);
+        },
+        wrap: (value) => {
+            if (typeof value === 'bigint') {
+                return Number(signed ? BigInt.asIntN(width, value) : BigInt.asUintN(width, value));
+            }
+            if (typeof value !== 'number')
+                return rejectKind(name, 'wrap', value);
+            if (!Number.isInteger(value))
+                return rejectFraction(name, 'wrap', value);
+            const wrapped = truncate(value);
+            return (wrapped === 0 ? 0 : wrapped);
+        },
+        is: (value) => typeof value === 'number' &&
+            Number.isInteger(value) &&
+            value >= low &&
+            value <= high,
+        add: (left, right) => accept('add', left + right),
+        subtract: (left, right) => accept('subtract', left - right),
+        // Exact below 2^53, and any product at or beyond it is already out of
+        // every range carried by a `number`, rounded or not — so checking the
+        // rounded product decides the exact one correctly.
+        multiply: (left, right) => accept('multiply', left * right),
+        // For operands under 2^32 the quotient sits at least 1/|dividend| away
+        // from the next integer, which is further than a double can round, so
+        // truncating the floating quotient gives the integer one.
+        divide: (left, right) => {
+            requireDivisor('divide', right);
+            return accept('divide', Math.trunc(left / right));
+        },
+        remainder: (left, right) => {
+            requireDivisor('remainder', right);
+            return accept('remainder', left % right);
+        },
+        // By squaring, each product checked as `multiply` checks it. The base is
+        // only squared while a higher bit of the exponent remains, and then the
+        // result will include that square as a factor — so a square out of range
+        // means a result out of range, never a false alarm.
+        power: (base, exponent) => {
+            let remaining = exponent;
+            if (remaining < 0)
+                return rejectNegativeExponent(name, remaining);
+            let result = 1;
+            let factor = base;
+            while (remaining > 0) {
+                if (remaining % 2 === 1) {
+                    result = accept('power', result * factor);
+                }
+                remaining = Math.floor(remaining / 2);
+                if (remaining > 0)
+                    factor = accept('power', factor * factor);
+            }
+            return accept('power', result);
+        },
+        negate: (value) => accept('negate', -value),
+        increment: (value) => accept('increment', value + 1),
+        decrement: (value) => accept('decrement', value - 1),
+        equals: (left, right) => left === right,
+        lessThan: (left, right) => left < right,
+        lessThanOrEqual: (left, right) => left <= right,
+        greaterThan: (left, right) => left > right,
+        greaterThanOrEqual: (left, right) => left >= right,
+        // Two values in range combine, through the engine's 32-bit operators,
+        // into a value whose low `width` bits are the answer; truncating keeps
+        // exactly those, sign-extended or masked as the type is.
+        bitwiseAnd: (left, right) => truncate(left & right),
+        bitwiseOr: (left, right) => truncate(left | right),
+        bitwiseXor: (left, right) => truncate(left ^ right),
+        bitwiseNot: (value) => truncate(~value),
+        shiftLeft: (value, count) => truncate(value << requireCount('shiftLeft', count)),
+        // Arithmetic on a signed type, whose values are already sign-correct
+        // numbers; on an unsigned one the value is non-negative, so the two
+        // shifts agree except at 32 bits, where only `>>>` reads it as unsigned.
+        shiftRight: (value, count) => {
+            const places = requireCount('shiftRight', count);
+            return (signed ? value >> places : value >>> places);
+        },
+        shiftRightLogical: (value, count) => {
+            const places = requireCount('shiftRightLogical', count);
+            const bits = width === 32 ? value >>> 0 : value & mask;
+            return truncate(bits >>> places);
+        },
+    };
+};
+/**
+ * Builds the descriptor of a width carried by a `bigint`.
+ *
+ * @param signed Whether the range includes negative values.
+ * @param width Width, in bits.
+ * @param name Name of the type.
+ * @param minimum Smallest value.
+ * @param maximum Largest value.
+ * @returns The descriptor.
+ */
+const createBigIntegerType = (signed, width, name, minimum, maximum) => {
+    const range = describeRange(minimum, maximum);
+    /**
+     * Accepts a result that fits.
+     *
+     * @param operation Operation that produced the value.
+     * @param value Exact result of the operation.
+     * @param reported The value as the caller wrote it, when it arrived as a
+     * `number` and was converted: the message repeats what was passed.
+     * @returns The value, as this type.
+     */
+    const accept = (operation, value, reported = value) => {
+        if (value < minimum || value > maximum) {
+            throw new RangeError(`${name}.${operation}: ${describeValue(reported)} is outside ${range}.`);
+        }
+        return value;
+    };
+    /**
+     * Turns an accepted input into a `bigint`.
+     *
+     * @param operation Operation being performed.
+     * @param value Value it was handed.
+     * @returns The value, as a `bigint`.
+     */
+    const toBigInt = (operation, value) => {
+        if (typeof value === 'bigint')
+            return value;
+        if (typeof value !== 'number')
+            return rejectKind(name, operation, value);
+        if (!Number.isInteger(value))
+            return rejectFraction(name, operation, value);
+        return BigInt(value);
+    };
+    /**
+     * Refuses a zero divisor, which `bigint` would also refuse, but without
+     * saying which type or operation it was.
+     *
+     * @param operation Operation being performed.
+     * @param divisor Divisor it was handed.
+     */
+    const requireDivisor = (operation, divisor) => {
+        if (divisor === 0n) {
+            throw new RangeError(`${name}.${operation}: division by zero.`);
+        }
+    };
+    /**
+     * Keeps the low `width` bits of a result, sign-extended or not as the type
+     * is.
+     *
+     * @param value Result of a bit operation, of any size.
+     * @returns The value, as this type.
+     */
+    const wrapBits = (value) => (signed ? BigInt.asIntN(width, value) : BigInt.asUintN(width, value));
+    /**
+     * Accepts a shift count within the width.
+     *
+     * @param operation Shift being performed.
+     * @param count Count it was handed.
+     * @returns The count.
+     */
+    const requireCount = (operation, count) => {
+        const places = count;
+        if (places < 0n || places >= BigInt(width)) {
+            return rejectCount(name, operation, width, places);
+        }
+        return places;
+    };
+    return {
+        name,
+        width,
+        signed,
+        minimum: minimum,
+        maximum: maximum,
+        from: (value) => accept('from', toBigInt('from', value), value),
+        wrap: (value) => {
+            const integer = toBigInt('wrap', value);
+            return (signed ? BigInt.asIntN(width, integer) : BigInt.asUintN(width, integer));
+        },
+        is: (value) => typeof value === 'bigint' && value >= minimum && value <= maximum,
+        add: (left, right) => accept('add', left + right),
+        subtract: (left, right) => accept('subtract', left - right),
+        multiply: (left, right) => accept('multiply', left * right),
+        // `bigint` division already truncates towards zero.
+        divide: (left, right) => {
+            requireDivisor('divide', right);
+            return accept('divide', left / right);
+        },
+        remainder: (left, right) => {
+            requireDivisor('remainder', right);
+            return accept('remainder', left % right);
+        },
+        // Any base of magnitude two or more overflows every width once the
+        // exponent reaches that width, so a large exponent is refused before the
+        // power is built — `2n ** 1_000_000_000n` would otherwise spend its time
+        // building a number only to reject it.
+        power: (base, exponent) => {
+            const power = exponent;
+            const value = base;
+            if (power < 0n)
+                return rejectNegativeExponent(name, power);
+            const magnitude = value < 0n ? -value : value;
+            if (magnitude >= 2n && power >= BigInt(width)) {
+                throw new RangeError(`${name}.power: ${describeValue(value)} ** ${describeValue(power)} is outside ${range}.`);
+            }
+            return accept('power', value ** power);
+        },
+        negate: (value) => accept('negate', -value),
+        increment: (value) => accept('increment', value + 1n),
+        decrement: (value) => accept('decrement', value - 1n),
+        equals: (left, right) => left === right,
+        lessThan: (left, right) => left < right,
+        lessThanOrEqual: (left, right) => left <= right,
+        greaterThan: (left, right) => left > right,
+        greaterThanOrEqual: (left, right) => left >= right,
+        bitwiseAnd: (left, right) => wrapBits(left & right),
+        bitwiseOr: (left, right) => wrapBits(left | right),
+        bitwiseXor: (left, right) => wrapBits(left ^ right),
+        bitwiseNot: (value) => wrapBits(~value),
+        shiftLeft: (value, count) => wrapBits(value << requireCount('shiftLeft', count)),
+        // `bigint` shifts are arithmetic, which is right for a signed type and,
+        // for the non-negative values of an unsigned one, the same as logical.
+        shiftRight: (value, count) => (value >> requireCount('shiftRight', count)),
+        shiftRightLogical: (value, count) => wrapBits(BigInt.asUintN(width, value) >>
+            requireCount('shiftRightLogical', count)),
+    };
+};

package/dist/languageService/index.d.ts

@@ -0,0 +1,21 @@
+import { type LanguageServicePlugin } from '@fulcro/transform-core';
+/**
+ * The editor plugin giving the operators their meaning on this package's
+ * numeric types: the types, the hover, the completions and the errors an editor
+ * shows are those of the rewritten code, mapped back onto the code as written.
+ *
+ * ```json
+ * {
+ * 	"compilerOptions": {
+ * 		"plugins": [{ "name": "@fulcro/types/language-service" }]
+ * 	}
+ * }
+ * ```
+ *
+ * VS Code loads it only from the workspace's own TypeScript: select it with
+ * **TypeScript: Select TypeScript Version → Use Workspace Version**. An editor
+ * that does not load it shows what `tsc` alone would — the operators on a
+ * `Decimal` underlined, the others typed as `number`.
+ */
+declare const plugin: LanguageServicePlugin;
+export = plugin;

package/dist/languageService/index.js

@@ -0,0 +1,23 @@
+"use strict";
+const transform_core_1 = require("@fulcro/transform-core");
+const rewriter_1 = require("../transformer/rewriter/index.js");
+/**
+ * The editor plugin giving the operators their meaning on this package's
+ * numeric types: the types, the hover, the completions and the errors an editor
+ * shows are those of the rewritten code, mapped back onto the code as written.
+ *
+ * ```json
+ * {
+ * 	"compilerOptions": {
+ * 		"plugins": [{ "name": "@fulcro/types/language-service" }]
+ * 	}
+ * }
+ * ```
+ *
+ * VS Code loads it only from the workspace's own TypeScript: select it with
+ * **TypeScript: Select TypeScript Version → Use Workspace Version**. An editor
+ * that does not load it shows what `tsc` alone would — the operators on a
+ * `Decimal` underlined, the others typed as `number`.
+ */
+const plugin = (0, transform_core_1.createLanguageServicePlugin)(rewriter_1.OPERATOR_REWRITER);
+module.exports = plugin;

package/dist/layout/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The memory layout a type declares, carried by the type and never by a value.
+ *
+ * ```ts
+ * type SignedInteger<32> = … & Layout<4, 4>;
+ * ```
+ *
+ * This is a protocol between packages rather than a type either of them owns.
+ * `sizeOf<T>()` and `alignOf<T>()` in `@fulcro/reflect` read the property
+ * through the type checker, at compile time, and constrain `T` to carry it — so
+ * `sizeOf<BigInteger>()`, which has no fixed layout, is a type error rather
+ * than a wrong number. Neither package imports the other for this: the shape is
+ * the whole agreement, which is also what lets a later value type declare its
+ * own layout without depending on this package.
+ *
+ * The key is a string with a leading `~`, not a symbol, because a symbol would
+ * have to be imported to be named, and naming it is exactly what the other side
+ * of the protocol needs to do. The tilde sorts the key after every real member
+ * in an editor's completion list — the convention Standard Schema settled on
+ * for its `~standard` property, for the same reason.
+ *
+ * The property is declared, never assigned: reading it at runtime yields
+ * `undefined`.
+ *
+ * @template TSize Size of the type, in bytes.
+ * @template TAlignment Alignment of the type, in bytes.
+ */
+export interface Layout<TSize extends number, TAlignment extends number> {
+    readonly '~layout': {
+        readonly size: TSize;
+        readonly alignment: TAlignment;
+    };
+}

package/dist/layout/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });