@budiauktioner/buildi-primitives 0.1.0 → 0.2.0

package/dist/cjs/measurement/frequency.js

@@ -0,0 +1,165 @@
+"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 frequency_exports = {};
+__export(frequency_exports, {
+  Frequency: () => Frequency,
+  maskFrequency: () => maskFrequency
+});
+module.exports = __toCommonJS(frequency_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_frequency_unit = require("./frequency-unit.js");
+const SCAN_PATTERN = new RegExp(
+  String.raw`(?<!\w)(?:[+-]\s*)?\d+[0-9 .,]*\s*(?:THz|GHz|MHz|kHz|Hz|rpm|rev/min|varv/min|r/min)\b`,
+  "giu"
+);
+class Frequency extends import_quantity.Quantity {
+  static typeInfo = Object.freeze({
+    englishName: "Frequency",
+    localizedName: "Frekvens",
+    emoji: "\u{1F4E1}",
+    sources: Object.freeze([
+      "https://www.bipm.org/en/measurement-units/si-derived-units",
+      "https://en.wikipedia.org/wiki/Conversion_of_units"
+    ])
+  });
+  get units() {
+    return import_frequency_unit.FrequencyUnit.index;
+  }
+  withBaseValue(baseValue, unit) {
+    return new Frequency(baseValue, unit);
+  }
+  get hertz() {
+    return this.in(import_frequency_unit.FrequencyUnit.Hertz);
+  }
+  get kilohertz() {
+    return this.in(import_frequency_unit.FrequencyUnit.Kilohertz);
+  }
+  get megahertz() {
+    return this.in(import_frequency_unit.FrequencyUnit.Megahertz);
+  }
+  get gigahertz() {
+    return this.in(import_frequency_unit.FrequencyUnit.Gigahertz);
+  }
+  get terahertz() {
+    return this.in(import_frequency_unit.FrequencyUnit.Terahertz);
+  }
+  get rpm() {
+    return this.in(import_frequency_unit.FrequencyUnit.RevolutionsPerMinute);
+  }
+  /** Creates a frequency from a value and unit. */
+  static create(value, unit) {
+    import_frequency_unit.FrequencyUnit.index.assertOwns(unit);
+    const amount = value instanceof import_decimal.Decimal ? value : Frequency.decimalOf(value);
+    return new Frequency(unit.toBase(amount), unit);
+  }
+  static fromHertz(value) {
+    return Frequency.create(value, import_frequency_unit.FrequencyUnit.Hertz);
+  }
+  static fromKilohertz(value) {
+    return Frequency.create(value, import_frequency_unit.FrequencyUnit.Kilohertz);
+  }
+  static fromMegahertz(value) {
+    return Frequency.create(value, import_frequency_unit.FrequencyUnit.Megahertz);
+  }
+  static fromGigahertz(value) {
+    return Frequency.create(value, import_frequency_unit.FrequencyUnit.Gigahertz);
+  }
+  static fromTerahertz(value) {
+    return Frequency.create(value, import_frequency_unit.FrequencyUnit.Terahertz);
+  }
+  static fromRpm(value) {
+    return Frequency.create(value, import_frequency_unit.FrequencyUnit.RevolutionsPerMinute);
+  }
+  static tryParse(input) {
+    const parsed = (0, import_quantity.tryParseQuantity)(input, import_frequency_unit.FrequencyUnit.index);
+    return parsed === null ? null : new Frequency(parsed.baseValue, parsed.unit);
+  }
+  static parse(input) {
+    const result = Frequency.tryParse(input);
+    if (result === null) throw new Error("Invalid frequency.");
+    return result;
+  }
+  static isValid(input) {
+    return Frequency.tryParse(input) !== null;
+  }
+  /** Display form in the parsed unit, or `null` when the input is invalid. */
+  static format(input, options) {
+    const parsed = Frequency.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 Frequency.fallback(input, options);
+  }
+  /** The value in hertz, or `null` when the input is invalid. */
+  static normalize(input, options) {
+    const parsed = Frequency.tryParse(input);
+    if (parsed !== null) return parsed.toNormalizedString();
+    return Frequency.fallback(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && Frequency.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 = Frequency.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: "Frequency",
+          category: import_text_candidate_category.TextCandidateCategory.Measurement,
+          normalizedForm: value.toNormalizedString(),
+          formattedForm: value.toString(),
+          maskedForm: maskFrequency(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 frequency: ${value}`);
+    return parsed;
+  }
+}
+function maskFrequency(value) {
+  return `*** ${value.originalUnit.symbol}`;
+}
+//# sourceMappingURL=frequency.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/frequency.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 { FrequencyUnit } from \"./frequency-unit.js\";\n\n/** Options for {@link Frequency.format} and {@link Frequency.normalize}. */\nexport interface FrequencyFormatOptions {\n  fallbackToTrimmedInputWhenInvalid?: boolean;\n  /** Convert to this unit instead of preserving the parsed one. */\n  unit?: FrequencyUnit;\n  /** Round to this many fractional digits, away from zero. */\n  decimals?: number;\n}\n\nconst SCAN_PATTERN = new RegExp(\n  String.raw`(?<!\\w)(?:[+-]\\s*)?\\d+[0-9 .,]*\\s*(?:THz|GHz|MHz|kHz|Hz|rpm|rev/min|varv/min|r/min)\\b`,\n  \"giu\",\n);\n\n/**\n * A frequency stored internally in hertz,\n * parsed from any supported unit and convertible between all of them.\n */\nexport class Frequency extends Quantity<FrequencyUnit> {\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Frequency\",\n    localizedName: \"Frekvens\",\n    emoji: \"\uD83D\uDCE1\",\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<FrequencyUnit> {\n    return FrequencyUnit.index;\n  }\n\n  protected withBaseValue(baseValue: Decimal, unit: FrequencyUnit): this {\n    return new Frequency(baseValue, unit) as this;\n  }\n\n  get hertz(): number {\n    return this.in(FrequencyUnit.Hertz);\n  }\n  get kilohertz(): number {\n    return this.in(FrequencyUnit.Kilohertz);\n  }\n  get megahertz(): number {\n    return this.in(FrequencyUnit.Megahertz);\n  }\n  get gigahertz(): number {\n    return this.in(FrequencyUnit.Gigahertz);\n  }\n  get terahertz(): number {\n    return this.in(FrequencyUnit.Terahertz);\n  }\n  get rpm(): number {\n    return this.in(FrequencyUnit.RevolutionsPerMinute);\n  }\n\n  /** Creates a frequency from a value and unit. */\n  static create(value: number | Decimal, unit: FrequencyUnit): Frequency {\n    FrequencyUnit.index.assertOwns(unit);\n    const amount = value instanceof Decimal ? value : Frequency.decimalOf(value);\n    return new Frequency(unit.toBase(amount), unit);\n  }\n\n  static fromHertz(value: number | Decimal): Frequency {\n    return Frequency.create(value, FrequencyUnit.Hertz);\n  }\n  static fromKilohertz(value: number | Decimal): Frequency {\n    return Frequency.create(value, FrequencyUnit.Kilohertz);\n  }\n  static fromMegahertz(value: number | Decimal): Frequency {\n    return Frequency.create(value, FrequencyUnit.Megahertz);\n  }\n  static fromGigahertz(value: number | Decimal): Frequency {\n    return Frequency.create(value, FrequencyUnit.Gigahertz);\n  }\n  static fromTerahertz(value: number | Decimal): Frequency {\n    return Frequency.create(value, FrequencyUnit.Terahertz);\n  }\n  static fromRpm(value: number | Decimal): Frequency {\n    return Frequency.create(value, FrequencyUnit.RevolutionsPerMinute);\n  }\n\n  static tryParse(input: string | null | undefined): Frequency | null {\n    const parsed = tryParseQuantity(input, FrequencyUnit.index);\n    return parsed === null ? null : new Frequency(parsed.baseValue, parsed.unit);\n  }\n\n  static parse(input: string): Frequency {\n    const result = Frequency.tryParse(input);\n    if (result === null) throw new Error(\"Invalid frequency.\");\n    return result;\n  }\n\n  static isValid(input: string | null | undefined): boolean {\n    return Frequency.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?: FrequencyFormatOptions): string | null {\n    const parsed = Frequency.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 Frequency.fallback(input, options);\n  }\n\n  /** The value in hertz, or `null` when the input is invalid. */\n  static normalize(\n    input: string | null | undefined,\n    options?: FrequencyFormatOptions,\n  ): string | null {\n    const parsed = Frequency.tryParse(input);\n    if (parsed !== null) return parsed.toNormalizedString();\n    return Frequency.fallback(input, options);\n  }\n\n  static isNormalized(input: string | null | undefined): boolean {\n    return input != null && Frequency.normalize(input) === input;\n  }\n\n  static findCandidatesInText(text: string): readonly TextCandidate<Frequency>[] {\n    if (!text) return [];\n\n    const out: TextCandidate<Frequency>[] = [];\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 = Frequency.tryParse(match[0]);\n      if (value === null) continue;\n      out.push(\n        new TextCandidate<Frequency>({\n          startIndex: match.index,\n          length: match[0].length,\n          originalText: match[0],\n          typeName: \"Frequency\",\n          category: TextCandidateCategory.Measurement,\n          normalizedForm: value.toNormalizedString(),\n          formattedForm: value.toString(),\n          maskedForm: maskFrequency(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?: FrequencyFormatOptions,\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 frequency: ${value}`);\n    return parsed;\n  }\n}\n\n/** Returns a masked frequency, e.g. `10 Hz` becomes `*** Hz`. */\nexport function maskFrequency(value: Frequency): string {\n  return `*** ${value.originalUnit.symbol}`;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/measurement/index.js

@@ -0,0 +1,136 @@
+"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 measurement_exports = {};
+__export(measurement_exports, {
+  Area: () => import_area.Area,
+  AreaUnit: () => import_area_unit.AreaUnit,
+  Count: () => import_count.Count,
+  DataSize: () => import_data_size.DataSize,
+  DataSizeUnit: () => import_data_size_unit.DataSizeUnit,
+  ElectricCharge: () => import_electric_charge.ElectricCharge,
+  ElectricChargeUnit: () => import_electric_charge_unit.ElectricChargeUnit,
+  ElectricCurrent: () => import_electric_current.ElectricCurrent,
+  ElectricCurrentUnit: () => import_electric_current_unit.ElectricCurrentUnit,
+  Energy: () => import_energy.Energy,
+  EnergyUnit: () => import_energy_unit.EnergyUnit,
+  FlowRate: () => import_flow_rate.FlowRate,
+  FlowRateUnit: () => import_flow_rate_unit.FlowRateUnit,
+  Frequency: () => import_frequency.Frequency,
+  FrequencyUnit: () => import_frequency_unit.FrequencyUnit,
+  Length: () => import_length.Length,
+  LengthUnit: () => import_length_unit.LengthUnit,
+  Luminance: () => import_luminance.Luminance,
+  LuminanceUnit: () => import_luminance_unit.LuminanceUnit,
+  LuminousFlux: () => import_luminous_flux.LuminousFlux,
+  LuminousFluxUnit: () => import_luminous_flux_unit.LuminousFluxUnit,
+  Percentage: () => import_percentage.Percentage,
+  Power: () => import_power.Power,
+  PowerUnit: () => import_power_unit.PowerUnit,
+  Pressure: () => import_pressure.Pressure,
+  PressureUnit: () => import_pressure_unit.PressureUnit,
+  RotationalSpeed: () => import_rotational_speed.RotationalSpeed,
+  RotationalSpeedUnit: () => import_rotational_speed_unit.RotationalSpeedUnit,
+  SoundLevel: () => import_sound_level.SoundLevel,
+  SoundWeighting: () => import_sound_level.SoundWeighting,
+  Speed: () => import_speed.Speed,
+  SpeedUnit: () => import_speed_unit.SpeedUnit,
+  Temperature: () => import_temperature.Temperature,
+  TemperatureDelta: () => import_temperature_delta.TemperatureDelta,
+  TemperatureUnit: () => import_temperature_unit.TemperatureUnit,
+  Torque: () => import_torque.Torque,
+  TorqueUnit: () => import_torque_unit.TorqueUnit,
+  Voltage: () => import_voltage.Voltage,
+  VoltageUnit: () => import_voltage_unit.VoltageUnit,
+  Volume: () => import_volume.Volume,
+  VolumeUnit: () => import_volume_unit.VolumeUnit,
+  Weight: () => import_weight.Weight,
+  WeightUnit: () => import_weight_unit.WeightUnit,
+  Year: () => import_year.Year,
+  YearMonth: () => import_year_month.YearMonth,
+  maskArea: () => import_area.maskArea,
+  maskCount: () => import_count.maskCount,
+  maskDataSize: () => import_data_size.maskDataSize,
+  maskElectricCharge: () => import_electric_charge.maskElectricCharge,
+  maskElectricCurrent: () => import_electric_current.maskElectricCurrent,
+  maskEnergy: () => import_energy.maskEnergy,
+  maskFlowRate: () => import_flow_rate.maskFlowRate,
+  maskFrequency: () => import_frequency.maskFrequency,
+  maskLength: () => import_length.maskLength,
+  maskLuminance: () => import_luminance.maskLuminance,
+  maskLuminousFlux: () => import_luminous_flux.maskLuminousFlux,
+  maskPercentage: () => import_percentage.maskPercentage,
+  maskPower: () => import_power.maskPower,
+  maskPressure: () => import_pressure.maskPressure,
+  maskRotationalSpeed: () => import_rotational_speed.maskRotationalSpeed,
+  maskSoundLevel: () => import_sound_level.maskSoundLevel,
+  maskSpeed: () => import_speed.maskSpeed,
+  maskTemperature: () => import_temperature.maskTemperature,
+  maskTorque: () => import_torque.maskTorque,
+  maskVoltage: () => import_voltage.maskVoltage,
+  maskVolume: () => import_volume.maskVolume,
+  maskWeight: () => import_weight.maskWeight,
+  maskYear: () => import_year.maskYear,
+  maskYearMonth: () => import_year_month.maskYearMonth
+});
+module.exports = __toCommonJS(measurement_exports);
+var import_area = require("./area.js");
+var import_area_unit = require("./area-unit.js");
+var import_count = require("./count.js");
+var import_data_size = require("./data-size.js");
+var import_data_size_unit = require("./data-size-unit.js");
+var import_electric_charge = require("./electric-charge.js");
+var import_electric_charge_unit = require("./electric-charge-unit.js");
+var import_electric_current = require("./electric-current.js");
+var import_electric_current_unit = require("./electric-current-unit.js");
+var import_energy = require("./energy.js");
+var import_energy_unit = require("./energy-unit.js");
+var import_flow_rate = require("./flow-rate.js");
+var import_flow_rate_unit = require("./flow-rate-unit.js");
+var import_frequency = require("./frequency.js");
+var import_frequency_unit = require("./frequency-unit.js");
+var import_length = require("./length.js");
+var import_length_unit = require("./length-unit.js");
+var import_luminance = require("./luminance.js");
+var import_luminance_unit = require("./luminance-unit.js");
+var import_luminous_flux = require("./luminous-flux.js");
+var import_luminous_flux_unit = require("./luminous-flux-unit.js");
+var import_percentage = require("./percentage.js");
+var import_power = require("./power.js");
+var import_power_unit = require("./power-unit.js");
+var import_pressure = require("./pressure.js");
+var import_pressure_unit = require("./pressure-unit.js");
+var import_rotational_speed = require("./rotational-speed.js");
+var import_rotational_speed_unit = require("./rotational-speed-unit.js");
+var import_sound_level = require("./sound-level.js");
+var import_speed = require("./speed.js");
+var import_speed_unit = require("./speed-unit.js");
+var import_temperature = require("./temperature.js");
+var import_temperature_unit = require("./temperature-unit.js");
+var import_temperature_delta = require("./temperature-delta.js");
+var import_torque = require("./torque.js");
+var import_torque_unit = require("./torque-unit.js");
+var import_voltage = require("./voltage.js");
+var import_voltage_unit = require("./voltage-unit.js");
+var import_volume = require("./volume.js");
+var import_volume_unit = require("./volume-unit.js");
+var import_weight = require("./weight.js");
+var import_weight_unit = require("./weight-unit.js");
+var import_year = require("./year.js");
+var import_year_month = require("./year-month.js");
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/index.ts"],
+  "sourcesContent": ["export { Area, maskArea, type AreaFormatOptions } from \"./area.js\";\nexport { AreaUnit } from \"./area-unit.js\";\nexport { Count, maskCount, type CountFormatOptions } from \"./count.js\";\nexport { DataSize, maskDataSize, type DataSizeFormatOptions } from \"./data-size.js\";\nexport { DataSizeUnit } from \"./data-size-unit.js\";\nexport {\n  ElectricCharge,\n  maskElectricCharge,\n  type ElectricChargeFormatOptions,\n} from \"./electric-charge.js\";\nexport { ElectricChargeUnit } from \"./electric-charge-unit.js\";\nexport {\n  ElectricCurrent,\n  maskElectricCurrent,\n  type ElectricCurrentFormatOptions,\n} from \"./electric-current.js\";\nexport { ElectricCurrentUnit } from \"./electric-current-unit.js\";\nexport { Energy, maskEnergy, type EnergyFormatOptions } from \"./energy.js\";\nexport { EnergyUnit } from \"./energy-unit.js\";\nexport { FlowRate, maskFlowRate, type FlowRateFormatOptions } from \"./flow-rate.js\";\nexport { FlowRateUnit } from \"./flow-rate-unit.js\";\nexport { Frequency, maskFrequency, type FrequencyFormatOptions } from \"./frequency.js\";\nexport { FrequencyUnit } from \"./frequency-unit.js\";\nexport { Length, maskLength, type LengthFormatOptions } from \"./length.js\";\nexport { LengthUnit } from \"./length-unit.js\";\nexport { Luminance, maskLuminance, type LuminanceFormatOptions } from \"./luminance.js\";\nexport { LuminanceUnit } from \"./luminance-unit.js\";\nexport { LuminousFlux, maskLuminousFlux, type LuminousFluxFormatOptions } from \"./luminous-flux.js\";\nexport { LuminousFluxUnit } from \"./luminous-flux-unit.js\";\nexport { Percentage, maskPercentage, type PercentageFormatOptions } from \"./percentage.js\";\nexport { Power, maskPower, type PowerFormatOptions } from \"./power.js\";\nexport { PowerUnit } from \"./power-unit.js\";\nexport { Pressure, maskPressure, type PressureFormatOptions } from \"./pressure.js\";\nexport { PressureUnit } from \"./pressure-unit.js\";\nexport {\n  RotationalSpeed,\n  maskRotationalSpeed,\n  type RotationalSpeedFormatOptions,\n} from \"./rotational-speed.js\";\nexport { RotationalSpeedUnit } from \"./rotational-speed-unit.js\";\nexport {\n  SoundLevel,\n  SoundWeighting,\n  maskSoundLevel,\n  type SoundLevelFormatOptions,\n} from \"./sound-level.js\";\nexport { Speed, maskSpeed, type SpeedFormatOptions } from \"./speed.js\";\nexport { SpeedUnit } from \"./speed-unit.js\";\nexport { Temperature, maskTemperature, type TemperatureFormatOptions } from \"./temperature.js\";\nexport { TemperatureUnit } from \"./temperature-unit.js\";\nexport { TemperatureDelta } from \"./temperature-delta.js\";\nexport { Torque, maskTorque, type TorqueFormatOptions } from \"./torque.js\";\nexport { TorqueUnit } from \"./torque-unit.js\";\nexport { Voltage, maskVoltage, type VoltageFormatOptions } from \"./voltage.js\";\nexport { VoltageUnit } from \"./voltage-unit.js\";\nexport { Volume, maskVolume, type VolumeFormatOptions } from \"./volume.js\";\nexport { VolumeUnit } from \"./volume-unit.js\";\nexport { Weight, maskWeight, type WeightFormatOptions } from \"./weight.js\";\nexport { WeightUnit } from \"./weight-unit.js\";\nexport { Year, maskYear, type YearFormatOptions } from \"./year.js\";\nexport { YearMonth, maskYearMonth, type YearMonthFormatOptions } from \"./year-month.js\";\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAuD;AACvD,uBAAyB;AACzB,mBAA0D;AAC1D,uBAAmE;AACnE,4BAA6B;AAC7B,6BAIO;AACP,kCAAmC;AACnC,8BAIO;AACP,mCAAoC;AACpC,oBAA6D;AAC7D,yBAA2B;AAC3B,uBAAmE;AACnE,4BAA6B;AAC7B,uBAAsE;AACtE,4BAA8B;AAC9B,oBAA6D;AAC7D,yBAA2B;AAC3B,uBAAsE;AACtE,4BAA8B;AAC9B,2BAA+E;AAC/E,gCAAiC;AACjC,wBAAyE;AACzE,mBAA0D;AAC1D,wBAA0B;AAC1B,sBAAmE;AACnE,2BAA6B;AAC7B,8BAIO;AACP,mCAAoC;AACpC,yBAKO;AACP,mBAA0D;AAC1D,wBAA0B;AAC1B,yBAA4E;AAC5E,8BAAgC;AAChC,+BAAiC;AACjC,oBAA6D;AAC7D,yBAA2B;AAC3B,qBAAgE;AAChE,0BAA4B;AAC5B,oBAA6D;AAC7D,yBAA2B;AAC3B,oBAA6D;AAC7D,yBAA2B;AAC3B,kBAAuD;AACvD,wBAAsE;",
+  "names": []
+}

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

@@ -0,0 +1,210 @@
+"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 length_unit_exports = {};
+__export(length_unit_exports, {
+  LengthUnit: () => LengthUnit
+});
+module.exports = __toCommonJS(length_unit_exports);
+var import_decimal = require("../internal/decimal.js");
+var import_measurement_unit = require("../internal/measurement-unit.js");
+function factor(literal) {
+  const parsed = import_decimal.Decimal.parse(literal);
+  if (parsed === null) throw new Error(`Invalid conversion factor: ${literal}`);
+  return parsed;
+}
+class LengthUnit extends import_measurement_unit.MeasurementUnit {
+  static typeInfo = Object.freeze({
+    englishName: "Length Unit",
+    localizedName: "L\xE4ngdenhet",
+    emoji: "\u{1F4CF}",
+    sources: Object.freeze([])
+  });
+  static Nanometer = new LengthUnit({
+    symbol: "nm",
+    englishName: "nanometer",
+    localizedName: "nanometer",
+    pluralEnglish: "nanometers",
+    pluralSwedish: "nanometer",
+    toBaseUnitFactor: factor("0.000000001"),
+    aliases: ["nanometre", "nanometres"]
+  });
+  static Micrometer = new LengthUnit({
+    symbol: "\xB5m",
+    englishName: "micrometer",
+    localizedName: "mikrometer",
+    pluralEnglish: "micrometers",
+    pluralSwedish: "mikrometer",
+    toBaseUnitFactor: factor("0.000001"),
+    aliases: ["micrometre", "micrometres", "um"]
+  });
+  static Millimeter = new LengthUnit({
+    symbol: "mm",
+    englishName: "millimeter",
+    localizedName: "millimeter",
+    pluralEnglish: "millimeters",
+    pluralSwedish: "millimeter",
+    toBaseUnitFactor: factor("0.001"),
+    aliases: ["millimetre", "millimetres"]
+  });
+  static Centimeter = new LengthUnit({
+    symbol: "cm",
+    englishName: "centimeter",
+    localizedName: "centimeter",
+    pluralEnglish: "centimeters",
+    pluralSwedish: "centimeter",
+    toBaseUnitFactor: factor("0.01"),
+    aliases: ["centimetre", "centimetres"]
+  });
+  static Decimeter = new LengthUnit({
+    symbol: "dm",
+    englishName: "decimeter",
+    localizedName: "decimeter",
+    pluralEnglish: "decimeters",
+    pluralSwedish: "decimeter",
+    toBaseUnitFactor: factor("0.1"),
+    aliases: ["decimetre", "decimetres"]
+  });
+  static Meter = new LengthUnit({
+    symbol: "m",
+    englishName: "meter",
+    localizedName: "meter",
+    pluralEnglish: "meters",
+    pluralSwedish: "meter",
+    toBaseUnitFactor: factor("1"),
+    aliases: ["metre", "metres"]
+  });
+  static Kilometer = new LengthUnit({
+    symbol: "km",
+    englishName: "kilometer",
+    localizedName: "kilometer",
+    pluralEnglish: "kilometers",
+    pluralSwedish: "kilometer",
+    toBaseUnitFactor: factor("1000"),
+    aliases: ["kilometre", "kilometres"]
+  });
+  static Inch = new LengthUnit({
+    symbol: "in",
+    englishName: "inch",
+    localizedName: "tum",
+    pluralEnglish: "inches",
+    pluralSwedish: "tum",
+    toBaseUnitFactor: factor("0.0254"),
+    aliases: ["inch", "inches", '"', "tum"]
+  });
+  static Foot = new LengthUnit({
+    symbol: "ft",
+    englishName: "foot",
+    localizedName: "fot",
+    pluralEnglish: "feet",
+    pluralSwedish: "fot",
+    toBaseUnitFactor: factor("0.3048"),
+    aliases: ["foot", "feet", "fot"]
+  });
+  static Yard = new LengthUnit({
+    symbol: "yd",
+    englishName: "yard",
+    localizedName: "yard",
+    pluralEnglish: "yards",
+    pluralSwedish: "yard",
+    toBaseUnitFactor: factor("0.9144"),
+    aliases: ["yard", "yards"]
+  });
+  static Mile = new LengthUnit({
+    symbol: "mi",
+    englishName: "mile",
+    localizedName: "engelsk mil",
+    pluralEnglish: "miles",
+    pluralSwedish: "engelska mil",
+    toBaseUnitFactor: factor("1609.344"),
+    aliases: ["mile", "miles"]
+  });
+  static NauticalMile = new LengthUnit({
+    symbol: "nmi",
+    englishName: "nautical mile",
+    localizedName: "nautisk mil",
+    pluralEnglish: "nautical miles",
+    pluralSwedish: "nautiska mil",
+    toBaseUnitFactor: factor("1852"),
+    aliases: ["nautical mile", "nautical miles", "sj\xF6mil", "NM"]
+  });
+  /** The Swedish `mil`, which is 10 km — not the international mile. */
+  static SwedishMile = new LengthUnit({
+    symbol: "mil",
+    englishName: "Swedish mile",
+    localizedName: "mil",
+    pluralEnglish: "Swedish miles",
+    pluralSwedish: "mil",
+    toBaseUnitFactor: factor("10000")
+  });
+  /** @internal Shared lookup and natural-scale walk. */
+  static index = new import_measurement_unit.MeasurementUnitIndex(
+    [
+      LengthUnit.Nanometer,
+      LengthUnit.Micrometer,
+      LengthUnit.Millimeter,
+      LengthUnit.Centimeter,
+      LengthUnit.Decimeter,
+      LengthUnit.Meter,
+      LengthUnit.Kilometer,
+      LengthUnit.Inch,
+      LengthUnit.Foot,
+      LengthUnit.Yard,
+      LengthUnit.Mile,
+      LengthUnit.NauticalMile,
+      LengthUnit.SwedishMile
+    ],
+    LengthUnit.Meter,
+    [LengthUnit.Millimeter, LengthUnit.Centimeter, LengthUnit.Meter, LengthUnit.Kilometer]
+  );
+  static get all() {
+    return LengthUnit.index.all;
+  }
+  /** The base SI unit: meter. */
+  static get baseUnit() {
+    return LengthUnit.index.baseUnit;
+  }
+  /**
+   * Metric units ordered small to large, used to auto-scale display. Imperial
+   * and niche units are excluded.
+   */
+  static get naturalScale() {
+    return LengthUnit.index.naturalScale;
+  }
+  /**
+   * Resolves a unit from a symbol, name, plural or alias, case-insensitively.
+   *
+   * `NM` is the one case-sensitive exception: uppercase means nautical mile,
+   * while `nm` is nanometer.
+   */
+  static tryParse(input) {
+    if (input == null) return null;
+    if (input.trim() === "NM") return LengthUnit.NauticalMile;
+    return LengthUnit.index.tryParse(input);
+  }
+  static parse(input) {
+    const result = LengthUnit.tryParse(input);
+    if (result === null) throw new Error("Unknown length unit.");
+    return result;
+  }
+  /** Returns the most human-readable unit for a value in meters. */
+  static getNatural(meters) {
+    return LengthUnit.index.getNatural(meters);
+  }
+}
+//# sourceMappingURL=length-unit.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/length-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 length identified by its symbol. Each unit carries English and\n * Swedish names, singular and plural forms, and an exact conversion factor to\n * the base SI unit (meter).\n */\nexport class LengthUnit extends MeasurementUnit {\n  declare private readonly __lengthUnitBrand: void;\n\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Length Unit\",\n    localizedName: \"L\u00E4ngdenhet\",\n    emoji: \"\uD83D\uDCCF\",\n    sources: Object.freeze([]),\n  });\n\n  static readonly Nanometer = new LengthUnit({\n    symbol: \"nm\",\n    englishName: \"nanometer\",\n    localizedName: \"nanometer\",\n    pluralEnglish: \"nanometers\",\n    pluralSwedish: \"nanometer\",\n    toBaseUnitFactor: factor(\"0.000000001\"),\n    aliases: [\"nanometre\", \"nanometres\"],\n  });\n\n  static readonly Micrometer = new LengthUnit({\n    symbol: \"\u00B5m\",\n    englishName: \"micrometer\",\n    localizedName: \"mikrometer\",\n    pluralEnglish: \"micrometers\",\n    pluralSwedish: \"mikrometer\",\n    toBaseUnitFactor: factor(\"0.000001\"),\n    aliases: [\"micrometre\", \"micrometres\", \"um\"],\n  });\n\n  static readonly Millimeter = new LengthUnit({\n    symbol: \"mm\",\n    englishName: \"millimeter\",\n    localizedName: \"millimeter\",\n    pluralEnglish: \"millimeters\",\n    pluralSwedish: \"millimeter\",\n    toBaseUnitFactor: factor(\"0.001\"),\n    aliases: [\"millimetre\", \"millimetres\"],\n  });\n\n  static readonly Centimeter = new LengthUnit({\n    symbol: \"cm\",\n    englishName: \"centimeter\",\n    localizedName: \"centimeter\",\n    pluralEnglish: \"centimeters\",\n    pluralSwedish: \"centimeter\",\n    toBaseUnitFactor: factor(\"0.01\"),\n    aliases: [\"centimetre\", \"centimetres\"],\n  });\n\n  static readonly Decimeter = new LengthUnit({\n    symbol: \"dm\",\n    englishName: \"decimeter\",\n    localizedName: \"decimeter\",\n    pluralEnglish: \"decimeters\",\n    pluralSwedish: \"decimeter\",\n    toBaseUnitFactor: factor(\"0.1\"),\n    aliases: [\"decimetre\", \"decimetres\"],\n  });\n\n  static readonly Meter = new LengthUnit({\n    symbol: \"m\",\n    englishName: \"meter\",\n    localizedName: \"meter\",\n    pluralEnglish: \"meters\",\n    pluralSwedish: \"meter\",\n    toBaseUnitFactor: factor(\"1\"),\n    aliases: [\"metre\", \"metres\"],\n  });\n\n  static readonly Kilometer = new LengthUnit({\n    symbol: \"km\",\n    englishName: \"kilometer\",\n    localizedName: \"kilometer\",\n    pluralEnglish: \"kilometers\",\n    pluralSwedish: \"kilometer\",\n    toBaseUnitFactor: factor(\"1000\"),\n    aliases: [\"kilometre\", \"kilometres\"],\n  });\n\n  static readonly Inch = new LengthUnit({\n    symbol: \"in\",\n    englishName: \"inch\",\n    localizedName: \"tum\",\n    pluralEnglish: \"inches\",\n    pluralSwedish: \"tum\",\n    toBaseUnitFactor: factor(\"0.0254\"),\n    aliases: [\"inch\", \"inches\", '\"', \"tum\"],\n  });\n\n  static readonly Foot = new LengthUnit({\n    symbol: \"ft\",\n    englishName: \"foot\",\n    localizedName: \"fot\",\n    pluralEnglish: \"feet\",\n    pluralSwedish: \"fot\",\n    toBaseUnitFactor: factor(\"0.3048\"),\n    aliases: [\"foot\", \"feet\", \"fot\"],\n  });\n\n  static readonly Yard = new LengthUnit({\n    symbol: \"yd\",\n    englishName: \"yard\",\n    localizedName: \"yard\",\n    pluralEnglish: \"yards\",\n    pluralSwedish: \"yard\",\n    toBaseUnitFactor: factor(\"0.9144\"),\n    aliases: [\"yard\", \"yards\"],\n  });\n\n  static readonly Mile = new LengthUnit({\n    symbol: \"mi\",\n    englishName: \"mile\",\n    localizedName: \"engelsk mil\",\n    pluralEnglish: \"miles\",\n    pluralSwedish: \"engelska mil\",\n    toBaseUnitFactor: factor(\"1609.344\"),\n    aliases: [\"mile\", \"miles\"],\n  });\n\n  static readonly NauticalMile = new LengthUnit({\n    symbol: \"nmi\",\n    englishName: \"nautical mile\",\n    localizedName: \"nautisk mil\",\n    pluralEnglish: \"nautical miles\",\n    pluralSwedish: \"nautiska mil\",\n    toBaseUnitFactor: factor(\"1852\"),\n    aliases: [\"nautical mile\", \"nautical miles\", \"sj\u00F6mil\", \"NM\"],\n  });\n\n  /** The Swedish `mil`, which is 10 km \u2014 not the international mile. */\n  static readonly SwedishMile = new LengthUnit({\n    symbol: \"mil\",\n    englishName: \"Swedish mile\",\n    localizedName: \"mil\",\n    pluralEnglish: \"Swedish miles\",\n    pluralSwedish: \"mil\",\n    toBaseUnitFactor: factor(\"10000\"),\n  });\n\n  /** @internal Shared lookup and natural-scale walk. */\n  static readonly index: MeasurementUnitIndex<LengthUnit> = new MeasurementUnitIndex<LengthUnit>(\n    [\n      LengthUnit.Nanometer,\n      LengthUnit.Micrometer,\n      LengthUnit.Millimeter,\n      LengthUnit.Centimeter,\n      LengthUnit.Decimeter,\n      LengthUnit.Meter,\n      LengthUnit.Kilometer,\n      LengthUnit.Inch,\n      LengthUnit.Foot,\n      LengthUnit.Yard,\n      LengthUnit.Mile,\n      LengthUnit.NauticalMile,\n      LengthUnit.SwedishMile,\n    ],\n    LengthUnit.Meter,\n    [LengthUnit.Millimeter, LengthUnit.Centimeter, LengthUnit.Meter, LengthUnit.Kilometer],\n  );\n\n  static get all(): readonly LengthUnit[] {\n    return LengthUnit.index.all;\n  }\n\n  /** The base SI unit: meter. */\n  static get baseUnit(): LengthUnit {\n    return LengthUnit.index.baseUnit;\n  }\n\n  /**\n   * Metric units ordered small to large, used to auto-scale display. Imperial\n   * and niche units are excluded.\n   */\n  static get naturalScale(): readonly LengthUnit[] {\n    return LengthUnit.index.naturalScale;\n  }\n\n  /**\n   * Resolves a unit from a symbol, name, plural or alias, case-insensitively.\n   *\n   * `NM` is the one case-sensitive exception: uppercase means nautical mile,\n   * while `nm` is nanometer.\n   */\n  static tryParse(input: string | null | undefined): LengthUnit | null {\n    if (input == null) return null;\n    if (input.trim() === \"NM\") return LengthUnit.NauticalMile;\n    return LengthUnit.index.tryParse(input);\n  }\n\n  static parse(input: string): LengthUnit {\n    const result = LengthUnit.tryParse(input);\n    if (result === null) throw new Error(\"Unknown length unit.\");\n    return result;\n  }\n\n  /** Returns the most human-readable unit for a value in meters. */\n  static getNatural(meters: Decimal): LengthUnit {\n    return LengthUnit.index.getNatural(meters);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}