@budiauktioner/buildi-primitives 0.1.0 → 0.2.0

package/dist/esm/measurement/energy.js

@@ -0,0 +1,187 @@
+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 { EnergyUnit } from "./energy-unit.js";
+const SCAN_PATTERN = new RegExp(
+  String.raw`(?<!\w)(?:[+-]\s*)?\d+[0-9 .,]*\s*(?:TWh|GWh|MWh|kWh|TJ|GJ|MJ|kJ|kcal|Wh|BTU|cal|J)\b`,
+  "giu"
+);
+class Energy extends Quantity {
+  static typeInfo = Object.freeze({
+    englishName: "Energy",
+    localizedName: "Energi",
+    emoji: "\u26A1",
+    sources: Object.freeze([
+      "https://www.bipm.org/en/measurement-units/si-derived-units",
+      "https://en.wikipedia.org/wiki/Conversion_of_units"
+    ])
+  });
+  get units() {
+    return EnergyUnit.index;
+  }
+  withBaseValue(baseValue, unit) {
+    return new Energy(baseValue, unit);
+  }
+  get joules() {
+    return this.in(EnergyUnit.Joule);
+  }
+  get kilojoules() {
+    return this.in(EnergyUnit.Kilojoule);
+  }
+  get megajoules() {
+    return this.in(EnergyUnit.Megajoule);
+  }
+  get gigajoules() {
+    return this.in(EnergyUnit.Gigajoule);
+  }
+  get terajoules() {
+    return this.in(EnergyUnit.Terajoule);
+  }
+  get wattHours() {
+    return this.in(EnergyUnit.WattHour);
+  }
+  get kilowattHours() {
+    return this.in(EnergyUnit.KilowattHour);
+  }
+  get megawattHours() {
+    return this.in(EnergyUnit.MegawattHour);
+  }
+  get gigawattHours() {
+    return this.in(EnergyUnit.GigawattHour);
+  }
+  get terawattHours() {
+    return this.in(EnergyUnit.TerawattHour);
+  }
+  get calories() {
+    return this.in(EnergyUnit.Calorie);
+  }
+  get kilocalories() {
+    return this.in(EnergyUnit.Kilocalorie);
+  }
+  get btus() {
+    return this.in(EnergyUnit.Btu);
+  }
+  /** Creates a energy from a value and unit. */
+  static create(value, unit) {
+    EnergyUnit.index.assertOwns(unit);
+    const amount = value instanceof Decimal ? value : Energy.decimalOf(value);
+    return new Energy(unit.toBase(amount), unit);
+  }
+  static fromJoules(value) {
+    return Energy.create(value, EnergyUnit.Joule);
+  }
+  static fromKilojoules(value) {
+    return Energy.create(value, EnergyUnit.Kilojoule);
+  }
+  static fromMegajoules(value) {
+    return Energy.create(value, EnergyUnit.Megajoule);
+  }
+  static fromGigajoules(value) {
+    return Energy.create(value, EnergyUnit.Gigajoule);
+  }
+  static fromTerajoules(value) {
+    return Energy.create(value, EnergyUnit.Terajoule);
+  }
+  static fromWattHours(value) {
+    return Energy.create(value, EnergyUnit.WattHour);
+  }
+  static fromKilowattHours(value) {
+    return Energy.create(value, EnergyUnit.KilowattHour);
+  }
+  static fromMegawattHours(value) {
+    return Energy.create(value, EnergyUnit.MegawattHour);
+  }
+  static fromGigawattHours(value) {
+    return Energy.create(value, EnergyUnit.GigawattHour);
+  }
+  static fromTerawattHours(value) {
+    return Energy.create(value, EnergyUnit.TerawattHour);
+  }
+  static fromCalories(value) {
+    return Energy.create(value, EnergyUnit.Calorie);
+  }
+  static fromKilocalories(value) {
+    return Energy.create(value, EnergyUnit.Kilocalorie);
+  }
+  static fromBtus(value) {
+    return Energy.create(value, EnergyUnit.Btu);
+  }
+  static tryParse(input) {
+    const parsed = tryParseQuantity(input, EnergyUnit.index);
+    return parsed === null ? null : new Energy(parsed.baseValue, parsed.unit);
+  }
+  static parse(input) {
+    const result = Energy.tryParse(input);
+    if (result === null) throw new Error("Invalid energy.");
+    return result;
+  }
+  static isValid(input) {
+    return Energy.tryParse(input) !== null;
+  }
+  /** Display form in the parsed unit, or `null` when the input is invalid. */
+  static format(input, options) {
+    const parsed = Energy.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 Energy.fallback(input, options);
+  }
+  /** The value in joules, or `null` when the input is invalid. */
+  static normalize(input, options) {
+    const parsed = Energy.tryParse(input);
+    if (parsed !== null) return parsed.toNormalizedString();
+    return Energy.fallback(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && Energy.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 = Energy.tryParse(match[0]);
+      if (value === null) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: match.index,
+          length: match[0].length,
+          originalText: match[0],
+          typeName: "Energy",
+          category: TextCandidateCategory.Measurement,
+          normalizedForm: value.toNormalizedString(),
+          formattedForm: value.toString(),
+          maskedForm: maskEnergy(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 energy: ${value}`);
+    return parsed;
+  }
+}
+function maskEnergy(value) {
+  return `*** ${value.originalUnit.symbol}`;
+}
+export {
+  Energy,
+  maskEnergy
+};
+//# sourceMappingURL=energy.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/energy.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 { EnergyUnit } from \"./energy-unit.js\";\n\n/** Options for {@link Energy.format} and {@link Energy.normalize}. */\nexport interface EnergyFormatOptions {\n  fallbackToTrimmedInputWhenInvalid?: boolean;\n  /** Convert to this unit instead of preserving the parsed one. */\n  unit?: EnergyUnit;\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*(?:TWh|GWh|MWh|kWh|TJ|GJ|MJ|kJ|kcal|Wh|BTU|cal|J)\\b`,\n  \"giu\",\n);\n\n/**\n * A energy stored internally in joules,\n * parsed from any supported unit and convertible between all of them.\n */\nexport class Energy extends Quantity<EnergyUnit> {\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Energy\",\n    localizedName: \"Energi\",\n    emoji: \"\u26A1\",\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<EnergyUnit> {\n    return EnergyUnit.index;\n  }\n\n  protected withBaseValue(baseValue: Decimal, unit: EnergyUnit): this {\n    return new Energy(baseValue, unit) as this;\n  }\n\n  get joules(): number {\n    return this.in(EnergyUnit.Joule);\n  }\n  get kilojoules(): number {\n    return this.in(EnergyUnit.Kilojoule);\n  }\n  get megajoules(): number {\n    return this.in(EnergyUnit.Megajoule);\n  }\n  get gigajoules(): number {\n    return this.in(EnergyUnit.Gigajoule);\n  }\n  get terajoules(): number {\n    return this.in(EnergyUnit.Terajoule);\n  }\n  get wattHours(): number {\n    return this.in(EnergyUnit.WattHour);\n  }\n  get kilowattHours(): number {\n    return this.in(EnergyUnit.KilowattHour);\n  }\n  get megawattHours(): number {\n    return this.in(EnergyUnit.MegawattHour);\n  }\n  get gigawattHours(): number {\n    return this.in(EnergyUnit.GigawattHour);\n  }\n  get terawattHours(): number {\n    return this.in(EnergyUnit.TerawattHour);\n  }\n  get calories(): number {\n    return this.in(EnergyUnit.Calorie);\n  }\n  get kilocalories(): number {\n    return this.in(EnergyUnit.Kilocalorie);\n  }\n  get btus(): number {\n    return this.in(EnergyUnit.Btu);\n  }\n\n  /** Creates a energy from a value and unit. */\n  static create(value: number | Decimal, unit: EnergyUnit): Energy {\n    EnergyUnit.index.assertOwns(unit);\n    const amount = value instanceof Decimal ? value : Energy.decimalOf(value);\n    return new Energy(unit.toBase(amount), unit);\n  }\n\n  static fromJoules(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.Joule);\n  }\n  static fromKilojoules(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.Kilojoule);\n  }\n  static fromMegajoules(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.Megajoule);\n  }\n  static fromGigajoules(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.Gigajoule);\n  }\n  static fromTerajoules(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.Terajoule);\n  }\n  static fromWattHours(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.WattHour);\n  }\n  static fromKilowattHours(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.KilowattHour);\n  }\n  static fromMegawattHours(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.MegawattHour);\n  }\n  static fromGigawattHours(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.GigawattHour);\n  }\n  static fromTerawattHours(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.TerawattHour);\n  }\n  static fromCalories(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.Calorie);\n  }\n  static fromKilocalories(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.Kilocalorie);\n  }\n  static fromBtus(value: number | Decimal): Energy {\n    return Energy.create(value, EnergyUnit.Btu);\n  }\n\n  static tryParse(input: string | null | undefined): Energy | null {\n    const parsed = tryParseQuantity(input, EnergyUnit.index);\n    return parsed === null ? null : new Energy(parsed.baseValue, parsed.unit);\n  }\n\n  static parse(input: string): Energy {\n    const result = Energy.tryParse(input);\n    if (result === null) throw new Error(\"Invalid energy.\");\n    return result;\n  }\n\n  static isValid(input: string | null | undefined): boolean {\n    return Energy.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?: EnergyFormatOptions): string | null {\n    const parsed = Energy.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 Energy.fallback(input, options);\n  }\n\n  /** The value in joules, or `null` when the input is invalid. */\n  static normalize(input: string | null | undefined, options?: EnergyFormatOptions): string | null {\n    const parsed = Energy.tryParse(input);\n    if (parsed !== null) return parsed.toNormalizedString();\n    return Energy.fallback(input, options);\n  }\n\n  static isNormalized(input: string | null | undefined): boolean {\n    return input != null && Energy.normalize(input) === input;\n  }\n\n  static findCandidatesInText(text: string): readonly TextCandidate<Energy>[] {\n    if (!text) return [];\n\n    const out: TextCandidate<Energy>[] = [];\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 = Energy.tryParse(match[0]);\n      if (value === null) continue;\n      out.push(\n        new TextCandidate<Energy>({\n          startIndex: match.index,\n          length: match[0].length,\n          originalText: match[0],\n          typeName: \"Energy\",\n          category: TextCandidateCategory.Measurement,\n          normalizedForm: value.toNormalizedString(),\n          formattedForm: value.toString(),\n          maskedForm: maskEnergy(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?: EnergyFormatOptions,\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 energy: ${value}`);\n    return parsed;\n  }\n}\n\n/** Returns a masked energy, e.g. `10 J` becomes `*** J`. */\nexport function maskEnergy(value: Energy): string {\n  return `*** ${value.originalUnit.symbol}`;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/measurement/flow-rate-unit.js

@@ -0,0 +1,112 @@
+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 FlowRateUnit extends MeasurementUnit {
+  static typeInfo = Object.freeze({
+    englishName: "Flow Rate Unit",
+    localizedName: "Fl\xF6desenhet",
+    emoji: "\u{1F30A}",
+    sources: Object.freeze([])
+  });
+  static LitersPerSecond = new FlowRateUnit({
+    symbol: "L/s",
+    englishName: "liter per second",
+    localizedName: "liter per sekund",
+    pluralEnglish: "liters per second",
+    pluralSwedish: "liter per sekund",
+    toBaseUnitFactor: factor("60"),
+    aliases: ["l/s"]
+  });
+  static LitersPerMinute = new FlowRateUnit({
+    symbol: "L/min",
+    englishName: "liter per minute",
+    localizedName: "liter per minut",
+    pluralEnglish: "liters per minute",
+    pluralSwedish: "liter per minut",
+    toBaseUnitFactor: factor("1"),
+    aliases: ["l/min"]
+  });
+  static LitersPerHour = new FlowRateUnit({
+    symbol: "L/h",
+    englishName: "liter per hour",
+    localizedName: "liter per timme",
+    pluralEnglish: "liters per hour",
+    pluralSwedish: "liter per timme",
+    toBaseUnitFactor: factor("0.0166666666666666666666666667"),
+    exactRatio: [factor("1"), factor("60")],
+    aliases: ["l/h", "l/timme", "liter/timme", "liter/h"]
+  });
+  static CubicMetersPerHour = new FlowRateUnit({
+    symbol: "m\xB3/h",
+    englishName: "cubic meter per hour",
+    localizedName: "kubikmeter per timme",
+    pluralEnglish: "cubic meters per hour",
+    pluralSwedish: "kubikmeter per timme",
+    toBaseUnitFactor: factor("16.666666666666666666666666667"),
+    exactRatio: [factor("1000"), factor("60")],
+    aliases: ["m3/h", "m\xB3/tim", "m3/tim", "cbm/h"]
+  });
+  static CubicMetersPerMinute = new FlowRateUnit({
+    symbol: "m\xB3/min",
+    englishName: "cubic meter per minute",
+    localizedName: "kubikmeter per minut",
+    pluralEnglish: "cubic meters per minute",
+    pluralSwedish: "kubikmeter per minut",
+    toBaseUnitFactor: factor("1000"),
+    aliases: ["m3/min"]
+  });
+  static GallonsPerMinute = new FlowRateUnit({
+    symbol: "gal/min",
+    englishName: "gallon per minute",
+    localizedName: "gallon per minut",
+    pluralEnglish: "gallons per minute",
+    pluralSwedish: "gallon per minut",
+    toBaseUnitFactor: factor("3.785411784"),
+    aliases: ["gpm", "GPM"]
+  });
+  /** @internal Shared lookup and natural-scale walk. */
+  static index = new MeasurementUnitIndex(
+    [
+      FlowRateUnit.LitersPerSecond,
+      FlowRateUnit.LitersPerMinute,
+      FlowRateUnit.LitersPerHour,
+      FlowRateUnit.CubicMetersPerHour,
+      FlowRateUnit.CubicMetersPerMinute,
+      FlowRateUnit.GallonsPerMinute
+    ],
+    FlowRateUnit.LitersPerMinute,
+    [FlowRateUnit.LitersPerHour, FlowRateUnit.LitersPerMinute, FlowRateUnit.CubicMetersPerHour]
+  );
+  static get all() {
+    return FlowRateUnit.index.all;
+  }
+  /** The base unit: L/min. */
+  static get baseUnit() {
+    return FlowRateUnit.index.baseUnit;
+  }
+  /** Units ordered small to large, used to auto-scale display. */
+  static get naturalScale() {
+    return FlowRateUnit.index.naturalScale;
+  }
+  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+  static tryParse(input) {
+    return FlowRateUnit.index.tryParse(input);
+  }
+  static parse(input) {
+    const result = FlowRateUnit.tryParse(input);
+    if (result === null) throw new Error("Unknown flow rate unit.");
+    return result;
+  }
+  /** Returns the most human-readable unit for a value in L/min. */
+  static getNatural(baseValue) {
+    return FlowRateUnit.index.getNatural(baseValue);
+  }
+}
+export {
+  FlowRateUnit
+};
+//# sourceMappingURL=flow-rate-unit.js.map

package/dist/esm/measurement/flow-rate-unit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/flow-rate-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 flow rate 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 FlowRateUnit extends MeasurementUnit {\n  declare private readonly __flowRateUnitBrand: void;\n\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Flow Rate Unit\",\n    localizedName: \"Fl\u00F6desenhet\",\n    emoji: \"\uD83C\uDF0A\",\n    sources: Object.freeze([]),\n  });\n\n  static readonly LitersPerSecond = new FlowRateUnit({\n    symbol: \"L/s\",\n    englishName: \"liter per second\",\n    localizedName: \"liter per sekund\",\n    pluralEnglish: \"liters per second\",\n    pluralSwedish: \"liter per sekund\",\n    toBaseUnitFactor: factor(\"60\"),\n    aliases: [\"l/s\"],\n  });\n\n  static readonly LitersPerMinute = new FlowRateUnit({\n    symbol: \"L/min\",\n    englishName: \"liter per minute\",\n    localizedName: \"liter per minut\",\n    pluralEnglish: \"liters per minute\",\n    pluralSwedish: \"liter per minut\",\n    toBaseUnitFactor: factor(\"1\"),\n    aliases: [\"l/min\"],\n  });\n\n  static readonly LitersPerHour = new FlowRateUnit({\n    symbol: \"L/h\",\n    englishName: \"liter per hour\",\n    localizedName: \"liter per timme\",\n    pluralEnglish: \"liters per hour\",\n    pluralSwedish: \"liter per timme\",\n    toBaseUnitFactor: factor(\"0.0166666666666666666666666667\"),\n    exactRatio: [factor(\"1\"), factor(\"60\")],\n    aliases: [\"l/h\", \"l/timme\", \"liter/timme\", \"liter/h\"],\n  });\n\n  static readonly CubicMetersPerHour = new FlowRateUnit({\n    symbol: \"m\u00B3/h\",\n    englishName: \"cubic meter per hour\",\n    localizedName: \"kubikmeter per timme\",\n    pluralEnglish: \"cubic meters per hour\",\n    pluralSwedish: \"kubikmeter per timme\",\n    toBaseUnitFactor: factor(\"16.666666666666666666666666667\"),\n    exactRatio: [factor(\"1000\"), factor(\"60\")],\n    aliases: [\"m3/h\", \"m\u00B3/tim\", \"m3/tim\", \"cbm/h\"],\n  });\n\n  static readonly CubicMetersPerMinute = new FlowRateUnit({\n    symbol: \"m\u00B3/min\",\n    englishName: \"cubic meter per minute\",\n    localizedName: \"kubikmeter per minut\",\n    pluralEnglish: \"cubic meters per minute\",\n    pluralSwedish: \"kubikmeter per minut\",\n    toBaseUnitFactor: factor(\"1000\"),\n    aliases: [\"m3/min\"],\n  });\n\n  static readonly GallonsPerMinute = new FlowRateUnit({\n    symbol: \"gal/min\",\n    englishName: \"gallon per minute\",\n    localizedName: \"gallon per minut\",\n    pluralEnglish: \"gallons per minute\",\n    pluralSwedish: \"gallon per minut\",\n    toBaseUnitFactor: factor(\"3.785411784\"),\n    aliases: [\"gpm\", \"GPM\"],\n  });\n\n  /** @internal Shared lookup and natural-scale walk. */\n  static readonly index: MeasurementUnitIndex<FlowRateUnit> =\n    new MeasurementUnitIndex<FlowRateUnit>(\n      [\n        FlowRateUnit.LitersPerSecond,\n        FlowRateUnit.LitersPerMinute,\n        FlowRateUnit.LitersPerHour,\n        FlowRateUnit.CubicMetersPerHour,\n        FlowRateUnit.CubicMetersPerMinute,\n        FlowRateUnit.GallonsPerMinute,\n      ],\n      FlowRateUnit.LitersPerMinute,\n      [FlowRateUnit.LitersPerHour, FlowRateUnit.LitersPerMinute, FlowRateUnit.CubicMetersPerHour],\n    );\n\n  static get all(): readonly FlowRateUnit[] {\n    return FlowRateUnit.index.all;\n  }\n\n  /** The base unit: L/min. */\n  static get baseUnit(): FlowRateUnit {\n    return FlowRateUnit.index.baseUnit;\n  }\n\n  /** Units ordered small to large, used to auto-scale display. */\n  static get naturalScale(): readonly FlowRateUnit[] {\n    return FlowRateUnit.index.naturalScale;\n  }\n\n  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */\n  static tryParse(input: string | null | undefined): FlowRateUnit | null {\n    return FlowRateUnit.index.tryParse(input);\n  }\n\n  static parse(input: string): FlowRateUnit {\n    const result = FlowRateUnit.tryParse(input);\n    if (result === null) throw new Error(\"Unknown flow rate unit.\");\n    return result;\n  }\n\n  /** Returns the most human-readable unit for a value in L/min. */\n  static getNatural(baseValue: Decimal): FlowRateUnit {\n    return FlowRateUnit.index.getNatural(baseValue);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/measurement/flow-rate.js

@@ -0,0 +1,142 @@
+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 { FlowRateUnit } from "./flow-rate-unit.js";
+const SCAN_PATTERN = new RegExp(
+  String.raw`(?<!\w)(?:[+-]\s*)?\d+[0-9 .,]*\s*(?:m[³3]/(?:h|min|tim)|l/(?:s|min|h|timme)|gal/min|gpm)\b`,
+  "giu"
+);
+class FlowRate extends Quantity {
+  static typeInfo = Object.freeze({
+    englishName: "Flow Rate",
+    localizedName: "Fl\xF6de",
+    emoji: "\u{1F30A}",
+    sources: Object.freeze(["https://en.wikipedia.org/wiki/Volumetric_flow_rate"])
+  });
+  get units() {
+    return FlowRateUnit.index;
+  }
+  withBaseValue(baseValue, unit) {
+    return new FlowRate(baseValue, unit);
+  }
+  get litersPerSecond() {
+    return this.in(FlowRateUnit.LitersPerSecond);
+  }
+  get litersPerMinute() {
+    return this.in(FlowRateUnit.LitersPerMinute);
+  }
+  get litersPerHour() {
+    return this.in(FlowRateUnit.LitersPerHour);
+  }
+  get cubicMetersPerHour() {
+    return this.in(FlowRateUnit.CubicMetersPerHour);
+  }
+  get cubicMetersPerMinute() {
+    return this.in(FlowRateUnit.CubicMetersPerMinute);
+  }
+  get gallonsPerMinute() {
+    return this.in(FlowRateUnit.GallonsPerMinute);
+  }
+  /** Creates a flow rate from a value and unit. */
+  static create(value, unit) {
+    FlowRateUnit.index.assertOwns(unit);
+    const amount = value instanceof Decimal ? value : FlowRate.decimalOf(value);
+    return new FlowRate(unit.toBase(amount), unit);
+  }
+  static fromLitersPerSecond(value) {
+    return FlowRate.create(value, FlowRateUnit.LitersPerSecond);
+  }
+  static fromLitersPerMinute(value) {
+    return FlowRate.create(value, FlowRateUnit.LitersPerMinute);
+  }
+  static fromLitersPerHour(value) {
+    return FlowRate.create(value, FlowRateUnit.LitersPerHour);
+  }
+  static fromCubicMetersPerHour(value) {
+    return FlowRate.create(value, FlowRateUnit.CubicMetersPerHour);
+  }
+  static fromCubicMetersPerMinute(value) {
+    return FlowRate.create(value, FlowRateUnit.CubicMetersPerMinute);
+  }
+  static fromGallonsPerMinute(value) {
+    return FlowRate.create(value, FlowRateUnit.GallonsPerMinute);
+  }
+  static tryParse(input) {
+    const parsed = tryParseQuantity(input, FlowRateUnit.index);
+    return parsed === null ? null : new FlowRate(parsed.baseValue, parsed.unit);
+  }
+  static parse(input) {
+    const result = FlowRate.tryParse(input);
+    if (result === null) throw new Error("Invalid flow rate.");
+    return result;
+  }
+  static isValid(input) {
+    return FlowRate.tryParse(input) !== null;
+  }
+  /** Display form in the parsed unit, or `null` when the input is invalid. */
+  static format(input, options) {
+    const parsed = FlowRate.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 FlowRate.fallback(input, options);
+  }
+  /** The value in liters per minute, or `null` when the input is invalid. */
+  static normalize(input, options) {
+    const parsed = FlowRate.tryParse(input);
+    if (parsed !== null) return parsed.toNormalizedString();
+    return FlowRate.fallback(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && FlowRate.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 = FlowRate.tryParse(match[0]);
+      if (value === null) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: match.index,
+          length: match[0].length,
+          originalText: match[0],
+          typeName: "FlowRate",
+          category: TextCandidateCategory.Measurement,
+          normalizedForm: value.toNormalizedString(),
+          formattedForm: value.toString(),
+          maskedForm: maskFlowRate(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 flow rate: ${value}`);
+    return parsed;
+  }
+}
+function maskFlowRate(value) {
+  return `*** ${value.originalUnit.symbol}`;
+}
+export {
+  FlowRate,
+  maskFlowRate
+};
+//# sourceMappingURL=flow-rate.js.map

package/dist/esm/measurement/flow-rate.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/flow-rate.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 { FlowRateUnit } from \"./flow-rate-unit.js\";\n\n/** Options for {@link FlowRate.format} and {@link FlowRate.normalize}. */\nexport interface FlowRateFormatOptions {\n  fallbackToTrimmedInputWhenInvalid?: boolean;\n  /** Convert to this unit instead of preserving the parsed one. */\n  unit?: FlowRateUnit;\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*(?:m[\u00B33]/(?:h|min|tim)|l/(?:s|min|h|timme)|gal/min|gpm)\\b`,\n  \"giu\",\n);\n\n/**\n * A flow rate stored internally in liters per minute,\n * parsed from any supported unit and convertible between all of them.\n */\nexport class FlowRate extends Quantity<FlowRateUnit> {\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Flow Rate\",\n    localizedName: \"Fl\u00F6de\",\n    emoji: \"\uD83C\uDF0A\",\n    sources: Object.freeze([\"https://en.wikipedia.org/wiki/Volumetric_flow_rate\"]),\n  });\n\n  protected get units(): MeasurementUnitIndex<FlowRateUnit> {\n    return FlowRateUnit.index;\n  }\n\n  protected withBaseValue(baseValue: Decimal, unit: FlowRateUnit): this {\n    return new FlowRate(baseValue, unit) as this;\n  }\n\n  get litersPerSecond(): number {\n    return this.in(FlowRateUnit.LitersPerSecond);\n  }\n  get litersPerMinute(): number {\n    return this.in(FlowRateUnit.LitersPerMinute);\n  }\n  get litersPerHour(): number {\n    return this.in(FlowRateUnit.LitersPerHour);\n  }\n  get cubicMetersPerHour(): number {\n    return this.in(FlowRateUnit.CubicMetersPerHour);\n  }\n  get cubicMetersPerMinute(): number {\n    return this.in(FlowRateUnit.CubicMetersPerMinute);\n  }\n  get gallonsPerMinute(): number {\n    return this.in(FlowRateUnit.GallonsPerMinute);\n  }\n\n  /** Creates a flow rate from a value and unit. */\n  static create(value: number | Decimal, unit: FlowRateUnit): FlowRate {\n    FlowRateUnit.index.assertOwns(unit);\n    const amount = value instanceof Decimal ? value : FlowRate.decimalOf(value);\n    return new FlowRate(unit.toBase(amount), unit);\n  }\n\n  static fromLitersPerSecond(value: number | Decimal): FlowRate {\n    return FlowRate.create(value, FlowRateUnit.LitersPerSecond);\n  }\n  static fromLitersPerMinute(value: number | Decimal): FlowRate {\n    return FlowRate.create(value, FlowRateUnit.LitersPerMinute);\n  }\n  static fromLitersPerHour(value: number | Decimal): FlowRate {\n    return FlowRate.create(value, FlowRateUnit.LitersPerHour);\n  }\n  static fromCubicMetersPerHour(value: number | Decimal): FlowRate {\n    return FlowRate.create(value, FlowRateUnit.CubicMetersPerHour);\n  }\n  static fromCubicMetersPerMinute(value: number | Decimal): FlowRate {\n    return FlowRate.create(value, FlowRateUnit.CubicMetersPerMinute);\n  }\n  static fromGallonsPerMinute(value: number | Decimal): FlowRate {\n    return FlowRate.create(value, FlowRateUnit.GallonsPerMinute);\n  }\n\n  static tryParse(input: string | null | undefined): FlowRate | null {\n    const parsed = tryParseQuantity(input, FlowRateUnit.index);\n    return parsed === null ? null : new FlowRate(parsed.baseValue, parsed.unit);\n  }\n\n  static parse(input: string): FlowRate {\n    const result = FlowRate.tryParse(input);\n    if (result === null) throw new Error(\"Invalid flow rate.\");\n    return result;\n  }\n\n  static isValid(input: string | null | undefined): boolean {\n    return FlowRate.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?: FlowRateFormatOptions): string | null {\n    const parsed = FlowRate.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 FlowRate.fallback(input, options);\n  }\n\n  /** The value in liters per minute, or `null` when the input is invalid. */\n  static normalize(\n    input: string | null | undefined,\n    options?: FlowRateFormatOptions,\n  ): string | null {\n    const parsed = FlowRate.tryParse(input);\n    if (parsed !== null) return parsed.toNormalizedString();\n    return FlowRate.fallback(input, options);\n  }\n\n  static isNormalized(input: string | null | undefined): boolean {\n    return input != null && FlowRate.normalize(input) === input;\n  }\n\n  static findCandidatesInText(text: string): readonly TextCandidate<FlowRate>[] {\n    if (!text) return [];\n\n    const out: TextCandidate<FlowRate>[] = [];\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 = FlowRate.tryParse(match[0]);\n      if (value === null) continue;\n      out.push(\n        new TextCandidate<FlowRate>({\n          startIndex: match.index,\n          length: match[0].length,\n          originalText: match[0],\n          typeName: \"FlowRate\",\n          category: TextCandidateCategory.Measurement,\n          normalizedForm: value.toNormalizedString(),\n          formattedForm: value.toString(),\n          maskedForm: maskFlowRate(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?: FlowRateFormatOptions,\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 flow rate: ${value}`);\n    return parsed;\n  }\n}\n\n/** Returns a masked flow rate, e.g. `10 L/min` becomes `*** L/min`. */\nexport function maskFlowRate(value: FlowRate): string {\n  return `*** ${value.originalUnit.symbol}`;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,112 @@
+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 FrequencyUnit extends MeasurementUnit {
+  static typeInfo = Object.freeze({
+    englishName: "Frequency Unit",
+    localizedName: "Frekvensenhet",
+    emoji: "\u{1F4E1}",
+    sources: Object.freeze([])
+  });
+  static Hertz = new FrequencyUnit({
+    symbol: "Hz",
+    englishName: "hertz",
+    localizedName: "hertz",
+    pluralEnglish: "hertz",
+    pluralSwedish: "hertz",
+    toBaseUnitFactor: factor("1")
+  });
+  static Kilohertz = new FrequencyUnit({
+    symbol: "kHz",
+    englishName: "kilohertz",
+    localizedName: "kilohertz",
+    pluralEnglish: "kilohertz",
+    pluralSwedish: "kilohertz",
+    toBaseUnitFactor: factor("1000")
+  });
+  static Megahertz = new FrequencyUnit({
+    symbol: "MHz",
+    englishName: "megahertz",
+    localizedName: "megahertz",
+    pluralEnglish: "megahertz",
+    pluralSwedish: "megahertz",
+    toBaseUnitFactor: factor("1000000")
+  });
+  static Gigahertz = new FrequencyUnit({
+    symbol: "GHz",
+    englishName: "gigahertz",
+    localizedName: "gigahertz",
+    pluralEnglish: "gigahertz",
+    pluralSwedish: "gigahertz",
+    toBaseUnitFactor: factor("1000000000")
+  });
+  static Terahertz = new FrequencyUnit({
+    symbol: "THz",
+    englishName: "terahertz",
+    localizedName: "terahertz",
+    pluralEnglish: "terahertz",
+    pluralSwedish: "terahertz",
+    toBaseUnitFactor: factor("1000000000000")
+  });
+  static RevolutionsPerMinute = new FrequencyUnit({
+    symbol: "rpm",
+    englishName: "revolution per minute",
+    localizedName: "varv per minut",
+    pluralEnglish: "revolutions per minute",
+    pluralSwedish: "varv per minut",
+    toBaseUnitFactor: factor("0.0166666666666666666666666667"),
+    exactRatio: [factor("1"), factor("60")],
+    aliases: ["RPM", "rev/min", "varv/min", "r/min"]
+  });
+  /** @internal Shared lookup and natural-scale walk. */
+  static index = new MeasurementUnitIndex(
+    [
+      FrequencyUnit.Hertz,
+      FrequencyUnit.Kilohertz,
+      FrequencyUnit.Megahertz,
+      FrequencyUnit.Gigahertz,
+      FrequencyUnit.Terahertz,
+      FrequencyUnit.RevolutionsPerMinute
+    ],
+    FrequencyUnit.Hertz,
+    [
+      FrequencyUnit.Hertz,
+      FrequencyUnit.Kilohertz,
+      FrequencyUnit.Megahertz,
+      FrequencyUnit.Gigahertz,
+      FrequencyUnit.Terahertz
+    ]
+  );
+  static get all() {
+    return FrequencyUnit.index.all;
+  }
+  /** The base unit: Hz. */
+  static get baseUnit() {
+    return FrequencyUnit.index.baseUnit;
+  }
+  /** Units ordered small to large, used to auto-scale display. */
+  static get naturalScale() {
+    return FrequencyUnit.index.naturalScale;
+  }
+  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+  static tryParse(input) {
+    return FrequencyUnit.index.tryParse(input);
+  }
+  static parse(input) {
+    const result = FrequencyUnit.tryParse(input);
+    if (result === null) throw new Error("Unknown frequency unit.");
+    return result;
+  }
+  /** Returns the most human-readable unit for a value in Hz. */
+  static getNatural(baseValue) {
+    return FrequencyUnit.index.getNatural(baseValue);
+  }
+}
+export {
+  FrequencyUnit
+};
+//# sourceMappingURL=frequency-unit.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/frequency-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 frequency 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 FrequencyUnit extends MeasurementUnit {\n  declare private readonly __frequencyUnitBrand: void;\n\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Frequency Unit\",\n    localizedName: \"Frekvensenhet\",\n    emoji: \"\uD83D\uDCE1\",\n    sources: Object.freeze([]),\n  });\n\n  static readonly Hertz = new FrequencyUnit({\n    symbol: \"Hz\",\n    englishName: \"hertz\",\n    localizedName: \"hertz\",\n    pluralEnglish: \"hertz\",\n    pluralSwedish: \"hertz\",\n    toBaseUnitFactor: factor(\"1\"),\n  });\n\n  static readonly Kilohertz = new FrequencyUnit({\n    symbol: \"kHz\",\n    englishName: \"kilohertz\",\n    localizedName: \"kilohertz\",\n    pluralEnglish: \"kilohertz\",\n    pluralSwedish: \"kilohertz\",\n    toBaseUnitFactor: factor(\"1000\"),\n  });\n\n  static readonly Megahertz = new FrequencyUnit({\n    symbol: \"MHz\",\n    englishName: \"megahertz\",\n    localizedName: \"megahertz\",\n    pluralEnglish: \"megahertz\",\n    pluralSwedish: \"megahertz\",\n    toBaseUnitFactor: factor(\"1000000\"),\n  });\n\n  static readonly Gigahertz = new FrequencyUnit({\n    symbol: \"GHz\",\n    englishName: \"gigahertz\",\n    localizedName: \"gigahertz\",\n    pluralEnglish: \"gigahertz\",\n    pluralSwedish: \"gigahertz\",\n    toBaseUnitFactor: factor(\"1000000000\"),\n  });\n\n  static readonly Terahertz = new FrequencyUnit({\n    symbol: \"THz\",\n    englishName: \"terahertz\",\n    localizedName: \"terahertz\",\n    pluralEnglish: \"terahertz\",\n    pluralSwedish: \"terahertz\",\n    toBaseUnitFactor: factor(\"1000000000000\"),\n  });\n\n  static readonly RevolutionsPerMinute = new FrequencyUnit({\n    symbol: \"rpm\",\n    englishName: \"revolution per minute\",\n    localizedName: \"varv per minut\",\n    pluralEnglish: \"revolutions per minute\",\n    pluralSwedish: \"varv per minut\",\n    toBaseUnitFactor: factor(\"0.0166666666666666666666666667\"),\n    exactRatio: [factor(\"1\"), factor(\"60\")],\n    aliases: [\"RPM\", \"rev/min\", \"varv/min\", \"r/min\"],\n  });\n\n  /** @internal Shared lookup and natural-scale walk. */\n  static readonly index: MeasurementUnitIndex<FrequencyUnit> =\n    new MeasurementUnitIndex<FrequencyUnit>(\n      [\n        FrequencyUnit.Hertz,\n        FrequencyUnit.Kilohertz,\n        FrequencyUnit.Megahertz,\n        FrequencyUnit.Gigahertz,\n        FrequencyUnit.Terahertz,\n        FrequencyUnit.RevolutionsPerMinute,\n      ],\n      FrequencyUnit.Hertz,\n      [\n        FrequencyUnit.Hertz,\n        FrequencyUnit.Kilohertz,\n        FrequencyUnit.Megahertz,\n        FrequencyUnit.Gigahertz,\n        FrequencyUnit.Terahertz,\n      ],\n    );\n\n  static get all(): readonly FrequencyUnit[] {\n    return FrequencyUnit.index.all;\n  }\n\n  /** The base unit: Hz. */\n  static get baseUnit(): FrequencyUnit {\n    return FrequencyUnit.index.baseUnit;\n  }\n\n  /** Units ordered small to large, used to auto-scale display. */\n  static get naturalScale(): readonly FrequencyUnit[] {\n    return FrequencyUnit.index.naturalScale;\n  }\n\n  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */\n  static tryParse(input: string | null | undefined): FrequencyUnit | null {\n    return FrequencyUnit.index.tryParse(input);\n  }\n\n  static parse(input: string): FrequencyUnit {\n    const result = FrequencyUnit.tryParse(input);\n    if (result === null) throw new Error(\"Unknown frequency unit.\");\n    return result;\n  }\n\n  /** Returns the most human-readable unit for a value in Hz. */\n  static getNatural(baseValue: Decimal): FrequencyUnit {\n    return FrequencyUnit.index.getNatural(baseValue);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}