universal-physics-tensor 6.1.0 → 8.0.0

package/dist/dimensional/hyphen-names.js

@@ -0,0 +1,27 @@
+/**
+ * Kebab catalog names are one token. A parser that treats `-` as subtraction
+ * splits them. Longest match first, so a longer declared name wins over a
+ * shorter one that is its suffix.
+ *
+ * @module dimensional/hyphen-names
+ */
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Rewrite declared kebab-case names to underscores. Names without a hyphen
+ * stay. A hyphen that is not a declared name stays subtraction.
+ */
+export function rewriteCatalogHyphens(text, catalogNames) {
+    const names = [...catalogNames]
+        .filter((n) => n.includes('-'))
+        .sort((a, b) => b.length - a.length || a.localeCompare(b));
+    let out = text;
+    for (const name of names) {
+        const underscored = name.replace(/-/g, '_');
+        const re = new RegExp(`(?<![A-Za-z0-9_])${escapeRegExp(name)}(?![A-Za-z0-9_])`, 'g');
+        out = out.replace(re, underscored);
+    }
+    return out;
+}
+//# sourceMappingURL=hyphen-names.js.map

package/dist/dimensional/hyphen-names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyphen-names.js","sourceRoot":"","sources":["../../src/dimensional/hyphen-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,SAAS,YAAY,CAAC,CAAS;IAC7B,OAAO,CAAC,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAClD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,IAAY,EACZ,YAAoD;IAEpD,MAAM,KAAK,GAAG,CAAC,GAAG,YAAY,CAAC;SAC5B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;SAC9B,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7D,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC5C,MAAM,EAAE,GAAG,IAAI,MAAM,CAAC,oBAAoB,YAAY,CAAC,IAAI,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC;QACrF,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/dimensional/quantity-registry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The quantity registry. Canonical id, aliases, dimension, and whether an
+ * affine temperature is an absolute point or an interval. Synonym groups and
+ * the temperature role are projections of this table.
+ *
+ * @module dimensional/quantity-registry
+ */
+import type { Dimension } from './types.js';
+/** Declared role of an affine temperature quantity. */
+export type QuantityKind = 'absolute' | 'interval';
+/** A carrier that enters a same-sign transport rule. */
+export type SignRole = 'charge' | 'mobility';
+/** One quantity. `graphNode` is false for a spelling that is not a graph node. */
+export interface QuantityRecord {
+    readonly id: string;
+    readonly symbol: string;
+    readonly dimension: Dimension;
+    readonly attributes: Readonly<Record<string, string>>;
+    readonly kind?: QuantityKind;
+    readonly aliases?: readonly string[];
+    readonly signRole?: SignRole;
+    readonly graphNode: boolean;
+}
+/** Every quantity record, graph nodes and spellings. */
+export declare function allQuantityRecords(): readonly QuantityRecord[];
+/** The record `name` spells, comparing `_` and `-` as the same character. */
+export declare function quantityRecord(name: string): QuantityRecord | undefined;
+/**
+ * Synonym groups projected from declared aliases. The canonical id is first.
+ * A quantity with no alias is not a group.
+ */
+export declare function synonymGroupsFromRegistry(): readonly (readonly string[])[];
+//# sourceMappingURL=quantity-registry.d.ts.map

package/dist/dimensional/quantity-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantity-registry.d.ts","sourceRoot":"","sources":["../../src/dimensional/quantity-registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,uDAAuD;AACvD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,UAAU,CAAC;AAEnD,wDAAwD;AACxD,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE7C,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AA0BD,wDAAwD;AACxD,wBAAgB,kBAAkB,IAAI,SAAS,cAAc,EAAE,CAE9D;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEvE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAQ1E"}

package/dist/dimensional/quantity-registry.js

