@budiauktioner/buildi-primitives 0.1.1 → 0.2.1

package/dist/esm/measurement/torque.js

@@ -0,0 +1,145 @@
+import { Decimal } from "../internal/decimal.js";
+import { Quantity, tryParseQuantity } from "../internal/quantity.js";
+import { TextCandidate } from "../text-scanning/text-candidate.js";
+import { TextCandidateCategory } from "../text-scanning/text-candidate-category.js";
+import { TextMatchConfidence } from "../text-scanning/text-match-confidence.js";
+import { TorqueUnit } from "./torque-unit.js";
+const SCAN_PATTERN = new RegExp(
+  String.raw`(?<![\p{L}\p{N}_])(?:[+-]\s*)?\d+[0-9 .,]*\s*(?:foot-pounds|foot-pound|inch-pounds|inch-pound|kilogramkraftmeter|kilonewton[\s-]?meters?|millinewton[\s-]?meters?|newtonmeter|fotpund|tumpund|kgf-m|kgf·m|kgfm|ft-lb|ft·lb|in-lb|in·lb|kN·m|kNm|mN·m|mNm|N·m|Nm)(?![\p{L}\p{N}_])`,
+  "giu"
+);
+class Torque extends Quantity {
+  static typeInfo = Object.freeze({
+    englishName: "Torque",
+    localizedName: "Vridmoment",
+    emoji: "\u{1F527}",
+    sources: Object.freeze([
+      "https://www.bipm.org/en/measurement-units/si-derived-units",
+      "https://en.wikipedia.org/wiki/Conversion_of_units"
+    ])
+  });
+  get units() {
+    return TorqueUnit.index;
+  }
+  withBaseValue(baseValue, unit) {
+    return new Torque(baseValue, unit);
+  }
+  get millinewtonMeters() {
+    return this.in(TorqueUnit.MillinewtonMeter);
+  }
+  get newtonMeters() {
+    return this.in(TorqueUnit.NewtonMeter);
+  }
+  get kilonewtonMeters() {
+    return this.in(TorqueUnit.KilonewtonMeter);
+  }
+  get footPounds() {
+    return this.in(TorqueUnit.FootPound);
+  }
+  get kilogramForceMeters() {
+    return this.in(TorqueUnit.KilogramForceMeter);
+  }
+  get inchPounds() {
+    return this.in(TorqueUnit.InchPound);
+  }
+  /** Creates a torque from a value and unit. */
+  static create(value, unit) {
+    TorqueUnit.index.assertOwns(unit);
+    const amount = value instanceof Decimal ? value : Torque.decimalOf(value);
+    return new Torque(unit.toBase(amount), unit);
+  }
+  static fromMillinewtonMeters(value) {
+    return Torque.create(value, TorqueUnit.MillinewtonMeter);
+  }
+  static fromNewtonMeters(value) {
+    return Torque.create(value, TorqueUnit.NewtonMeter);
+  }
+  static fromKilonewtonMeters(value) {
+    return Torque.create(value, TorqueUnit.KilonewtonMeter);
+  }
+  static fromFootPounds(value) {
+    return Torque.create(value, TorqueUnit.FootPound);
+  }
+  static fromKilogramForceMeters(value) {
+    return Torque.create(value, TorqueUnit.KilogramForceMeter);
+  }
+  static fromInchPounds(value) {
+    return Torque.create(value, TorqueUnit.InchPound);
+  }
+  static tryParse(input) {
+    const parsed = tryParseQuantity(input, TorqueUnit.index);
+    return parsed === null ? null : new Torque(parsed.baseValue, parsed.unit);
+  }
+  static parse(input) {
+    const result = Torque.tryParse(input);
+    if (result === null) throw new Error("Invalid torque.");
+    return result;
+  }
+  static isValid(input) {
+    return Torque.tryParse(input) !== null;
+  }
+  /** Display form in the parsed unit, or `null` when the input is invalid. */
+  static format(input, options) {
+    const parsed = Torque.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 Torque.fallback(input, options);
+  }
+  /** The value in newton meters, or `null` when the input is invalid. */
+  static normalize(input, options) {
+    const parsed = Torque.tryParse(input);
+    if (parsed !== null) return parsed.toNormalizedString();
+    return Torque.fallback(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && Torque.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 = Torque.tryParse(match[0]);
+      if (value === null) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: match.index,
+          length: match[0].length,
+          originalText: match[0],
+          typeName: "Torque",
+          category: TextCandidateCategory.Measurement,
+          normalizedForm: value.toNormalizedString(),
+          formattedForm: value.toString(),
+          maskedForm: maskTorque(value),
+          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 = Decimal.fromNumber(value);
+    if (parsed === null) throw new Error(`Value cannot be represented as a torque: ${value}`);
+    return parsed;
+  }
+}
+function maskTorque(value) {
+  return `*** ${value.originalUnit.symbol}`;
+}
+export {
+  Torque,
+  maskTorque
+};
+//# sourceMappingURL=torque.js.map

package/dist/esm/measurement/torque.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/torque.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 { TorqueUnit } from \"./torque-unit.js\";\n\n/** Options for {@link Torque.format} and {@link Torque.normalize}. */\nexport interface TorqueFormatOptions {\n  fallbackToTrimmedInputWhenInvalid?: boolean;\n  /** Convert to this unit instead of preserving the parsed one. */\n  unit?: TorqueUnit;\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*(?:foot-pounds|foot-pound|inch-pounds|inch-pound|kilogramkraftmeter|kilonewton[\\s-]?meters?|millinewton[\\s-]?meters?|newtonmeter|fotpund|tumpund|kgf-m|kgf\u00B7m|kgfm|ft-lb|ft\u00B7lb|in-lb|in\u00B7lb|kN\u00B7m|kNm|mN\u00B7m|mNm|N\u00B7m|Nm)(?![\\p{L}\\p{N}_])`,\n  \"giu\",\n);\n\n/**\n * A torque stored internally in newton meters,\n * parsed from any supported unit and convertible between all of them.\n */\nexport class Torque extends Quantity<TorqueUnit> {\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Torque\",\n    localizedName: \"Vridmoment\",\n    emoji: \"\uD83D\uDD27\",\n    sources: Object.freeze([\n      \"https://www.bipm.org/en/measurement-units/si-derived-units\",\n      \"https://en.wikipedia.org/wiki/Conversion_of_units\",\n    ]),\n  });\n\n  protected get units(): MeasurementUnitIndex<TorqueUnit> {\n    return TorqueUnit.index;\n  }\n\n  protected withBaseValue(baseValue: Decimal, unit: TorqueUnit): this {\n    return new Torque(baseValue, unit) as this;\n  }\n\n  get millinewtonMeters(): number {\n    return this.in(TorqueUnit.MillinewtonMeter);\n  }\n  get newtonMeters(): number {\n    return this.in(TorqueUnit.NewtonMeter);\n  }\n  get kilonewtonMeters(): number {\n    return this.in(TorqueUnit.KilonewtonMeter);\n  }\n  get footPounds(): number {\n    return this.in(TorqueUnit.FootPound);\n  }\n  get kilogramForceMeters(): number {\n    return this.in(TorqueUnit.KilogramForceMeter);\n  }\n  get inchPounds(): number {\n    return this.in(TorqueUnit.InchPound);\n  }\n\n  /** Creates a torque from a value and unit. */\n  static create(value: number | Decimal, unit: TorqueUnit): Torque {\n    TorqueUnit.index.assertOwns(unit);\n    const amount = value instanceof Decimal ? value : Torque.decimalOf(value);\n    return new Torque(unit.toBase(amount), unit);\n  }\n\n  static fromMillinewtonMeters(value: number | Decimal): Torque {\n    return Torque.create(value, TorqueUnit.MillinewtonMeter);\n  }\n  static fromNewtonMeters(value: number | Decimal): Torque {\n    return Torque.create(value, TorqueUnit.NewtonMeter);\n  }\n  static fromKilonewtonMeters(value: number | Decimal): Torque {\n    return Torque.create(value, TorqueUnit.KilonewtonMeter);\n  }\n  static fromFootPounds(value: number | Decimal): Torque {\n    return Torque.create(value, TorqueUnit.FootPound);\n  }\n  static fromKilogramForceMeters(value: number | Decimal): Torque {\n    return Torque.create(value, TorqueUnit.KilogramForceMeter);\n  }\n  static fromInchPounds(value: number | Decimal): Torque {\n    return Torque.create(value, TorqueUnit.InchPound);\n  }\n\n  static tryParse(input: string | null | undefined): Torque | null {\n    const parsed = tryParseQuantity(input, TorqueUnit.index);\n    return parsed === null ? null : new Torque(parsed.baseValue, parsed.unit);\n  }\n\n  static parse(input: string): Torque {\n    const result = Torque.tryParse(input);\n    if (result === null) throw new Error(\"Invalid torque.\");\n    return result;\n  }\n\n  static isValid(input: string | null | undefined): boolean {\n    return Torque.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?: TorqueFormatOptions): string | null {\n    const parsed = Torque.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 Torque.fallback(input, options);\n  }\n\n  /** The value in newton meters, or `null` when the input is invalid. */\n  static normalize(input: string | null | undefined, options?: TorqueFormatOptions): string | null {\n    const parsed = Torque.tryParse(input);\n    if (parsed !== null) return parsed.toNormalizedString();\n    return Torque.fallback(input, options);\n  }\n\n  static isNormalized(input: string | null | undefined): boolean {\n    return input != null && Torque.normalize(input) === input;\n  }\n\n  static findCandidatesInText(text: string): readonly TextCandidate<Torque>[] {\n    if (!text) return [];\n\n    const out: TextCandidate<Torque>[] = [];\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 = Torque.tryParse(match[0]);\n      if (value === null) continue;\n      out.push(\n        new TextCandidate<Torque>({\n          startIndex: match.index,\n          length: match[0].length,\n          originalText: match[0],\n          typeName: \"Torque\",\n          category: TextCandidateCategory.Measurement,\n          normalizedForm: value.toNormalizedString(),\n          formattedForm: value.toString(),\n          maskedForm: maskTorque(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?: TorqueFormatOptions,\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 torque: ${value}`);\n    return parsed;\n  }\n}\n\n/** Returns a masked torque, e.g. `10 Nm` becomes `*** Nm`. */\nexport function maskTorque(value: Torque): string {\n  return `*** ${value.originalUnit.symbol}`;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/measurement/voltage-unit.js

@@ -0,0 +1,107 @@
+import { Decimal } from "../internal/decimal.js";
+import { MeasurementUnit, MeasurementUnitIndex } from "../internal/measurement-unit.js";
+function factor(literal) {
+  const parsed = Decimal.parse(literal);
+  if (parsed === null) throw new Error(`Invalid conversion factor: ${literal}`);
+  return parsed;
+}
+class VoltageUnit extends MeasurementUnit {
+  static typeInfo = Object.freeze({
+    englishName: "Voltage Unit",
+    localizedName: "Sp\xE4nningsenhet",
+    emoji: "\u{1F50C}",
+    sources: Object.freeze([])
+  });
+  static Microvolt = new VoltageUnit({
+    symbol: "\xB5V",
+    englishName: "microvolt",
+    localizedName: "mikrovolt",
+    pluralEnglish: "microvolts",
+    pluralSwedish: "mikrovolt",
+    toBaseUnitFactor: factor("0.000001"),
+    aliases: ["uV"]
+  });
+  static Millivolt = new VoltageUnit({
+    symbol: "mV",
+    englishName: "millivolt",
+    localizedName: "millivolt",
+    pluralEnglish: "millivolts",
+    pluralSwedish: "millivolt",
+    toBaseUnitFactor: factor("0.001")
+  });
+  static Volt = new VoltageUnit({
+    symbol: "V",
+    englishName: "volt",
+    localizedName: "volt",
+    pluralEnglish: "volts",
+    pluralSwedish: "volt",
+    toBaseUnitFactor: factor("1")
+  });
+  static Kilovolt = new VoltageUnit({
+    symbol: "kV",
+    englishName: "kilovolt",
+    localizedName: "kilovolt",
+    pluralEnglish: "kilovolts",
+    pluralSwedish: "kilovolt",
+    toBaseUnitFactor: factor("1000")
+  });
+  static Megavolt = new VoltageUnit({
+    symbol: "MV",
+    englishName: "megavolt",
+    localizedName: "megavolt",
+    pluralEnglish: "megavolts",
+    pluralSwedish: "megavolt",
+    toBaseUnitFactor: factor("1000000")
+  });
+  /** @internal Shared lookup and natural-scale walk. */
+  static index = new MeasurementUnitIndex(
+    [
+      VoltageUnit.Microvolt,
+      VoltageUnit.Millivolt,
+      VoltageUnit.Volt,
+      VoltageUnit.Kilovolt,
+      VoltageUnit.Megavolt
+    ],
+    VoltageUnit.Volt,
+    [VoltageUnit.Millivolt, VoltageUnit.Volt, VoltageUnit.Kilovolt],
+    [VoltageUnit.Millivolt, VoltageUnit.Megavolt]
+  );
+  static get all() {
+    return VoltageUnit.index.all;
+  }
+  /** The base unit: V. */
+  static get baseUnit() {
+    return VoltageUnit.index.baseUnit;
+  }
+  /** Units ordered small to large, used to auto-scale display. */
+  static get naturalScale() {
+    return VoltageUnit.index.naturalScale;
+  }
+  /**
+   * Resolves a unit from a symbol, name, plural or alias, case-insensitively —
+   * except for `mV` and `MV`, which differ by a factor of a billion and are
+   * therefore the one case-sensitive pair.
+   */
+  static tryParse(input) {
+    if (input == null) return null;
+    const trimmed = input.trim();
+    if (trimmed.length === 2 && (trimmed[1] === "V" || trimmed[1] === "v")) {
+      if (trimmed[0] === "m") return VoltageUnit.Millivolt;
+      if (trimmed[0] === "M") return VoltageUnit.Megavolt;
+    }
+    return VoltageUnit.index.tryParse(trimmed);
+  }
+  static parse(input) {
+    const result = VoltageUnit.tryParse(input);
+    if (result === null) throw new Error("Unknown voltage unit.");
+    return result;
+  }
+  /** Returns the most human-readable unit for a value in V. */
+  static getNatural(baseValue) {
+    return VoltageUnit.index.getNatural(baseValue);
+  }
+}
+export {
+  VoltageUnit
+};
+//# sourceMappingURL=voltage-unit.js.map

package/dist/esm/measurement/voltage-unit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/voltage-unit.ts"],
+  "sourcesContent": ["import { Decimal } from \"../internal/decimal.js\";\nimport { MeasurementUnit, MeasurementUnitIndex } from \"../internal/measurement-unit.js\";\nimport type { PrimitiveTypeInfo } from \"../primitive-type-info.js\";\n\nfunction factor(literal: string): Decimal {\n  const parsed = Decimal.parse(literal);\n  /* c8 ignore next */\n  if (parsed === null) throw new Error(`Invalid conversion factor: ${literal}`);\n  return parsed;\n}\n\n/**\n * A unit of voltage identified by its symbol.\n * Each unit carries English and Swedish names, singular and plural forms, and an\n * exact conversion factor to the base unit.\n */\nexport class VoltageUnit extends MeasurementUnit {\n  declare private readonly __voltageUnitBrand: void;\n\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Voltage Unit\",\n    localizedName: \"Sp\u00E4nningsenhet\",\n    emoji: \"\uD83D\uDD0C\",\n    sources: Object.freeze([]),\n  });\n\n  static readonly Microvolt = new VoltageUnit({\n    symbol: \"\u00B5V\",\n    englishName: \"microvolt\",\n    localizedName: \"mikrovolt\",\n    pluralEnglish: \"microvolts\",\n    pluralSwedish: \"mikrovolt\",\n    toBaseUnitFactor: factor(\"0.000001\"),\n    aliases: [\"uV\"],\n  });\n\n  static readonly Millivolt = new VoltageUnit({\n    symbol: \"mV\",\n    englishName: \"millivolt\",\n    localizedName: \"millivolt\",\n    pluralEnglish: \"millivolts\",\n    pluralSwedish: \"millivolt\",\n    toBaseUnitFactor: factor(\"0.001\"),\n  });\n\n  static readonly Volt = new VoltageUnit({\n    symbol: \"V\",\n    englishName: \"volt\",\n    localizedName: \"volt\",\n    pluralEnglish: \"volts\",\n    pluralSwedish: \"volt\",\n    toBaseUnitFactor: factor(\"1\"),\n  });\n\n  static readonly Kilovolt = new VoltageUnit({\n    symbol: \"kV\",\n    englishName: \"kilovolt\",\n    localizedName: \"kilovolt\",\n    pluralEnglish: \"kilovolts\",\n    pluralSwedish: \"kilovolt\",\n    toBaseUnitFactor: factor(\"1000\"),\n  });\n\n  static readonly Megavolt = new VoltageUnit({\n    symbol: \"MV\",\n    englishName: \"megavolt\",\n    localizedName: \"megavolt\",\n    pluralEnglish: \"megavolts\",\n    pluralSwedish: \"megavolt\",\n    toBaseUnitFactor: factor(\"1000000\"),\n  });\n\n  /** @internal Shared lookup and natural-scale walk. */\n  static readonly index: MeasurementUnitIndex<VoltageUnit> = new MeasurementUnitIndex<VoltageUnit>(\n    [\n      VoltageUnit.Microvolt,\n      VoltageUnit.Millivolt,\n      VoltageUnit.Volt,\n      VoltageUnit.Kilovolt,\n      VoltageUnit.Megavolt,\n    ],\n    VoltageUnit.Volt,\n    [VoltageUnit.Millivolt, VoltageUnit.Volt, VoltageUnit.Kilovolt],\n    [VoltageUnit.Millivolt, VoltageUnit.Megavolt],\n  );\n\n  static get all(): readonly VoltageUnit[] {\n    return VoltageUnit.index.all;\n  }\n\n  /** The base unit: V. */\n  static get baseUnit(): VoltageUnit {\n    return VoltageUnit.index.baseUnit;\n  }\n\n  /** Units ordered small to large, used to auto-scale display. */\n  static get naturalScale(): readonly VoltageUnit[] {\n    return VoltageUnit.index.naturalScale;\n  }\n\n  /**\n   * Resolves a unit from a symbol, name, plural or alias, case-insensitively \u2014\n   * except for `mV` and `MV`, which differ by a factor of a billion and are\n   * therefore the one case-sensitive pair.\n   */\n  static tryParse(input: string | null | undefined): VoltageUnit | null {\n    if (input == null) return null;\n    const trimmed = input.trim();\n\n    if (trimmed.length === 2 && (trimmed[1] === \"V\" || trimmed[1] === \"v\")) {\n      if (trimmed[0] === \"m\") return VoltageUnit.Millivolt;\n      if (trimmed[0] === \"M\") return VoltageUnit.Megavolt;\n    }\n\n    return VoltageUnit.index.tryParse(trimmed);\n  }\n\n  static parse(input: string): VoltageUnit {\n    const result = VoltageUnit.tryParse(input);\n    if (result === null) throw new Error(\"Unknown voltage unit.\");\n    return result;\n  }\n\n  /** Returns the most human-readable unit for a value in V. */\n  static getNatural(baseValue: Decimal): VoltageUnit {\n    return VoltageUnit.index.getNatural(baseValue);\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,eAAe;AACxB,SAAS,iBAAiB,4BAA4B;AAGtD,SAAS,OAAO,SAA0B;AACxC,QAAM,SAAS,QAAQ,MAAM,OAAO;AAEpC,MAAI,WAAW,KAAM,OAAM,IAAI,MAAM,8BAA8B,OAAO,EAAE;AAC5E,SAAO;AACT;AAOO,MAAM,oBAAoB,gBAAgB;AAAA,EAG/C,OAAgB,WAA8B,OAAO,OAAO;AAAA,IAC1D,aAAa;AAAA,IACb,eAAe;AAAA,IACf,OAAO;AAAA,IACP,SAAS,OAAO,OAAO,CAAC,CAAC;AAAA,EAC3B,CAAC;AAAA,EAED,OAAgB,YAAY,IAAI,YAAY;AAAA,IAC1C,QAAQ;AAAA,IACR,aAAa;AAAA,IACb,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,IACf,kBAAkB,OAAO,UAAU;AAAA,IACnC,SAAS,CAAC,IAAI;AAAA,EAChB,CAAC;AAAA,EAED,OAAgB,YAAY,IAAI,YAAY;AAAA,IAC1C,QAAQ;AAAA,IACR,aAAa;AAAA,IACb,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,IACf,kBAAkB,OAAO,OAAO;AAAA,EAClC,CAAC;AAAA,EAED,OAAgB,OAAO,IAAI,YAAY;AAAA,IACrC,QAAQ;AAAA,IACR,aAAa;AAAA,IACb,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,IACf,kBAAkB,OAAO,GAAG;AAAA,EAC9B,CAAC;AAAA,EAED,OAAgB,WAAW,IAAI,YAAY;AAAA,IACzC,QAAQ;AAAA,IACR,aAAa;AAAA,IACb,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,IACf,kBAAkB,OAAO,MAAM;AAAA,EACjC,CAAC;AAAA,EAED,OAAgB,WAAW,IAAI,YAAY;AAAA,IACzC,QAAQ;AAAA,IACR,aAAa;AAAA,IACb,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,IACf,kBAAkB,OAAO,SAAS;AAAA,EACpC,CAAC;AAAA;AAAA,EAGD,OAAgB,QAA2C,IAAI;AAAA,IAC7D;AAAA,MACE,YAAY;AAAA,MACZ,YAAY;AAAA,MACZ,YAAY;AAAA,MACZ,YAAY;AAAA,MACZ,YAAY;AAAA,IACd;AAAA,IACA,YAAY;AAAA,IACZ,CAAC,YAAY,WAAW,YAAY,MAAM,YAAY,QAAQ;AAAA,IAC9D,CAAC,YAAY,WAAW,YAAY,QAAQ;AAAA,EAC9C;AAAA,EAEA,WAAW,MAA8B;AACvC,WAAO,YAAY,MAAM;AAAA,EAC3B;AAAA;AAAA,EAGA,WAAW,WAAwB;AACjC,WAAO,YAAY,MAAM;AAAA,EAC3B;AAAA;AAAA,EAGA,WAAW,eAAuC;AAChD,WAAO,YAAY,MAAM;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO,SAAS,OAAsD;AACpE,QAAI,SAAS,KAAM,QAAO;AAC1B,UAAM,UAAU,MAAM,KAAK;AAE3B,QAAI,QAAQ,WAAW,MAAM,QAAQ,CAAC,MAAM,OAAO,QAAQ,CAAC,MAAM,MAAM;AACtE,UAAI,QAAQ,CAAC,MAAM,IAAK,QAAO,YAAY;AAC3C,UAAI,QAAQ,CAAC,MAAM,IAAK,QAAO,YAAY;AAAA,IAC7C;AAEA,WAAO,YAAY,MAAM,SAAS,OAAO;AAAA,EAC3C;AAAA,EAEA,OAAO,MAAM,OAA4B;AACvC,UAAM,SAAS,YAAY,SAAS,KAAK;AACzC,QAAI,WAAW,KAAM,OAAM,IAAI,MAAM,uBAAuB;AAC5D,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,WAAW,WAAiC;AACjD,WAAO,YAAY,MAAM,WAAW,SAAS;AAAA,EAC/C;AACF;",
+  "names": []
+}

package/dist/esm/measurement/voltage.js

@@ -0,0 +1,139 @@
+import { Decimal } from "../internal/decimal.js";
+import { Quantity, tryParseQuantity } from "../internal/quantity.js";
+import { TextCandidate } from "../text-scanning/text-candidate.js";
+import { TextCandidateCategory } from "../text-scanning/text-candidate-category.js";
+import { TextMatchConfidence } from "../text-scanning/text-match-confidence.js";
+import { VoltageUnit } from "./voltage-unit.js";
+const SCAN_PATTERN = new RegExp(
+  String.raw`(?<![\p{L}\p{N}_])(?:[+-]\s*)?\d+[0-9 .,]*\s*(?:µV|uV|mV|kV|MV|V)(?![\p{L}\p{N}_])`,
+  "giu"
+);
+class Voltage extends Quantity {
+  static typeInfo = Object.freeze({
+    englishName: "Voltage",
+    localizedName: "Sp\xE4nning",
+    emoji: "\u{1F50C}",
+    sources: Object.freeze([
+      "https://www.bipm.org/en/measurement-units/si-derived-units",
+      "https://en.wikipedia.org/wiki/Volt"
+    ])
+  });
+  get units() {
+    return VoltageUnit.index;
+  }
+  withBaseValue(baseValue, unit) {
+    return new Voltage(baseValue, unit);
+  }
+  get microvolts() {
+    return this.in(VoltageUnit.Microvolt);
+  }
+  get millivolts() {
+    return this.in(VoltageUnit.Millivolt);
+  }
+  get volts() {
+    return this.in(VoltageUnit.Volt);
+  }
+  get kilovolts() {
+    return this.in(VoltageUnit.Kilovolt);
+  }
+  get megavolts() {
+    return this.in(VoltageUnit.Megavolt);
+  }
+  /** Creates a voltage from a value and unit. */
+  static create(value, unit) {
+    VoltageUnit.index.assertOwns(unit);
+    const amount = value instanceof Decimal ? value : Voltage.decimalOf(value);
+    return new Voltage(unit.toBase(amount), unit);
+  }
+  static fromMicrovolts(value) {
+    return Voltage.create(value, VoltageUnit.Microvolt);
+  }
+  static fromMillivolts(value) {
+    return Voltage.create(value, VoltageUnit.Millivolt);
+  }
+  static fromVolts(value) {
+    return Voltage.create(value, VoltageUnit.Volt);
+  }
+  static fromKilovolts(value) {
+    return Voltage.create(value, VoltageUnit.Kilovolt);
+  }
+  static fromMegavolts(value) {
+    return Voltage.create(value, VoltageUnit.Megavolt);
+  }
+  static tryParse(input) {
+    const parsed = tryParseQuantity(input, VoltageUnit.index, VoltageUnit.tryParse);
+    return parsed === null ? null : new Voltage(parsed.baseValue, parsed.unit);
+  }
+  static parse(input) {
+    const result = Voltage.tryParse(input);
+    if (result === null) throw new Error("Invalid voltage.");
+    return result;
+  }
+  static isValid(input) {
+    return Voltage.tryParse(input) !== null;
+  }
+  /** Display form in the parsed unit, or `null` when the input is invalid. */
+  static format(input, options) {
+    const parsed = Voltage.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 Voltage.fallback(input, options);
+  }
+  /** The value in volts, or `null` when the input is invalid. */
+  static normalize(input, options) {
+    const parsed = Voltage.tryParse(input);
+    if (parsed !== null) return parsed.toNormalizedString();
+    return Voltage.fallback(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && Voltage.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 = Voltage.tryParse(match[0]);
+      if (value === null) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: match.index,
+          length: match[0].length,
+          originalText: match[0],
+          typeName: "Voltage",
+          category: TextCandidateCategory.Measurement,
+          normalizedForm: value.toNormalizedString(),
+          formattedForm: value.toString(),
+          maskedForm: maskVoltage(value),
+          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 = Decimal.fromNumber(value);
+    if (parsed === null) throw new Error(`Value cannot be represented as a voltage: ${value}`);
+    return parsed;
+  }
+}
+function maskVoltage(value) {
+  return `*** ${value.originalUnit.symbol}`;
+}
+export {
+  Voltage,
+  maskVoltage
+};
+//# sourceMappingURL=voltage.js.map

package/dist/esm/measurement/voltage.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/voltage.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 { VoltageUnit } from \"./voltage-unit.js\";\n\n/** Options for {@link Voltage.format} and {@link Voltage.normalize}. */\nexport interface VoltageFormatOptions {\n  fallbackToTrimmedInputWhenInvalid?: boolean;\n  /** Convert to this unit instead of preserving the parsed one. */\n  unit?: VoltageUnit;\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*(?:\u00B5V|uV|mV|kV|MV|V)(?![\\p{L}\\p{N}_])`,\n  \"giu\",\n);\n\n/**\n * A voltage stored internally in volts,\n * parsed from any supported unit and convertible between all of them.\n */\nexport class Voltage extends Quantity<VoltageUnit> {\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Voltage\",\n    localizedName: \"Sp\u00E4nning\",\n    emoji: \"\uD83D\uDD0C\",\n    sources: Object.freeze([\n      \"https://www.bipm.org/en/measurement-units/si-derived-units\",\n      \"https://en.wikipedia.org/wiki/Volt\",\n    ]),\n  });\n\n  protected get units(): MeasurementUnitIndex<VoltageUnit> {\n    return VoltageUnit.index;\n  }\n\n  protected withBaseValue(baseValue: Decimal, unit: VoltageUnit): this {\n    return new Voltage(baseValue, unit) as this;\n  }\n\n  get microvolts(): number {\n    return this.in(VoltageUnit.Microvolt);\n  }\n  get millivolts(): number {\n    return this.in(VoltageUnit.Millivolt);\n  }\n  get volts(): number {\n    return this.in(VoltageUnit.Volt);\n  }\n  get kilovolts(): number {\n    return this.in(VoltageUnit.Kilovolt);\n  }\n  get megavolts(): number {\n    return this.in(VoltageUnit.Megavolt);\n  }\n\n  /** Creates a voltage from a value and unit. */\n  static create(value: number | Decimal, unit: VoltageUnit): Voltage {\n    VoltageUnit.index.assertOwns(unit);\n    const amount = value instanceof Decimal ? value : Voltage.decimalOf(value);\n    return new Voltage(unit.toBase(amount), unit);\n  }\n\n  static fromMicrovolts(value: number | Decimal): Voltage {\n    return Voltage.create(value, VoltageUnit.Microvolt);\n  }\n  static fromMillivolts(value: number | Decimal): Voltage {\n    return Voltage.create(value, VoltageUnit.Millivolt);\n  }\n  static fromVolts(value: number | Decimal): Voltage {\n    return Voltage.create(value, VoltageUnit.Volt);\n  }\n  static fromKilovolts(value: number | Decimal): Voltage {\n    return Voltage.create(value, VoltageUnit.Kilovolt);\n  }\n  static fromMegavolts(value: number | Decimal): Voltage {\n    return Voltage.create(value, VoltageUnit.Megavolt);\n  }\n\n  static tryParse(input: string | null | undefined): Voltage | null {\n    const parsed = tryParseQuantity(input, VoltageUnit.index, VoltageUnit.tryParse);\n    return parsed === null ? null : new Voltage(parsed.baseValue, parsed.unit);\n  }\n\n  static parse(input: string): Voltage {\n    const result = Voltage.tryParse(input);\n    if (result === null) throw new Error(\"Invalid voltage.\");\n    return result;\n  }\n\n  static isValid(input: string | null | undefined): boolean {\n    return Voltage.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?: VoltageFormatOptions): string | null {\n    const parsed = Voltage.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 Voltage.fallback(input, options);\n  }\n\n  /** The value in volts, or `null` when the input is invalid. */\n  static normalize(\n    input: string | null | undefined,\n    options?: VoltageFormatOptions,\n  ): string | null {\n    const parsed = Voltage.tryParse(input);\n    if (parsed !== null) return parsed.toNormalizedString();\n    return Voltage.fallback(input, options);\n  }\n\n  static isNormalized(input: string | null | undefined): boolean {\n    return input != null && Voltage.normalize(input) === input;\n  }\n\n  static findCandidatesInText(text: string): readonly TextCandidate<Voltage>[] {\n    if (!text) return [];\n\n    const out: TextCandidate<Voltage>[] = [];\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 = Voltage.tryParse(match[0]);\n      if (value === null) continue;\n      out.push(\n        new TextCandidate<Voltage>({\n          startIndex: match.index,\n          length: match[0].length,\n          originalText: match[0],\n          typeName: \"Voltage\",\n          category: TextCandidateCategory.Measurement,\n          normalizedForm: value.toNormalizedString(),\n          formattedForm: value.toString(),\n          maskedForm: maskVoltage(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?: VoltageFormatOptions,\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 voltage: ${value}`);\n    return parsed;\n  }\n}\n\n/** Returns a masked voltage, e.g. `10 V` becomes `*** V`. */\nexport function maskVoltage(value: Voltage): string {\n  return `*** ${value.originalUnit.symbol}`;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/measurement/volume-unit.js

@@ -0,0 +1,158 @@
+import { Decimal } from "../internal/decimal.js";
+import { MeasurementUnit, MeasurementUnitIndex } from "../internal/measurement-unit.js";
+function factor(literal) {
+  const parsed = Decimal.parse(literal);
+  if (parsed === null) throw new Error(`Invalid conversion factor: ${literal}`);
+  return parsed;
+}
+class VolumeUnit extends MeasurementUnit {
+  static typeInfo = Object.freeze({
+    englishName: "Volume Unit",
+    localizedName: "Volymenhet",
+    emoji: "\u{1F9EA}",
+    sources: Object.freeze([])
+  });
+  static Microliter = new VolumeUnit({
+    symbol: "\xB5L",
+    englishName: "microliter",
+    localizedName: "mikroliter",
+    pluralEnglish: "microliters",
+    pluralSwedish: "mikroliter",
+    toBaseUnitFactor: factor("0.000001"),
+    aliases: ["\xB5l", "ul", "microlitre", "microlitres"]
+  });
+  static Milliliter = new VolumeUnit({
+    symbol: "mL",
+    englishName: "milliliter",
+    localizedName: "milliliter",
+    pluralEnglish: "milliliters",
+    pluralSwedish: "milliliter",
+    toBaseUnitFactor: factor("0.001"),
+    aliases: ["ml", "millilitre", "millilitres"]
+  });
+  static Centiliter = new VolumeUnit({
+    symbol: "cL",
+    englishName: "centiliter",
+    localizedName: "centiliter",
+    pluralEnglish: "centiliters",
+    pluralSwedish: "centiliter",
+    toBaseUnitFactor: factor("0.01"),
+    aliases: ["cl", "centilitre", "centilitres"]
+  });
+  static Deciliter = new VolumeUnit({
+    symbol: "dL",
+    englishName: "deciliter",
+    localizedName: "deciliter",
+    pluralEnglish: "deciliters",
+    pluralSwedish: "deciliter",
+    toBaseUnitFactor: factor("0.1"),
+    aliases: ["dl", "decilitre", "decilitres"]
+  });
+  static Liter = new VolumeUnit({
+    symbol: "L",
+    englishName: "liter",
+    localizedName: "liter",
+    pluralEnglish: "liters",
+    pluralSwedish: "liter",
+    toBaseUnitFactor: factor("1"),
+    aliases: ["litre", "litres"]
+  });
+  static Hectoliter = new VolumeUnit({
+    symbol: "hL",
+    englishName: "hectoliter",
+    localizedName: "hektoliter",
+    pluralEnglish: "hectoliters",
+    pluralSwedish: "hektoliter",
+    toBaseUnitFactor: factor("100"),
+    aliases: ["hl", "hectolitre", "hectolitres"]
+  });
+  static CubicMeter = new VolumeUnit({
+    symbol: "m\xB3",
+    englishName: "cubic meter",
+    localizedName: "kubikmeter",
+    pluralEnglish: "cubic meters",
+    pluralSwedish: "kubikmeter",
+    toBaseUnitFactor: factor("1000"),
+    aliases: ["m3", "cbm", "kubikmeter", "cubic metre", "cubic metres"]
+  });
+  static Gallon = new VolumeUnit({
+    symbol: "gal",
+    englishName: "gallon",
+    localizedName: "gallon",
+    pluralEnglish: "gallons",
+    pluralSwedish: "gallon",
+    toBaseUnitFactor: factor("3.785411784"),
+    aliases: ["gallon", "gallons"]
+  });
+  static Pint = new VolumeUnit({
+    symbol: "pt",
+    englishName: "pint",
+    localizedName: "pint",
+    pluralEnglish: "pints",
+    pluralSwedish: "pint",
+    toBaseUnitFactor: factor("0.473176473")
+  });
+  static FluidOunce = new VolumeUnit({
+    symbol: "fl oz",
+    englishName: "fluid ounce",
+    localizedName: "v\xE4tskeans",
+    pluralEnglish: "fluid ounces",
+    pluralSwedish: "v\xE4tskeans",
+    toBaseUnitFactor: factor("0.0295735296"),
+    aliases: ["fluid ounce", "fluid ounces", "floz"]
+  });
+  static Cup = new VolumeUnit({
+    symbol: "cup",
+    englishName: "cup",
+    localizedName: "kopp",
+    pluralEnglish: "cups",
+    pluralSwedish: "koppar",
+    toBaseUnitFactor: factor("0.2365882365")
+  });
+  /** @internal Shared lookup and natural-scale walk. */
+  static index = new MeasurementUnitIndex(
+    [
+      VolumeUnit.Microliter,
+      VolumeUnit.Milliliter,
+      VolumeUnit.Centiliter,
+      VolumeUnit.Deciliter,
+      VolumeUnit.Liter,
+      VolumeUnit.Hectoliter,
+      VolumeUnit.CubicMeter,
+      VolumeUnit.Gallon,
+      VolumeUnit.Pint,
+      VolumeUnit.FluidOunce,
+      VolumeUnit.Cup
+    ],
+    VolumeUnit.Liter,
+    [VolumeUnit.Milliliter, VolumeUnit.Deciliter, VolumeUnit.Liter, VolumeUnit.CubicMeter]
+  );
+  static get all() {
+    return VolumeUnit.index.all;
+  }
+  /** The base unit: L. */
+  static get baseUnit() {
+    return VolumeUnit.index.baseUnit;
+  }
+  /** Units ordered small to large, used to auto-scale display. */
+  static get naturalScale() {
+    return VolumeUnit.index.naturalScale;
+  }
+  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+  static tryParse(input) {
+    return VolumeUnit.index.tryParse(input);
+  }
+  static parse(input) {
+    const result = VolumeUnit.tryParse(input);
+    if (result === null) throw new Error("Unknown volume unit.");
+    return result;
+  }
+  /** Returns the most human-readable unit for a value in L. */
+  static getNatural(baseValue) {
+    return VolumeUnit.index.getNatural(baseValue);
+  }
+}
+export {
+  VolumeUnit
+};
+//# sourceMappingURL=volume-unit.js.map

package/dist/esm/measurement/volume-unit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/volume-unit.ts"],
+  "sourcesContent": ["import { Decimal } from \"../internal/decimal.js\";\nimport { MeasurementUnit, MeasurementUnitIndex } from \"../internal/measurement-unit.js\";\nimport type { PrimitiveTypeInfo } from \"../primitive-type-info.js\";\n\nfunction factor(literal: string): Decimal {\n  const parsed = Decimal.parse(literal);\n  /* c8 ignore next */\n  if (parsed === null) throw new Error(`Invalid conversion factor: ${literal}`);\n  return parsed;\n}\n\n/**\n * A unit of volume identified by its symbol.\n * Each unit carries English and Swedish names, singular and plural forms, and an\n * exact conversion factor to the base unit.\n */\nexport class VolumeUnit extends MeasurementUnit {\n  declare private readonly __volumeUnitBrand: void;\n\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Volume Unit\",\n    localizedName: \"Volymenhet\",\n    emoji: \"\uD83E\uDDEA\",\n    sources: Object.freeze([]),\n  });\n\n  static readonly Microliter = new VolumeUnit({\n    symbol: \"\u00B5L\",\n    englishName: \"microliter\",\n    localizedName: \"mikroliter\",\n    pluralEnglish: \"microliters\",\n    pluralSwedish: \"mikroliter\",\n    toBaseUnitFactor: factor(\"0.000001\"),\n    aliases: [\"\u00B5l\", \"ul\", \"microlitre\", \"microlitres\"],\n  });\n\n  static readonly Milliliter = new VolumeUnit({\n    symbol: \"mL\",\n    englishName: \"milliliter\",\n    localizedName: \"milliliter\",\n    pluralEnglish: \"milliliters\",\n    pluralSwedish: \"milliliter\",\n    toBaseUnitFactor: factor(\"0.001\"),\n    aliases: [\"ml\", \"millilitre\", \"millilitres\"],\n  });\n\n  static readonly Centiliter = new VolumeUnit({\n    symbol: \"cL\",\n    englishName: \"centiliter\",\n    localizedName: \"centiliter\",\n    pluralEnglish: \"centiliters\",\n    pluralSwedish: \"centiliter\",\n    toBaseUnitFactor: factor(\"0.01\"),\n    aliases: [\"cl\", \"centilitre\", \"centilitres\"],\n  });\n\n  static readonly Deciliter = new VolumeUnit({\n    symbol: \"dL\",\n    englishName: \"deciliter\",\n    localizedName: \"deciliter\",\n    pluralEnglish: \"deciliters\",\n    pluralSwedish: \"deciliter\",\n    toBaseUnitFactor: factor(\"0.1\"),\n    aliases: [\"dl\", \"decilitre\", \"decilitres\"],\n  });\n\n  static readonly Liter = new VolumeUnit({\n    symbol: \"L\",\n    englishName: \"liter\",\n    localizedName: \"liter\",\n    pluralEnglish: \"liters\",\n    pluralSwedish: \"liter\",\n    toBaseUnitFactor: factor(\"1\"),\n    aliases: [\"litre\", \"litres\"],\n  });\n\n  static readonly Hectoliter = new VolumeUnit({\n    symbol: \"hL\",\n    englishName: \"hectoliter\",\n    localizedName: \"hektoliter\",\n    pluralEnglish: \"hectoliters\",\n    pluralSwedish: \"hektoliter\",\n    toBaseUnitFactor: factor(\"100\"),\n    aliases: [\"hl\", \"hectolitre\", \"hectolitres\"],\n  });\n\n  static readonly CubicMeter = new VolumeUnit({\n    symbol: \"m\u00B3\",\n    englishName: \"cubic meter\",\n    localizedName: \"kubikmeter\",\n    pluralEnglish: \"cubic meters\",\n    pluralSwedish: \"kubikmeter\",\n    toBaseUnitFactor: factor(\"1000\"),\n    aliases: [\"m3\", \"cbm\", \"kubikmeter\", \"cubic metre\", \"cubic metres\"],\n  });\n\n  static readonly Gallon = new VolumeUnit({\n    symbol: \"gal\",\n    englishName: \"gallon\",\n    localizedName: \"gallon\",\n    pluralEnglish: \"gallons\",\n    pluralSwedish: \"gallon\",\n    toBaseUnitFactor: factor(\"3.785411784\"),\n    aliases: [\"gallon\", \"gallons\"],\n  });\n\n  static readonly Pint = new VolumeUnit({\n    symbol: \"pt\",\n    englishName: \"pint\",\n    localizedName: \"pint\",\n    pluralEnglish: \"pints\",\n    pluralSwedish: \"pint\",\n    toBaseUnitFactor: factor(\"0.473176473\"),\n  });\n\n  static readonly FluidOunce = new VolumeUnit({\n    symbol: \"fl oz\",\n    englishName: \"fluid ounce\",\n    localizedName: \"v\u00E4tskeans\",\n    pluralEnglish: \"fluid ounces\",\n    pluralSwedish: \"v\u00E4tskeans\",\n    toBaseUnitFactor: factor(\"0.0295735296\"),\n    aliases: [\"fluid ounce\", \"fluid ounces\", \"floz\"],\n  });\n\n  static readonly Cup = new VolumeUnit({\n    symbol: \"cup\",\n    englishName: \"cup\",\n    localizedName: \"kopp\",\n    pluralEnglish: \"cups\",\n    pluralSwedish: \"koppar\",\n    toBaseUnitFactor: factor(\"0.2365882365\"),\n  });\n\n  /** @internal Shared lookup and natural-scale walk. */\n  static readonly index: MeasurementUnitIndex<VolumeUnit> = new MeasurementUnitIndex<VolumeUnit>(\n    [\n      VolumeUnit.Microliter,\n      VolumeUnit.Milliliter,\n      VolumeUnit.Centiliter,\n      VolumeUnit.Deciliter,\n      VolumeUnit.Liter,\n      VolumeUnit.Hectoliter,\n      VolumeUnit.CubicMeter,\n      VolumeUnit.Gallon,\n      VolumeUnit.Pint,\n      VolumeUnit.FluidOunce,\n      VolumeUnit.Cup,\n    ],\n    VolumeUnit.Liter,\n    [VolumeUnit.Milliliter, VolumeUnit.Deciliter, VolumeUnit.Liter, VolumeUnit.CubicMeter],\n  );\n\n  static get all(): readonly VolumeUnit[] {\n    return VolumeUnit.index.all;\n  }\n\n  /** The base unit: L. */\n  static get baseUnit(): VolumeUnit {\n    return VolumeUnit.index.baseUnit;\n  }\n\n  /** Units ordered small to large, used to auto-scale display. */\n  static get naturalScale(): readonly VolumeUnit[] {\n    return VolumeUnit.index.naturalScale;\n  }\n\n  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */\n  static tryParse(input: string | null | undefined): VolumeUnit | null {\n    return VolumeUnit.index.tryParse(input);\n  }\n\n  static parse(input: string): VolumeUnit {\n    const result = VolumeUnit.tryParse(input);\n    if (result === null) throw new Error(\"Unknown volume unit.\");\n    return result;\n  }\n\n  /** Returns the most human-readable unit for a value in L. */\n  static getNatural(baseValue: Decimal): VolumeUnit {\n    return VolumeUnit.index.getNatural(baseValue);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}