@budiauktioner/buildi-primitives 0.1.0 → 0.2.0

package/dist/cjs/internal/luhn.js

@@ -0,0 +1,40 @@
+"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 luhn_exports = {};
+__export(luhn_exports, {
+  luhnIsValid: () => luhnIsValid
+});
+module.exports = __toCommonJS(luhn_exports);
+function luhnIsValid(digits) {
+  if (!digits) return false;
+  let sum = 0;
+  const len = digits.length;
+  for (let i = 0; i < len; i++) {
+    const code = digits.charCodeAt(i);
+    if (code < 48 || code > 57) return false;
+    let d = code - 48;
+    if ((len - i) % 2 === 0) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+  }
+  return sum % 10 === 0;
+}
+//# sourceMappingURL=luhn.js.map

package/dist/cjs/internal/luhn.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/luhn.ts"],
+  "sourcesContent": ["/**\n * Validates a standard Luhn (mod 10) checksum.\n * Checks the entire string: the last digit is assumed to be the control digit.\n *\n * Equivalent of `Buildi.Primitives.Luhn.IsValid` (internal in .NET).\n */\nexport function luhnIsValid(digits: string): boolean {\n  if (!digits) return false;\n\n  let sum = 0;\n  const len = digits.length;\n  for (let i = 0; i < len; i++) {\n    const code = digits.charCodeAt(i);\n    if (code < 0x30 || code > 0x39) return false;\n    let d = code - 0x30;\n    if ((len - i) % 2 === 0) {\n      d *= 2;\n      if (d > 9) d -= 9;\n    }\n    sum += d;\n  }\n  return sum % 10 === 0;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,SAAS,YAAY,QAAyB;AACnD,MAAI,CAAC,OAAQ,QAAO;AAEpB,MAAI,MAAM;AACV,QAAM,MAAM,OAAO;AACnB,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,UAAM,OAAO,OAAO,WAAW,CAAC;AAChC,QAAI,OAAO,MAAQ,OAAO,GAAM,QAAO;AACvC,QAAI,IAAI,OAAO;AACf,SAAK,MAAM,KAAK,MAAM,GAAG;AACvB,WAAK;AACL,UAAI,IAAI,EAAG,MAAK;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AACA,SAAO,MAAM,OAAO;AACtB;",
+  "names": []
+}

package/dist/cjs/internal/measurement-unit-parser.js

@@ -0,0 +1,86 @@
+"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_unit_parser_exports = {};
+__export(measurement_unit_parser_exports, {
+  tryParseNumberOnly: () => tryParseNumberOnly,
+  trySplitMeasurement: () => trySplitMeasurement
+});
+module.exports = __toCommonJS(measurement_unit_parser_exports);
+var import_decimal = require("./decimal.js");
+var import_input_sanitization = require("./input-sanitization.js");
+const MAX_INPUT_LENGTH = 100;
+const INPUT_PATTERN = /^(?<sign>[+-])?\s*(?<number>[0-9][0-9 .,]*[0-9]|[0-9])\s*(?<unit>.+)$/u;
+function trySplitMeasurement(input) {
+  if (input == null || input.trim().length === 0) return null;
+  const trimmed = (0, import_input_sanitization.sanitizeInput)(input).trim();
+  if (trimmed.length > MAX_INPUT_LENGTH) return null;
+  const match = INPUT_PATTERN.exec(trimmed);
+  if (match?.groups === void 0) return null;
+  const unitSuffix = (match.groups["unit"] ?? "").trim();
+  if (unitSuffix.length === 0) return null;
+  const value = tryParseNumber(match.groups["number"] ?? "");
+  if (value === null) return null;
+  return {
+    value: match.groups["sign"] === "-" ? value.negated() : value,
+    unitSuffix
+  };
+}
+const BARE_NUMBER_CHARACTERS = /^[0-9.,\u0020\u00A0]+$/u;
+function tryParseNumberOnly(input) {
+  if (input == null || input.trim().length === 0) return null;
+  const trimmed = input.trim();
+  if (trimmed.length > MAX_INPUT_LENGTH) return null;
+  let rest = trimmed;
+  let negative = false;
+  if (rest.startsWith("-")) {
+    negative = true;
+    rest = rest.slice(1).trimStart();
+  } else if (rest.startsWith("+")) {
+    rest = rest.slice(1).trimStart();
+  }
+  if (rest.length === 0 || !BARE_NUMBER_CHARACTERS.test(rest)) return null;
+  const value = tryParseNumber(rest);
+  if (value === null) return null;
+  return negative ? value.negated() : value;
+}
+function tryParseNumber(raw) {
+  const s = raw.trim();
+  if (s.length === 0) return null;
+  const lastComma = s.lastIndexOf(",");
+  const lastPeriod = s.lastIndexOf(".");
+  let integerPart = s;
+  let fractionPart = "";
+  if (lastComma > lastPeriod) {
+    const afterComma = s.slice(lastComma + 1);
+    if (afterComma.length > 0 && afterComma.length <= 10 && /^\d+$/u.test(afterComma)) {
+      fractionPart = afterComma;
+      integerPart = s.slice(0, lastComma);
+    }
+  } else if (lastPeriod > lastComma) {
+    const afterPeriod = s.slice(lastPeriod + 1);
+    if (afterPeriod.length > 0 && afterPeriod.length <= 10 && /^\d+$/u.test(afterPeriod)) {
+      fractionPart = afterPeriod;
+      integerPart = s.slice(0, lastPeriod);
+    }
+  }
+  const cleanInteger = integerPart.replace(/[ \u00A0.,]/gu, "");
+  if (cleanInteger.length === 0 || !/^\d+$/u.test(cleanInteger)) return null;
+  return import_decimal.Decimal.parse(fractionPart.length > 0 ? `${cleanInteger}.${fractionPart}` : cleanInteger);
+}
+//# sourceMappingURL=measurement-unit-parser.js.map