@@ -0,0 +1,49 @@
+/**
+ * The quantity registry. Canonical id, aliases, dimension, and whether an
+ * affine temperature is an absolute point or an interval. Synonym groups and
+ * the temperature role are projections of this table.
+ *
+ * @module dimensional/quantity-registry
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const foldName = (s) => s.replace(/_/g, '-');
+function loadQuantities() {
+    const path = join(dirname(fileURLToPath(import.meta.url)), '../../data/quantities.json');
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    return parsed.quantities;
+}
+const QUANTITIES = loadQuantities();
+const BY_KEY = new Map();
+for (const row of QUANTITIES) {
+    BY_KEY.set(row.id, row);
+    BY_KEY.set(foldName(row.id), row);
+    for (const alias of row.aliases ?? []) {
+        BY_KEY.set(alias, row);
+        BY_KEY.set(foldName(alias), row);
+    }
+}
+/** Every quantity record, graph nodes and spellings. */
+export function allQuantityRecords() {
+    return QUANTITIES;
+}
+/** The record `name` spells, comparing `_` and `-` as the same character. */
+export function quantityRecord(name) {
+    return BY_KEY.get(name) ?? BY_KEY.get(foldName(name));
+}
+/**
+ * Synonym groups projected from declared aliases. The canonical id is first.
+ * A quantity with no alias is not a group.
+ */
+export function synonymGroupsFromRegistry() {
+    const groups = [];
+    for (const row of QUANTITIES) {
+        const aliases = row.aliases ?? [];
+        if (aliases.length === 0)
+            continue;
+        groups.push([row.id, ...aliases]);
+    }
+    return groups;
+}
+//# sourceMappingURL=quantity-registry.js.map

package/dist/dimensional/quantity-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantity-registry.js","sourceRoot":"","sources":["../../src/dimensional/quantity-registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAyBzC,MAAM,QAAQ,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAE7D,SAAS,cAAc;IACrB,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,4BAA4B,CAAC,CAAC;IACzF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAiB,CAAC;IACtE,OAAO,MAAM,CAAC,UAAU,CAAC;AAC3B,CAAC;AAED,MAAM,UAAU,GAAG,cAAc,EAAE,CAAC;AAEpC,MAAM,MAAM,GAAG,IAAI,GAAG,EAA0B,CAAC;AACjD,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;IAC7B,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IACxB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IAClC,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC;QACtC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACvB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC;IACnC,CAAC;AACH,CAAC;AAED,wDAAwD;AACxD,MAAM,UAAU,kBAAkB;IAChC,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,yBAAyB;IACvC,MAAM,MAAM,GAAe,EAAE,CAAC;IAC9B,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;QAC7B,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC;QAClC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QACnC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/dimensional/units.d.ts

