@budiauktioner/buildi-primitives 0.1.1 → 0.2.1

package/dist/cjs/measurement/speed.js

@@ -0,0 +1,159 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var speed_exports = {};
+__export(speed_exports, {
+  Speed: () => Speed,
+  maskSpeed: () => maskSpeed
+});
+module.exports = __toCommonJS(speed_exports);
+var import_decimal = require("../internal/decimal.js");
+var import_quantity = require("../internal/quantity.js");
+var import_text_candidate = require("../text-scanning/text-candidate.js");
+var import_text_candidate_category = require("../text-scanning/text-candidate-category.js");
+var import_text_match_confidence = require("../text-scanning/text-match-confidence.js");
+var import_speed_unit = require("./speed-unit.js");
+const SCAN_PATTERN = new RegExp(
+  String.raw`(?<![\p{L}\p{N}_])(?:[+-]\s*)?\d+[0-9 .,]*\s*(?:miles\s+per\s+hour|km/h|ft/s|m/s|kph|kmh|km/t|mph|knots?|knop|kt|kn)(?![\p{L}\p{N}_])`,
+  "giu"
+);
+class Speed extends import_quantity.Quantity {
+  static typeInfo = Object.freeze({
+    englishName: "Speed",
+    localizedName: "Hastighet",
+    emoji: "\u{1F3CE}\uFE0F",
+    sources: Object.freeze([
+      "https://www.bipm.org/en/measurement-units/si-base-units",
+      "https://en.wikipedia.org/wiki/Conversion_of_units"
+    ])
+  });
+  get units() {
+    return import_speed_unit.SpeedUnit.index;
+  }
+  withBaseValue(baseValue, unit) {
+    return new Speed(baseValue, unit);
+  }
+  get metersPerSecond() {
+    return this.in(import_speed_unit.SpeedUnit.MetersPerSecond);
+  }
+  get kilometersPerHour() {
+    return this.in(import_speed_unit.SpeedUnit.KilometersPerHour);
+  }
+  get milesPerHour() {
+    return this.in(import_speed_unit.SpeedUnit.MilesPerHour);
+  }
+  get feetPerSecond() {
+    return this.in(import_speed_unit.SpeedUnit.FeetPerSecond);
+  }
+  get knots() {
+    return this.in(import_speed_unit.SpeedUnit.Knot);
+  }
+  /** Creates a speed from a value and unit. */
+  static create(value, unit) {
+    import_speed_unit.SpeedUnit.index.assertOwns(unit);
+    const amount = value instanceof import_decimal.Decimal ? value : Speed.decimalOf(value);
+    return new Speed(unit.toBase(amount), unit);
+  }
+  static fromMetersPerSecond(value) {
+    return Speed.create(value, import_speed_unit.SpeedUnit.MetersPerSecond);
+  }
+  static fromKilometersPerHour(value) {
+    return Speed.create(value, import_speed_unit.SpeedUnit.KilometersPerHour);
+  }
+  static fromMilesPerHour(value) {
+    return Speed.create(value, import_speed_unit.SpeedUnit.MilesPerHour);
+  }
+  static fromFeetPerSecond(value) {
+    return Speed.create(value, import_speed_unit.SpeedUnit.FeetPerSecond);
+  }
+  static fromKnots(value) {
+    return Speed.create(value, import_speed_unit.SpeedUnit.Knot);
+  }
+  static tryParse(input) {
+    const parsed = (0, import_quantity.tryParseQuantity)(input, import_speed_unit.SpeedUnit.index);
+    return parsed === null ? null : new Speed(parsed.baseValue, parsed.unit);
+  }
+  static parse(input) {
+    const result = Speed.tryParse(input);
+    if (result === null) throw new Error("Invalid speed.");
+    return result;
+  }
+  static isValid(input) {
+    return Speed.tryParse(input) !== null;
+  }
+  /** Display form in the parsed unit, or `null` when the input is invalid. */
+  static format(input, options) {
+    const parsed = Speed.tryParse(input);
+    if (parsed !== null) {
+      if (options?.unit !== void 0 || options?.decimals !== void 0) {
+        return parsed.toStringInUnit(options.unit ?? parsed.originalUnit, options.decimals);
+      }
+      return parsed.toString();
+    }
+    return Speed.fallback(input, options);
+  }
+  /** The value in meters per second, or `null` when the input is invalid. */
+  static normalize(input, options) {
+    const parsed = Speed.tryParse(input);
+    if (parsed !== null) return parsed.toNormalizedString();
+    return Speed.fallback(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && Speed.normalize(input) === input;
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    const pattern = new RegExp(SCAN_PATTERN.source, SCAN_PATTERN.flags);
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const value = Speed.tryParse(match[0]);
+      if (value === null) continue;
+      out.push(
+        new import_text_candidate.TextCandidate({
+          startIndex: match.index,
+          length: match[0].length,
+          originalText: match[0],
+          typeName: "Speed",
+          category: import_text_candidate_category.TextCandidateCategory.Measurement,
+          normalizedForm: value.toNormalizedString(),
+          formattedForm: value.toString(),
+          maskedForm: maskSpeed(value),
+          confidence: import_text_match_confidence.TextMatchConfidence.Medium,
+          value
+        })
+      );
+    }
+    return out;
+  }
+  static fallback(input, options) {
+    if (options?.fallbackToTrimmedInputWhenInvalid !== true) return null;
+    if (input == null) return null;
+    const trimmed = input.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  static decimalOf(value) {
+    const parsed = import_decimal.Decimal.fromNumber(value);
+    if (parsed === null) throw new Error(`Value cannot be represented as a speed: ${value}`);
+    return parsed;
+  }
+}
+function maskSpeed(value) {
+  return `*** ${value.originalUnit.symbol}`;
+}
+//# sourceMappingURL=speed.js.map

package/dist/cjs/measurement/speed.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/speed.ts"],
+  "sourcesContent": ["import { Decimal } from \"../internal/decimal.js\";\nimport type { MeasurementUnitIndex } from \"../internal/measurement-unit.js\";\nimport { Quantity, tryParseQuantity } from \"../internal/quantity.js\";\nimport type { PrimitiveTypeInfo } from \"../primitive-type-info.js\";\nimport { TextCandidate } from \"../text-scanning/text-candidate.js\";\nimport { TextCandidateCategory } from \"../text-scanning/text-candidate-category.js\";\nimport { TextMatchConfidence } from \"../text-scanning/text-match-confidence.js\";\nimport { SpeedUnit } from \"./speed-unit.js\";\n\n/** Options for {@link Speed.format} and {@link Speed.normalize}. */\nexport interface SpeedFormatOptions {\n  fallbackToTrimmedInputWhenInvalid?: boolean;\n  /** Convert to this unit instead of preserving the parsed one. */\n  unit?: SpeedUnit;\n  /** Round to this many fractional digits, away from zero. */\n  decimals?: number;\n}\n\nconst SCAN_PATTERN = new RegExp(\n  String.raw`(?<![\\p{L}\\p{N}_])(?:[+-]\\s*)?\\d+[0-9 .,]*\\s*(?:miles\\s+per\\s+hour|km/h|ft/s|m/s|kph|kmh|km/t|mph|knots?|knop|kt|kn)(?![\\p{L}\\p{N}_])`,\n  \"giu\",\n);\n\n/**\n * A speed stored internally in meters per second,\n * parsed from any supported unit and convertible between all of them.\n */\nexport class Speed extends Quantity<SpeedUnit> {\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Speed\",\n    localizedName: \"Hastighet\",\n    emoji: \"\uD83C\uDFCE\uFE0F\",\n    sources: Object.freeze([\n      \"https://www.bipm.org/en/measurement-units/si-base-units\",\n      \"https://en.wikipedia.org/wiki/Conversion_of_units\",\n    ]),\n  });\n\n  protected get units(): MeasurementUnitIndex<SpeedUnit> {\n    return SpeedUnit.index;\n  }\n\n  protected withBaseValue(baseValue: Decimal, unit: SpeedUnit): this {\n    return new Speed(baseValue, unit) as this;\n  }\n\n  get metersPerSecond(): number {\n    return this.in(SpeedUnit.MetersPerSecond);\n  }\n  get kilometersPerHour(): number {\n    return this.in(SpeedUnit.KilometersPerHour);\n  }\n  get milesPerHour(): number {\n    return this.in(SpeedUnit.MilesPerHour);\n  }\n  get feetPerSecond(): number {\n    return this.in(SpeedUnit.FeetPerSecond);\n  }\n  get knots(): number {\n    return this.in(SpeedUnit.Knot);\n  }\n\n  /** Creates a speed from a value and unit. */\n  static create(value: number | Decimal, unit: SpeedUnit): Speed {\n    SpeedUnit.index.assertOwns(unit);\n    const amount = value instanceof Decimal ? value : Speed.decimalOf(value);\n    return new Speed(unit.toBase(amount), unit);\n  }\n\n  static fromMetersPerSecond(value: number | Decimal): Speed {\n    return Speed.create(value, SpeedUnit.MetersPerSecond);\n  }\n  static fromKilometersPerHour(value: number | Decimal): Speed {\n    return Speed.create(value, SpeedUnit.KilometersPerHour);\n  }\n  static fromMilesPerHour(value: number | Decimal): Speed {\n    return Speed.create(value, SpeedUnit.MilesPerHour);\n  }\n  static fromFeetPerSecond(value: number | Decimal): Speed {\n    return Speed.create(value, SpeedUnit.FeetPerSecond);\n  }\n  static fromKnots(value: number | Decimal): Speed {\n    return Speed.create(value, SpeedUnit.Knot);\n  }\n\n  static tryParse(input: string | null | undefined): Speed | null {\n    const parsed = tryParseQuantity(input, SpeedUnit.index);\n    return parsed === null ? null : new Speed(parsed.baseValue, parsed.unit);\n  }\n\n  static parse(input: string): Speed {\n    const result = Speed.tryParse(input);\n    if (result === null) throw new Error(\"Invalid speed.\");\n    return result;\n  }\n\n  static isValid(input: string | null | undefined): boolean {\n    return Speed.tryParse(input) !== null;\n  }\n\n  /** Display form in the parsed unit, or `null` when the input is invalid. */\n  static format(input: string | null | undefined, options?: SpeedFormatOptions): string | null {\n    const parsed = Speed.tryParse(input);\n    if (parsed !== null) {\n      if (options?.unit !== undefined || options?.decimals !== undefined) {\n        return parsed.toStringInUnit(options.unit ?? parsed.originalUnit, options.decimals);\n      }\n      return parsed.toString();\n    }\n    return Speed.fallback(input, options);\n  }\n\n  /** The value in meters per second, or `null` when the input is invalid. */\n  static normalize(input: string | null | undefined, options?: SpeedFormatOptions): string | null {\n    const parsed = Speed.tryParse(input);\n    if (parsed !== null) return parsed.toNormalizedString();\n    return Speed.fallback(input, options);\n  }\n\n  static isNormalized(input: string | null | undefined): boolean {\n    return input != null && Speed.normalize(input) === input;\n  }\n\n  static findCandidatesInText(text: string): readonly TextCandidate<Speed>[] {\n    if (!text) return [];\n\n    const out: TextCandidate<Speed>[] = [];\n    const pattern = new RegExp(SCAN_PATTERN.source, SCAN_PATTERN.flags);\n    let match: RegExpExecArray | null;\n\n    while ((match = pattern.exec(text)) !== null) {\n      const value = Speed.tryParse(match[0]);\n      if (value === null) continue;\n      out.push(\n        new TextCandidate<Speed>({\n          startIndex: match.index,\n          length: match[0].length,\n          originalText: match[0],\n          typeName: \"Speed\",\n          category: TextCandidateCategory.Measurement,\n          normalizedForm: value.toNormalizedString(),\n          formattedForm: value.toString(),\n          maskedForm: maskSpeed(value),\n          confidence: TextMatchConfidence.Medium,\n          value,\n        }),\n      );\n    }\n\n    return out;\n  }\n\n  private static fallback(\n    input: string | null | undefined,\n    options?: SpeedFormatOptions,\n  ): string | null {\n    if (options?.fallbackToTrimmedInputWhenInvalid !== true) return null;\n    if (input == null) return null;\n    const trimmed = input.trim();\n    return trimmed.length > 0 ? trimmed : null;\n  }\n\n  private static decimalOf(value: number): Decimal {\n    const parsed = Decimal.fromNumber(value);\n    if (parsed === null) throw new Error(`Value cannot be represented as a speed: ${value}`);\n    return parsed;\n  }\n}\n\n/** Returns a masked speed, e.g. `10 m/s` becomes `*** m/s`. */\nexport function maskSpeed(value: Speed): string {\n  return `*** ${value.originalUnit.symbol}`;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/measurement/temperature-delta.js

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var temperature_delta_exports = {};
+__export(temperature_delta_exports, {
+  TemperatureDelta: () => TemperatureDelta
+});
+module.exports = __toCommonJS(temperature_delta_exports);
+var import_decimal = require("../internal/decimal.js");
+const NINE = import_decimal.Decimal.parse("9");
+const FIVE = import_decimal.Decimal.parse("5");
+class TemperatureDelta {
+  constructor(deltaKelvin) {
+    this.deltaKelvin = deltaKelvin;
+  }
+  deltaKelvin;
+  static typeInfo = Object.freeze({
+    englishName: "Temperature Difference",
+    localizedName: "Temperaturskillnad",
+    emoji: "\u{1F321}\uFE0F",
+    sources: Object.freeze([])
+  });
+  /** The interval in kelvin, numerically the same as {@link celsius}. */
+  get kelvin() {
+    return this.deltaKelvin.toNumber();
+  }
+  /** The interval in degrees Celsius, numerically the same as {@link kelvin}. */
+  get celsius() {
+    return this.deltaKelvin.toNumber();
+  }
+  /** The interval in degrees Fahrenheit, so a 5 K interval is 9 °F. */
+  get fahrenheit() {
+    return this.fahrenheitDecimal().toNumber();
+  }
+  /** @internal The exact interval in kelvin, for {@link Temperature} arithmetic. */
+  get exactKelvin() {
+    return this.deltaKelvin;
+  }
+  static fromKelvin(value) {
+    return new TemperatureDelta(toDecimal(value));
+  }
+  static fromCelsius(value) {
+    return new TemperatureDelta(toDecimal(value));
+  }
+  static fromFahrenheit(value) {
+    return new TemperatureDelta(toDecimal(value).times(FIVE).dividedBy(NINE));
+  }
+  plus(other) {
+    return new TemperatureDelta(this.deltaKelvin.plus(other.deltaKelvin));
+  }
+  minus(other) {
+    return new TemperatureDelta(this.deltaKelvin.minus(other.deltaKelvin));
+  }
+  times(factor) {
+    return new TemperatureDelta(this.deltaKelvin.times(toDecimal(factor)));
+  }
+  dividedBy(divisor) {
+    return new TemperatureDelta(this.deltaKelvin.dividedBy(toDecimal(divisor)));
+  }
+  negated() {
+    return new TemperatureDelta(this.deltaKelvin.negated());
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.deltaKelvin.compareTo(other.deltaKelvin);
+  }
+  equals(other) {
+    return other != null && this.deltaKelvin.equals(other.deltaKelvin);
+  }
+  isLessThan(other) {
+    return this.compareTo(other) < 0;
+  }
+  isGreaterThan(other) {
+    return this.compareTo(other) > 0;
+  }
+  fahrenheitDecimal() {
+    return this.deltaKelvin.times(NINE).dividedBy(FIVE);
+  }
+}
+function toDecimal(value) {
+  if (value instanceof import_decimal.Decimal) return value;
+  const parsed = import_decimal.Decimal.fromNumber(value);
+  if (parsed === null) throw new Error(`Value cannot be represented as a temperature: ${value}`);
+  return parsed;
+}
+//# sourceMappingURL=temperature-delta.js.map

package/dist/cjs/measurement/temperature-delta.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/temperature-delta.ts"],
+  "sourcesContent": ["import { Decimal } from \"../internal/decimal.js\";\nimport type { PrimitiveTypeInfo } from \"../primitive-type-info.js\";\n\nconst NINE = Decimal.parse(\"9\")!;\nconst FIVE = Decimal.parse(\"5\")!;\n\n/**\n * A temperature difference, stored in kelvin.\n *\n * Differences do not carry the offset that absolute temperatures do: one kelvin\n * of difference is one degree Celsius, while a Fahrenheit interval scales by\n * 9/5. Subtracting two {@link Temperature} values produces one of these.\n */\nexport class TemperatureDelta {\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Temperature Difference\",\n    localizedName: \"Temperaturskillnad\",\n    emoji: \"\uD83C\uDF21\uFE0F\",\n    sources: Object.freeze([]),\n  });\n\n  private constructor(private readonly deltaKelvin: Decimal) {}\n\n  /** The interval in kelvin, numerically the same as {@link celsius}. */\n  get kelvin(): number {\n    return this.deltaKelvin.toNumber();\n  }\n\n  /** The interval in degrees Celsius, numerically the same as {@link kelvin}. */\n  get celsius(): number {\n    return this.deltaKelvin.toNumber();\n  }\n\n  /** The interval in degrees Fahrenheit, so a 5 K interval is 9 \u00B0F. */\n  get fahrenheit(): number {\n    return this.fahrenheitDecimal().toNumber();\n  }\n\n  /** @internal The exact interval in kelvin, for {@link Temperature} arithmetic. */\n  get exactKelvin(): Decimal {\n    return this.deltaKelvin;\n  }\n\n  static fromKelvin(value: number | Decimal): TemperatureDelta {\n    return new TemperatureDelta(toDecimal(value));\n  }\n\n  static fromCelsius(value: number | Decimal): TemperatureDelta {\n    return new TemperatureDelta(toDecimal(value));\n  }\n\n  static fromFahrenheit(value: number | Decimal): TemperatureDelta {\n    return new TemperatureDelta(toDecimal(value).times(FIVE).dividedBy(NINE));\n  }\n\n  plus(other: TemperatureDelta): TemperatureDelta {\n    return new TemperatureDelta(this.deltaKelvin.plus(other.deltaKelvin));\n  }\n\n  minus(other: TemperatureDelta): TemperatureDelta {\n    return new TemperatureDelta(this.deltaKelvin.minus(other.deltaKelvin));\n  }\n\n  times(factor: number | Decimal): TemperatureDelta {\n    return new TemperatureDelta(this.deltaKelvin.times(toDecimal(factor)));\n  }\n\n  dividedBy(divisor: number | Decimal): TemperatureDelta {\n    return new TemperatureDelta(this.deltaKelvin.dividedBy(toDecimal(divisor)));\n  }\n\n  negated(): TemperatureDelta {\n    return new TemperatureDelta(this.deltaKelvin.negated());\n  }\n\n  compareTo(other: TemperatureDelta | null | undefined): number {\n    if (other == null) return 1;\n    return this.deltaKelvin.compareTo(other.deltaKelvin);\n  }\n\n  equals(other: TemperatureDelta | null | undefined): boolean {\n    return other != null && this.deltaKelvin.equals(other.deltaKelvin);\n  }\n\n  isLessThan(other: TemperatureDelta): boolean {\n    return this.compareTo(other) < 0;\n  }\n\n  isGreaterThan(other: TemperatureDelta): boolean {\n    return this.compareTo(other) > 0;\n  }\n\n  private fahrenheitDecimal(): Decimal {\n    return this.deltaKelvin.times(NINE).dividedBy(FIVE);\n  }\n}\n\nfunction toDecimal(value: number | Decimal): Decimal {\n  if (value instanceof Decimal) return value;\n  const parsed = Decimal.fromNumber(value);\n  if (parsed === null) throw new Error(`Value cannot be represented as a temperature: ${value}`);\n  return parsed;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAwB;AAGxB,MAAM,OAAO,uBAAQ,MAAM,GAAG;AAC9B,MAAM,OAAO,uBAAQ,MAAM,GAAG;AASvB,MAAM,iBAAiB;AAAA,EAQpB,YAA6B,aAAsB;AAAtB;AAAA,EAAuB;AAAA,EAAvB;AAAA,EAPrC,OAAgB,WAA8B,OAAO,OAAO;AAAA,IAC1D,aAAa;AAAA,IACb,eAAe;AAAA,IACf,OAAO;AAAA,IACP,SAAS,OAAO,OAAO,CAAC,CAAC;AAAA,EAC3B,CAAC;AAAA;AAAA,EAKD,IAAI,SAAiB;AACnB,WAAO,KAAK,YAAY,SAAS;AAAA,EACnC;AAAA;AAAA,EAGA,IAAI,UAAkB;AACpB,WAAO,KAAK,YAAY,SAAS;AAAA,EACnC;AAAA;AAAA,EAGA,IAAI,aAAqB;AACvB,WAAO,KAAK,kBAAkB,EAAE,SAAS;AAAA,EAC3C;AAAA;AAAA,EAGA,IAAI,cAAuB;AACzB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,OAAO,WAAW,OAA2C;AAC3D,WAAO,IAAI,iBAAiB,UAAU,KAAK,CAAC;AAAA,EAC9C;AAAA,EAEA,OAAO,YAAY,OAA2C;AAC5D,WAAO,IAAI,iBAAiB,UAAU,KAAK,CAAC;AAAA,EAC9C;AAAA,EAEA,OAAO,eAAe,OAA2C;AAC/D,WAAO,IAAI,iBAAiB,UAAU,KAAK,EAAE,MAAM,IAAI,EAAE,UAAU,IAAI,CAAC;AAAA,EAC1E;AAAA,EAEA,KAAK,OAA2C;AAC9C,WAAO,IAAI,iBAAiB,KAAK,YAAY,KAAK,MAAM,WAAW,CAAC;AAAA,EACtE;AAAA,EAEA,MAAM,OAA2C;AAC/C,WAAO,IAAI,iBAAiB,KAAK,YAAY,MAAM,MAAM,WAAW,CAAC;AAAA,EACvE;AAAA,EAEA,MAAM,QAA4C;AAChD,WAAO,IAAI,iBAAiB,KAAK,YAAY,MAAM,UAAU,MAAM,CAAC,CAAC;AAAA,EACvE;AAAA,EAEA,UAAU,SAA6C;AACrD,WAAO,IAAI,iBAAiB,KAAK,YAAY,UAAU,UAAU,OAAO,CAAC,CAAC;AAAA,EAC5E;AAAA,EAEA,UAA4B;AAC1B,WAAO,IAAI,iBAAiB,KAAK,YAAY,QAAQ,CAAC;AAAA,EACxD;AAAA,EAEA,UAAU,OAAoD;AAC5D,QAAI,SAAS,KAAM,QAAO;AAC1B,WAAO,KAAK,YAAY,UAAU,MAAM,WAAW;AAAA,EACrD;AAAA,EAEA,OAAO,OAAqD;AAC1D,WAAO,SAAS,QAAQ,KAAK,YAAY,OAAO,MAAM,WAAW;AAAA,EACnE;AAAA,EAEA,WAAW,OAAkC;AAC3C,WAAO,KAAK,UAAU,KAAK,IAAI;AAAA,EACjC;AAAA,EAEA,cAAc,OAAkC;AAC9C,WAAO,KAAK,UAAU,KAAK,IAAI;AAAA,EACjC;AAAA,EAEQ,oBAA6B;AACnC,WAAO,KAAK,YAAY,MAAM,IAAI,EAAE,UAAU,IAAI;AAAA,EACpD;AACF;AAEA,SAAS,UAAU,OAAkC;AACnD,MAAI,iBAAiB,uBAAS,QAAO;AACrC,QAAM,SAAS,uBAAQ,WAAW,KAAK;AACvC,MAAI,WAAW,KAAM,OAAM,IAAI,MAAM,iDAAiD,KAAK,EAAE;AAC7F,SAAO;AACT;",
+  "names": []
+}

package/dist/cjs/measurement/temperature-unit.js

@@ -0,0 +1,130 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var temperature_unit_exports = {};
+__export(temperature_unit_exports, {
+  TemperatureUnit: () => TemperatureUnit
+});
+module.exports = __toCommonJS(temperature_unit_exports);
+var import_measurement_unit = require("../internal/measurement-unit.js");
+class TemperatureUnit {
+  static typeInfo = Object.freeze({
+    englishName: "Temperature Unit",
+    localizedName: "Temperaturenhet",
+    emoji: "\u{1F321}\uFE0F",
+    sources: Object.freeze([])
+  });
+  static index = null;
+  symbol;
+  englishName;
+  localizedName;
+  pluralEnglish;
+  pluralSwedish;
+  aliases;
+  constructor(definition) {
+    this.symbol = definition.symbol;
+    this.englishName = definition.englishName;
+    this.localizedName = definition.localizedName;
+    this.pluralEnglish = definition.pluralEnglish;
+    this.pluralSwedish = definition.pluralSwedish;
+    this.aliases = Object.freeze([...definition.aliases]);
+    return new Proxy(this, {
+      set() {
+        throw new TypeError("Measurement units are immutable.");
+      }
+    });
+  }
+  static Celsius = new TemperatureUnit({
+    symbol: "\xB0C",
+    englishName: "degree Celsius",
+    localizedName: "grad Celsius",
+    pluralEnglish: "degrees Celsius",
+    pluralSwedish: "grader Celsius",
+    aliases: ["C", "celsius", "grader"]
+  });
+  static Fahrenheit = new TemperatureUnit({
+    symbol: "\xB0F",
+    englishName: "degree Fahrenheit",
+    localizedName: "grad Fahrenheit",
+    pluralEnglish: "degrees Fahrenheit",
+    pluralSwedish: "grader Fahrenheit",
+    aliases: ["F", "fahrenheit"]
+  });
+  static Kelvin = new TemperatureUnit({
+    symbol: "K",
+    englishName: "kelvin",
+    localizedName: "kelvin",
+    pluralEnglish: "kelvin",
+    pluralSwedish: "kelvin",
+    aliases: ["kelvin"]
+  });
+  static units = Object.freeze([
+    TemperatureUnit.Celsius,
+    TemperatureUnit.Fahrenheit,
+    TemperatureUnit.Kelvin
+  ]);
+  static {
+    for (const unit of TemperatureUnit.units) Object.freeze(unit);
+  }
+  static get all() {
+    return TemperatureUnit.units;
+  }
+  /** The SI base unit for thermodynamic temperature: kelvin. */
+  static get baseUnit() {
+    return TemperatureUnit.Kelvin;
+  }
+  /** Resolves a scale from a symbol, name, plural or alias, case-insensitively. */
+  static tryParse(input) {
+    if (input == null) return null;
+    const trimmed = input.trim();
+    if (trimmed.length === 0) return null;
+    return TemperatureUnit.symbolIndex().get((0, import_measurement_unit.foldForUnitLookup)(trimmed)) ?? null;
+  }
+  static parse(input) {
+    const result = TemperatureUnit.tryParse(input);
+    if (result === null) throw new Error("Unknown temperature unit.");
+    return result;
+  }
+  static assertOwns(unit) {
+    if (!TemperatureUnit.units.includes(unit)) {
+      throw new RangeError("Unit belongs to another dimension.");
+    }
+  }
+  toString() {
+    return this.symbol;
+  }
+  static symbolIndex() {
+    if (TemperatureUnit.index !== null) return TemperatureUnit.index;
+    const index = /* @__PURE__ */ new Map();
+    const add = (key, unit) => {
+      const folded = (0, import_measurement_unit.foldForUnitLookup)(key);
+      if (folded.length > 0 && !index.has(folded)) index.set(folded, unit);
+    };
+    for (const unit of TemperatureUnit.all) {
+      add(unit.symbol, unit);
+      add(unit.englishName, unit);
+      add(unit.localizedName, unit);
+      add(unit.pluralEnglish, unit);
+      add(unit.pluralSwedish, unit);
+      for (const alias of unit.aliases) add(alias, unit);
+    }
+    TemperatureUnit.index = index;
+    return index;
+  }
+}
+//# sourceMappingURL=temperature-unit.js.map

package/dist/cjs/measurement/temperature-unit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/temperature-unit.ts"],
+  "sourcesContent": ["import { foldForUnitLookup } from \"../internal/measurement-unit.js\";\nimport type { PrimitiveTypeInfo } from \"../primitive-type-info.js\";\n\n/**\n * A temperature scale identified by its symbol.\n *\n * Unlike every other unit in this namespace, temperature scales carry no\n * conversion factor: Celsius, Fahrenheit and kelvin differ by an offset as well\n * as a scale, so {@link Temperature} converts between them explicitly. That is\n * also why this class does not share the common unit machinery.\n */\nexport class TemperatureUnit {\n  declare private readonly __temperatureUnitBrand: void;\n\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Temperature Unit\",\n    localizedName: \"Temperaturenhet\",\n    emoji: \"\uD83C\uDF21\uFE0F\",\n    sources: Object.freeze([]),\n  });\n\n  private static index: Map<string, TemperatureUnit> | null = null;\n\n  readonly symbol: string;\n  readonly englishName: string;\n  readonly localizedName: string;\n  readonly pluralEnglish: string;\n  readonly pluralSwedish: string;\n  readonly aliases: readonly string[];\n\n  private constructor(definition: {\n    symbol: string;\n    englishName: string;\n    localizedName: string;\n    pluralEnglish: string;\n    pluralSwedish: string;\n    aliases: readonly string[];\n  }) {\n    this.symbol = definition.symbol;\n    this.englishName = definition.englishName;\n    this.localizedName = definition.localizedName;\n    this.pluralEnglish = definition.pluralEnglish;\n    this.pluralSwedish = definition.pluralSwedish;\n    this.aliases = Object.freeze([...definition.aliases]);\n\n    return new Proxy(this, {\n      set() {\n        throw new TypeError(\"Measurement units are immutable.\");\n      },\n    });\n  }\n\n  static readonly Celsius = new TemperatureUnit({\n    symbol: \"\u00B0C\",\n    englishName: \"degree Celsius\",\n    localizedName: \"grad Celsius\",\n    pluralEnglish: \"degrees Celsius\",\n    pluralSwedish: \"grader Celsius\",\n    aliases: [\"C\", \"celsius\", \"grader\"],\n  });\n\n  static readonly Fahrenheit = new TemperatureUnit({\n    symbol: \"\u00B0F\",\n    englishName: \"degree Fahrenheit\",\n    localizedName: \"grad Fahrenheit\",\n    pluralEnglish: \"degrees Fahrenheit\",\n    pluralSwedish: \"grader Fahrenheit\",\n    aliases: [\"F\", \"fahrenheit\"],\n  });\n\n  static readonly Kelvin = new TemperatureUnit({\n    symbol: \"K\",\n    englishName: \"kelvin\",\n    localizedName: \"kelvin\",\n    pluralEnglish: \"kelvin\",\n    pluralSwedish: \"kelvin\",\n    aliases: [\"kelvin\"],\n  });\n\n  private static readonly units: readonly TemperatureUnit[] = Object.freeze([\n    TemperatureUnit.Celsius,\n    TemperatureUnit.Fahrenheit,\n    TemperatureUnit.Kelvin,\n  ]);\n\n  static {\n    for (const unit of TemperatureUnit.units) Object.freeze(unit);\n  }\n\n  static get all(): readonly TemperatureUnit[] {\n    return TemperatureUnit.units;\n  }\n\n  /** The SI base unit for thermodynamic temperature: kelvin. */\n  static get baseUnit(): TemperatureUnit {\n    return TemperatureUnit.Kelvin;\n  }\n\n  /** Resolves a scale from a symbol, name, plural or alias, case-insensitively. */\n  static tryParse(input: string | null | undefined): TemperatureUnit | null {\n    if (input == null) return null;\n    const trimmed = input.trim();\n    if (trimmed.length === 0) return null;\n    return TemperatureUnit.symbolIndex().get(foldForUnitLookup(trimmed)) ?? null;\n  }\n\n  static parse(input: string): TemperatureUnit {\n    const result = TemperatureUnit.tryParse(input);\n    if (result === null) throw new Error(\"Unknown temperature unit.\");\n    return result;\n  }\n\n  static assertOwns(unit: unknown): asserts unit is TemperatureUnit {\n    if (!TemperatureUnit.units.includes(unit as TemperatureUnit)) {\n      throw new RangeError(\"Unit belongs to another dimension.\");\n    }\n  }\n\n  toString(): string {\n    return this.symbol;\n  }\n\n  private static symbolIndex(): Map<string, TemperatureUnit> {\n    if (TemperatureUnit.index !== null) return TemperatureUnit.index;\n\n    const index = new Map<string, TemperatureUnit>();\n    const add = (key: string, unit: TemperatureUnit): void => {\n      const folded = foldForUnitLookup(key);\n      if (folded.length > 0 && !index.has(folded)) index.set(folded, unit);\n    };\n\n    for (const unit of TemperatureUnit.all) {\n      add(unit.symbol, unit);\n      add(unit.englishName, unit);\n      add(unit.localizedName, unit);\n      add(unit.pluralEnglish, unit);\n      add(unit.pluralSwedish, unit);\n      for (const alias of unit.aliases) add(alias, unit);\n    }\n\n    TemperatureUnit.index = index;\n    return index;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/measurement/temperature.js

@@ -0,0 +1,216 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var temperature_exports = {};
+__export(temperature_exports, {
+  Temperature: () => Temperature,
+  maskTemperature: () => maskTemperature
+});
+module.exports = __toCommonJS(temperature_exports);
+var import_decimal = require("../internal/decimal.js");
+var import_measurement_unit_parser = require("../internal/measurement-unit-parser.js");
+var import_quantity = require("../internal/quantity.js");
+var import_text_candidate = require("../text-scanning/text-candidate.js");
+var import_text_candidate_category = require("../text-scanning/text-candidate-category.js");
+var import_text_match_confidence = require("../text-scanning/text-match-confidence.js");
+var import_temperature_delta = require("./temperature-delta.js");
+var import_temperature_unit = require("./temperature-unit.js");
+const CELSIUS_OFFSET = import_decimal.Decimal.parse("273.15");
+const NINE = import_decimal.Decimal.parse("9");
+const FIVE = import_decimal.Decimal.parse("5");
+const THIRTY_TWO = import_decimal.Decimal.parse("32");
+const SCAN_PATTERN = /(?<![\p{L}\p{N}_])(?:[+-]\s*)?\d+[0-9 .,]*\s*(?:°[CF]|[CFK])(?![\p{L}\p{N}_])/giu;
+class Temperature {
+  constructor(kelvinValue, originalUnit) {
+    this.kelvinValue = kelvinValue;
+    this.originalUnit = originalUnit;
+  }
+  kelvinValue;
+  originalUnit;
+  static typeInfo = Object.freeze({
+    englishName: "Temperature",
+    localizedName: "Temperatur",
+    emoji: "\u{1F321}\uFE0F",
+    sources: Object.freeze([
+      "https://www.bipm.org/en/measurement-units/si-base-units",
+      "https://en.wikipedia.org/wiki/Conversion_of_units"
+    ])
+  });
+  /** The value in degrees Celsius, so `0` at the ice point. */
+  get celsius() {
+    return this.inDecimal(import_temperature_unit.TemperatureUnit.Celsius).toNumber();
+  }
+  /** The value in degrees Fahrenheit, so `32` at 0 °C. */
+  get fahrenheit() {
+    return this.inDecimal(import_temperature_unit.TemperatureUnit.Fahrenheit).toNumber();
+  }
+  /** The value in kelvin. */
+  get kelvin() {
+    return this.kelvinValue.toNumber();
+  }
+  /** The exact value converted to `unit`. */
+  inDecimal(unit) {
+    import_temperature_unit.TemperatureUnit.assertOwns(unit);
+    if (unit === import_temperature_unit.TemperatureUnit.Kelvin) return this.kelvinValue;
+    const celsius = this.kelvinValue.minus(CELSIUS_OFFSET);
+    if (unit === import_temperature_unit.TemperatureUnit.Celsius) return celsius;
+    if (unit === import_temperature_unit.TemperatureUnit.Fahrenheit) {
+      return celsius.times(NINE).dividedBy(FIVE).plus(THIRTY_TWO);
+    }
+    throw new RangeError("Unit belongs to another dimension.");
+  }
+  /** The value converted to `unit`, as a `number` for ergonomic access. */
+  in(unit) {
+    return this.inDecimal(unit).toNumber();
+  }
+  static fromCelsius(value) {
+    return new Temperature(toDecimal(value).plus(CELSIUS_OFFSET), import_temperature_unit.TemperatureUnit.Celsius);
+  }
+  static fromFahrenheit(value) {
+    const celsius = toDecimal(value).minus(THIRTY_TWO).times(FIVE).dividedBy(NINE);
+    return new Temperature(celsius.plus(CELSIUS_OFFSET), import_temperature_unit.TemperatureUnit.Fahrenheit);
+  }
+  static fromKelvin(value) {
+    return new Temperature(toDecimal(value), import_temperature_unit.TemperatureUnit.Kelvin);
+  }
+  /** Creates a temperature from a value on the given scale. */
+  static create(value, unit) {
+    import_temperature_unit.TemperatureUnit.assertOwns(unit);
+    if (unit === import_temperature_unit.TemperatureUnit.Celsius) return Temperature.fromCelsius(value);
+    if (unit === import_temperature_unit.TemperatureUnit.Fahrenheit) return Temperature.fromFahrenheit(value);
+    if (unit === import_temperature_unit.TemperatureUnit.Kelvin) return Temperature.fromKelvin(value);
+    throw new RangeError("Unit belongs to another dimension.");
+  }
+  static tryParse(input) {
+    const split = (0, import_measurement_unit_parser.trySplitMeasurement)(input);
+    if (split === null) return null;
+    const unit = import_temperature_unit.TemperatureUnit.tryParse(split.unitSuffix);
+    if (unit === null) return null;
+    try {
+      return Temperature.create(split.value, unit);
+    } catch {
+      return null;
+    }
+  }
+  static parse(input) {
+    const result = Temperature.tryParse(input);
+    if (result === null) throw new Error("Invalid temperature.");
+    return result;
+  }
+  static isValid(input) {
+    return Temperature.tryParse(input) !== null;
+  }
+  /** Display form on the parsed scale, or `null` when the input is invalid. */
+  static format(input, options) {
+    const parsed = Temperature.tryParse(input);
+    if (parsed !== null) {
+      if (options?.unit !== void 0 || options?.decimals !== void 0) {
+        return parsed.toStringInUnit(options.unit ?? parsed.originalUnit, options.decimals);
+      }
+      return parsed.toString();
+    }
+    return Temperature.fallback(input, options);
+  }
+  /** The value in kelvin, or `null` when the input is invalid. */
+  static normalize(input, options) {
+    const parsed = Temperature.tryParse(input);
+    if (parsed !== null) return parsed.toNormalizedString();
+    return Temperature.fallback(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && Temperature.normalize(input) === input;
+  }
+  /** The value in kelvin, e.g. `293.15 K`. */
+  toNormalizedString() {
+    return `${(0, import_quantity.formatQuantityDecimal)(this.kelvinValue)} ${import_temperature_unit.TemperatureUnit.Kelvin.symbol}`;
+  }
+  /** The value on the scale it was parsed from, e.g. `20 °C`. */
+  toString() {
+    return this.toStringInUnit(this.originalUnit);
+  }
+  /** The value converted to `unit`, e.g. `68 °F`. */
+  toStringInUnit(unit, decimals) {
+    return `${(0, import_quantity.formatQuantityDecimal)(this.inDecimal(unit), decimals)} ${unit.symbol}`;
+  }
+  /** Adds a temperature difference, keeping the original scale. */
+  plus(delta) {
+    return new Temperature(this.kelvinValue.plus(delta.exactKelvin), this.originalUnit);
+  }
+  /** Subtracts a temperature difference, keeping the original scale. */
+  minus(delta) {
+    return new Temperature(this.kelvinValue.minus(delta.exactKelvin), this.originalUnit);
+  }
+  /** The difference between two temperatures. */
+  difference(other) {
+    return import_temperature_delta.TemperatureDelta.fromKelvin(this.kelvinValue.minus(other.kelvinValue));
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.kelvinValue.compareTo(other.kelvinValue);
+  }
+  equals(other) {
+    return other != null && this.kelvinValue.equals(other.kelvinValue);
+  }
+  isLessThan(other) {
+    return this.compareTo(other) < 0;
+  }
+  isGreaterThan(other) {
+    return this.compareTo(other) > 0;
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    const pattern = new RegExp(SCAN_PATTERN.source, SCAN_PATTERN.flags);
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const value = Temperature.tryParse(match[0]);
+      if (value === null) continue;
+      out.push(
+        new import_text_candidate.TextCandidate({
+          startIndex: match.index,
+          length: match[0].length,
+          originalText: match[0],
+          typeName: "Temperature",
+          category: import_text_candidate_category.TextCandidateCategory.Measurement,
+          normalizedForm: value.toNormalizedString(),
+          formattedForm: value.toString(),
+          maskedForm: maskTemperature(value),
+          confidence: import_text_match_confidence.TextMatchConfidence.Medium,
+          value
+        })
+      );
+    }
+    return out;
+  }
+  static fallback(input, options) {
+    if (options?.fallbackToTrimmedInputWhenInvalid !== true) return null;
+    if (input == null) return null;
+    const trimmed = input.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+}
+function toDecimal(value) {
+  if (value instanceof import_decimal.Decimal) return value;
+  const parsed = import_decimal.Decimal.fromNumber(value);
+  if (parsed === null) throw new Error(`Value cannot be represented as a temperature: ${value}`);
+  return parsed;
+}
+function maskTemperature(value) {
+  return `*** ${value.originalUnit.symbol}`;
+}
+//# sourceMappingURL=temperature.js.map