package/dist/cjs/internal/measurement-unit-parser.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/measurement-unit-parser.ts"],
+  "sourcesContent": ["/**\n * Splits measurement strings such as `10 km`, `5.5cm` or `3,5 m` into a numeric\n * part and a unit suffix, tolerating both European and US decimal separators\n * plus space, period and comma as thousands separators.\n *\n * Unit lookup is the caller's job \u2014 this only hands back the raw suffix.\n *\n * Equivalent of `Buildi.Primitives.Measurement.MeasurementUnitParser`\n * (internal in .NET).\n */\n\nimport { Decimal } from \"./decimal.js\";\nimport { sanitizeInput } from \"./input-sanitization.js\";\n\nconst MAX_INPUT_LENGTH = 100;\n\nconst INPUT_PATTERN = /^(?<sign>[+-])?\\s*(?<number>[0-9][0-9 .,]*[0-9]|[0-9])\\s*(?<unit>.+)$/u;\n\n/** The numeric value and trailing unit suffix of a measurement string. */\nexport interface MeasurementSplit {\n  readonly value: Decimal;\n  readonly unitSuffix: string;\n}\n\n/**\n * Splits `input` into a value and a unit suffix, or returns `null` when it does\n * not look like a measurement.\n */\nexport function trySplitMeasurement(input: string | null | undefined): MeasurementSplit | null {\n  if (input == null || input.trim().length === 0) return null;\n\n  const trimmed = sanitizeInput(input).trim();\n  if (trimmed.length > MAX_INPUT_LENGTH) return null;\n\n  const match = INPUT_PATTERN.exec(trimmed);\n  if (match?.groups === undefined) return null;\n\n  const unitSuffix = (match.groups[\"unit\"] ?? \"\").trim();\n  if (unitSuffix.length === 0) return null;\n\n  const value = tryParseNumber(match.groups[\"number\"] ?? \"\");\n  if (value === null) return null;\n\n  return {\n    value: match.groups[\"sign\"] === \"-\" ? value.negated() : value,\n    unitSuffix,\n  };\n}\n\nconst BARE_NUMBER_CHARACTERS = /^[0-9.,\\u0020\\u00A0]+$/u;\n\n/** Parses a bare number with no unit suffix, e.g. the input to `Count`. */\nexport function tryParseNumberOnly(input: string | null | undefined): Decimal | null {\n  if (input == null || input.trim().length === 0) return null;\n\n  const trimmed = input.trim();\n  if (trimmed.length > MAX_INPUT_LENGTH) return null;\n\n  let rest = trimmed;\n  let negative = false;\n  if (rest.startsWith(\"-\")) {\n    negative = true;\n    rest = rest.slice(1).trimStart();\n  } else if (rest.startsWith(\"+\")) {\n    rest = rest.slice(1).trimStart();\n  }\n\n  if (rest.length === 0 || !BARE_NUMBER_CHARACTERS.test(rest)) return null;\n\n  const value = tryParseNumber(rest);\n  if (value === null) return null;\n\n  return negative ? value.negated() : value;\n}\n\n/**\n * Resolves which separator is the decimal point by taking the last one that\n * appears, so both `1.234,5` and `1,234.5` come out as the same value. A group\n * of more than ten digits after the separator is treated as a thousands group\n * rather than a fraction.\n */\nfunction tryParseNumber(raw: string): Decimal | null {\n  const s = raw.trim();\n  if (s.length === 0) return null;\n\n  const lastComma = s.lastIndexOf(\",\");\n  const lastPeriod = s.lastIndexOf(\".\");\n\n  let integerPart = s;\n  let fractionPart = \"\";\n\n  if (lastComma > lastPeriod) {\n    const afterComma = s.slice(lastComma + 1);\n    if (afterComma.length > 0 && afterComma.length <= 10 && /^\\d+$/u.test(afterComma)) {\n      fractionPart = afterComma;\n      integerPart = s.slice(0, lastComma);\n    }\n  } else if (lastPeriod > lastComma) {\n    const afterPeriod = s.slice(lastPeriod + 1);\n    if (afterPeriod.length > 0 && afterPeriod.length <= 10 && /^\\d+$/u.test(afterPeriod)) {\n      fractionPart = afterPeriod;\n      integerPart = s.slice(0, lastPeriod);\n    }\n  }\n\n  const cleanInteger = integerPart.replace(/[ \\u00A0.,]/gu, \"\");\n  if (cleanInteger.length === 0 || !/^\\d+$/u.test(cleanInteger)) return null;\n\n  return Decimal.parse(fractionPart.length > 0 ? `${cleanInteger}.${fractionPart}` : cleanInteger);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,qBAAwB;AACxB,gCAA8B;AAE9B,MAAM,mBAAmB;AAEzB,MAAM,gBAAgB;AAYf,SAAS,oBAAoB,OAA2D;AAC7F,MAAI,SAAS,QAAQ,MAAM,KAAK,EAAE,WAAW,EAAG,QAAO;AAEvD,QAAM,cAAU,yCAAc,KAAK,EAAE,KAAK;AAC1C,MAAI,QAAQ,SAAS,iBAAkB,QAAO;AAE9C,QAAM,QAAQ,cAAc,KAAK,OAAO;AACxC,MAAI,OAAO,WAAW,OAAW,QAAO;AAExC,QAAM,cAAc,MAAM,OAAO,MAAM,KAAK,IAAI,KAAK;AACrD,MAAI,WAAW,WAAW,EAAG,QAAO;AAEpC,QAAM,QAAQ,eAAe,MAAM,OAAO,QAAQ,KAAK,EAAE;AACzD,MAAI,UAAU,KAAM,QAAO;AAE3B,SAAO;AAAA,IACL,OAAO,MAAM,OAAO,MAAM,MAAM,MAAM,MAAM,QAAQ,IAAI;AAAA,IACxD;AAAA,EACF;AACF;AAEA,MAAM,yBAAyB;AAGxB,SAAS,mBAAmB,OAAkD;AACnF,MAAI,SAAS,QAAQ,MAAM,KAAK,EAAE,WAAW,EAAG,QAAO;AAEvD,QAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,QAAQ,SAAS,iBAAkB,QAAO;AAE9C,MAAI,OAAO;AACX,MAAI,WAAW;AACf,MAAI,KAAK,WAAW,GAAG,GAAG;AACxB,eAAW;AACX,WAAO,KAAK,MAAM,CAAC,EAAE,UAAU;AAAA,EACjC,WAAW,KAAK,WAAW,GAAG,GAAG;AAC/B,WAAO,KAAK,MAAM,CAAC,EAAE,UAAU;AAAA,EACjC;AAEA,MAAI,KAAK,WAAW,KAAK,CAAC,uBAAuB,KAAK,IAAI,EAAG,QAAO;AAEpE,QAAM,QAAQ,eAAe,IAAI;AACjC,MAAI,UAAU,KAAM,QAAO;AAE3B,SAAO,WAAW,MAAM,QAAQ,IAAI;AACtC;AAQA,SAAS,eAAe,KAA6B;AACnD,QAAM,IAAI,IAAI,KAAK;AACnB,MAAI,EAAE,WAAW,EAAG,QAAO;AAE3B,QAAM,YAAY,EAAE,YAAY,GAAG;AACnC,QAAM,aAAa,EAAE,YAAY,GAAG;AAEpC,MAAI,cAAc;AAClB,MAAI,eAAe;AAEnB,MAAI,YAAY,YAAY;AAC1B,UAAM,aAAa,EAAE,MAAM,YAAY,CAAC;AACxC,QAAI,WAAW,SAAS,KAAK,WAAW,UAAU,MAAM,SAAS,KAAK,UAAU,GAAG;AACjF,qBAAe;AACf,oBAAc,EAAE,MAAM,GAAG,SAAS;AAAA,IACpC;AAAA,EACF,WAAW,aAAa,WAAW;AACjC,UAAM,cAAc,EAAE,MAAM,aAAa,CAAC;AAC1C,QAAI,YAAY,SAAS,KAAK,YAAY,UAAU,MAAM,SAAS,KAAK,WAAW,GAAG;AACpF,qBAAe;AACf,oBAAc,EAAE,MAAM,GAAG,UAAU;AAAA,IACrC;AAAA,EACF;AAEA,QAAM,eAAe,YAAY,QAAQ,iBAAiB,EAAE;AAC5D,MAAI,aAAa,WAAW,KAAK,CAAC,SAAS,KAAK,YAAY,EAAG,QAAO;AAEtE,SAAO,uBAAQ,MAAM,aAAa,SAAS,IAAI,GAAG,YAAY,IAAI,YAAY,KAAK,YAAY;AACjG;",
+  "names": []
+}

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

