@budiauktioner/buildi-primitives 0.1.1 → 0.2.0

package/dist/cjs/internal/decimal.js

@@ -0,0 +1,262 @@
+"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 decimal_exports = {};
+__export(decimal_exports, {
+  Decimal: () => Decimal,
+  DecimalDivisionByZeroError: () => DecimalDivisionByZeroError,
+  DecimalOverflowError: () => DecimalOverflowError
+});
+module.exports = __toCommonJS(decimal_exports);
+const MAX_SCALE = 28;
+const MAX_UNSCALED = (1n << 96n) - 1n;
+const POW10_CACHE = [];
+function pow10(exponent) {
+  if (exponent < 0) throw new RangeError("Negative power of ten.");
+  const cached = POW10_CACHE[exponent];
+  if (cached !== void 0) return cached;
+  let value = 1n;
+  for (let i = 0; i < exponent; i++) value *= 10n;
+  POW10_CACHE[exponent] = value;
+  return value;
+}
+function absBigInt(value) {
+  return value < 0n ? -value : value;
+}
+function divideRounded(numerator, denominator, mode) {
+  let n = numerator;
+  let d = denominator;
+  if (d < 0n) {
+    n = -n;
+    d = -d;
+  }
+  const negative = n < 0n;
+  const magnitude = negative ? -n : n;
+  let quotient = magnitude / d;
+  const doubledRemainder = magnitude % d * 2n;
+  if (doubledRemainder > d) {
+    quotient += 1n;
+  } else if (doubledRemainder === d) {
+    if (mode === "away-from-zero" || quotient % 2n === 1n) quotient += 1n;
+  }
+  return negative ? -quotient : quotient;
+}
+class DecimalOverflowError extends Error {
+  constructor() {
+    super("Decimal overflow.");
+    this.name = "DecimalOverflowError";
+  }
+}
+class DecimalDivisionByZeroError extends Error {
+  constructor() {
+    super("Decimal division by zero.");
+    this.name = "DecimalDivisionByZeroError";
+  }
+}
+const DECIMAL_PATTERN = /^[+-]?(?:\d+)(?:\.\d+)?$/;
+class Decimal {
+  constructor(units, scale) {
+    this.units = units;
+    this.scale = scale;
+  }
+  units;
+  scale;
+  static zero = new Decimal(0n, 0);
+  static one = new Decimal(1n, 0);
+  /**
+   * Drops scale until the value fits in 96 bits and 28 fractional digits.
+   *
+   * .NET reduces precision before it gives up, which is why `1e-16 * 1e-16`
+   * yields a scale-28 zero rather than throwing.
+   */
+  static fit(units, scale, mode) {
+    let u = units;
+    let s = scale;
+    while (s > MAX_SCALE || absBigInt(u) > MAX_UNSCALED) {
+      if (s === 0) throw new DecimalOverflowError();
+      let dropped = Math.max(1, s - MAX_SCALE);
+      let rounded = divideRounded(u, pow10(dropped), mode);
+      while (absBigInt(rounded) > MAX_UNSCALED && dropped < s) {
+        dropped += 1;
+        rounded = divideRounded(u, pow10(dropped), mode);
+      }
+      u = rounded;
+      s -= dropped;
+    }
+    return new Decimal(u, s);
+  }
+  /** Builds a value from an integer. Throws if it does not fit. */
+  static fromBigInt(value) {
+    if (absBigInt(value) > MAX_UNSCALED) throw new DecimalOverflowError();
+    return new Decimal(value, 0);
+  }
+  /**
+   * Parses a plain decimal literal such as `-12.750`. Trailing zeros are
+   * significant and preserved, as in .NET. Exponent notation is not accepted.
+   * Returns `null` when the input is malformed or too large.
+   */
+  static parse(input) {
+    if (!DECIMAL_PATTERN.test(input)) return null;
+    const negative = input.startsWith("-");
+    const unsigned = input.startsWith("+") || negative ? input.slice(1) : input;
+    const pointIndex = unsigned.indexOf(".");
+    const integerDigits = pointIndex < 0 ? unsigned : unsigned.slice(0, pointIndex);
+    const fractionDigits = pointIndex < 0 ? "" : unsigned.slice(pointIndex + 1);
+    let units = BigInt(integerDigits + fractionDigits);
+    if (negative) units = -units;
+    try {
+      return Decimal.fit(units, fractionDigits.length, "half-even");
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Converts a `number`, expanding the exponent notation JavaScript uses for
+   * very large and very small magnitudes so that `1e-7` parses as
+   * `0.0000001`. Returns `null` for non-finite input or a magnitude outside the
+   * representable range.
+   */
+  static fromNumber(value) {
+    if (!Number.isFinite(value)) return null;
+    const rendered = String(value);
+    const exponentIndex = rendered.search(/[eE]/u);
+    if (exponentIndex < 0) return Decimal.parse(rendered);
+    const exponent = Number(rendered.slice(exponentIndex + 1));
+    const mantissa = rendered.slice(0, exponentIndex);
+    const negative = mantissa.startsWith("-");
+    const unsigned = negative ? mantissa.slice(1) : mantissa;
+    const pointIndex = unsigned.indexOf(".");
+    const digits = pointIndex < 0 ? unsigned : unsigned.replace(".", "");
+    const pointPosition = (pointIndex < 0 ? unsigned.length : pointIndex) + exponent;
+    let expanded;
+    if (pointPosition <= 0) expanded = `0.${"0".repeat(-pointPosition)}${digits}`;
+    else if (pointPosition >= digits.length)
+      expanded = digits + "0".repeat(pointPosition - digits.length);
+    else expanded = `${digits.slice(0, pointPosition)}.${digits.slice(pointPosition)}`;
+    return Decimal.parse(negative ? `-${expanded}` : expanded);
+  }
+  get isZero() {
+    return this.units === 0n;
+  }
+  get isNegative() {
+    return this.units < 0n;
+  }
+  plus(other) {
+    const scale = Math.max(this.scale, other.scale);
+    const a = this.units * pow10(scale - this.scale);
+    const b = other.units * pow10(scale - other.scale);
+    return Decimal.fit(a + b, scale, "half-even");
+  }
+  minus(other) {
+    const scale = Math.max(this.scale, other.scale);
+    const a = this.units * pow10(scale - this.scale);
+    const b = other.units * pow10(scale - other.scale);
+    return Decimal.fit(a - b, scale, "half-even");
+  }
+  /** Scales add, as in .NET: `1.0 * 1.0` is `1.00`. */
+  times(other) {
+    return Decimal.fit(this.units * other.units, this.scale + other.scale, "half-even");
+  }
+  /**
+   * Divides at the highest precision that still fits, which is how .NET arrives
+   * at `1m / 0.0254m === 39.370078740157480314960629921` — 27 fractional
+   * digits, because 28 would not fit in 96 bits.
+   *
+   * Unlike the other operations, division discards trailing zeros down to a
+   * preferred scale of `dividend scale - divisor scale`. That is what makes
+   * `536870912m / 2.5m` come out as `214748364.8` while `1.00m / 2m` keeps both
+   * digits as `0.50`.
+   */
+  dividedBy(other) {
+    if (other.units === 0n) throw new DecimalDivisionByZeroError();
+    const preferredScale = Math.max(0, this.scale - other.scale);
+    for (let target = MAX_SCALE; target >= 0; target--) {
+      const shift = target - this.scale + other.scale;
+      let numerator = this.units;
+      let denominator = other.units;
+      if (shift >= 0) numerator *= pow10(shift);
+      else denominator *= pow10(-shift);
+      let quotient = divideRounded(numerator, denominator, "half-even");
+      if (absBigInt(quotient) > MAX_UNSCALED) continue;
+      const floorScale = quotient === 0n ? 0 : preferredScale;
+      let scale = target;
+      while (scale > floorScale && quotient % 10n === 0n) {
+        quotient /= 10n;
+        scale -= 1;
+      }
+      return new Decimal(quotient, scale);
+    }
+    throw new DecimalOverflowError();
+  }
+  negated() {
+    return new Decimal(-this.units, this.scale);
+  }
+  abs() {
+    return this.units < 0n ? this.negated() : this;
+  }
+  /**
+   * Rounds to `decimals` fractional digits. Asking for more digits than the
+   * value carries leaves it untouched, matching .NET `Math.Round`.
+   */
+  round(decimals, mode = "half-even") {
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > MAX_SCALE) {
+      throw new RangeError(`Decimals must be an integer from 0 through ${MAX_SCALE}.`);
+    }
+    if (decimals >= this.scale) return this;
+    const dropped = this.scale - decimals;
+    return new Decimal(divideRounded(this.units, pow10(dropped), mode), decimals);
+  }
+  /** Compares by value; scale is ignored, so `1.0` and `1.00` are equal. */
+  compareTo(other) {
+    const scale = Math.max(this.scale, other.scale);
+    const a = this.units * pow10(scale - this.scale);
+    const b = other.units * pow10(scale - other.scale);
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  equals(other) {
+    return this.compareTo(other) === 0;
+  }
+  /** Renders with trailing zeros intact, as .NET does. */
+  toString() {
+    const negative = this.units < 0n;
+    const digits = absBigInt(this.units).toString();
+    if (this.scale === 0) return negative ? `-${digits}` : digits;
+    const padded = digits.padStart(this.scale + 1, "0");
+    const split = padded.length - this.scale;
+    const rendered = `${padded.slice(0, split)}.${padded.slice(split)}`;
+    return negative ? `-${rendered}` : rendered;
+  }
+  /**
+   * Renders without trailing fractional zeros, e.g. `0.9144` rather than
+   * `0.914400`. This is the form the quantity types display.
+   */
+  toTrimmedString() {
+    const rendered = this.toString();
+    if (!rendered.includes(".")) return rendered;
+    return rendered.replace(/0+$/, "").replace(/\.$/, "");
+  }
+  /**
+   * Converts to a binary `number` for ergonomic consumer-facing accessors.
+   * Lossy beyond 17 significant digits — never round-trip a value through this
+   * on the normalization path.
+   */
+  toNumber() {
+    return Number(this.toString());
+  }
+}
+//# sourceMappingURL=decimal.js.map

package/dist/cjs/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/cjs/internal/gs1-prefix.js

@@ -0,0 +1,164 @@
+"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 gs1_prefix_exports = {};
+__export(gs1_prefix_exports, {
+  resolveGs1Prefix: () => resolveGs1Prefix
+});
+module.exports = __toCommonJS(gs1_prefix_exports);
+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;
+}
+//# sourceMappingURL=gs1-prefix.js.map

package/dist/cjs/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/cjs/internal/gtin-check-digit.js

@@ -0,0 +1,46 @@
+"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 gtin_check_digit_exports = {};
+__export(gtin_check_digit_exports, {
+  GTIN_VALID_LENGTHS: () => GTIN_VALID_LENGTHS,
+  extractGtinDigits: () => extractGtinDigits,
+  validateGtinCheckDigit: () => validateGtinCheckDigit
+});
+module.exports = __toCommonJS(gtin_check_digit_exports);
+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;
+}
+//# sourceMappingURL=gtin-check-digit.js.map

package/dist/cjs/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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;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/cjs/internal/input-sanitization.js

@@ -0,0 +1,79 @@
+"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 input_sanitization_exports = {};
+__export(input_sanitization_exports, {
+  collapseWhitespace: () => collapseWhitespace,
+  keepAsciiAlphanumericUppercase: () => keepAsciiAlphanumericUppercase,
+  keepDigits: () => keepDigits,
+  sanitizeInput: () => sanitizeInput
+});
+module.exports = __toCommonJS(input_sanitization_exports);
+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;
+}
+//# sourceMappingURL=input-sanitization.js.map

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