@budiauktioner/buildi-primitives 0.1.0 → 0.2.0

package/dist/esm/internal/decimal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/decimal.ts"],
+  "sourcesContent": ["/**\n * Exact base-10 arithmetic matching the observable semantics of .NET\n * `System.Decimal`, which is what every `Measurement` quantity in\n * `Buildi.Primitives` stores its value as.\n *\n * A binary `number` cannot stand in here. Unit conversion multiplies by exact\n * decimal factors, and the result is what `normalize()` writes out as the\n * canonical storage form:\n *\n * ```text\n * 3 ft -> meters      number: 0.9144000000000001      decimal: 0.9144\n * ```\n *\n * Since `isNormalized(input)` is defined as `input === normalize(input)`, that\n * drift would break the contract the package is built around, and would fail\n * the parity vectors ported from the .NET test suite.\n *\n * A value is `units / 10 ** scale`. Both the 96-bit magnitude limit and the\n * maximum scale of 28 are reproduced so that inputs .NET rejects as overflow\n * are rejected here too.\n *\n * Equivalent of .NET `System.Decimal`. Internal; not re-exported publicly.\n */\n\n/** Largest number of fractional digits a .NET decimal can carry. */\nconst MAX_SCALE = 28;\n\n/** 2^96 - 1 \u2014 the largest unscaled magnitude, i.e. `decimal.MaxValue`. */\nconst MAX_UNSCALED = (1n << 96n) - 1n;\n\n/**\n * How to break a tie when discarding digits.\n *\n * .NET uses `HalfEven` for arithmetic (verified: `1m / 536870912m` yields\n * `0.0000000018626451492309570312`, keeping the even `2` where away-from-zero\n * would produce `3`), while `Math.Round(x, n, MidpointRounding.AwayFromZero)`\n * is what the quantity formatters ask for explicitly.\n */\nexport type RoundingMode = \"half-even\" | \"away-from-zero\";\n\nconst POW10_CACHE: bigint[] = [];\n\nfunction pow10(exponent: number): bigint {\n  if (exponent < 0) throw new RangeError(\"Negative power of ten.\");\n  const cached = POW10_CACHE[exponent];\n  if (cached !== undefined) return cached;\n  let value = 1n;\n  for (let i = 0; i < exponent; i++) value *= 10n;\n  POW10_CACHE[exponent] = value;\n  return value;\n}\n\nfunction absBigInt(value: bigint): bigint {\n  return value < 0n ? -value : value;\n}\n\n/** Divides and rounds in one step, keeping the sign out of the tie logic. */\nfunction divideRounded(numerator: bigint, denominator: bigint, mode: RoundingMode): bigint {\n  let n = numerator;\n  let d = denominator;\n  if (d < 0n) {\n    n = -n;\n    d = -d;\n  }\n\n  const negative = n < 0n;\n  const magnitude = negative ? -n : n;\n\n  let quotient = magnitude / d;\n  const doubledRemainder = (magnitude % d) * 2n;\n\n  if (doubledRemainder > d) {\n    quotient += 1n;\n  } else if (doubledRemainder === d) {\n    if (mode === \"away-from-zero\" || quotient % 2n === 1n) quotient += 1n;\n  }\n\n  return negative ? -quotient : quotient;\n}\n\n/** Thrown when a result cannot be represented, mirroring .NET `OverflowException`. */\nexport class DecimalOverflowError extends Error {\n  constructor() {\n    super(\"Decimal overflow.\");\n    this.name = \"DecimalOverflowError\";\n  }\n}\n\n/** Thrown by division by zero, mirroring .NET `DivideByZeroException`. */\nexport class DecimalDivisionByZeroError extends Error {\n  constructor() {\n    super(\"Decimal division by zero.\");\n    this.name = \"DecimalDivisionByZeroError\";\n  }\n}\n\nconst DECIMAL_PATTERN = /^[+-]?(?:\\d+)(?:\\.\\d+)?$/;\n\nexport class Decimal {\n  static readonly zero = new Decimal(0n, 0);\n  static readonly one = new Decimal(1n, 0);\n\n  private constructor(\n    private readonly units: bigint,\n    private readonly scale: number,\n  ) {}\n\n  /**\n   * Drops scale until the value fits in 96 bits and 28 fractional digits.\n   *\n   * .NET reduces precision before it gives up, which is why `1e-16 * 1e-16`\n   * yields a scale-28 zero rather than throwing.\n   */\n  private static fit(units: bigint, scale: number, mode: RoundingMode): Decimal {\n    let u = units;\n    let s = scale;\n    while (s > MAX_SCALE || absBigInt(u) > MAX_UNSCALED) {\n      if (s === 0) throw new DecimalOverflowError();\n      let dropped = Math.max(1, s - MAX_SCALE);\n      let rounded = divideRounded(u, pow10(dropped), mode);\n      while (absBigInt(rounded) > MAX_UNSCALED && dropped < s) {\n        dropped += 1;\n        rounded = divideRounded(u, pow10(dropped), mode);\n      }\n      u = rounded;\n      s -= dropped;\n    }\n    return new Decimal(u, s);\n  }\n\n  /** Builds a value from an integer. Throws if it does not fit. */\n  static fromBigInt(value: bigint): Decimal {\n    if (absBigInt(value) > MAX_UNSCALED) throw new DecimalOverflowError();\n    return new Decimal(value, 0);\n  }\n\n  /**\n   * Parses a plain decimal literal such as `-12.750`. Trailing zeros are\n   * significant and preserved, as in .NET. Exponent notation is not accepted.\n   * Returns `null` when the input is malformed or too large.\n   */\n  static parse(input: string): Decimal | null {\n    if (!DECIMAL_PATTERN.test(input)) return null;\n\n    const negative = input.startsWith(\"-\");\n    const unsigned = input.startsWith(\"+\") || negative ? input.slice(1) : input;\n\n    const pointIndex = unsigned.indexOf(\".\");\n    const integerDigits = pointIndex < 0 ? unsigned : unsigned.slice(0, pointIndex);\n    const fractionDigits = pointIndex < 0 ? \"\" : unsigned.slice(pointIndex + 1);\n\n    let units = BigInt(integerDigits + fractionDigits);\n    if (negative) units = -units;\n\n    try {\n      return Decimal.fit(units, fractionDigits.length, \"half-even\");\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Converts a `number`, expanding the exponent notation JavaScript uses for\n   * very large and very small magnitudes so that `1e-7` parses as\n   * `0.0000001`. Returns `null` for non-finite input or a magnitude outside the\n   * representable range.\n   */\n  static fromNumber(value: number): Decimal | null {\n    if (!Number.isFinite(value)) return null;\n\n    const rendered = String(value);\n    const exponentIndex = rendered.search(/[eE]/u);\n    if (exponentIndex < 0) return Decimal.parse(rendered);\n\n    const exponent = Number(rendered.slice(exponentIndex + 1));\n    const mantissa = rendered.slice(0, exponentIndex);\n    const negative = mantissa.startsWith(\"-\");\n    const unsigned = negative ? mantissa.slice(1) : mantissa;\n\n    const pointIndex = unsigned.indexOf(\".\");\n    const digits = pointIndex < 0 ? unsigned : unsigned.replace(\".\", \"\");\n    const pointPosition = (pointIndex < 0 ? unsigned.length : pointIndex) + exponent;\n\n    let expanded: string;\n    if (pointPosition <= 0) expanded = `0.${\"0\".repeat(-pointPosition)}${digits}`;\n    else if (pointPosition >= digits.length)\n      expanded = digits + \"0\".repeat(pointPosition - digits.length);\n    else expanded = `${digits.slice(0, pointPosition)}.${digits.slice(pointPosition)}`;\n\n    return Decimal.parse(negative ? `-${expanded}` : expanded);\n  }\n\n  get isZero(): boolean {\n    return this.units === 0n;\n  }\n\n  get isNegative(): boolean {\n    return this.units < 0n;\n  }\n\n  plus(other: Decimal): Decimal {\n    const scale = Math.max(this.scale, other.scale);\n    const a = this.units * pow10(scale - this.scale);\n    const b = other.units * pow10(scale - other.scale);\n    return Decimal.fit(a + b, scale, \"half-even\");\n  }\n\n  minus(other: Decimal): Decimal {\n    const scale = Math.max(this.scale, other.scale);\n    const a = this.units * pow10(scale - this.scale);\n    const b = other.units * pow10(scale - other.scale);\n    return Decimal.fit(a - b, scale, \"half-even\");\n  }\n\n  /** Scales add, as in .NET: `1.0 * 1.0` is `1.00`. */\n  times(other: Decimal): Decimal {\n    return Decimal.fit(this.units * other.units, this.scale + other.scale, \"half-even\");\n  }\n\n  /**\n   * Divides at the highest precision that still fits, which is how .NET arrives\n   * at `1m / 0.0254m === 39.370078740157480314960629921` \u2014 27 fractional\n   * digits, because 28 would not fit in 96 bits.\n   *\n   * Unlike the other operations, division discards trailing zeros down to a\n   * preferred scale of `dividend scale - divisor scale`. That is what makes\n   * `536870912m / 2.5m` come out as `214748364.8` while `1.00m / 2m` keeps both\n   * digits as `0.50`.\n   */\n  dividedBy(other: Decimal): Decimal {\n    if (other.units === 0n) throw new DecimalDivisionByZeroError();\n\n    const preferredScale = Math.max(0, this.scale - other.scale);\n\n    for (let target = MAX_SCALE; target >= 0; target--) {\n      const shift = target - this.scale + other.scale;\n      let numerator = this.units;\n      let denominator = other.units;\n      if (shift >= 0) numerator *= pow10(shift);\n      else denominator *= pow10(-shift);\n\n      let quotient = divideRounded(numerator, denominator, \"half-even\");\n      if (absBigInt(quotient) > MAX_UNSCALED) continue;\n\n      // A quotient that underflows to zero loses its scale entirely rather\n      // than honouring the preferred scale.\n      const floorScale = quotient === 0n ? 0 : preferredScale;\n\n      let scale = target;\n      while (scale > floorScale && quotient % 10n === 0n) {\n        quotient /= 10n;\n        scale -= 1;\n      }\n      return new Decimal(quotient, scale);\n    }\n\n    throw new DecimalOverflowError();\n  }\n\n  negated(): Decimal {\n    return new Decimal(-this.units, this.scale);\n  }\n\n  abs(): Decimal {\n    return this.units < 0n ? this.negated() : this;\n  }\n\n  /**\n   * Rounds to `decimals` fractional digits. Asking for more digits than the\n   * value carries leaves it untouched, matching .NET `Math.Round`.\n   */\n  round(decimals: number, mode: RoundingMode = \"half-even\"): Decimal {\n    if (!Number.isInteger(decimals) || decimals < 0 || decimals > MAX_SCALE) {\n      throw new RangeError(`Decimals must be an integer from 0 through ${MAX_SCALE}.`);\n    }\n    if (decimals >= this.scale) return this;\n    const dropped = this.scale - decimals;\n    return new Decimal(divideRounded(this.units, pow10(dropped), mode), decimals);\n  }\n\n  /** Compares by value; scale is ignored, so `1.0` and `1.00` are equal. */\n  compareTo(other: Decimal): number {\n    const scale = Math.max(this.scale, other.scale);\n    const a = this.units * pow10(scale - this.scale);\n    const b = other.units * pow10(scale - other.scale);\n    return a < b ? -1 : a > b ? 1 : 0;\n  }\n\n  equals(other: Decimal): boolean {\n    return this.compareTo(other) === 0;\n  }\n\n  /** Renders with trailing zeros intact, as .NET does. */\n  toString(): string {\n    const negative = this.units < 0n;\n    const digits = absBigInt(this.units).toString();\n\n    if (this.scale === 0) return negative ? `-${digits}` : digits;\n\n    const padded = digits.padStart(this.scale + 1, \"0\");\n    const split = padded.length - this.scale;\n    const rendered = `${padded.slice(0, split)}.${padded.slice(split)}`;\n    return negative ? `-${rendered}` : rendered;\n  }\n\n  /**\n   * Renders without trailing fractional zeros, e.g. `0.9144` rather than\n   * `0.914400`. This is the form the quantity types display.\n   */\n  toTrimmedString(): string {\n    const rendered = this.toString();\n    if (!rendered.includes(\".\")) return rendered;\n    return rendered.replace(/0+$/, \"\").replace(/\\.$/, \"\");\n  }\n\n  /**\n   * Converts to a binary `number` for ergonomic consumer-facing accessors.\n   * Lossy beyond 17 significant digits \u2014 never round-trip a value through this\n   * on the normalization path.\n   */\n  toNumber(): number {\n    return Number(this.toString());\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/internal/gs1-prefix.js

@@ -0,0 +1,144 @@
+const RANGES = [
+  [0, 19, "USA & Canada", null],
+  [20, 29, "Restricted distribution", null],
+  [30, 39, "USA (drugs)", "US"],
+  [40, 49, "Restricted distribution", null],
+  [50, 59, "Coupons (USA)", null],
+  [60, 99, "USA & Canada", null],
+  [100, 139, "USA", "US"],
+  [200, 299, "Restricted distribution (in-store)", null],
+  [300, 379, "France & Monaco", "FR"],
+  [380, 380, "Bulgaria", "BG"],
+  [383, 383, "Slovenia", "SI"],
+  [385, 385, "Croatia", "HR"],
+  [387, 387, "Bosnia & Herzegovina", "BA"],
+  [389, 389, "Montenegro", "ME"],
+  [390, 390, "Kosovo", "XK"],
+  [400, 440, "Germany", "DE"],
+  [450, 459, "Japan", "JP"],
+  [460, 469, "Russia", "RU"],
+  [470, 470, "Kyrgyzstan", "KG"],
+  [471, 471, "Taiwan", "TW"],
+  [474, 474, "Estonia", "EE"],
+  [475, 475, "Latvia", "LV"],
+  [476, 476, "Azerbaijan", "AZ"],
+  [477, 477, "Lithuania", "LT"],
+  [478, 478, "Uzbekistan", "UZ"],
+  [479, 479, "Sri Lanka", "LK"],
+  [480, 480, "Philippines", "PH"],
+  [481, 481, "Belarus", "BY"],
+  [482, 482, "Ukraine", "UA"],
+  [484, 484, "Moldova", "MD"],
+  [485, 485, "Armenia", "AM"],
+  [486, 486, "Georgia", "GE"],
+  [487, 487, "Kazakhstan", "KZ"],
+  [488, 488, "Tajikistan", "TJ"],
+  [489, 489, "Hong Kong", "HK"],
+  [490, 499, "Japan", "JP"],
+  [500, 509, "United Kingdom", "GB"],
+  [520, 521, "Greece", "GR"],
+  [528, 528, "Lebanon", "LB"],
+  [529, 529, "Cyprus", "CY"],
+  [530, 530, "Albania", "AL"],
+  [531, 531, "North Macedonia", "MK"],
+  [535, 535, "Malta", "MT"],
+  [539, 539, "Ireland", "IE"],
+  [540, 549, "Belgium & Luxembourg", "BE"],
+  [560, 560, "Portugal", "PT"],
+  [569, 569, "Iceland", "IS"],
+  [570, 579, "Denmark", "DK"],
+  [590, 590, "Poland", "PL"],
+  [594, 594, "Romania", "RO"],
+  [599, 599, "Hungary", "HU"],
+  [600, 601, "South Africa", "ZA"],
+  [603, 603, "Ghana", "GH"],
+  [604, 604, "Senegal", "SN"],
+  [608, 608, "Bahrain", "BH"],
+  [609, 609, "Mauritius", "MU"],
+  [611, 611, "Morocco", "MA"],
+  [613, 613, "Algeria", "DZ"],
+  [615, 615, "Nigeria", "NG"],
+  [616, 616, "Kenya", "KE"],
+  [617, 617, "Cameroon", "CM"],
+  [618, 618, "Ivory Coast", "CI"],
+  [619, 619, "Tunisia", "TN"],
+  [620, 620, "Tanzania", "TZ"],
+  [621, 621, "Syria", "SY"],
+  [622, 622, "Egypt", "EG"],
+  [623, 623, "Brunei", "BN"],
+  [624, 624, "Libya", "LY"],
+  [625, 625, "Jordan", "JO"],
+  [626, 626, "Iran", "IR"],
+  [627, 627, "Kuwait", "KW"],
+  [628, 628, "Saudi Arabia", "SA"],
+  [629, 629, "United Arab Emirates", "AE"],
+  [640, 649, "Finland", "FI"],
+  [690, 699, "China", "CN"],
+  [700, 709, "Norway", "NO"],
+  [729, 729, "Israel", "IL"],
+  [730, 739, "Sweden", "SE"],
+  [740, 740, "Guatemala", "GT"],
+  [741, 741, "El Salvador", "SV"],
+  [742, 742, "Honduras", "HN"],
+  [743, 743, "Nicaragua", "NI"],
+  [744, 744, "Costa Rica", "CR"],
+  [745, 745, "Panama", "PA"],
+  [746, 746, "Dominican Republic", "DO"],
+  [750, 750, "Mexico", "MX"],
+  [754, 755, "Canada", "CA"],
+  [759, 759, "Venezuela", "VE"],
+  [760, 769, "Switzerland & Liechtenstein", "CH"],
+  [770, 771, "Colombia", "CO"],
+  [773, 773, "Uruguay", "UY"],
+  [775, 775, "Peru", "PE"],
+  [777, 777, "Bolivia", "BO"],
+  [778, 779, "Argentina", "AR"],
+  [780, 780, "Chile", "CL"],
+  [784, 784, "Paraguay", "PY"],
+  [786, 786, "Ecuador", "EC"],
+  [789, 790, "Brazil", "BR"],
+  [800, 839, "Italy", "IT"],
+  [840, 849, "Spain & Andorra", "ES"],
+  [850, 850, "Cuba", "CU"],
+  [858, 858, "Slovakia", "SK"],
+  [859, 859, "Czech Republic", "CZ"],
+  [860, 860, "Serbia", "RS"],
+  [865, 865, "Mongolia", "MN"],
+  [867, 867, "North Korea", "KP"],
+  [868, 869, "Turkey", "TR"],
+  [870, 879, "Netherlands", "NL"],
+  [880, 880, "South Korea", "KR"],
+  [884, 884, "Cambodia", "KH"],
+  [885, 885, "Thailand", "TH"],
+  [888, 888, "Singapore", "SG"],
+  [890, 890, "India", "IN"],
+  [893, 893, "Vietnam", "VN"],
+  [896, 896, "Pakistan", "PK"],
+  [899, 899, "Indonesia", "ID"],
+  [900, 919, "Austria", "AT"],
+  [930, 939, "Australia", "AU"],
+  [940, 949, "New Zealand", "NZ"],
+  [950, 950, "GS1 Global Office", null],
+  [951, 951, "GS1 Global Office (EPC)", null],
+  [955, 955, "Malaysia", "MY"],
+  [958, 958, "Macau", "MO"],
+  [960, 969, "GS1 Global Office (GTIN-8)", null],
+  [977, 977, "Periodicals (ISSN)", null],
+  [978, 979, "Books (ISBN)", null],
+  [980, 980, "Refund receipts", null],
+  [981, 984, "Common currency coupons", null],
+  [990, 999, "Coupons", null]
+];
+function resolveGs1Prefix(prefix) {
+  if (prefix.length < 1) return null;
+  const value = Number(prefix.length <= 3 ? prefix : prefix.slice(0, 3));
+  if (!Number.isInteger(value)) return null;
+  for (const [from, to, name, countryCode] of RANGES) {
+    if (value >= from && value <= to) return { name, countryCode };
+  }
+  return null;
+}
+export {
+  resolveGs1Prefix
+};
+//# sourceMappingURL=gs1-prefix.js.map

package/dist/esm/internal/gs1-prefix.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/gs1-prefix.ts"],
+  "sourcesContent": ["/** A GS1 prefix range and the organization or country it identifies. */\nexport interface Gs1PrefixAssignment {\n  /** Organization or country name, e.g. `Sweden`. */\n  readonly name: string;\n  /** ISO 3166-1 alpha-2 code, or `null` for non-country assignments such as ISBN. */\n  readonly countryCode: string | null;\n}\n\n/**\n * GS1 company prefix ranges, maintained by GS1 and published at\n * https://www.gs1.org/standards/id-keys/company-prefix.\n */\nconst RANGES: readonly (readonly [number, number, string, string | null])[] = [\n  [0, 19, \"USA & Canada\", null],\n  [20, 29, \"Restricted distribution\", null],\n  [30, 39, \"USA (drugs)\", \"US\"],\n  [40, 49, \"Restricted distribution\", null],\n  [50, 59, \"Coupons (USA)\", null],\n  [60, 99, \"USA & Canada\", null],\n  [100, 139, \"USA\", \"US\"],\n  [200, 299, \"Restricted distribution (in-store)\", null],\n  [300, 379, \"France & Monaco\", \"FR\"],\n  [380, 380, \"Bulgaria\", \"BG\"],\n  [383, 383, \"Slovenia\", \"SI\"],\n  [385, 385, \"Croatia\", \"HR\"],\n  [387, 387, \"Bosnia & Herzegovina\", \"BA\"],\n  [389, 389, \"Montenegro\", \"ME\"],\n  [390, 390, \"Kosovo\", \"XK\"],\n  [400, 440, \"Germany\", \"DE\"],\n  [450, 459, \"Japan\", \"JP\"],\n  [460, 469, \"Russia\", \"RU\"],\n  [470, 470, \"Kyrgyzstan\", \"KG\"],\n  [471, 471, \"Taiwan\", \"TW\"],\n  [474, 474, \"Estonia\", \"EE\"],\n  [475, 475, \"Latvia\", \"LV\"],\n  [476, 476, \"Azerbaijan\", \"AZ\"],\n  [477, 477, \"Lithuania\", \"LT\"],\n  [478, 478, \"Uzbekistan\", \"UZ\"],\n  [479, 479, \"Sri Lanka\", \"LK\"],\n  [480, 480, \"Philippines\", \"PH\"],\n  [481, 481, \"Belarus\", \"BY\"],\n  [482, 482, \"Ukraine\", \"UA\"],\n  [484, 484, \"Moldova\", \"MD\"],\n  [485, 485, \"Armenia\", \"AM\"],\n  [486, 486, \"Georgia\", \"GE\"],\n  [487, 487, \"Kazakhstan\", \"KZ\"],\n  [488, 488, \"Tajikistan\", \"TJ\"],\n  [489, 489, \"Hong Kong\", \"HK\"],\n  [490, 499, \"Japan\", \"JP\"],\n  [500, 509, \"United Kingdom\", \"GB\"],\n  [520, 521, \"Greece\", \"GR\"],\n  [528, 528, \"Lebanon\", \"LB\"],\n  [529, 529, \"Cyprus\", \"CY\"],\n  [530, 530, \"Albania\", \"AL\"],\n  [531, 531, \"North Macedonia\", \"MK\"],\n  [535, 535, \"Malta\", \"MT\"],\n  [539, 539, \"Ireland\", \"IE\"],\n  [540, 549, \"Belgium & Luxembourg\", \"BE\"],\n  [560, 560, \"Portugal\", \"PT\"],\n  [569, 569, \"Iceland\", \"IS\"],\n  [570, 579, \"Denmark\", \"DK\"],\n  [590, 590, \"Poland\", \"PL\"],\n  [594, 594, \"Romania\", \"RO\"],\n  [599, 599, \"Hungary\", \"HU\"],\n  [600, 601, \"South Africa\", \"ZA\"],\n  [603, 603, \"Ghana\", \"GH\"],\n  [604, 604, \"Senegal\", \"SN\"],\n  [608, 608, \"Bahrain\", \"BH\"],\n  [609, 609, \"Mauritius\", \"MU\"],\n  [611, 611, \"Morocco\", \"MA\"],\n  [613, 613, \"Algeria\", \"DZ\"],\n  [615, 615, \"Nigeria\", \"NG\"],\n  [616, 616, \"Kenya\", \"KE\"],\n  [617, 617, \"Cameroon\", \"CM\"],\n  [618, 618, \"Ivory Coast\", \"CI\"],\n  [619, 619, \"Tunisia\", \"TN\"],\n  [620, 620, \"Tanzania\", \"TZ\"],\n  [621, 621, \"Syria\", \"SY\"],\n  [622, 622, \"Egypt\", \"EG\"],\n  [623, 623, \"Brunei\", \"BN\"],\n  [624, 624, \"Libya\", \"LY\"],\n  [625, 625, \"Jordan\", \"JO\"],\n  [626, 626, \"Iran\", \"IR\"],\n  [627, 627, \"Kuwait\", \"KW\"],\n  [628, 628, \"Saudi Arabia\", \"SA\"],\n  [629, 629, \"United Arab Emirates\", \"AE\"],\n  [640, 649, \"Finland\", \"FI\"],\n  [690, 699, \"China\", \"CN\"],\n  [700, 709, \"Norway\", \"NO\"],\n  [729, 729, \"Israel\", \"IL\"],\n  [730, 739, \"Sweden\", \"SE\"],\n  [740, 740, \"Guatemala\", \"GT\"],\n  [741, 741, \"El Salvador\", \"SV\"],\n  [742, 742, \"Honduras\", \"HN\"],\n  [743, 743, \"Nicaragua\", \"NI\"],\n  [744, 744, \"Costa Rica\", \"CR\"],\n  [745, 745, \"Panama\", \"PA\"],\n  [746, 746, \"Dominican Republic\", \"DO\"],\n  [750, 750, \"Mexico\", \"MX\"],\n  [754, 755, \"Canada\", \"CA\"],\n  [759, 759, \"Venezuela\", \"VE\"],\n  [760, 769, \"Switzerland & Liechtenstein\", \"CH\"],\n  [770, 771, \"Colombia\", \"CO\"],\n  [773, 773, \"Uruguay\", \"UY\"],\n  [775, 775, \"Peru\", \"PE\"],\n  [777, 777, \"Bolivia\", \"BO\"],\n  [778, 779, \"Argentina\", \"AR\"],\n  [780, 780, \"Chile\", \"CL\"],\n  [784, 784, \"Paraguay\", \"PY\"],\n  [786, 786, \"Ecuador\", \"EC\"],\n  [789, 790, \"Brazil\", \"BR\"],\n  [800, 839, \"Italy\", \"IT\"],\n  [840, 849, \"Spain & Andorra\", \"ES\"],\n  [850, 850, \"Cuba\", \"CU\"],\n  [858, 858, \"Slovakia\", \"SK\"],\n  [859, 859, \"Czech Republic\", \"CZ\"],\n  [860, 860, \"Serbia\", \"RS\"],\n  [865, 865, \"Mongolia\", \"MN\"],\n  [867, 867, \"North Korea\", \"KP\"],\n  [868, 869, \"Turkey\", \"TR\"],\n  [870, 879, \"Netherlands\", \"NL\"],\n  [880, 880, \"South Korea\", \"KR\"],\n  [884, 884, \"Cambodia\", \"KH\"],\n  [885, 885, \"Thailand\", \"TH\"],\n  [888, 888, \"Singapore\", \"SG\"],\n  [890, 890, \"India\", \"IN\"],\n  [893, 893, \"Vietnam\", \"VN\"],\n  [896, 896, \"Pakistan\", \"PK\"],\n  [899, 899, \"Indonesia\", \"ID\"],\n  [900, 919, \"Austria\", \"AT\"],\n  [930, 939, \"Australia\", \"AU\"],\n  [940, 949, \"New Zealand\", \"NZ\"],\n  [950, 950, \"GS1 Global Office\", null],\n  [951, 951, \"GS1 Global Office (EPC)\", null],\n  [955, 955, \"Malaysia\", \"MY\"],\n  [958, 958, \"Macau\", \"MO\"],\n  [960, 969, \"GS1 Global Office (GTIN-8)\", null],\n  [977, 977, \"Periodicals (ISSN)\", null],\n  [978, 979, \"Books (ISBN)\", null],\n  [980, 980, \"Refund receipts\", null],\n  [981, 984, \"Common currency coupons\", null],\n  [990, 999, \"Coupons\", null],\n];\n\n/**\n * Resolves the first three digits of a GTIN to their GS1 assignment. Returns `null` when the\n * prefix falls outside every published range.\n */\nexport function resolveGs1Prefix(prefix: string): Gs1PrefixAssignment | null {\n  if (prefix.length < 1) return null;\n\n  const value = Number(prefix.length <= 3 ? prefix : prefix.slice(0, 3));\n  if (!Number.isInteger(value)) return null;\n\n  for (const [from, to, name, countryCode] of RANGES) {\n    if (value >= from && value <= to) return { name, countryCode };\n  }\n\n  return null;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/internal/gtin-check-digit.js

@@ -0,0 +1,26 @@
+const GTIN_VALID_LENGTHS = [8, 12, 13, 14];
+function extractGtinDigits(input) {
+  if (input == null || input.trim().length === 0) return null;
+  let digits = "";
+  for (const character of input) {
+    if (character >= "0" && character <= "9") digits += character;
+    else if (character !== " " && character !== "-") return null;
+  }
+  return digits.length === 0 ? null : digits;
+}
+function validateGtinCheckDigit(digits) {
+  let sum = 0;
+  for (let i = 0; i < digits.length - 1; i++) {
+    const digit = digits.charCodeAt(i) - 48;
+    const positionFromRight = digits.length - 1 - i;
+    sum += digit * (positionFromRight % 2 === 1 ? 3 : 1);
+  }
+  const expected = (10 - sum % 10) % 10;
+  return expected === digits.charCodeAt(digits.length - 1) - 48;
+}
+export {
+  GTIN_VALID_LENGTHS,
+  extractGtinDigits,
+  validateGtinCheckDigit
+};
+//# sourceMappingURL=gtin-check-digit.js.map

package/dist/esm/internal/gtin-check-digit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/gtin-check-digit.ts"],
+  "sourcesContent": ["/** The four GTIN lengths GS1 defines: GTIN-8, GTIN-12, GTIN-13 and GTIN-14. */\nexport const GTIN_VALID_LENGTHS: readonly number[] = [8, 12, 13, 14];\n\n/**\n * Strips the separators a printed GTIN may carry. Spaces and hyphens are dropped; anything\n * else disqualifies the input, so `59012341234-57` extracts but `590.1234` does not.\n * Returns `null` when nothing is left or a foreign character appears.\n */\nexport function extractGtinDigits(input: string | null | undefined): string | null {\n  if (input == null || input.trim().length === 0) return null;\n\n  let digits = \"\";\n  for (const character of input) {\n    if (character >= \"0\" && character <= \"9\") digits += character;\n    else if (character !== \" \" && character !== \"-\") return null;\n  }\n\n  return digits.length === 0 ? null : digits;\n}\n\n/**\n * Validates the GS1 modulo-10 check digit, where digits are weighted 3 and 1 alternating from\n * the right, ahead of the trailing check digit itself.\n */\nexport function validateGtinCheckDigit(digits: string): boolean {\n  let sum = 0;\n  for (let i = 0; i < digits.length - 1; i++) {\n    const digit = digits.charCodeAt(i) - 48;\n    const positionFromRight = digits.length - 1 - i;\n    sum += digit * (positionFromRight % 2 === 1 ? 3 : 1);\n  }\n\n  const expected = (10 - (sum % 10)) % 10;\n  return expected === digits.charCodeAt(digits.length - 1) - 48;\n}\n"],
+  "mappings": "AACO,MAAM,qBAAwC,CAAC,GAAG,IAAI,IAAI,EAAE;AAO5D,SAAS,kBAAkB,OAAiD;AACjF,MAAI,SAAS,QAAQ,MAAM,KAAK,EAAE,WAAW,EAAG,QAAO;AAEvD,MAAI,SAAS;AACb,aAAW,aAAa,OAAO;AAC7B,QAAI,aAAa,OAAO,aAAa,IAAK,WAAU;AAAA,aAC3C,cAAc,OAAO,cAAc,IAAK,QAAO;AAAA,EAC1D;AAEA,SAAO,OAAO,WAAW,IAAI,OAAO;AACtC;AAMO,SAAS,uBAAuB,QAAyB;AAC9D,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,OAAO,SAAS,GAAG,KAAK;AAC1C,UAAM,QAAQ,OAAO,WAAW,CAAC,IAAI;AACrC,UAAM,oBAAoB,OAAO,SAAS,IAAI;AAC9C,WAAO,SAAS,oBAAoB,MAAM,IAAI,IAAI;AAAA,EACpD;AAEA,QAAM,YAAY,KAAM,MAAM,MAAO;AACrC,SAAO,aAAa,OAAO,WAAW,OAAO,SAAS,CAAC,IAAI;AAC7D;",
+  "names": []
+}

package/dist/esm/internal/input-sanitization.js

@@ -0,0 +1,59 @@
+const FORMAT_OR_NOT_ASSIGNED = /[\p{Cf}\p{Cn}]/u;
+const SPACE_SEPARATOR = /[\p{Zs}\p{Zl}\p{Zp}]/u;
+const CONTROL = /\p{Cc}/u;
+function sanitizeInput(input) {
+  let out = "";
+  for (const c of input) {
+    if (c === "\u2018" || c === "\u2019" || c === "\u201A" || c === "\u201B") {
+      out += "'";
+      continue;
+    }
+    if (c === "\u201C" || c === "\u201D" || c === "\u201E" || c === "\u201F" || c === "\xAB" || c === "\xBB") {
+      out += '"';
+      continue;
+    }
+    if (FORMAT_OR_NOT_ASSIGNED.test(c)) {
+      continue;
+    }
+    if (CONTROL.test(c)) {
+      if (c === "	" || c === "\n" || c === "\r") out += " ";
+      continue;
+    }
+    if (SPACE_SEPARATOR.test(c)) {
+      out += " ";
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+const WHITESPACE_RUN = /\s+/g;
+function collapseWhitespace(input) {
+  if (input == null) return "";
+  return sanitizeInput(input).trim().replace(WHITESPACE_RUN, " ");
+}
+function keepDigits(input) {
+  let out = "";
+  for (let i = 0; i < input.length; i++) {
+    const c = input.charCodeAt(i);
+    if (c >= 48 && c <= 57) out += input[i];
+  }
+  return out;
+}
+function keepAsciiAlphanumericUppercase(input) {
+  let out = "";
+  for (let i = 0; i < input.length; i++) {
+    const c = input.charCodeAt(i);
+    if (c >= 48 && c <= 57) out += input[i];
+    else if (c >= 65 && c <= 90) out += input[i];
+    else if (c >= 97 && c <= 122) out += String.fromCharCode(c - 32);
+  }
+  return out;
+}
+export {
+  collapseWhitespace,
+  keepAsciiAlphanumericUppercase,
+  keepDigits,
+  sanitizeInput
+};
+//# sourceMappingURL=input-sanitization.js.map

package/dist/esm/internal/input-sanitization.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/input-sanitization.ts"],
+  "sourcesContent": ["/**\n * Shared input sanitization for text inputs across domain types.\n * Provides invisible-character stripping, whitespace normalization, and common\n * character-filtering helpers (digits-only, alphanumeric-only, collapse whitespace).\n *\n * Real-world inputs (e.g. from CRM/banking systems) commonly contain invisible\n * Unicode characters that break validation while being completely invisible in UIs\n * and logs. The most frequent offender is `U+202A` LEFT-TO-RIGHT EMBEDDING,\n * especially on values originating from RTL-language contexts (Arabic, Hebrew).\n * Other common contaminants include non-breaking spaces from web/PDF copy-paste,\n * null bytes from binary data, stray newlines from multi-line form fields,\n * and typographic (smart/curly) quotes from mobile keyboards and word processors.\n *\n * Equivalent of `Buildi.Primitives.InputSanitization` (internal in .NET).\n * Exposed via `internal/` and not re-exported from the public package entry.\n */\n\nconst FORMAT_OR_NOT_ASSIGNED = /[\\p{Cf}\\p{Cn}]/u;\nconst SPACE_SEPARATOR = /[\\p{Zs}\\p{Zl}\\p{Zp}]/u;\nconst CONTROL = /\\p{Cc}/u;\n\n/**\n * Strips invisible/non-printable characters, normalizes all whitespace variants\n * to ASCII space (`U+0020`), normalizes typographic single quotes to ASCII\n * apostrophe (`'`), and normalizes typographic and guillemet double quotes to\n * ASCII quotation mark (`\"`).\n */\nexport function sanitizeInput(input: string): string {\n  let out = \"\";\n  for (const c of input) {\n    // Smart single quotes -> ASCII apostrophe.\n    if (c === \"\\u2018\" || c === \"\\u2019\" || c === \"\\u201A\" || c === \"\\u201B\") {\n      out += \"'\";\n      continue;\n    }\n    // Smart and guillemet double quotes -> ASCII quotation mark.\n    if (\n      c === \"\\u201C\" ||\n      c === \"\\u201D\" ||\n      c === \"\\u201E\" ||\n      c === \"\\u201F\" ||\n      c === \"\\u00AB\" ||\n      c === \"\\u00BB\"\n    ) {\n      out += '\"';\n      continue;\n    }\n\n    if (FORMAT_OR_NOT_ASSIGNED.test(c)) {\n      // Drop format characters (Cf) and unassigned code points (Cn).\n      continue;\n    }\n\n    if (CONTROL.test(c)) {\n      if (c === \"\\t\" || c === \"\\n\" || c === \"\\r\") out += \" \";\n      continue;\n    }\n\n    if (SPACE_SEPARATOR.test(c)) {\n      out += \" \";\n      continue;\n    }\n\n    out += c;\n  }\n  return out;\n}\n\nconst WHITESPACE_RUN = /\\s+/g;\n\n/**\n * Sanitizes the input, trims, and collapses whitespace runs to a single space.\n * Returns an empty string when `input` is `null` or `undefined`.\n */\nexport function collapseWhitespace(input: string | null | undefined): string {\n  if (input == null) return \"\";\n  return sanitizeInput(input).trim().replace(WHITESPACE_RUN, \" \");\n}\n\n/** Keeps only ASCII digits (`0`-`9`), stripping everything else. */\nexport function keepDigits(input: string): string {\n  let out = \"\";\n  for (let i = 0; i < input.length; i++) {\n    const c = input.charCodeAt(i);\n    if (c >= 0x30 && c <= 0x39) out += input[i];\n  }\n  return out;\n}\n\n/**\n * Keeps only ASCII letters and digits, uppercasing letters.\n * Strips whitespace, hyphens, and all other non-alphanumeric characters.\n */\nexport function keepAsciiAlphanumericUppercase(input: string): string {\n  let out = \"\";\n  for (let i = 0; i < input.length; i++) {\n    const c = input.charCodeAt(i);\n    if (c >= 0x30 && c <= 0x39) out += input[i];\n    else if (c >= 0x41 && c <= 0x5a) out += input[i];\n    else if (c >= 0x61 && c <= 0x7a) out += String.fromCharCode(c - 32);\n  }\n  return out;\n}\n"],
+  "mappings": "AAiBA,MAAM,yBAAyB;AAC/B,MAAM,kBAAkB;AACxB,MAAM,UAAU;AAQT,SAAS,cAAc,OAAuB;AACnD,MAAI,MAAM;AACV,aAAW,KAAK,OAAO;AAErB,QAAI,MAAM,YAAY,MAAM,YAAY,MAAM,YAAY,MAAM,UAAU;AACxE,aAAO;AACP;AAAA,IACF;AAEA,QACE,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,UACN,MAAM,QACN;AACA,aAAO;AACP;AAAA,IACF;AAEA,QAAI,uBAAuB,KAAK,CAAC,GAAG;AAElC;AAAA,IACF;AAEA,QAAI,QAAQ,KAAK,CAAC,GAAG;AACnB,UAAI,MAAM,OAAQ,MAAM,QAAQ,MAAM,KAAM,QAAO;AACnD;AAAA,IACF;AAEA,QAAI,gBAAgB,KAAK,CAAC,GAAG;AAC3B,aAAO;AACP;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,MAAM,iBAAiB;AAMhB,SAAS,mBAAmB,OAA0C;AAC3E,MAAI,SAAS,KAAM,QAAO;AAC1B,SAAO,cAAc,KAAK,EAAE,KAAK,EAAE,QAAQ,gBAAgB,GAAG;AAChE;AAGO,SAAS,WAAW,OAAuB;AAChD,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAM,IAAI,MAAM,WAAW,CAAC;AAC5B,QAAI,KAAK,MAAQ,KAAK,GAAM,QAAO,MAAM,CAAC;AAAA,EAC5C;AACA,SAAO;AACT;AAMO,SAAS,+BAA+B,OAAuB;AACpE,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAM,IAAI,MAAM,WAAW,CAAC;AAC5B,QAAI,KAAK,MAAQ,KAAK,GAAM,QAAO,MAAM,CAAC;AAAA,aACjC,KAAK,MAAQ,KAAK,GAAM,QAAO,MAAM,CAAC;AAAA,aACtC,KAAK,MAAQ,KAAK,IAAM,QAAO,OAAO,aAAa,IAAI,EAAE;AAAA,EACpE;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/esm/internal/luhn.js

@@ -0,0 +1,20 @@
+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;
+}
+export {
+  luhnIsValid
+};
+//# sourceMappingURL=luhn.js.map

package/dist/esm/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": "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/esm/internal/measurement-unit-parser.js

@@ -0,0 +1,66 @@
+import { Decimal } from "./decimal.js";
+import { sanitizeInput } from "./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 = 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 Decimal.parse(fractionPart.length > 0 ? `${cleanInteger}.${fractionPart}` : cleanInteger);
+}
+export {
+  tryParseNumberOnly,
+  trySplitMeasurement
+};
+//# sourceMappingURL=measurement-unit-parser.js.map

package/dist/esm/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": "AAWA,SAAS,eAAe;AACxB,SAAS,qBAAqB;AAE9B,MAAM,mBAAmB;AAEzB,MAAM,gBAAgB;AAYf,SAAS,oBAAoB,OAA2D;AAC7F,MAAI,SAAS,QAAQ,MAAM,KAAK,EAAE,WAAW,EAAG,QAAO;AAEvD,QAAM,UAAU,cAAc,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,QAAQ,MAAM,aAAa,SAAS,IAAI,GAAG,YAAY,IAAI,YAAY,KAAK,YAAY;AACjG;",
+  "names": []
+}

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

@@ -0,0 +1,110 @@
+import { Decimal } from "./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(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();
+}
+export {
+  MeasurementUnit,
+  MeasurementUnitIndex,
+  foldForUnitLookup
+};
+//# sourceMappingURL=measurement-unit.js.map

package/dist/esm/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": []
+}