@@ -0,0 +1,130 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var measurement_unit_exports = {};
+__export(measurement_unit_exports, {
+  MeasurementUnit: () => MeasurementUnit,
+  MeasurementUnitIndex: () => MeasurementUnitIndex,
+  foldForUnitLookup: () => foldForUnitLookup
+});
+module.exports = __toCommonJS(measurement_unit_exports);
+var import_decimal = require("./decimal.js");
+class MeasurementUnit {
+  symbol;
+  englishName;
+  localizedName;
+  pluralEnglish;
+  pluralSwedish;
+  toBaseUnitFactor;
+  aliases;
+  exactRatio;
+  constructor(definition) {
+    this.symbol = definition.symbol;
+    this.englishName = definition.englishName;
+    this.localizedName = definition.localizedName;
+    this.pluralEnglish = definition.pluralEnglish;
+    this.pluralSwedish = definition.pluralSwedish;
+    this.toBaseUnitFactor = definition.toBaseUnitFactor;
+    this.aliases = Object.freeze([...definition.aliases ?? []]);
+    this.exactRatio = definition.exactRatio === void 0 ? null : Object.freeze([definition.exactRatio[0], definition.exactRatio[1]]);
+    return new Proxy(this, {
+      set() {
+        throw new TypeError("Measurement units are immutable.");
+      }
+    });
+  }
+  /** Converts a value expressed in this unit into the dimension's base unit. */
+  toBase(value) {
+    if (this.exactRatio === null) return value.times(this.toBaseUnitFactor);
+    return value.times(this.exactRatio[0]).dividedBy(this.exactRatio[1]);
+  }
+  /** Converts a value expressed in the base unit into this unit. */
+  fromBase(baseValue) {
+    if (this.exactRatio === null) return baseValue.dividedBy(this.toBaseUnitFactor);
+    return baseValue.times(this.exactRatio[1]).dividedBy(this.exactRatio[0]);
+  }
+  toString() {
+    return this.symbol;
+  }
+}
+class MeasurementUnitIndex {
+  all;
+  baseUnit;
+  naturalScale;
+  symbolsExcludedFromIndex;
+  index;
+  ownedUnits;
+  constructor(all, baseUnit, naturalScale, symbolsExcludedFromIndex = []) {
+    this.all = Object.freeze([...all]);
+    this.baseUnit = baseUnit;
+    this.naturalScale = Object.freeze([...naturalScale]);
+    this.symbolsExcludedFromIndex = Object.freeze([...symbolsExcludedFromIndex]);
+    this.ownedUnits = new Set(this.all);
+    this.index = this.buildSymbolIndex();
+    for (const unit of this.all) Object.freeze(unit);
+  }
+  assertOwns(unit) {
+    if (!this.ownedUnits.has(unit)) throw new RangeError("Unit belongs to another dimension.");
+  }
+  /**
+   * Matches on symbol, English and Swedish names, plurals and aliases. Earlier
+   * units win a collision, mirroring the `TryAdd` order in .NET.
+   */
+  tryParse(input) {
+    if (input == null) return null;
+    const trimmed = input.trim();
+    if (trimmed.length === 0) return null;
+    return this.index.get(foldForUnitLookup(trimmed)) ?? null;
+  }
+  /**
+   * Picks the largest unit on the natural scale where the magnitude is still at
+   * least one, so 1500 meters displays as `1.5 km`.
+   */
+  getNatural(baseValue) {
+    const magnitude = baseValue.abs();
+    let result = this.naturalScale[0] ?? this.baseUnit;
+    for (let i = 1; i < this.naturalScale.length; i++) {
+      const candidate = this.naturalScale[i];
+      if (candidate === void 0) break;
+      if (magnitude.dividedBy(candidate.toBaseUnitFactor).compareTo(import_decimal.Decimal.one) >= 0) {
+        result = candidate;
+      } else break;
+    }
+    return result;
+  }
+  buildSymbolIndex() {
+    const index = /* @__PURE__ */ new Map();
+    const add = (key, unit) => {
+      const normalized = foldForUnitLookup(key);
+      if (normalized.length > 0 && !index.has(normalized)) index.set(normalized, unit);
+    };
+    for (const unit of this.all) {
+      if (!this.symbolsExcludedFromIndex.includes(unit)) add(unit.symbol, unit);
+      add(unit.englishName, unit);
+      add(unit.localizedName, unit);
+      add(unit.pluralEnglish, unit);
+      add(unit.pluralSwedish, unit);
+      for (const alias of unit.aliases) add(alias, unit);
+    }
+    return index;
+  }
+}
+function foldForUnitLookup(key) {
+  return key.toUpperCase();
+}
+//# sourceMappingURL=measurement-unit.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/measurement-unit.ts"],
+  "sourcesContent": ["/**\n * Shared machinery for the `Measurement` unit classes (`LengthUnit`,\n * `PowerUnit`, and the rest).\n *\n * In .NET each of these is a hand-written class repeating the same symbol\n * index, natural-scale walk and lookup. Repetition is free there; here it would\n * be bytes shipped to a browser for all nineteen dimensions, so the shared part\n * lives once and each public unit class supplies only its table.\n *\n * Internal; not re-exported publicly.\n */\n\nimport { Decimal } from \"./decimal.js\";\n\n/** The fields every unit in a dimension carries. */\nexport interface MeasurementUnitDefinition {\n  readonly symbol: string;\n  readonly englishName: string;\n  readonly localizedName: string;\n  readonly pluralEnglish: string;\n  readonly pluralSwedish: string;\n  /** Multiply a value in this unit by this factor to reach the base unit. */\n  readonly toBaseUnitFactor: Decimal;\n  /**\n   * Exact conversion as a `[numerator, denominator]` pair, for units whose\n   * factor is a repeating decimal \u2014 1/60 for rpm, 1/3600 for coulomb, 1000/3600\n   * for km/h. Multiplying by the rounded factor and dividing by it are not\n   * inverses, so both directions go through the ratio instead. .NET\n   * special-cases exactly these units for the same reason.\n   */\n  readonly exactRatio?: readonly [numerator: Decimal, denominator: Decimal];\n  readonly aliases?: readonly string[];\n}\n\nexport class MeasurementUnit {\n  readonly symbol: string;\n  readonly englishName: string;\n  readonly localizedName: string;\n  readonly pluralEnglish: string;\n  readonly pluralSwedish: string;\n  readonly toBaseUnitFactor: Decimal;\n  readonly aliases: readonly string[];\n  private readonly exactRatio: readonly [Decimal, Decimal] | null;\n\n  protected constructor(definition: MeasurementUnitDefinition) {\n    this.symbol = definition.symbol;\n    this.englishName = definition.englishName;\n    this.localizedName = definition.localizedName;\n    this.pluralEnglish = definition.pluralEnglish;\n    this.pluralSwedish = definition.pluralSwedish;\n    this.toBaseUnitFactor = definition.toBaseUnitFactor;\n    this.aliases = Object.freeze([...(definition.aliases ?? [])]);\n    this.exactRatio =\n      definition.exactRatio === undefined\n        ? null\n        : Object.freeze([definition.exactRatio[0], definition.exactRatio[1]]);\n\n    return new Proxy(this, {\n      set() {\n        throw new TypeError(\"Measurement units are immutable.\");\n      },\n    });\n  }\n\n  /** Converts a value expressed in this unit into the dimension's base unit. */\n  toBase(value: Decimal): Decimal {\n    if (this.exactRatio === null) return value.times(this.toBaseUnitFactor);\n    return value.times(this.exactRatio[0]).dividedBy(this.exactRatio[1]);\n  }\n\n  /** Converts a value expressed in the base unit into this unit. */\n  fromBase(baseValue: Decimal): Decimal {\n    if (this.exactRatio === null) return baseValue.dividedBy(this.toBaseUnitFactor);\n    return baseValue.times(this.exactRatio[1]).dividedBy(this.exactRatio[0]);\n  }\n\n  toString(): string {\n    return this.symbol;\n  }\n}\n\n/**\n * Case-insensitive lookup over a dimension's units plus the natural-scale walk\n * used for display.\n */\nexport class MeasurementUnitIndex<TUnit extends MeasurementUnit> {\n  readonly all: readonly TUnit[];\n  readonly baseUnit: TUnit;\n  readonly naturalScale: readonly TUnit[];\n  private readonly symbolsExcludedFromIndex: readonly TUnit[];\n  private readonly index: ReadonlyMap<string, TUnit>;\n  private readonly ownedUnits: ReadonlySet<MeasurementUnit>;\n\n  constructor(\n    all: readonly TUnit[],\n    baseUnit: TUnit,\n    /** Metric units ordered small to large, used to auto-scale display. */\n    naturalScale: readonly TUnit[],\n    /**\n     * Units whose symbol is deliberately left out of the index because it\n     * collides case-insensitively with another unit's \u2014 `mW` against `MW`. The\n     * owning class resolves those itself.\n     */\n    symbolsExcludedFromIndex: readonly TUnit[] = [],\n  ) {\n    this.all = Object.freeze([...all]);\n    this.baseUnit = baseUnit;\n    this.naturalScale = Object.freeze([...naturalScale]);\n    this.symbolsExcludedFromIndex = Object.freeze([...symbolsExcludedFromIndex]);\n    this.ownedUnits = new Set(this.all);\n    this.index = this.buildSymbolIndex();\n\n    for (const unit of this.all) Object.freeze(unit);\n  }\n\n  assertOwns(unit: MeasurementUnit): asserts unit is TUnit {\n    if (!this.ownedUnits.has(unit)) throw new RangeError(\"Unit belongs to another dimension.\");\n  }\n\n  /**\n   * Matches on symbol, English and Swedish names, plurals and aliases. Earlier\n   * units win a collision, mirroring the `TryAdd` order in .NET.\n   */\n  tryParse(input: string | null | undefined): TUnit | null {\n    if (input == null) return null;\n    const trimmed = input.trim();\n    if (trimmed.length === 0) return null;\n    return this.index.get(foldForUnitLookup(trimmed)) ?? null;\n  }\n\n  /**\n   * Picks the largest unit on the natural scale where the magnitude is still at\n   * least one, so 1500 meters displays as `1.5 km`.\n   */\n  getNatural(baseValue: Decimal): TUnit {\n    const magnitude = baseValue.abs();\n    let result = this.naturalScale[0] ?? this.baseUnit;\n\n    for (let i = 1; i < this.naturalScale.length; i++) {\n      const candidate = this.naturalScale[i];\n      if (candidate === undefined) break;\n      if (magnitude.dividedBy(candidate.toBaseUnitFactor).compareTo(Decimal.one) >= 0) {\n        result = candidate;\n      } else break;\n    }\n\n    return result;\n  }\n\n  private buildSymbolIndex(): ReadonlyMap<string, TUnit> {\n    const index = new Map<string, TUnit>();\n    const add = (key: string, unit: TUnit): void => {\n      const normalized = foldForUnitLookup(key);\n      if (normalized.length > 0 && !index.has(normalized)) index.set(normalized, unit);\n    };\n\n    for (const unit of this.all) {\n      if (!this.symbolsExcludedFromIndex.includes(unit)) add(unit.symbol, unit);\n      add(unit.englishName, unit);\n      add(unit.localizedName, unit);\n      add(unit.pluralEnglish, unit);\n      add(unit.pluralSwedish, unit);\n      for (const alias of unit.aliases) add(alias, unit);\n    }\n\n    return index;\n  }\n}\n\n/**\n * Case-folds a lookup key the way .NET's `StringComparer.OrdinalIgnoreCase`\n * does, by upper-casing. Lower-casing would not do: the micro sign `\u00B5` and the\n * Greek capital mu `\u039C` fold together going up but not going down, so `\u039CW` would\n * stop resolving to microwatt.\n */\nexport function foldForUnitLookup(key: string): string {\n  return key.toUpperCase();\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/internal/quantity.js

@@ -0,0 +1,122 @@
+"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 quantity_exports = {};
+__export(quantity_exports, {
+  Quantity: () => Quantity,
+  formatQuantityDecimal: () => formatQuantityDecimal,
+  tryParseQuantity: () => tryParseQuantity
+});
+module.exports = __toCommonJS(quantity_exports);
+var import_decimal = require("./decimal.js");
+var import_measurement_unit_parser = require("./measurement-unit-parser.js");
+function formatQuantityDecimal(value, decimals) {
+  const rounded = decimals === void 0 ? value : value.round(decimals, "away-from-zero");
+  return rounded.toTrimmedString();
+}
+class Quantity {
+  constructor(baseValue, originalUnit) {
+    this.baseValue = baseValue;
+    this.originalUnit = originalUnit;
+  }
+  baseValue;
+  originalUnit;
+  /** The exact value converted to `unit`. */
+  inDecimal(unit) {
+    const units = this.units;
+    units.assertOwns(unit);
+    return unit.fromBase(this.baseValue);
+  }
+  /** The value converted to `unit`, as a `number` for ergonomic access. */
+  in(unit) {
+    return this.inDecimal(unit).toNumber();
+  }
+  /** The most human-readable unit on this dimension's natural scale. */
+  get naturalUnit() {
+    return this.units.getNatural(this.baseValue);
+  }
+  /** The value in the base unit, e.g. `10000 m`. */
+  toNormalizedString() {
+    return `${formatQuantityDecimal(this.baseValue)} ${this.units.baseUnit.symbol}`;
+  }
+  /** The value in the unit it was parsed from, e.g. `10 km`. */
+  toString() {
+    return `${formatQuantityDecimal(this.inDecimal(this.originalUnit))} ${this.originalUnit.symbol}`;
+  }
+  /** The value converted to `unit`, e.g. `0.01 km`. */
+  toStringInUnit(unit, decimals) {
+    return `${formatQuantityDecimal(this.inDecimal(unit), decimals)} ${unit.symbol}`;
+  }
+  /** The value in the most readable unit, e.g. `1.5 km` rather than `1500 m`. */
+  toNaturalString(decimals) {
+    return this.toStringInUnit(this.naturalUnit, decimals);
+  }
+  // TypeScript has no operator overloading, so the C# `+ - * /` become methods.
+  plus(other) {
+    this.assertSameDimension(other);
+    return this.withBaseValue(this.baseValue.plus(other.baseValue), this.originalUnit);
+  }
+  minus(other) {
+    this.assertSameDimension(other);
+    return this.withBaseValue(this.baseValue.minus(other.baseValue), this.originalUnit);
+  }
+  times(factor) {
+    return this.withBaseValue(this.baseValue.times(toDecimal(factor)), this.originalUnit);
+  }
+  dividedBy(divisor) {
+    return this.withBaseValue(this.baseValue.dividedBy(toDecimal(divisor)), this.originalUnit);
+  }
+  negated() {
+    return this.withBaseValue(this.baseValue.negated(), this.originalUnit);
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    this.assertSameDimension(other);
+    return this.baseValue.compareTo(other.baseValue);
+  }
+  equals(other) {
+    return other != null && this.units === other.units && this.baseValue.equals(other.baseValue);
+  }
+  isLessThan(other) {
+    return this.compareTo(other) < 0;
+  }
+  isGreaterThan(other) {
+    return this.compareTo(other) > 0;
+  }
+  assertSameDimension(other) {
+    if (this.units !== other.units) throw new RangeError("Quantity belongs to another dimension.");
+  }
+}
+function toDecimal(value) {
+  if (value instanceof import_decimal.Decimal) return value;
+  const parsed = import_decimal.Decimal.fromNumber(value);
+  if (parsed === null) throw new RangeError(`Scalar cannot be represented as a decimal: ${value}`);
+  return parsed;
+}
+function tryParseQuantity(input, units, resolveUnit) {
+  const split = (0, import_measurement_unit_parser.trySplitMeasurement)(input);
+  if (split === null) return null;
+  const unit = resolveUnit ? resolveUnit(split.unitSuffix) : units.tryParse(split.unitSuffix);
+  if (unit === null) return null;
+  try {
+    return { baseValue: unit.toBase(split.value), unit };
+  } catch {
+    return null;
+  }
+}
+//# sourceMappingURL=quantity.js.map

package/dist/cjs/internal/quantity.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/quantity.ts"],
+  "sourcesContent": ["/**\n * Shared behaviour for the `Measurement` quantity types (`Length`, `Power`,\n * `Weight`, and the rest).\n *\n * Each of those is ~230 near-identical lines in .NET. Here the common half \u2014\n * parsing, conversion, formatting, comparison and arithmetic \u2014 lives once, and\n * a public type supplies its unit table plus the named accessors that make its\n * API readable.\n *\n * The value is held in the base unit as an exact {@link Decimal}. Converting\n * only at the formatting boundary is what keeps `normalize()` byte-identical to\n * .NET; see the note at the top of `decimal.ts`.\n *\n * Internal; not re-exported publicly.\n */\n\nimport { Decimal } from \"./decimal.js\";\nimport { trySplitMeasurement } from \"./measurement-unit-parser.js\";\nimport type { MeasurementUnit, MeasurementUnitIndex } from \"./measurement-unit.js\";\n\n/** Options shared by the `format` static on every quantity type. */\nexport interface QuantityFormatOptions<TUnit extends MeasurementUnit> {\n  fallbackToTrimmedInputWhenInvalid?: boolean;\n  /** Convert to this unit instead of preserving the parsed one. */\n  unit?: TUnit;\n  /** Round to this many fractional digits, away from zero. */\n  decimals?: number;\n}\n\n/**\n * Renders a value the way .NET's private `FormatDecimal` does: optionally\n * rounded away from zero, then stripped of trailing fractional zeros.\n */\nexport function formatQuantityDecimal(value: Decimal, decimals?: number): string {\n  const rounded = decimals === undefined ? value : value.round(decimals, \"away-from-zero\");\n  return rounded.toTrimmedString();\n}\n\nexport abstract class Quantity<TUnit extends MeasurementUnit> {\n  protected constructor(\n    /** The value expressed in the dimension's base unit. */\n    protected readonly baseValue: Decimal,\n    /** The unit the value was originally parsed from. */\n    readonly originalUnit: TUnit,\n  ) {}\n\n  /** The unit index for this dimension, supplied by the concrete type. */\n  protected abstract get units(): MeasurementUnitIndex<TUnit>;\n\n  /** Builds another instance of the concrete type, used by the arithmetic. */\n  protected abstract withBaseValue(baseValue: Decimal, unit: TUnit): this;\n\n  /** The exact value converted to `unit`. */\n  inDecimal(unit: TUnit): Decimal {\n    const units: MeasurementUnitIndex<TUnit> = this.units;\n    units.assertOwns(unit);\n    return unit.fromBase(this.baseValue);\n  }\n\n  /** The value converted to `unit`, as a `number` for ergonomic access. */\n  in(unit: TUnit): number {\n    return this.inDecimal(unit).toNumber();\n  }\n\n  /** The most human-readable unit on this dimension's natural scale. */\n  get naturalUnit(): TUnit {\n    return this.units.getNatural(this.baseValue);\n  }\n\n  /** The value in the base unit, e.g. `10000 m`. */\n  toNormalizedString(): string {\n    return `${formatQuantityDecimal(this.baseValue)} ${this.units.baseUnit.symbol}`;\n  }\n\n  /** The value in the unit it was parsed from, e.g. `10 km`. */\n  toString(): string {\n    return `${formatQuantityDecimal(this.inDecimal(this.originalUnit))} ${this.originalUnit.symbol}`;\n  }\n\n  /** The value converted to `unit`, e.g. `0.01 km`. */\n  toStringInUnit(unit: TUnit, decimals?: number): string {\n    return `${formatQuantityDecimal(this.inDecimal(unit), decimals)} ${unit.symbol}`;\n  }\n\n  /** The value in the most readable unit, e.g. `1.5 km` rather than `1500 m`. */\n  toNaturalString(decimals?: number): string {\n    return this.toStringInUnit(this.naturalUnit, decimals);\n  }\n\n  // TypeScript has no operator overloading, so the C# `+ - * /` become methods.\n\n  plus(other: Quantity<TUnit>): this {\n    this.assertSameDimension(other);\n    return this.withBaseValue(this.baseValue.plus(other.baseValue), this.originalUnit);\n  }\n\n  minus(other: Quantity<TUnit>): this {\n    this.assertSameDimension(other);\n    return this.withBaseValue(this.baseValue.minus(other.baseValue), this.originalUnit);\n  }\n\n  times(factor: number | Decimal): this {\n    return this.withBaseValue(this.baseValue.times(toDecimal(factor)), this.originalUnit);\n  }\n\n  dividedBy(divisor: number | Decimal): this {\n    return this.withBaseValue(this.baseValue.dividedBy(toDecimal(divisor)), this.originalUnit);\n  }\n\n  negated(): this {\n    return this.withBaseValue(this.baseValue.negated(), this.originalUnit);\n  }\n\n  compareTo(other: Quantity<TUnit> | null | undefined): number {\n    if (other == null) return 1;\n    this.assertSameDimension(other);\n    return this.baseValue.compareTo(other.baseValue);\n  }\n\n  equals(other: Quantity<TUnit> | null | undefined): boolean {\n    return other != null && this.units === other.units && this.baseValue.equals(other.baseValue);\n  }\n\n  isLessThan(other: Quantity<TUnit>): boolean {\n    return this.compareTo(other) < 0;\n  }\n\n  isGreaterThan(other: Quantity<TUnit>): boolean {\n    return this.compareTo(other) > 0;\n  }\n\n  private assertSameDimension(other: Quantity<TUnit>): void {\n    if (this.units !== other.units) throw new RangeError(\"Quantity belongs to another dimension.\");\n  }\n}\n\nfunction toDecimal(value: number | Decimal): Decimal {\n  if (value instanceof Decimal) return value;\n  const parsed = Decimal.fromNumber(value);\n  if (parsed === null) throw new RangeError(`Scalar cannot be represented as a decimal: ${value}`);\n  return parsed;\n}\n\n/**\n * The shared body of every quantity's `tryParse`: split off the unit suffix,\n * resolve it against the dimension's index, and scale into the base unit.\n *\n * Returns the exact base value and the unit it came from, or `null` when the\n * input is not a measurement in this dimension. Overflow is reported as `null`\n * rather than thrown, matching the .NET types which swallow `OverflowException`\n * inside `TryParse`.\n */\nexport function tryParseQuantity<TUnit extends MeasurementUnit>(\n  input: string | null | undefined,\n  units: MeasurementUnitIndex<TUnit>,\n  resolveUnit?: (suffix: string) => TUnit | null,\n): { baseValue: Decimal; unit: TUnit } | null {\n  const split = trySplitMeasurement(input);\n  if (split === null) return null;\n\n  const unit = resolveUnit ? resolveUnit(split.unitSuffix) : units.tryParse(split.unitSuffix);\n  if (unit === null) return null;\n\n  try {\n    return { baseValue: unit.toBase(split.value), unit };\n  } catch {\n    return null;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/internal/shoe-size-format.js

@@ -0,0 +1,31 @@
+"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 shoe_size_format_exports = {};
+__export(shoe_size_format_exports, {
+  formatEuShoeSize: () => formatEuShoeSize,
+  formatShoeNumber: () => formatShoeNumber
+});
+module.exports = __toCommonJS(shoe_size_format_exports);
+function formatEuShoeSize(euSize) {
+  return `EU ${formatShoeNumber(euSize)}`;
+}
+function formatShoeNumber(size) {
+  return Number.isInteger(size) ? String(Math.trunc(size)) : size.toFixed(1);
+}
+//# sourceMappingURL=shoe-size-format.js.map

package/dist/cjs/internal/shoe-size-format.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/shoe-size-format.ts"],
+  "sourcesContent": ["/** Renders a shoe size as `EU 42` for whole sizes and `EU 42.5` for half sizes. */\nexport function formatEuShoeSize(euSize: number): string {\n  return `EU ${formatShoeNumber(euSize)}`;\n}\n\n/** Renders a shoe size number with one decimal only when it has a fractional part. */\nexport function formatShoeNumber(size: number): string {\n  return Number.isInteger(size) ? String(Math.trunc(size)) : size.toFixed(1);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACO,SAAS,iBAAiB,QAAwB;AACvD,SAAO,MAAM,iBAAiB,MAAM,CAAC;AACvC;AAGO,SAAS,iBAAiB,MAAsB;AACrD,SAAO,OAAO,UAAU,IAAI,IAAI,OAAO,KAAK,MAAM,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC;AAC3E;",
+  "names": []
+}

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

@@ -0,0 +1,158 @@
+"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 area_unit_exports = {};
+__export(area_unit_exports, {
+  AreaUnit: () => AreaUnit
+});
+module.exports = __toCommonJS(area_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 AreaUnit extends import_measurement_unit.MeasurementUnit {
+  static typeInfo = Object.freeze({
+    englishName: "Area Unit",
+    localizedName: "Ytenhet",
+    emoji: "\u{1F4D0}",
+    sources: Object.freeze([])
+  });
+  static SquareMillimeter = new AreaUnit({
+    symbol: "mm\xB2",
+    englishName: "square millimeter",
+    localizedName: "kvadratmillimeter",
+    pluralEnglish: "square millimeters",
+    pluralSwedish: "kvadratmillimeter",
+    toBaseUnitFactor: factor("0.000001"),
+    aliases: ["mm2", "sq mm", "square millimetre", "square millimetres"]
+  });
+  static SquareCentimeter = new AreaUnit({
+    symbol: "cm\xB2",
+    englishName: "square centimeter",
+    localizedName: "kvadratcentimeter",
+    pluralEnglish: "square centimeters",
+    pluralSwedish: "kvadratcentimeter",
+    toBaseUnitFactor: factor("0.0001"),
+    aliases: ["cm2", "sq cm", "square centimetre", "square centimetres"]
+  });
+  static SquareMeter = new AreaUnit({
+    symbol: "m\xB2",
+    englishName: "square meter",
+    localizedName: "kvadratmeter",
+    pluralEnglish: "square meters",
+    pluralSwedish: "kvadratmeter",
+    toBaseUnitFactor: factor("1"),
+    aliases: ["m2", "sq m", "sqm", "square metre", "square metres"]
+  });
+  static SquareKilometer = new AreaUnit({
+    symbol: "km\xB2",
+    englishName: "square kilometer",
+    localizedName: "kvadratkilometer",
+    pluralEnglish: "square kilometers",
+    pluralSwedish: "kvadratkilometer",
+    toBaseUnitFactor: factor("1000000"),
+    aliases: ["km2", "sq km", "square kilometre", "square kilometres"]
+  });
+  static Hectare = new AreaUnit({
+    symbol: "ha",
+    englishName: "hectare",
+    localizedName: "hektar",
+    pluralEnglish: "hectares",
+    pluralSwedish: "hektar",
+    toBaseUnitFactor: factor("10000")
+  });
+  static Acre = new AreaUnit({
+    symbol: "acre",
+    englishName: "acre",
+    localizedName: "acre",
+    pluralEnglish: "acres",
+    pluralSwedish: "acre",
+    toBaseUnitFactor: factor("4046.8564224")
+  });
+  static SquareFoot = new AreaUnit({
+    symbol: "sq ft",
+    englishName: "square foot",
+    localizedName: "kvadratfot",
+    pluralEnglish: "square feet",
+    pluralSwedish: "kvadratfot",
+    toBaseUnitFactor: factor("0.09290304"),
+    aliases: ["sqft", "square feet", "square foot"]
+  });
+  static SquareInch = new AreaUnit({
+    symbol: "sq in",
+    englishName: "square inch",
+    localizedName: "kvadrattum",
+    pluralEnglish: "square inches",
+    pluralSwedish: "kvadrattum",
+    toBaseUnitFactor: factor("0.00064516"),
+    aliases: ["sqin", "square inches", "square inch"]
+  });
+  static SquareYard = new AreaUnit({
+    symbol: "sq yd",
+    englishName: "square yard",
+    localizedName: "kvadratyard",
+    pluralEnglish: "square yards",
+    pluralSwedish: "kvadratyard",
+    toBaseUnitFactor: factor("0.83612736"),
+    aliases: ["sqyd", "square yards", "square yard"]
+  });
+  /** @internal Shared lookup and natural-scale walk. */
+  static index = new import_measurement_unit.MeasurementUnitIndex(
+    [
+      AreaUnit.SquareMillimeter,
+      AreaUnit.SquareCentimeter,
+      AreaUnit.SquareMeter,
+      AreaUnit.SquareKilometer,
+      AreaUnit.Hectare,
+      AreaUnit.Acre,
+      AreaUnit.SquareFoot,
+      AreaUnit.SquareInch,
+      AreaUnit.SquareYard
+    ],
+    AreaUnit.SquareMeter,
+    [AreaUnit.SquareCentimeter, AreaUnit.SquareMeter, AreaUnit.Hectare, AreaUnit.SquareKilometer]
+  );
+  static get all() {
+    return AreaUnit.index.all;
+  }
+  /** The base unit: m². */
+  static get baseUnit() {
+    return AreaUnit.index.baseUnit;
+  }
+  /** Units ordered small to large, used to auto-scale display. */
+  static get naturalScale() {
+    return AreaUnit.index.naturalScale;
+  }
+  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+  static tryParse(input) {
+    return AreaUnit.index.tryParse(input);
+  }
+  static parse(input) {
+    const result = AreaUnit.tryParse(input);
+    if (result === null) throw new Error("Unknown area unit.");
+    return result;
+  }
+  /** Returns the most human-readable unit for a value in m². */
+  static getNatural(baseValue) {
+    return AreaUnit.index.getNatural(baseValue);
+  }
+}
+//# sourceMappingURL=area-unit.js.map