@@ -3,8 +3,8 @@ import type { Dimension } from './types.js';
 export interface ParsedUnit {
     readonly scale: number;
     readonly dim: Dimension;
-    /** `'celsius'` only for a lone `degC`, which is affine and needs a reading. */
-    readonly affine?: 'celsius';
+    /** Set only for a lone affine temperature, which needs a reading. */
+    readonly affine?: 'celsius' | 'fahrenheit';
 }
 /** Thrown for any input that does not parse as a value with a known unit. @public */
 export declare class UnitError extends Error {
@@ -21,6 +21,8 @@ export declare function unitConventionNotes(given: string): string[];
 export declare function parseUnit(text: string): ParsedUnit;
 /** How a temperature value is read: as a point on the scale, or as a difference. @public */
 export type TemperatureReading = 'absolute' | 'difference';
+/** Kelvin added when this affine unit is an absolute point. @internal */
+export declare function affineAbsoluteOffsetK(id: 'celsius' | 'fahrenheit'): number;
 /**
  * Convert `raw` (`<number>[unit]`) into `target` (a unit expression). A bare
  * number is taken to be in `target` already. The dimensions must agree.

package/dist/dimensional/units.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"units.d.ts","sourceRoot":"","sources":["../../src/dimensional/units.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;CAC7B;AAED,qFAAqF;AACrF,qBAAa,SAAU,SAAQ,KAAK;IAClC,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAuHD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAe3D;AAED,0EAA0E;AAC1E,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAYlD;AAED,4FAA4F;AAC5F,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,YAAY,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,kBAA+B,GACvC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAsBlC;AA6CD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,UAAU,GAChB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,SAAS,CAU/C;AAOD,6DAA6D;AAC7D,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAErD;AAED,4GAA4G;AAC5G,wBAAgB,UAAU,IAAI;IAC5B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;IAClE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,cAAc,EAAE,MAAM,CAAC;CACxB,CAEA"}
+{"version":3,"file":"units.d.ts","sourceRoot":"","sources":["../../src/dimensional/units.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAK5C,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,qEAAqE;IACrE,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,YAAY,CAAC;CAC5C;AAED,qFAAqF;AACrF,qBAAa,SAAU,SAAQ,KAAK;IAClC,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAmUD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAgB3D;AAED,0EAA0E;AAC1E,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAUlD;AAED,4FAA4F;AAC5F,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,YAAY,CAAC;AAE3D,yEAAyE;AACzE,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,SAAS,GAAG,YAAY,GAAG,MAAM,CAI1E;AASD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,kBAA+B,GACvC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CA0BlC;AA6CD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,UAAU,GAChB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,SAAS,CAU/C;AAOD,6DAA6D;AAC7D,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAErD;AAED,4GAA4G;AAC5G,wBAAgB,UAAU,IAAI;IAC5B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;IAClE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,cAAc,EAAE,MAAM,CAAC;CACxB,CAEA"}

package/dist/dimensional/units.js

@@ -6,15 +6,30 @@
  * `W/m*K` both mean W·m⁻¹·K⁻¹). An exact symbol is matched before a prefixed
  * one, so `min` is a minute, `Pa` a pascal and `mm` a millimetre.
  *
- * Temperature in °C is affine, so it is accepted only alone and only with an
- * explicit reading: an ABSOLUTE temperature adds 273.15 K; a temperature
- * DIFFERENCE (an uncertainty, an interval) does not. °F is refused rather than
- * converted.
+ * An affine temperature (`degC`, `°C`, `degF`, `°F`) is accepted only alone.
+ * The kelvin value is `value × scale + offset` for an absolute reading and
+ * `value × scale` for a difference. Rankine is proportional (`°R × 5/9`), not
+ * affine. The caller decides which reading, from the quantity's role.
  *
  * An exact symbol wins over a prefix: `T` is the tesla and `Ts` is a
- * terasecond; `G` is the gauss and `GPa` is a gigapascal. A glued positive
- * exponent is that power when the letters are already a unit, so `K2` and
- * `K²` are `K^2`. An unknown token that ends in a digit stays unknown.
+ * terasecond; `G` is the gauss and `GPa` is a gigapascal; `P` is the poise
+ * and `PV` is still a petavolt. A glued positive exponent is that power when
+ * the letters are already a unit, so `K2` and `K²` are `K^2`.
+ *
+ * A token with no separator is one factor when the whole token is an exact
+ * unit or a prefix plus a unit, with an optional exponent. That reading
+ * wins on a bare token, so `ms` stays a millisecond, `mm` a millimetre,
+ * `mK` a millikelvin, and `Ts` a terasecond. Inside a larger expression the
+ * prefixed reading competes with a heterogeneous product (`mK` is millikelvin
+ * or metre·kelvin; `ms` is millisecond or metre·second). A homogeneous power
+ * does not compete (`mm` is a millimetre, not metre·metre). `parseUnit` names
+ * every remaining reading and refuses. `convertValue` keeps the one reading
+ * whose dimension is the declared unit. A token that is not one factor is a
+ * product when exactly one split exists: `m2K` is `m^2·K`, `Vs` is `V·s`,
+ * and `cm^2/Vs` is `cm^2/(V·s)`. Zero splits are an unknown unit. Two or more
+ * splits name each reading and are refused (`mAs` is milliampere·second or
+ * metre·ampere·second). An unknown token that ends in a digit stays unknown
+ * when it is not that product.
  * `AU` is the same exact metre count as `au`. `Msun` is `M_SUN_SI` kilograms; `Msun_iau` is
  * `GM_SUN_SI / G_SI`. `myr` is a milliyear because `m` is the SI prefix.
  * `eV` takes an SI prefix, so `GeV` is 10⁹ eV in joules. `nat` is the
@@ -90,67 +105,252 @@ const UNITS = new Map([
     // IAU-style parsec; the prefix applies, so `Mpc` is a megaparsec.
     ['pc', [3.0856775814913673e16, D({ L: 1 }), true]],
     ['ly', [C_SI * 365.25 * 86400, D({ L: 1 }), false]],
+    // CGPM 1964: 1 L = 1 dm³ = 10⁻³ m³ exactly. Prefixable, so mL is a millilitre.
+    // `l` is the same litre. Bare `mL` stays the prefix; `mol/mL` competes with metre·litre.
+    ['L', [1e-3, D({ L: 3 }), true]],
+    ['l', [1e-3, D({ L: 3 }), true]],
+    // Thermochemical calorie: 1 cal_th = 4.184 J exactly (NIST). Not cal_IT = 4.1868 J.
+    // Prefixable, so kcal is 4184 J.
+    ['cal', [4.184, JOULE, true]],
+    // International Steam Table BTU: cal_IT × (lb/g) / (°F per 1.8 °C).
+    // 4.1868 × 453.59237 / 1.8 J exactly. Not the thermochemical calorie.
+    ['BTU', [(4.1868 * 453.59237) / 1.8, JOULE, false]],
+    // psi = lbf/in². lbf = 0.45359237 kg × 9.80665 m/s² (1959 pound × standard gravity).
+    // inch = 0.0254 m exactly.
+    ['psi', [(0.45359237 * 9.80665) / (0.0254 * 0.0254), D({ L: -1, M: 1, T: -2 }), false]],
+    // torr = 1/760 of a standard atmosphere = 101325/760 Pa exactly. Prefixable (mtorr).
+    ['torr', [101325 / 760, D({ L: -1, M: 1, T: -2 }), true]],
+    // Conventional millimetre of mercury, 133.322387415 Pa exactly (NIST SP 811).
+    // Not the torr, and not `mm` × `Hg`.
+    ['mmHg', [133.322387415, D({ L: -1, M: 1, T: -2 }), false]],
+    // Poise = 0.1 Pa·s exactly. Prefixable, so cP = 10⁻³ Pa·s. Exact `P` wins over peta.
+    ['P', [0.1, D({ L: -1, M: 1, T: -1 }), true]],
+    // Rankine is proportional: K = °R × 5/9. Not affine.
+    ['degR', [5 / 9, D({ Theta: 1 }), false]],
+    ['°R', [5 / 9, D({ Theta: 1 }), false]],
+    // Revolutions per minute = 1/60 Hz. Prefixable, so krpm is a kilorevolution per minute.
+    ['rpm', [1 / 60, D({ T: -1 }), true]],
+    // Mechanical horsepower = 550 ft·lbf/s. ft = 0.3048 m.
+    ['hp', [550 * 0.3048 * 0.45359237 * 9.80665, D({ L: 2, M: 1, T: -3 }), false]],
 ]);
 const CELSIUS_OFFSET_K = 273.15;
+const FAHRENHEIT_SCALE = 5 / 9;
+/** Lone spellings. A compound that contains one is refused. */
+const AFFINE = [
+    { id: 'celsius', scale: 1, offset: CELSIUS_OFFSET_K, symbols: ['degC', '°C'] },
+    {
+        id: 'fahrenheit',
+        scale: FAHRENHEIT_SCALE,
+        offset: CELSIUS_OFFSET_K - 32 * FAHRENHEIT_SCALE,
+        symbols: ['degF', '°F'],
+    },
+];
+function affineRow(text) {
+    return AFFINE.find((row) => row.symbols.includes(text));
+}
 const PREFIXES = new Map([
     ['Y', 1e24], ['Z', 1e21], ['E', 1e18], ['P', 1e15], ['T', 1e12], ['G', 1e9], ['M', 1e6], ['k', 1e3],
     ['h', 1e2], ['da', 1e1], ['d', 1e-1], ['c', 1e-2], ['m', 1e-3], ['u', 1e-6], ['µ', 1e-6], ['μ', 1e-6],
     ['n', 1e-9], ['p', 1e-12], ['f', 1e-15], ['a', 1e-18], ['z', 1e-21], ['y', 1e-24],
 ]);
 function parseSymbol(sym) {
+    const parsed = trySymbol(sym);
+    if (parsed !== null)
+        return parsed;
+    throw new UnitError(`unknown unit '${sym}'`);
+}
+function trySymbol(sym) {
     const exact = UNITS.get(sym);
     if (exact !== undefined)
         return [exact[0], exact[1]];
     for (const [p, f] of PREFIXES) {
-        if (!sym.startsWith(p))
+        if (!sym.startsWith(p) || sym.length === p.length)
             continue;
         const base = UNITS.get(sym.slice(p.length));
         if (base !== undefined && base[2])
             return [f * base[0], base[1]];
     }
-    throw new UnitError(`unknown unit '${sym}'`);
+    return null;
+}
+/** One factor, or null when `token` is not exactly one unit with an optional exponent. */
+function tryOneFactor(token) {
+    let base = token;
+    let exp = 1;
+    const caret = /^(.+)\^([+-]?\d+)$/.exec(token);
+    if (caret !== null) {
+        base = caret[1];
+        exp = Number(caret[2]);
+    }
+    else {
+        const uni = /^(.*?)([¹²³])$/.exec(token);
+        const superExp = uni === null ? undefined : SUPERSCRIPT[uni[2]];
+        if (uni !== null && superExp !== undefined && uni[1].length > 0) {
+            base = uni[1];
+            exp = superExp;
+        }
+        else {
+            const glued = /^(.*?)([1-9]\d*)$/.exec(token);
+            if (glued !== null && glued[1].length > 0 && trySymbol(glued[1]) !== null) {
+                base = glued[1];
+                exp = Number(glued[2]);
+            }
+        }
+    }
+    const parsed = trySymbol(base);
+    if (parsed === null || !Number.isFinite(exp))
+        return null;
+    return { base, exp, scale: parsed[0], dim: parsed[1] };
+}
+function formatReading(factors) {
+    return factors.map((factor) => (factor.exp === 1 ? factor.base : `${factor.base}^${factor.exp}`)).join('·');
+}
+/** The unprefixed unit a prefix spelling attaches to, or null when `symbol` is exact. */
+function attachedUnit(symbol) {
+    if (UNITS.has(symbol))
+        return null;
+    for (const [prefix] of PREFIXES) {
+        if (!symbol.startsWith(prefix) || symbol.length === prefix.length)
+            continue;
+        const base = symbol.slice(prefix.length);
+        const row = UNITS.get(base);
+        if (row !== undefined && row[2])
+            return base;
+    }
+    return null;
 }
-const SUPERSCRIPT = { '¹': 1, '²': 2, '³': 3 };
 /**
- * A factor is `symbol`, `symbol^n`, `symbol²`, or `symbol` with a glued
- * positive exponent (`K2` is K²). The glued form is read only when the
- * letters are already a unit, so an unknown token stays unknown.
+ * A product of the same unprefixed unit the prefix attaches to (`mm` = m·m,
+ * `mm2` = m·m²). Powers are written `m2` / `m^2`, so this reading does not
+ * compete with the prefix.
  */
-function factorExponent(factor) {
-    const caret = /^([^\^]+)(?:\^([+-]?\d+))?$/.exec(factor);
-    if (caret !== null && caret[2] !== undefined)
-        return { base: caret[1], exp: Number(caret[2]) };
-    const uni = /^(.*?)([¹²³])$/.exec(factor);
-    const superExp = uni === null ? undefined : SUPERSCRIPT[uni[2]];
-    if (uni !== null && superExp !== undefined && uni[1].length > 0)
-        return { base: uni[1], exp: superExp };
-    const glued = /^(.*?)([1-9]\d*)$/.exec(factor);
-    if (glued !== null && glued[1].length > 0) {
-        try {
-            parseSymbol(glued[1]);
-            return { base: glued[1], exp: Number(glued[2]) };
-        }
-        catch (e) {
-            if (!(e instanceof UnitError))
-                throw e;
+function homogeneousPower(single, product) {
+    const unit = attachedUnit(single.base);
+    if (unit === null)
+        return false;
+    return product.every((factor) => factor.base === unit && attachedUnit(factor.base) === null);
+}
+/** Every way to split `token` into one or more factors. A one-factor token is included. */
+function segmentations(token) {
+    const ways = Array.from({ length: token.length + 1 }, () => []);
+    ways[0].push([]);
+    for (let i = 0; i < token.length; i++) {
+        if (ways[i].length === 0)
+            continue;
+        for (let j = i + 1; j <= token.length; j++) {
+            const factor = tryOneFactor(token.slice(i, j));
+            if (factor === null)
+                continue;
+            for (const prev of ways[i])
+                ways[j].push([...prev, factor]);
         }
     }
-    if (caret === null)
-        throw new UnitError(`cannot read unit factor '${factor}'`);
-    return { base: caret[1], exp: 1 };
+    const unique = new Map();
+    for (const way of ways[token.length])
+        unique.set(formatReading(way), way);
+    return [...unique.values()];
+}
+/**
+ * Ways to read one token. A bare expression keeps a one-factor reading and
+ * does not also split it. Inside a compound, a prefixed factor also competes
+ * with each heterogeneous product. A homogeneous power does not.
+ */
+function tokenWays(token, compete) {
+    const single = tryOneFactor(token);
+    if (single !== null && !compete)
+        return [[single]];
+    const products = segmentations(token).filter((way) => way.length > 1);
+    const extra = single === null ? products : products.filter((way) => !homogeneousPower(single, way));
+    const ways = [];
+    if (single !== null)
+        ways.push([single]);
+    for (const way of extra)
+        ways.push(way);
+    const unique = new Map();
+    for (const way of ways)
+        unique.set(formatReading(way), way);
+    const list = [...unique.values()];
+    if (list.length === 0)
+        throw new UnitError(`unknown unit '${token}'`);
+    return list;
+}
+function cartesian(lists) {
+    let acc = [[]];
+    for (const list of lists) {
+        const next = [];
+        for (const prev of acc)
+            for (const item of list)
+                next.push([...prev, item]);
+        acc = next;
+    }
+    return acc;
 }
-function parseFactors(text, sign) {
+function sideTokens(text) {
+    return text.split(/[*·\s]+/).filter((part) => part.length > 0);
+}
+function formatSide(tokens) {
+    return tokens.map((factors) => formatReading(factors)).join('·');
+}
+function formatExpression(num, den) {
+    const numerator = formatSide(num);
+    if (den.length === 0)
+        return numerator;
+    const denominator = formatSide(den);
+    return denominator.includes('·') ? `${numerator}/(${denominator})` : `${numerator}/${denominator}`;
+}
+function accumulate(tokens, sign) {
     let scale = 1;
     let dim = DIMENSIONLESS;
-    for (const f of text.split(/[*·\s]+/).filter((x) => x.length > 0)) {
-        const { base, exp } = factorExponent(f);
-        const n = sign * exp;
-        const [s, d] = parseSymbol(base);
-        scale *= s ** n;
-        dim = multiply(dim, power(d, n));
+    for (const factors of tokens) {
+        for (const factor of factors) {
+            const n = sign * factor.exp;
+            scale *= factor.scale ** n;
+            dim = multiply(dim, power(factor.dim, n));
+        }
     }
     return { scale, dim };
 }
+/** Every dimensionally distinct spelling of one unit expression. */
+function unitReadings(text) {
+    const t = text.trim();
+    if (t === '' || t === '1')
+        return [{ scale: 1, dim: DIMENSIONLESS, label: '1' }];
+    const affine = affineRow(t);
+    if (affine !== undefined) {
+        return [{ scale: affine.scale, dim: D({ Theta: 1 }), affine: affine.id, label: t }];
+    }
+    if (AFFINE.some((row) => row.symbols.some((symbol) => t.includes(symbol))) ||
+        /deg\s+[CFcf]|°\s*[CFcf]/.test(t)) {
+        throw new UnitError('an affine temperature cannot be part of a compound unit; give K');
+    }
+    const parts = t.split('/');
+    if (parts.length > 2)
+        throw new UnitError(`'${t}' has more than one '/'; put the whole denominator after one '/'`);
+    const compete = /[*·/\s]/.test(t);
+    const numerator = sideTokens(parts[0]);
+    const denominatorText = parts.length === 1 ? '' : parts[1].replace(/^\((.*)\)$/, '$1');
+    const denominator = denominatorText === '' ? [] : sideTokens(denominatorText);
+    // `/s` is a dimensionless numerator over seconds. A bare `/` is not a unit.
+    if (numerator.length === 0 && denominator.length === 0)
+        throw new UnitError(`unknown unit '${t}'`);
+    const numWays = numerator.map((token) => tokenWays(token, compete));
+    const denWays = denominator.map((token) => tokenWays(token, compete));
+    const numCombos = numerator.length === 0 ? [[]] : cartesian(numWays);
+    const denCombos = denominator.length === 0 ? [[]] : cartesian(denWays);
+    const unique = new Map();
+    for (const num of numCombos) {
+        for (const den of denCombos) {
+            const n = accumulate(num, 1);
+            const d = accumulate(den, -1);
+            const label = formatExpression(num, den);
+            unique.set(label, { scale: n.scale * d.scale, dim: multiply(n.dim, d.dim), label });
+        }
+    }
+    return [...unique.values()];
+}
+function ambiguousMessage(text, readings) {
+    return `'${text}' is ambiguous: ${readings.map((reading) => reading.label).join(' or ')}`;
+}
+const SUPERSCRIPT = { '¹': 1, '²': 2, '³': 3 };
 /**
  * Spellings that convert correctly and still mean something else to a reader.
  * `myr` is a milliyear, `Msun` is `M_SUN_SI`, bare `G` is the gauss, bare `T`
@@ -172,27 +372,35 @@ export function unitConventionNotes(given) {
         notes.push('bare T is the tesla; Ts is a terasecond');
     if (symbols.includes('A'))
         notes.push('bare A is the ampere, not the angstrom; write angstrom or Å for 10^-10 m');
+    if (symbols.includes('P'))
+        notes.push('bare P is the poise (0.1 Pa·s); PV is still a petavolt');
     return notes;
 }
 /** Parse a unit expression; the empty string is dimensionless. @public */
 export function parseUnit(text) {
     const t = text.trim();
-    if (t === '' || t === '1')
-        return { scale: 1, dim: DIMENSIONLESS };
-    if (t === 'degC' || t === '°C')
-        return { scale: 1, dim: D({ Theta: 1 }), affine: 'celsius' };
-    if (/deg ?F|°F/.test(t))
-        throw new UnitError('Fahrenheit is not accepted; give K or degC');
-    if (/degC|°C/.test(t))
-        throw new UnitError('degC is affine and cannot be part of a compound unit; give K');
-    const parts = t.split('/');
-    if (parts.length > 2)
-        throw new UnitError(`'${t}' has more than one '/'; put the whole denominator after one '/'`);
-    const num = parseFactors(parts[0], 1);
-    if (parts.length === 1)
-        return num;
-    const den = parseFactors(parts[1].replace(/^\((.*)\)$/, '$1'), -1);
-    return { scale: num.scale * den.scale, dim: multiply(num.dim, den.dim) };
+    const readings = unitReadings(t);
+    if (readings.length !== 1)
+        throw new UnitError(ambiguousMessage(t, readings));
+    const reading = readings[0];
+    return {
+        scale: reading.scale,
+        dim: reading.dim,
+        ...(reading.affine !== undefined ? { affine: reading.affine } : {}),
+    };
+}
+/** Kelvin added when this affine unit is an absolute point. @internal */
+export function affineAbsoluteOffsetK(id) {
+    const row = AFFINE.find((candidate) => candidate.id === id);
+    if (row === undefined)
+        throw new UnitError(`unknown affine temperature '${id}'`);
+    return row.offset;
+}
+/** Kelvin from an affine or proportional reading. A difference drops the offset. */
+function kelvinFrom(value, unit, reading) {
+    const row = unit.affine === undefined ? undefined : AFFINE.find((candidate) => candidate.id === unit.affine);
+    const offset = row !== undefined && reading === 'absolute' ? row.offset : 0;
+    return value * unit.scale + offset;
 }
 /**
  * Convert `raw` (`<number>[unit]`) into `target` (a unit expression). A bare
@@ -211,15 +419,21 @@ export function convertValue(raw, target, reading = 'absolute') {
         throw new UnitError(`'${raw}' is not a finite number`);
     if (given === '')
         return { value: v, given };
-    const from = parseUnit(given);
+    const readings = unitReadings(given);
     const to = parseUnit(target);
     if (to.affine !== undefined)
         throw new UnitError(`a declared unit cannot be affine ('${target}')`);
-    if (!equals(from.dim, to.dim)) {
+    const matched = readings.filter((candidate) => equals(candidate.dim, to.dim));
+    if (matched.length !== 1) {
+        if (readings.length > 1)
+            throw new UnitError(ambiguousMessage(given, readings));
+        const from = readings[0];
+        if (from === undefined)
+            throw new UnitError(`unknown unit '${given}'`);
         throw new UnitError(`'${given}' is ${format(from.dim)}, but this input is ${format(to.dim)} (${target || 'dimensionless'})`);
     }
-    const offset = from.affine === 'celsius' && reading === 'absolute' ? CELSIUS_OFFSET_K : 0;
-    const local = (v * from.scale + offset) / to.scale;
+    const from = matched[0];
+    const local = kelvinFrom(v, from, reading) / to.scale;
     // MathTS `unit` + `toSI` is the conversion when it reads the same quantity.
     // A temperature difference must not take the absolute offset `toSI` adds.
     // `bit` is ln 2 nat here; MathTS reads `bit` as 1. Symbols MathTS does not