@openmbee/opensysml 0.9.1

package/dist/core/values.js

@@ -0,0 +1,687 @@
+// Values, quantities and verdicts as discriminated unions: a caller switches on
+// `kind` and the compiler checks the switch is exhaustive.
+import { create } from "@bufbuild/protobuf";
+import { ArraySchema, ComplexSchema, EnumLiteralSchema, FailureReason, FunctionSchema, MeasurementRefSchema, MetaobjectSchema, QuantitySchema, TensorQuantitySchema, UnitFactorSchema, UnitTermSchema, ValueSchema, ValueSequenceSchema, ValueSetSchema, VectorQuantitySchema, VectorSchema, } from "../generated/sysml_pb.js";
+import { MalformedValueError } from "./errors.js";
+/**
+ * Decodes a `sysml.Value` into the union.
+ *
+ * @throws {MalformedValueError} for a value that contradicts itself: an array
+ *   whose elements do not fill its dimensions, a vector with a component that
+ *   is not a number, a vector quantity with no components, a set listing a
+ *   member twice, a tensor quantity whose components do not fill its
+ *   dimensions, a quantity (alone or as a component) with no magnitude, a
+ *   measurement reference naming no unit or a unit without its reduction, or a
+ *   metaobject naming no element.
+ */
+export function decodeValue(value) {
+    if (value === undefined) {
+        return { kind: "absent" };
+    }
+    const kind = value.kind;
+    switch (kind.case) {
+        case "intValue":
+            return { kind: "int", value: kind.value };
+        case "realValue":
+            return { kind: "real", value: kind.value };
+        case "complex":
+            return { kind: "complex", value: { real: kind.value.real, imaginary: kind.value.imaginary } };
+        case "boolValue":
+            return { kind: "boolean", value: kind.value };
+        case "stringValue":
+            return { kind: "string", value: kind.value };
+        case "instanceId":
+            return { kind: "instance", id: kind.value };
+        case "sequence":
+            return { kind: "sequence", elements: kind.value.elements.map(decodeValue) };
+        case "quantity":
+            return { kind: "quantity", ...decodeQuantity(kind.value) };
+        case "measurementRef":
+            return { kind: "measurementRef", ...decodeMeasurementRef(kind.value) };
+        case "function":
+            return { kind: "function", ...decodeFunction(kind.value) };
+        case "enumLiteral":
+            return { kind: "enum", value: decodeEnumLiteral(kind.value) };
+        case "array":
+            return { kind: "array", ...decodeArray(kind.value) };
+        case "vector":
+            return { kind: "vector", components: decodeVector(kind.value) };
+        case "vectorQuantity":
+            return { kind: "vectorQuantity", components: decodeVectorQuantity(kind.value) };
+        case "set":
+            return { kind: "set", elements: decodeSet(kind.value) };
+        case "tensorQuantity":
+            return { kind: "tensorQuantity", ...decodeTensorQuantity(kind.value) };
+        case "metaobject":
+            return { kind: "metaobject", ...decodeMetaobject(kind.value) };
+        case "null":
+            return { kind: "null", reason: kind.value };
+        case "unset":
+            return { kind: "unset" };
+        case "undetermined":
+            return {
+                kind: "undetermined",
+                reason: kind.value.reason,
+                countLower: kind.value.count?.lower ?? "",
+                countUpper: kind.value.count?.upper ?? "",
+            };
+        case "infinity":
+            // Only an asserted arm carries the unbounded value.
+            if (!kind.value) {
+                throw new MalformedValueError("the infinity arm states no value unless it is true");
+            }
+            return { kind: "infinity" };
+        case undefined:
+            return { kind: "absent" };
+    }
+}
+/**
+ * Encodes the union as the `sysml.Value` the service decodes: the inverse of
+ * {@link decodeValue} for every kind but `absent`, which is no value at all.
+ *
+ * @throws {MalformedValueError} for an `absent` value, or a structured value
+ *   the service would refuse (see {@link decodeValue}).
+ */
+export function encodeValue(value) {
+    switch (value.kind) {
+        case "int":
+            return create(ValueSchema, { kind: { case: "intValue", value: value.value } });
+        case "real":
+            return create(ValueSchema, { kind: { case: "realValue", value: value.value } });
+        case "complex":
+            return create(ValueSchema, {
+                kind: { case: "complex", value: create(ComplexSchema, value.value) },
+            });
+        case "boolean":
+            return create(ValueSchema, { kind: { case: "boolValue", value: value.value } });
+        case "string":
+            return create(ValueSchema, { kind: { case: "stringValue", value: value.value } });
+        case "instance":
+            return create(ValueSchema, { kind: { case: "instanceId", value: value.id } });
+        case "sequence":
+            return create(ValueSchema, {
+                kind: {
+                    case: "sequence",
+                    value: create(ValueSequenceSchema, { elements: value.elements.map(encodeValue) }),
+                },
+            });
+        case "quantity":
+            return create(ValueSchema, { kind: { case: "quantity", value: encodeQuantity(value) } });
+        case "measurementRef":
+            return create(ValueSchema, {
+                kind: { case: "measurementRef", value: encodeMeasurementRef(value) },
+            });
+        case "function":
+            return create(ValueSchema, { kind: { case: "function", value: encodeFunction(value) } });
+        case "enum":
+            return create(ValueSchema, {
+                kind: { case: "enumLiteral", value: encodeEnumLiteral(value.value) },
+            });
+        case "array":
+            checkShape("an array", value.dimensions, value.elements.length);
+            return create(ValueSchema, {
+                kind: {
+                    case: "array",
+                    value: create(ArraySchema, {
+                        dimensions: value.dimensions,
+                        elements: value.elements.map(encodeValue),
+                    }),
+                },
+            });
+        case "vector":
+            return create(ValueSchema, {
+                kind: {
+                    case: "vector",
+                    value: create(VectorSchema, { components: value.components.map(encodeMagnitude) }),
+                },
+            });
+        case "vectorQuantity":
+            if (value.components.length === 0) {
+                throw new MalformedValueError("a vector quantity has no components");
+            }
+            return create(ValueSchema, {
+                kind: {
+                    case: "vectorQuantity",
+                    value: create(VectorQuantitySchema, { components: value.components.map(encodeQuantity) }),
+                },
+            });
+        case "set":
+            return create(ValueSchema, {
+                kind: {
+                    case: "set",
+                    value: create(ValueSetSchema, {
+                        elements: uniqueMembers(value.elements).map(encodeValue),
+                    }),
+                },
+            });
+        case "tensorQuantity":
+            checkShape("a tensor quantity", value.dimensions, value.components.length);
+            return create(ValueSchema, {
+                kind: {
+                    case: "tensorQuantity",
+                    value: create(TensorQuantitySchema, {
+                        dimensions: value.dimensions,
+                        components: value.components.map(encodeQuantity),
+                    }),
+                },
+            });
+        case "metaobject":
+            return create(ValueSchema, { kind: { case: "metaobject", value: encodeMetaobject(value) } });
+        case "null":
+            return create(ValueSchema, { kind: { case: "null", value: value.reason } });
+        case "unset":
+            return create(ValueSchema, { kind: { case: "unset", value: true } });
+        case "undetermined":
+            throw new MalformedValueError("an undetermined result is something to read, not to send");
+        case "infinity":
+            return create(ValueSchema, { kind: { case: "infinity", value: true } });
+        case "absent":
+            throw new MalformedValueError("an absent value is no value at all, so it cannot be sent");
+    }
+}
+/** Decodes a `sysml.Verdict` into the union. */
+export function decodeVerdict(verdict) {
+    const subject = {
+        kind: verdict.kind,
+        elementId: verdict.elementId,
+        element: verdict.element,
+        ...(verdict.instanceId === 0n ? {} : { instanceId: verdict.instanceId }),
+        ...(verdict.instanceTypeId === "" ? {} : { instanceTypeId: verdict.instanceTypeId }),
+    };
+    const standing = decodeStanding(verdict);
+    if (verdict.error !== "") {
+        return {
+            kind: "undecided",
+            subject,
+            error: verdict.error,
+            cause: failureCause(verdict.failureReason),
+            standing,
+        };
+    }
+    return verdict.holds
+        ? { kind: "holds", subject, standing }
+        : { kind: "fails", subject, condition: verdict.condition, standing };
+}
+/** Reads the standing fields the `engines` capability adds to a verdict. */
+export function decodeStanding(verdict) {
+    return {
+        engine: verdict.engine,
+        strength: verdict.strength,
+        bounds: verdict.bounds.map((b) => ({ name: b.name, limit: b.limit, reached: b.reached })),
+    };
+}
+/** Names the enum the service reports for a failure it could not answer through. */
+export function failureCause(reason) {
+    switch (reason) {
+        case FailureReason.EVALUATION:
+            return "evaluation";
+        case FailureReason.WRONG_KIND:
+            return "wrong_kind";
+        case FailureReason.AMBIGUOUS_SUBJECT:
+            return "ambiguous_subject";
+        case FailureReason.UNSPECIFIED:
+            return "unspecified";
+        case FailureReason.UNDECIDED:
+            return "undecided";
+    }
+}
+/** Renders a value the way the REPL prints one, for logs and error messages. */
+export function formatValue(value) {
+    switch (value.kind) {
+        case "int":
+            return value.value.toString();
+        case "real":
+            return formatReal(value.value);
+        case "complex":
+            return formatComplex(value.value);
+        case "boolean":
+            return value.value ? "true" : "false";
+        case "string":
+            return JSON.stringify(value.value);
+        case "instance":
+            return `<instance ${value.id.toString()}>`;
+        case "sequence":
+            return `(${value.elements.map(formatValue).join(", ")})`;
+        case "quantity": {
+            const magnitude = formatMagnitude(value.magnitude);
+            return value.unit === "" ? magnitude : `${magnitude}[${value.unit}]`;
+        }
+        case "measurementRef":
+            return value.unit === "" ? formatUnitTerm(value.unitTerm) : value.unit;
+        case "function":
+            return value.calcId;
+        case "enum":
+            return value.value.name;
+        case "array":
+            return `Array(${value.dimensions.join(", ")})[${value.elements.map(formatValue).join(", ")}]`;
+        case "vector":
+            return `⟨${value.components.map(formatMagnitude).join(", ")}⟩`;
+        case "vectorQuantity":
+            return `⟨${value.components.map((c) => formatValue({ kind: "quantity", ...c })).join(", ")}⟩`;
+        case "set":
+            return `{${value.elements.map(formatValue).join(", ")}}`;
+        case "tensorQuantity":
+            return formatTensorQuantity(value);
+        case "metaobject":
+            return `meta(${value.elementId} : ${value.metaclassId})`;
+        case "null":
+            return value.reason === "" ? "null" : `null (${value.reason})`;
+        case "unset":
+            return "unset";
+        case "undetermined":
+            return "<undetermined>";
+        case "infinity":
+            return "*";
+        case "absent":
+            return "absent";
+    }
+}
+function formatReal(value) {
+    return Number.isInteger(value) ? value.toFixed(1) : value.toString();
+}
+function formatMagnitude(magnitude) {
+    return magnitude.kind === "int" ? magnitude.value.toString() : formatReal(magnitude.value);
+}
+/** `Tensor(2, 2, 2)[1.0, …, 8.0][Pa]` when every component shares a unit; else each with its own. */
+function formatTensorQuantity(tensor) {
+    const dims = tensor.dimensions.join(", ");
+    const units = new Set(tensor.components.map((c) => c.unit));
+    if (units.size === 1 && tensor.components[0]?.unit !== "") {
+        const body = tensor.components.map((c) => formatMagnitude(c.magnitude)).join(", ");
+        return `Tensor(${dims})[${body}][${tensor.components[0]?.unit ?? ""}]`;
+    }
+    const body = tensor.components.map((c) => formatValue({ kind: "quantity", ...c })).join(", ");
+    return `Tensor(${dims})[${body}]`;
+}
+/** `1.5 - 2.0i`, as the REPL prints a Complex; the sign is the imaginary part's. */
+function formatComplex(value) {
+    const sign = value.imaginary < 0 || Object.is(value.imaginary, -0) ? "-" : "+";
+    return `${formatReal(value.real)} ${sign} ${formatReal(Math.abs(value.imaginary))}i`;
+}
+function decodeQuantity(quantity) {
+    let magnitude;
+    switch (quantity.magnitude.case) {
+        case "intMagnitude":
+            magnitude = { kind: "int", value: quantity.magnitude.value };
+            break;
+        case "realMagnitude":
+            magnitude = { kind: "real", value: quantity.magnitude.value };
+            break;
+        default:
+            throw new MalformedValueError(`a quantity in [${quantity.unit}] has no magnitude`);
+    }
+    const unitTerm = quantity.unitTerm === undefined ? undefined : decodeUnitTerm(quantity.unitTerm);
+    return {
+        magnitude,
+        unit: quantity.unit,
+        ...(unitTerm === undefined ? {} : { unitTerm }),
+    };
+}
+function encodeQuantity(quantity) {
+    return create(QuantitySchema, {
+        magnitude: quantity.magnitude.kind === "int"
+            ? { case: "intMagnitude", value: quantity.magnitude.value }
+            : { case: "realMagnitude", value: quantity.magnitude.value },
+        unit: quantity.unit,
+        ...(quantity.unitTerm === undefined ? {} : { unitTerm: encodeUnitTerm(quantity.unitTerm) }),
+    });
+}
+function decodeMeasurementRef(ref) {
+    if (ref.unit === "" && ref.unitId === "" && ref.unitTerm === undefined) {
+        throw new MalformedValueError("a measurement reference names no unit");
+    }
+    if (ref.unitTerm === undefined) {
+        throw new MalformedValueError(`a measurement reference ${ref.unit || ref.unitId} has no reduction to base units`);
+    }
+    return {
+        unit: ref.unit,
+        unitTerm: decodeUnitTerm(ref.unitTerm),
+        ...(ref.unitId === "" ? {} : { unitId: ref.unitId }),
+    };
+}
+function encodeMeasurementRef(ref) {
+    return create(MeasurementRefSchema, {
+        unit: ref.unit,
+        unitTerm: encodeUnitTerm(ref.unitTerm),
+        unitId: ref.unitId ?? "",
+    });
+}
+function decodeFunction(fn) {
+    if (fn.calcId === "") {
+        throw new MalformedValueError("a function names no calc");
+    }
+    return { calcId: fn.calcId, ...(fn.selfId === 0n ? {} : { selfId: fn.selfId }) };
+}
+function encodeFunction(fn) {
+    if (fn.calcId === "") {
+        throw new MalformedValueError("a function names no calc");
+    }
+    return create(FunctionSchema, { calcId: fn.calcId, selfId: fn.selfId ?? 0n });
+}
+function decodeMetaobject(meta) {
+    if (meta.elementId === "") {
+        throw new MalformedValueError("a metaobject names no element");
+    }
+    return { elementId: meta.elementId, metaclassId: meta.metaclassId };
+}
+function encodeMetaobject(meta) {
+    if (meta.elementId === "") {
+        throw new MalformedValueError("a metaobject names no element");
+    }
+    return create(MetaobjectSchema, { elementId: meta.elementId, metaclassId: meta.metaclassId });
+}
+function encodeUnitTerm(term) {
+    return create(UnitTermSchema, {
+        scaleNum: term.scaleNum,
+        scaleDen: term.scaleDen,
+        factors: term.factors.map((factor) => create(UnitFactorSchema, factor)),
+    });
+}
+/** `1000·SI::metre·SI::second^-1`, for a unit that was never written down. */
+function formatUnitTerm(term) {
+    const parts = [];
+    if (term.scaleNum !== 1 || term.scaleDen !== 1) {
+        parts.push(term.scaleDen === 1 ? `${term.scaleNum}` : `${term.scaleNum}/${term.scaleDen}`);
+    }
+    for (const factor of term.factors) {
+        parts.push(factor.exponent === 1 ? factor.unitId : `${factor.unitId}^${factor.exponent}`);
+    }
+    return parts.length === 0 ? "1" : parts.join("·");
+}
+function encodeMagnitude(magnitude) {
+    return magnitude.kind === "int"
+        ? create(ValueSchema, { kind: { case: "intValue", value: magnitude.value } })
+        : create(ValueSchema, { kind: { case: "realValue", value: magnitude.value } });
+}
+/** The flattened size the dimensions demand, refusing a dimension that is not positive. */
+function checkShape(what, dimensions, elementCount) {
+    let size = 1n;
+    for (const extent of dimensions) {
+        if (extent <= 0n) {
+            throw new MalformedValueError(`${what} dimension is ${extent.toString()}, not positive`);
+        }
+        size *= extent;
+    }
+    if (size !== BigInt(elementCount)) {
+        throw new MalformedValueError(`${what} of dimensions (${dimensions.join(", ")}) holds ${elementCount} element(s), want ${size.toString()}`);
+    }
+}
+function decodeArray(array) {
+    checkShape("an array", array.dimensions, array.elements.length);
+    return { dimensions: [...array.dimensions], elements: array.elements.map(decodeValue) };
+}
+function decodeSet(set) {
+    return uniqueMembers(set.elements.map(decodeValue));
+}
+/** Returns the members as given, refusing one listed twice by {@link valuesEqual}. */
+function uniqueMembers(members) {
+    members.forEach((member, i) => {
+        if (members.slice(0, i).some((held) => valuesEqual(held, member))) {
+            throw new MalformedValueError(`a set lists a member twice: ${formatValue(member)}`);
+        }
+    });
+    return members;
+}
+/**
+ * Whether two values are the same value to the model, as the service judges a
+ * set's membership: numbers by value, so a whole `real` is the `int` of its
+ * value and a `complex` on the real axis is its real part, exactly across the
+ * whole `int` range; a `sequence`'s order counts and a `set`'s does not, nor
+ * does a member it lists twice; a quantity is the same over its base units; a
+ * `measurementRef` is one reduction at one scale however spelt, except that a
+ * named unit of dimension one is only its own declaration (`rad` is not `sr`);
+ * an `enum` is its `literalId`, whatever else describes it; a `function` is
+ * its `calcId` read against its `selfId`; a `null` is the same whatever its
+ * reason, and the same as an empty `sequence` or `set` — the model's absent
+ * value however spelt.
+ */
+export function valuesEqual(a, b) {
+    if (isEmpty(a) || isEmpty(b)) {
+        return isEmpty(a) && isEmpty(b);
+    }
+    switch (a.kind) {
+        case "int":
+        case "real":
+        case "complex":
+            return numbersEqual(a, b);
+        case "boolean":
+            return b.kind === "boolean" && a.value === b.value;
+        case "string":
+            return b.kind === "string" && a.value === b.value;
+        case "instance":
+            return b.kind === "instance" && a.id === b.id;
+        case "sequence":
+            return b.kind === "sequence" && elementsEqual(a.elements, b.elements);
+        case "quantity":
+            return b.kind === "quantity" && quantitiesEqual(a, b);
+        case "measurementRef":
+            return b.kind === "measurementRef" && measurementRefsEqual(a, b);
+        case "enum":
+            return b.kind === "enum" && a.value.literalId === b.value.literalId;
+        case "function":
+            return (b.kind === "function" &&
+                a.calcId === b.calcId &&
+                a.selfId === b.selfId);
+        case "array":
+            return (b.kind === "array" &&
+                dimensionsEqual(a.dimensions, b.dimensions) &&
+                elementsEqual(a.elements, b.elements));
+        case "vector":
+            return b.kind === "vector" && magnitudesEqual(a.components, b.components);
+        case "vectorQuantity":
+            return (b.kind === "vectorQuantity" &&
+                componentsEqual(a.components, b.components));
+        case "set":
+            return (b.kind === "set" &&
+                subsetOf(a.elements, b.elements) &&
+                subsetOf(b.elements, a.elements));
+        case "tensorQuantity":
+            return (b.kind === "tensorQuantity" &&
+                dimensionsEqual(a.dimensions, b.dimensions) &&
+                componentsEqual(a.components, b.components));
+        case "metaobject":
+            // The element is the identity, whatever type each side was cast to.
+            return b.kind === "metaobject" && a.elementId === b.elementId;
+        case "undetermined":
+            return (b.kind === "undetermined" &&
+                a.reason === b.reason &&
+                a.countLower === b.countLower &&
+                a.countUpper === b.countUpper);
+        case "infinity":
+        case "null":
+        case "unset":
+        case "absent":
+            return b.kind === a.kind;
+    }
+}
+/** The model's absent value: a `null`, or a collection with no members. */
+function isEmpty(value) {
+    switch (value.kind) {
+        case "null":
+            return true;
+        case "sequence":
+        case "set":
+            return value.elements.length === 0;
+        default:
+            return false;
+    }
+}
+function elementsEqual(a, b) {
+    return (a.length === b.length &&
+        a.every((e, i) => valuesEqual(e, b[i])));
+}
+function subsetOf(members, of) {
+    return members.every((e) => of.some((o) => valuesEqual(e, o)));
+}
+function dimensionsEqual(a, b) {
+    return a.length === b.length && a.every((d, i) => d === b[i]);
+}
+function numbersEqual(a, b) {
+    if (a.kind === "complex") {
+        if (a.value.imaginary !== 0) {
+            return (b.kind === "complex" &&
+                a.value.real === b.value.real &&
+                a.value.imaginary === b.value.imaginary);
+        }
+        a = { kind: "real", value: a.value.real };
+    }
+    if (b.kind === "complex") {
+        if (b.value.imaginary !== 0) {
+            return false;
+        }
+        b = { kind: "real", value: b.value.real };
+    }
+    if (a.kind === "int") {
+        if (b.kind === "int")
+            return a.value === b.value;
+        return b.kind === "real" && realIsInt(b.value, a.value);
+    }
+    if (b.kind === "int")
+        return realIsInt(a.value, b.value);
+    return b.kind === "real" && a.value === b.value;
+}
+// Whether r is exactly the integer n, never rounding n.
+function realIsInt(r, n) {
+    return Number.isInteger(r) && r >= -(2 ** 63) && r < 2 ** 63 && BigInt(r) === n;
+}
+function magnitudesEqual(a, b) {
+    return a.length === b.length && a.every((m, i) => numbersEqual(m, b[i]));
+}
+function componentsEqual(a, b) {
+    return (a.length === b.length &&
+        a.every((q, i) => quantitiesEqual(q, b[i])));
+}
+// Commensurable quantities are equal over their base units, as the service
+// judges them; one carrying no reduction is compared in its unit as written.
+function quantitiesEqual(a, b) {
+    if (a.unitTerm === undefined || b.unitTerm === undefined) {
+        return (numbersEqual(a.magnitude, b.magnitude) &&
+            a.unit === b.unit &&
+            unitTermsEqual(a.unitTerm, b.unitTerm));
+    }
+    if (!commensurable(a.unitTerm, b.unitTerm) ||
+        zeroScale(a.unitTerm) ||
+        zeroScale(b.unitTerm)) {
+        return false;
+    }
+    if (a.magnitude.kind === "int" &&
+        b.magnitude.kind === "int" &&
+        wholeScale(a.unitTerm) &&
+        wholeScale(b.unitTerm)) {
+        // m₁·n₁/d₁ = m₂·n₂/d₂ exactly, cross-multiplied in bigint.
+        return (a.magnitude.value * BigInt(a.unitTerm.scaleNum) * BigInt(b.unitTerm.scaleDen) ===
+            b.magnitude.value * BigInt(b.unitTerm.scaleNum) * BigInt(a.unitTerm.scaleDen));
+    }
+    return baseMagnitude(a.magnitude, a.unitTerm) === baseMagnitude(b.magnitude, b.unitTerm);
+}
+function baseMagnitude(magnitude, term) {
+    return (Number(magnitude.value) * term.scaleNum) / term.scaleDen;
+}
+// The reduction as base unit → exponent, repeated base units summed and
+// cancelled ones dropped, so two reductions compare however they are listed.
+function exponents(term) {
+    const totals = new Map();
+    for (const factor of term.factors) {
+        totals.set(factor.unitId, (totals.get(factor.unitId) ?? 0) + factor.exponent);
+    }
+    for (const [unitId, exponent] of totals) {
+        if (exponent === 0) {
+            totals.delete(unitId);
+        }
+    }
+    return totals;
+}
+function commensurable(a, b) {
+    const x = exponents(a);
+    const y = exponents(b);
+    return x.size === y.size && [...x].every(([unitId, exponent]) => y.get(unitId) === exponent);
+}
+function zeroScale(term) {
+    return term.scaleNum === 0 || term.scaleDen === 0;
+}
+/** One reduction: commensurable at one scale, however the ratio is written. */
+function sameReduction(a, b) {
+    return (commensurable(a, b) &&
+        !zeroScale(a) &&
+        !zeroScale(b) &&
+        a.scaleNum * b.scaleDen === b.scaleNum * a.scaleDen);
+}
+// One reduction at one scale (`SI::'m/s'` is `m/s`, `km/m` is `m/mm`); a named
+// unit reducing to nothing is only the declaration it names.
+function measurementRefsEqual(a, b) {
+    if (!sameReduction(a.unitTerm, b.unitTerm)) {
+        return false;
+    }
+    if (exponents(a.unitTerm).size === 0 && (a.unitId !== undefined || b.unitId !== undefined)) {
+        return a.unitId === b.unitId;
+    }
+    return true;
+}
+function wholeScale(term) {
+    return Number.isInteger(term.scaleNum) && Number.isInteger(term.scaleDen);
+}
+function unitTermsEqual(a, b) {
+    if (a === undefined || b === undefined) {
+        return a === b;
+    }
+    return (a.scaleNum === b.scaleNum &&
+        a.scaleDen === b.scaleDen &&
+        a.factors.length === b.factors.length &&
+        a.factors.every((f, i) => f.unitId === b.factors[i]?.unitId &&
+            f.exponent === b.factors[i]?.exponent));
+}
+function decodeTensorQuantity(tensor) {
+    checkShape("a tensor quantity", tensor.dimensions, tensor.components.length);
+    return { dimensions: [...tensor.dimensions], components: tensor.components.map(decodeQuantity) };
+}
+function decodeVector(vector) {
+    return vector.components.map((component) => {
+        switch (component.kind.case) {
+            case "intValue":
+                return { kind: "int", value: component.kind.value };
+            case "realValue":
+                return { kind: "real", value: component.kind.value };
+            default:
+                throw new MalformedValueError(`a vector component is ${component.kind.case ?? "empty"}, not a number`);
+        }
+    });
+}
+function decodeVectorQuantity(vector) {
+    if (vector.components.length === 0) {
+        throw new MalformedValueError("a vector quantity has no components");
+    }
+    return vector.components.map(decodeQuantity);
+}
+function decodeUnitTerm(term) {
+    return {
+        scaleNum: term.scaleNum,
+        scaleDen: term.scaleDen,
+        factors: term.factors.map((factor) => ({
+            unitId: factor.unitId,
+            exponent: factor.exponent,
+        })),
+    };
+}
+function decodeEnumLiteral(literal) {
+    const decoded = {
+        name: literal.name,
+        literalId: literal.literalId,
+        enumerationId: literal.enumerationId,
+    };
+    if (literal.value !== undefined) {
+        const scalar = decodeValue(literal.value);
+        if (scalar.kind === "absent") {
+            throw new MalformedValueError("an enumeration literal's value, when present, states a scalar");
+        }
+        decoded.value = scalar;
+    }
+    return decoded;
+}
+function encodeEnumLiteral(literal) {
+    return create(EnumLiteralSchema, {
+        name: literal.name,
+        literalId: literal.literalId,
+        enumerationId: literal.enumerationId,
+        value: literal.value === undefined ? undefined : encodeValue(literal.value),
+    });
+}